ab6f11da6913a467b29e08ec9d4ac10807f13d2d
[WebKit-https.git] / Source / JavaScriptCore / parser / Parser.h
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2011, 2013 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef Parser_h
24 #define Parser_h
25
26 #include "Debugger.h"
27 #include "ExceptionHelpers.h"
28 #include "Executable.h"
29 #include "JSGlobalObject.h"
30 #include "Lexer.h"
31 #include "Nodes.h"
32 #include "ParserArena.h"
33 #include "ParserError.h"
34 #include "ParserFunctionInfo.h"
35 #include "ParserTokens.h"
36 #include "RuntimeFlags.h"
37 #include "SourceProvider.h"
38 #include "SourceProviderCache.h"
39 #include "SourceProviderCacheItem.h"
40 #include "VariableEnvironment.h"
41 #include <wtf/Forward.h>
42 #include <wtf/Noncopyable.h>
43 #include <wtf/RefPtr.h>
44
45 namespace JSC {
46
47 class ExecState;
48 class FunctionMetadataNode;
49 class FunctionParameters;
50 class Identifier;
51 class VM;
52 class ProgramNode;
53 class SourceCode;
54 class SyntaxChecker;
55
56 // Macros to make the more common TreeBuilder types a little less verbose
57 #define TreeStatement typename TreeBuilder::Statement
58 #define TreeExpression typename TreeBuilder::Expression
59 #define TreeFormalParameterList typename TreeBuilder::FormalParameterList
60 #define TreeSourceElements typename TreeBuilder::SourceElements
61 #define TreeClause typename TreeBuilder::Clause
62 #define TreeClauseList typename TreeBuilder::ClauseList
63 #define TreeArguments typename TreeBuilder::Arguments
64 #define TreeArgumentsList typename TreeBuilder::ArgumentsList
65 #define TreeFunctionBody typename TreeBuilder::FunctionBody
66 #define TreeClassExpression typename TreeBuilder::ClassExpression
67 #define TreeProperty typename TreeBuilder::Property
68 #define TreePropertyList typename TreeBuilder::PropertyList
69 #define TreeDestructuringPattern typename TreeBuilder::DestructuringPattern
70
71 COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);
72
73 enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };
74 enum FunctionBodyType { ArrowFunctionBodyExpression, ArrowFunctionBodyBlock, StandardFunctionBodyBlock };
75 enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };
76
77 enum class DestructuringKind {
78     DestructureToVariables,
79     DestructureToLet,
80     DestructureToConst,
81     DestructureToCatchParameters,
82     DestructureToParameters,
83     DestructureToExpressions
84 };
85
86 enum class DeclarationType { 
87     VarDeclaration, 
88     LetDeclaration,
89     ConstDeclaration
90 };
91
92 enum class DeclarationImportType {
93     Imported,
94     ImportedNamespace,
95     NotImported
96 };
97
98 enum DeclarationResult {
99     Valid = 0,
100     InvalidStrictMode = 1 << 0,
101     InvalidDuplicateDeclaration = 1 << 1
102 };
103
104 typedef uint8_t DeclarationResultMask;
105
106
107 template <typename T> inline bool isEvalNode() { return false; }
108 template <> inline bool isEvalNode<EvalNode>() { return true; }
109
110 struct ScopeLabelInfo {
111     UniquedStringImpl* uid;
112     bool isLoop;
113 };
114
115 ALWAYS_INLINE static bool isArguments(const VM* vm, const Identifier* ident)
116 {
117     return vm->propertyNames->arguments == *ident;
118 }
119 ALWAYS_INLINE static bool isEval(const VM* vm, const Identifier* ident)
120 {
121     return vm->propertyNames->eval == *ident;
122 }
123 ALWAYS_INLINE static bool isEvalOrArgumentsIdentifier(const VM* vm, const Identifier* ident)
124 {
125     return isEval(vm, ident) || isArguments(vm, ident);
126 }
127 ALWAYS_INLINE static bool isIdentifierOrKeyword(const JSToken& token)
128 {
129     return token.m_type == IDENT || token.m_type == AWAIT || token.m_type & KeywordTokenFlag;
130 }
131
132 class ModuleScopeData : public RefCounted<ModuleScopeData> {
133 public:
134     static Ref<ModuleScopeData> create() { return adoptRef(*new ModuleScopeData); }
135
136     const IdentifierSet& exportedBindings() const { return m_exportedBindings; }
137
138     bool exportName(const Identifier& exportedName)
139     {
140         return m_exportedNames.add(exportedName.impl()).isNewEntry;
141     }
142
143     void exportBinding(const Identifier& localName)
144     {
145         m_exportedBindings.add(localName.impl());
146     }
147
148 private:
149     IdentifierSet m_exportedNames { };
150     IdentifierSet m_exportedBindings { };
151 };
152
153 struct Scope {
154     WTF_MAKE_NONCOPYABLE(Scope);
155
156 public:
157     Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode, bool isArrowFunction, bool isAsyncFunction)
158         : m_vm(vm)
159         , m_shadowsArguments(false)
160         , m_usesEval(false)
161         , m_needsFullActivation(false)
162         , m_hasDirectSuper(false)
163         , m_needsSuperBinding(false)
164         , m_allowsVarDeclarations(true)
165         , m_allowsLexicalDeclarations(true)
166         , m_strictMode(strictMode)
167         , m_isFunction(isFunction)
168         , m_isGenerator(isGenerator)
169         , m_isGeneratorBoundary(false)
170         , m_isArrowFunction(isArrowFunction)
171         , m_isArrowFunctionBoundary(false)
172         , m_isAsyncFunction(isAsyncFunction)
173         , m_isAsyncFunctionBoundary(false)
174         , m_isLexicalScope(false)
175         , m_isFunctionBoundary(false)
176         , m_isValidStrictMode(true)
177         , m_hasArguments(false)
178         , m_isEvalContext(false)
179         , m_evalContextType(EvalContextType::None)
180         , m_constructorKind(static_cast<unsigned>(ConstructorKind::None))
181         , m_expectedSuperBinding(static_cast<unsigned>(SuperBinding::NotNeeded))
182         , m_loopDepth(0)
183         , m_switchDepth(0)
184         , m_innerArrowFunctionFeatures(0)
185     {
186         m_usedVariables.append(UniquedStringImplPtrSet());
187     }
188
189     Scope(Scope&& other)
190         : m_vm(other.m_vm)
191         , m_shadowsArguments(other.m_shadowsArguments)
192         , m_usesEval(other.m_usesEval)
193         , m_needsFullActivation(other.m_needsFullActivation)
194         , m_hasDirectSuper(other.m_hasDirectSuper)
195         , m_needsSuperBinding(other.m_needsSuperBinding)
196         , m_allowsVarDeclarations(other.m_allowsVarDeclarations)
197         , m_allowsLexicalDeclarations(other.m_allowsLexicalDeclarations)
198         , m_strictMode(other.m_strictMode)
199         , m_isFunction(other.m_isFunction)
200         , m_isGenerator(other.m_isGenerator)
201         , m_isGeneratorBoundary(other.m_isGeneratorBoundary)
202         , m_isArrowFunction(other.m_isArrowFunction)
203         , m_isArrowFunctionBoundary(other.m_isArrowFunctionBoundary)
204         , m_isLexicalScope(other.m_isLexicalScope)
205         , m_isFunctionBoundary(other.m_isFunctionBoundary)
206         , m_isValidStrictMode(other.m_isValidStrictMode)
207         , m_hasArguments(other.m_hasArguments)
208         , m_isEvalContext(other.m_isEvalContext)
209         , m_constructorKind(other.m_constructorKind)
210         , m_expectedSuperBinding(other.m_expectedSuperBinding)
211         , m_loopDepth(other.m_loopDepth)
212         , m_switchDepth(other.m_switchDepth)
213         , m_innerArrowFunctionFeatures(other.m_innerArrowFunctionFeatures)
214         , m_labels(WTFMove(other.m_labels))
215         , m_declaredParameters(WTFMove(other.m_declaredParameters))
216         , m_declaredVariables(WTFMove(other.m_declaredVariables))
217         , m_lexicalVariables(WTFMove(other.m_lexicalVariables))
218         , m_usedVariables(WTFMove(other.m_usedVariables))
219         , m_closedVariableCandidates(WTFMove(other.m_closedVariableCandidates))
220         , m_moduleScopeData(WTFMove(other.m_moduleScopeData))
221         , m_functionDeclarations(WTFMove(other.m_functionDeclarations))
222     {
223     }
224
225     void startSwitch() { m_switchDepth++; }
226     void endSwitch() { m_switchDepth--; }
227     void startLoop() { m_loopDepth++; }
228     void endLoop() { ASSERT(m_loopDepth); m_loopDepth--; }
229     bool inLoop() { return !!m_loopDepth; }
230     bool breakIsValid() { return m_loopDepth || m_switchDepth; }
231     bool continueIsValid() { return m_loopDepth; }
232
233     void pushLabel(const Identifier* label, bool isLoop)
234     {
235         if (!m_labels)
236             m_labels = std::make_unique<LabelStack>();
237         m_labels->append(ScopeLabelInfo { label->impl(), isLoop });
238     }
239
240     void popLabel()
241     {
242         ASSERT(m_labels);
243         ASSERT(m_labels->size());
244         m_labels->removeLast();
245     }
246
247     ScopeLabelInfo* getLabel(const Identifier* label)
248     {
249         if (!m_labels)
250             return 0;
251         for (int i = m_labels->size(); i > 0; i--) {
252             if (m_labels->at(i - 1).uid == label->impl())
253                 return &m_labels->at(i - 1);
254         }
255         return 0;
256     }
257
258     void setSourceParseMode(SourceParseMode mode)
259     {
260         switch (mode) {
261         case SourceParseMode::AsyncArrowFunctionBodyMode:
262             setIsAsyncArrowFunctionBody();
263             break;
264
265         case SourceParseMode::AsyncFunctionBodyMode:
266             setIsAsyncFunctionBody();
267             break;
268
269         case SourceParseMode::GeneratorBodyMode:
270             setIsGenerator();
271             break;
272
273         case SourceParseMode::GeneratorWrapperFunctionMode:
274             setIsGeneratorFunction();
275             break;
276
277         case SourceParseMode::NormalFunctionMode:
278         case SourceParseMode::GetterMode:
279         case SourceParseMode::SetterMode:
280         case SourceParseMode::MethodMode:
281             setIsFunction();
282             break;
283
284         case SourceParseMode::ArrowFunctionMode:
285             setIsArrowFunction();
286             break;
287
288         case SourceParseMode::AsyncFunctionMode:
289         case SourceParseMode::AsyncMethodMode:
290             setIsAsyncFunction();
291             break;
292
293         case SourceParseMode::AsyncArrowFunctionMode:
294             setIsAsyncArrowFunction();
295             break;
296
297         case SourceParseMode::ProgramMode:
298             break;
299
300         case SourceParseMode::ModuleAnalyzeMode:
301         case SourceParseMode::ModuleEvaluateMode:
302             setIsModule();
303             break;
304         }
305     }
306
307     bool isFunction() const { return m_isFunction; }
308     bool isFunctionBoundary() const { return m_isFunctionBoundary; }
309     bool isGenerator() const { return m_isGenerator; }
310     bool isGeneratorBoundary() const { return m_isGeneratorBoundary; }
311     bool isAsyncFunction() const { return m_isAsyncFunction; }
312     bool isAsyncFunctionBoundary() const { return m_isAsyncFunctionBoundary; }
313
314     bool hasArguments() const { return m_hasArguments; }
315
316     void setIsLexicalScope() 
317     { 
318         m_isLexicalScope = true;
319         m_allowsLexicalDeclarations = true;
320     }
321     bool isLexicalScope() { return m_isLexicalScope; }
322
323     const HashSet<UniquedStringImpl*>& closedVariableCandidates() const { return m_closedVariableCandidates; }
324     VariableEnvironment& declaredVariables() { return m_declaredVariables; }
325     VariableEnvironment& lexicalVariables() { return m_lexicalVariables; }
326     VariableEnvironment& finalizeLexicalEnvironment() 
327     { 
328         if (m_usesEval || m_needsFullActivation)
329             m_lexicalVariables.markAllVariablesAsCaptured();
330         else
331             computeLexicallyCapturedVariablesAndPurgeCandidates();
332
333         return m_lexicalVariables;
334     }
335
336     ModuleScopeData& moduleScopeData() const
337     {
338         ASSERT(m_moduleScopeData);
339         return *m_moduleScopeData;
340     }
341
342     bool isModule() const
343     {
344         return !!m_moduleScopeData;
345     }
346
347     void computeLexicallyCapturedVariablesAndPurgeCandidates()
348     {
349         // Because variables may be defined at any time in the range of a lexical scope, we must
350         // track lexical variables that might be captured. Then, when we're preparing to pop the top
351         // lexical scope off the stack, we should find which variables are truly captured, and which
352         // variable still may be captured in a parent scope.
353         if (m_lexicalVariables.size() && m_closedVariableCandidates.size()) {
354             for (UniquedStringImpl* impl : m_closedVariableCandidates)
355                 m_lexicalVariables.markVariableAsCapturedIfDefined(impl);
356         }
357
358         // We can now purge values from the captured candidates because they're captured in this scope.
359         {
360             for (auto entry : m_lexicalVariables) {
361                 if (entry.value.isCaptured())
362                     m_closedVariableCandidates.remove(entry.key.get());
363             }
364         }
365     }
366
367     DeclarationResultMask declareCallee(const Identifier* ident)
368     {
369         auto addResult = m_declaredVariables.add(ident->impl());
370         // We want to track if callee is captured, but we don't want to act like it's a 'var'
371         // because that would cause the BytecodeGenerator to emit bad code.
372         addResult.iterator->value.clearIsVar();
373
374         DeclarationResultMask result = DeclarationResult::Valid;
375         if (isEvalOrArgumentsIdentifier(m_vm, ident))
376             result |= DeclarationResult::InvalidStrictMode;
377         return result;
378     }
379
380     DeclarationResultMask declareVariable(const Identifier* ident)
381     {
382         ASSERT(m_allowsVarDeclarations);
383         DeclarationResultMask result = DeclarationResult::Valid;
384         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
385         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
386         auto addResult = m_declaredVariables.add(ident->impl());
387         addResult.iterator->value.setIsVar();
388         if (!isValidStrictMode)
389             result |= DeclarationResult::InvalidStrictMode;
390         if (m_lexicalVariables.contains(ident->impl()))
391             result |= DeclarationResult::InvalidDuplicateDeclaration;
392         return result;
393     }
394
395     DeclarationResultMask declareFunction(const Identifier* ident, bool declareAsVar, bool isSloppyModeHoistingCandidate)
396     {
397         ASSERT(m_allowsVarDeclarations || m_allowsLexicalDeclarations);
398         DeclarationResultMask result = DeclarationResult::Valid;
399         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
400         if (!isValidStrictMode)
401             result |= DeclarationResult::InvalidStrictMode;
402         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
403         auto addResult = declareAsVar ? m_declaredVariables.add(ident->impl()) : m_lexicalVariables.add(ident->impl());
404         if (isSloppyModeHoistingCandidate)
405             addResult.iterator->value.setIsSloppyModeHoistingCandidate();
406         if (declareAsVar) {
407             addResult.iterator->value.setIsVar();
408             if (m_lexicalVariables.contains(ident->impl()))
409                 result |= DeclarationResult::InvalidDuplicateDeclaration;
410         } else {
411             addResult.iterator->value.setIsLet();
412             ASSERT_WITH_MESSAGE(!m_declaredVariables.size(), "We should only declare a function as a lexically scoped variable in scopes where var declarations aren't allowed. I.e, in strict mode and not at the top-level scope of a function or program.");
413             if (!addResult.isNewEntry) {
414                 if (!isSloppyModeHoistingCandidate || !addResult.iterator->value.isFunction())
415                     result |= DeclarationResult::InvalidDuplicateDeclaration;
416             }
417         }
418
419         addResult.iterator->value.setIsFunction();
420
421         return result;
422     }
423
424     void addSloppyModeHoistableFunctionCandidate(const Identifier* ident)
425     {
426         ASSERT(m_allowsVarDeclarations);
427         m_sloppyModeHoistableFunctionCandidates.add(ident->impl());
428     }
429
430     void appendFunction(FunctionMetadataNode* node)
431     { 
432         ASSERT(node);
433         m_functionDeclarations.append(node);
434     }
435     DeclarationStacks::FunctionStack&& takeFunctionDeclarations() { return WTFMove(m_functionDeclarations); }
436     
437
438     DeclarationResultMask declareLexicalVariable(const Identifier* ident, bool isConstant, DeclarationImportType importType = DeclarationImportType::NotImported)
439     {
440         ASSERT(m_allowsLexicalDeclarations);
441         DeclarationResultMask result = DeclarationResult::Valid;
442         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
443         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
444         auto addResult = m_lexicalVariables.add(ident->impl());
445         if (isConstant)
446             addResult.iterator->value.setIsConst();
447         else
448             addResult.iterator->value.setIsLet();
449
450         if (importType == DeclarationImportType::Imported)
451             addResult.iterator->value.setIsImported();
452         else if (importType == DeclarationImportType::ImportedNamespace) {
453             addResult.iterator->value.setIsImported();
454             addResult.iterator->value.setIsImportedNamespace();
455         }
456
457         if (!addResult.isNewEntry)
458             result |= DeclarationResult::InvalidDuplicateDeclaration;
459         if (!isValidStrictMode)
460             result |= DeclarationResult::InvalidStrictMode;
461
462         return result;
463     }
464
465     bool hasDeclaredVariable(const Identifier& ident)
466     {
467         return hasDeclaredVariable(ident.impl());
468     }
469
470     bool hasDeclaredVariable(const RefPtr<UniquedStringImpl>& ident)
471     {
472         auto iter = m_declaredVariables.find(ident.get());
473         if (iter == m_declaredVariables.end())
474             return false;
475         VariableEnvironmentEntry entry = iter->value;
476         return entry.isVar(); // The callee isn't a "var".
477     }
478
479     bool hasLexicallyDeclaredVariable(const RefPtr<UniquedStringImpl>& ident) const
480     {
481         return m_lexicalVariables.contains(ident.get());
482     }
483     
484     ALWAYS_INLINE bool hasDeclaredParameter(const Identifier& ident)
485     {
486         return hasDeclaredParameter(ident.impl());
487     }
488
489     bool hasDeclaredParameter(const RefPtr<UniquedStringImpl>& ident)
490     {
491         return m_declaredParameters.contains(ident.get()) || hasDeclaredVariable(ident);
492     }
493     
494     void preventAllVariableDeclarations()
495     {
496         m_allowsVarDeclarations = false; 
497         m_allowsLexicalDeclarations = false;
498     }
499     void preventVarDeclarations() { m_allowsVarDeclarations = false; }
500     bool allowsVarDeclarations() const { return m_allowsVarDeclarations; }
501     bool allowsLexicalDeclarations() const { return m_allowsLexicalDeclarations; }
502
503     DeclarationResultMask declareParameter(const Identifier* ident)
504     {
505         ASSERT(m_allowsVarDeclarations);
506         DeclarationResultMask result = DeclarationResult::Valid;
507         bool isArgumentsIdent = isArguments(m_vm, ident);
508         auto addResult = m_declaredVariables.add(ident->impl());
509         addResult.iterator->value.clearIsVar();
510         addResult.iterator->value.setIsParameter();
511         bool isValidStrictMode = addResult.isNewEntry && m_vm->propertyNames->eval != *ident && !isArgumentsIdent;
512         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
513         m_declaredParameters.add(ident->impl());
514         if (!isValidStrictMode)
515             result |= DeclarationResult::InvalidStrictMode;
516         if (isArgumentsIdent)
517             m_shadowsArguments = true;
518         if (!addResult.isNewEntry)
519             result |= DeclarationResult::InvalidDuplicateDeclaration;
520
521         return result;
522     }
523     
524     bool usedVariablesContains(UniquedStringImpl* impl) const
525     { 
526         for (const UniquedStringImplPtrSet& set : m_usedVariables) {
527             if (set.contains(impl))
528                 return true;
529         }
530         return false;
531     }
532     template <typename Func>
533     void forEachUsedVariable(const Func& func)
534     {
535         for (const UniquedStringImplPtrSet& set : m_usedVariables) {
536             for (UniquedStringImpl* impl : set)
537                 func(impl);
538         }
539     }
540     void useVariable(const Identifier* ident, bool isEval)
541     {
542         useVariable(ident->impl(), isEval);
543     }
544     void useVariable(UniquedStringImpl* impl, bool isEval)
545     {
546         m_usesEval |= isEval;
547         m_usedVariables.last().add(impl);
548     }
549
550     void pushUsedVariableSet() { m_usedVariables.append(UniquedStringImplPtrSet()); }
551     size_t currentUsedVariablesSize() { return m_usedVariables.size(); }
552
553     void revertToPreviousUsedVariables(size_t size) { m_usedVariables.resize(size); }
554
555     void setNeedsFullActivation() { m_needsFullActivation = true; }
556     bool needsFullActivation() const { return m_needsFullActivation; }
557     bool isArrowFunctionBoundary() { return m_isArrowFunctionBoundary; }
558     bool isArrowFunction() { return m_isArrowFunction; }
559
560     bool hasDirectSuper() const { return m_hasDirectSuper; }
561     bool setHasDirectSuper() { return std::exchange(m_hasDirectSuper, true); }
562
563     bool needsSuperBinding() const { return m_needsSuperBinding; }
564     bool setNeedsSuperBinding() { return std::exchange(m_needsSuperBinding, true); }
565     
566     void setEvalContextType(EvalContextType evalContextType) { m_evalContextType = evalContextType; }
567     EvalContextType evalContextType() { return m_evalContextType; }
568     
569     InnerArrowFunctionCodeFeatures innerArrowFunctionFeatures() { return m_innerArrowFunctionFeatures; }
570     
571     void setExpectedSuperBinding(SuperBinding superBinding) { m_expectedSuperBinding = static_cast<unsigned>(superBinding); }
572     SuperBinding expectedSuperBinding() const { return static_cast<SuperBinding>(m_expectedSuperBinding); }
573     void setConstructorKind(ConstructorKind constructorKind) { m_constructorKind = static_cast<unsigned>(constructorKind); }
574     ConstructorKind constructorKind() const { return static_cast<ConstructorKind>(m_constructorKind); }
575
576     void setInnerArrowFunctionUsesSuperCall() { m_innerArrowFunctionFeatures |= SuperCallInnerArrowFunctionFeature; }
577     void setInnerArrowFunctionUsesSuperProperty() { m_innerArrowFunctionFeatures |= SuperPropertyInnerArrowFunctionFeature; }
578     void setInnerArrowFunctionUsesEval() { m_innerArrowFunctionFeatures |= EvalInnerArrowFunctionFeature; }
579     void setInnerArrowFunctionUsesThis() { m_innerArrowFunctionFeatures |= ThisInnerArrowFunctionFeature; }
580     void setInnerArrowFunctionUsesNewTarget() { m_innerArrowFunctionFeatures |= NewTargetInnerArrowFunctionFeature; }
581     void setInnerArrowFunctionUsesArguments() { m_innerArrowFunctionFeatures |= ArgumentsInnerArrowFunctionFeature; }
582     
583     bool isEvalContext() const { return m_isEvalContext; }
584     void setIsEvalContext(bool isEvalContext) { m_isEvalContext = isEvalContext; }
585
586     void setInnerArrowFunctionUsesEvalAndUseArgumentsIfNeeded()
587     {
588         ASSERT(m_isArrowFunction);
589
590         if (m_usesEval)
591             setInnerArrowFunctionUsesEval();
592         
593         if (usedVariablesContains(m_vm->propertyNames->arguments.impl()))
594             setInnerArrowFunctionUsesArguments();
595     }
596     
597     void collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
598     {
599         if (nestedScope->m_usesEval)
600             m_usesEval = true;
601
602         {
603             UniquedStringImplPtrSet& destinationSet = m_usedVariables.last();
604             for (const UniquedStringImplPtrSet& usedVariablesSet : nestedScope->m_usedVariables) {
605                 for (UniquedStringImpl* impl : usedVariablesSet) {
606                     if (nestedScope->m_declaredVariables.contains(impl) || nestedScope->m_lexicalVariables.contains(impl))
607                         continue;
608
609                     // "arguments" reference should be resolved at function boudary.
610                     if (nestedScope->isFunctionBoundary() && nestedScope->hasArguments() && impl == m_vm->propertyNames->arguments.impl() && !nestedScope->isArrowFunctionBoundary())
611                         continue;
612
613                     destinationSet.add(impl);
614                     // We don't want a declared variable that is used in an inner scope to be thought of as captured if
615                     // that inner scope is both a lexical scope and not a function. Only inner functions and "catch" 
616                     // statements can cause variables to be captured.
617                     if (shouldTrackClosedVariables && (nestedScope->m_isFunctionBoundary || !nestedScope->m_isLexicalScope))
618                         m_closedVariableCandidates.add(impl);
619                 }
620             }
621         }
622         // Propagate closed variable candidates downwards within the same function.
623         // Cross function captures will be realized via m_usedVariables propagation.
624         if (shouldTrackClosedVariables && !nestedScope->m_isFunctionBoundary && nestedScope->m_closedVariableCandidates.size()) {
625             auto end = nestedScope->m_closedVariableCandidates.end();
626             auto begin = nestedScope->m_closedVariableCandidates.begin();
627             m_closedVariableCandidates.add(begin, end);
628         }
629     }
630     
631     void mergeInnerArrowFunctionFeatures(InnerArrowFunctionCodeFeatures arrowFunctionCodeFeatures)
632     {
633         m_innerArrowFunctionFeatures = m_innerArrowFunctionFeatures | arrowFunctionCodeFeatures;
634     }
635     
636     void getSloppyModeHoistedFunctions(UniquedStringImplPtrSet& sloppyModeHoistedFunctions)
637     {
638         for (UniquedStringImpl* function : m_sloppyModeHoistableFunctionCandidates) {
639             // ES6 Annex B.3.3. The only time we can't hoist a function is if a syntax error would
640             // be caused by declaring a var with that function's name or if we have a parameter with
641             // that function's name. Note that we would only cause a syntax error if we had a let/const/class
642             // variable with the same name.
643             if (!m_lexicalVariables.contains(function)) {
644                 auto iter = m_declaredVariables.find(function);
645                 bool isParameter = iter != m_declaredVariables.end() && iter->value.isParameter();
646                 if (!isParameter) {
647                     auto addResult = m_declaredVariables.add(function);
648                     addResult.iterator->value.setIsVar();
649                     sloppyModeHoistedFunctions.add(function);
650                 }
651             }
652         }
653     }
654
655     void getCapturedVars(IdentifierSet& capturedVariables)
656     {
657         if (m_needsFullActivation || m_usesEval) {
658             for (auto& entry : m_declaredVariables)
659                 capturedVariables.add(entry.key);
660             return;
661         }
662         for (UniquedStringImpl* impl : m_closedVariableCandidates) {
663             // We refer to m_declaredVariables here directly instead of a hasDeclaredVariable because we want to mark the callee as captured.
664             if (!m_declaredVariables.contains(impl)) 
665                 continue;
666             capturedVariables.add(impl);
667         }
668     }
669     void setStrictMode() { m_strictMode = true; }
670     bool strictMode() const { return m_strictMode; }
671     bool isValidStrictMode() const { return m_isValidStrictMode; }
672     bool shadowsArguments() const { return m_shadowsArguments; }
673
674     void copyCapturedVariablesToVector(const UniquedStringImplPtrSet& usedVariables, Vector<UniquedStringImpl*, 8>& vector)
675     {
676         for (UniquedStringImpl* impl : usedVariables) {
677             if (m_declaredVariables.contains(impl) || m_lexicalVariables.contains(impl))
678                 continue;
679             vector.append(impl);
680         }
681     }
682
683     void fillParametersForSourceProviderCache(SourceProviderCacheItemCreationParameters& parameters, const UniquedStringImplPtrSet& capturesFromParameterExpressions)
684     {
685         ASSERT(m_isFunction);
686         parameters.usesEval = m_usesEval;
687         parameters.strictMode = m_strictMode;
688         parameters.needsFullActivation = m_needsFullActivation;
689         parameters.innerArrowFunctionFeatures = m_innerArrowFunctionFeatures;
690         for (const UniquedStringImplPtrSet& set : m_usedVariables)
691             copyCapturedVariablesToVector(set, parameters.usedVariables);
692
693         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=156962
694         // We add these unconditionally because we currently don't keep a separate
695         // declaration scope for a function's parameters and its var/let/const declarations.
696         // This is somewhat unfortunate and we should refactor to do this at some point
697         // because parameters logically form a parent scope to var/let/const variables.
698         // But because we don't do this, we must grab capture candidates from a parameter
699         // list before we parse the body of a function because the body's declarations
700         // might make us believe something isn't actually a capture candidate when it really
701         // is.
702         for (UniquedStringImpl* impl : capturesFromParameterExpressions)
703             parameters.usedVariables.append(impl);
704     }
705
706     void restoreFromSourceProviderCache(const SourceProviderCacheItem* info)
707     {
708         ASSERT(m_isFunction);
709         m_usesEval = info->usesEval;
710         m_strictMode = info->strictMode;
711         m_innerArrowFunctionFeatures = info->innerArrowFunctionFeatures;
712         m_needsFullActivation = info->needsFullActivation;
713         UniquedStringImplPtrSet& destSet = m_usedVariables.last();
714         for (unsigned i = 0; i < info->usedVariablesCount; ++i)
715             destSet.add(info->usedVariables()[i]);
716     }
717
718 private:
719     void setIsFunction()
720     {
721         m_isFunction = true;
722         m_isFunctionBoundary = true;
723         m_hasArguments = true;
724         setIsLexicalScope();
725         m_isGenerator = false;
726         m_isGeneratorBoundary = false;
727         m_isArrowFunctionBoundary = false;
728         m_isArrowFunction = false;
729         m_isAsyncFunctionBoundary = false;
730         m_isAsyncFunction = false;
731     }
732
733     void setIsGeneratorFunction()
734     {
735         setIsFunction();
736         m_isGenerator = true;
737     }
738
739     void setIsGenerator()
740     {
741         setIsFunction();
742         m_isGenerator = true;
743         m_isGeneratorBoundary = true;
744         m_hasArguments = false;
745     }
746     
747     void setIsArrowFunction()
748     {
749         setIsFunction();
750         m_isArrowFunctionBoundary = true;
751         m_isArrowFunction = true;
752     }
753
754     void setIsAsyncArrowFunction()
755     {
756         setIsArrowFunction();
757         m_isAsyncFunction = true;
758     }
759
760     void setIsAsyncFunction()
761     {
762         setIsFunction();
763         m_isAsyncFunction = true;
764     }
765
766     void setIsAsyncFunctionBody()
767     {
768         setIsFunction();
769         m_hasArguments = false;
770         m_isAsyncFunction = true;
771         m_isAsyncFunctionBoundary = true;
772     }
773
774     void setIsAsyncArrowFunctionBody()
775     {
776         setIsArrowFunction();
777         m_hasArguments = false;
778         m_isAsyncFunction = true;
779         m_isAsyncFunctionBoundary = true;
780     }
781
782     void setIsModule()
783     {
784         m_moduleScopeData = ModuleScopeData::create();
785     }
786
787     const VM* m_vm;
788     bool m_shadowsArguments;
789     bool m_usesEval;
790     bool m_needsFullActivation;
791     bool m_hasDirectSuper;
792     bool m_needsSuperBinding;
793     bool m_allowsVarDeclarations;
794     bool m_allowsLexicalDeclarations;
795     bool m_strictMode;
796     bool m_isFunction;
797     bool m_isGenerator;
798     bool m_isGeneratorBoundary;
799     bool m_isArrowFunction;
800     bool m_isArrowFunctionBoundary;
801     bool m_isAsyncFunction;
802     bool m_isAsyncFunctionBoundary;
803     bool m_isLexicalScope;
804     bool m_isFunctionBoundary;
805     bool m_isValidStrictMode;
806     bool m_hasArguments;
807     bool m_isEvalContext;
808     EvalContextType m_evalContextType;
809     unsigned m_constructorKind;
810     unsigned m_expectedSuperBinding;
811     int m_loopDepth;
812     int m_switchDepth;
813     InnerArrowFunctionCodeFeatures m_innerArrowFunctionFeatures;
814
815     typedef Vector<ScopeLabelInfo, 2> LabelStack;
816     std::unique_ptr<LabelStack> m_labels;
817     UniquedStringImplPtrSet m_declaredParameters;
818     VariableEnvironment m_declaredVariables;
819     VariableEnvironment m_lexicalVariables;
820     Vector<UniquedStringImplPtrSet, 6> m_usedVariables;
821     UniquedStringImplPtrSet m_sloppyModeHoistableFunctionCandidates;
822     HashSet<UniquedStringImpl*> m_closedVariableCandidates;
823     RefPtr<ModuleScopeData> m_moduleScopeData;
824     DeclarationStacks::FunctionStack m_functionDeclarations;
825 };
826
827 typedef Vector<Scope, 10> ScopeStack;
828
829 struct ScopeRef {
830     ScopeRef(ScopeStack* scopeStack, unsigned index)
831         : m_scopeStack(scopeStack)
832         , m_index(index)
833     {
834     }
835     Scope* operator->() { return &m_scopeStack->at(m_index); }
836     unsigned index() const { return m_index; }
837
838     bool hasContainingScope()
839     {
840         return m_index && !m_scopeStack->at(m_index).isFunctionBoundary();
841     }
842
843     ScopeRef containingScope()
844     {
845         ASSERT(hasContainingScope());
846         return ScopeRef(m_scopeStack, m_index - 1);
847     }
848
849     bool operator==(const ScopeRef& other)
850     {
851         ASSERT(other.m_scopeStack == m_scopeStack);
852         return m_index == other.m_index;
853     }
854
855     bool operator!=(const ScopeRef& other)
856     {
857         return !(*this == other);
858     }
859
860 private:
861     ScopeStack* m_scopeStack;
862     unsigned m_index;
863 };
864
865 enum class ArgumentType {
866     Normal,
867     Spread
868 };
869
870 template <typename LexerType>
871 class Parser {
872     WTF_MAKE_NONCOPYABLE(Parser);
873     WTF_MAKE_FAST_ALLOCATED;
874
875 public:
876     Parser(VM*, RuntimeFlags, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding, ConstructorKind defaultConstructorKind = ConstructorKind::None, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None);
877     ~Parser();
878
879     template <class ParsedNode>
880     std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, SourceParseMode);
881
882     JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }
883     JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }
884
885 private:
886     struct AllowInOverride {
887         AllowInOverride(Parser* parser)
888             : m_parser(parser)
889             , m_oldAllowsIn(parser->m_allowsIn)
890         {
891             parser->m_allowsIn = true;
892         }
893         ~AllowInOverride()
894         {
895             m_parser->m_allowsIn = m_oldAllowsIn;
896         }
897         Parser* m_parser;
898         bool m_oldAllowsIn;
899     };
900
901     struct AutoPopScopeRef : public ScopeRef {
902         AutoPopScopeRef(Parser* parser, ScopeRef scope)
903         : ScopeRef(scope)
904         , m_parser(parser)
905         {
906         }
907         
908         ~AutoPopScopeRef()
909         {
910             if (m_parser)
911                 m_parser->popScope(*this, false);
912         }
913         
914         void setPopped()
915         {
916             m_parser = 0;
917         }
918         
919     private:
920         Parser* m_parser;
921     };
922
923     struct AutoCleanupLexicalScope {
924         // We can allocate this object on the stack without actually knowing beforehand if we're 
925         // going to create a new lexical scope. If we decide to create a new lexical scope, we
926         // can pass the scope into this obejct and it will take care of the cleanup for us if the parse fails.
927         // This is helpful if we may fail from syntax errors after creating a lexical scope conditionally.
928         AutoCleanupLexicalScope()
929             : m_scope(nullptr, UINT_MAX)
930             , m_parser(nullptr)
931         {
932         }
933
934         ~AutoCleanupLexicalScope()
935         {
936             // This should only ever be called if we fail from a syntax error. Otherwise
937             // it's the intention that a user of this class pops this scope manually on a 
938             // successful parse. 
939             if (isValid())
940                 m_parser->popScope(*this, false);
941         }
942
943         void setIsValid(ScopeRef& scope, Parser* parser)
944         {
945             RELEASE_ASSERT(scope->isLexicalScope());
946             m_scope = scope;
947             m_parser = parser;
948         }
949
950         bool isValid() const { return !!m_parser; }
951
952         void setPopped()
953         {
954             m_parser = nullptr;
955         }
956
957         ScopeRef& scope() { return m_scope; }
958
959     private:
960         ScopeRef m_scope;
961         Parser* m_parser;
962     };
963
964     enum ExpressionErrorClass {
965         ErrorIndicatesNothing = 0,
966         ErrorIndicatesPattern,
967         ErrorIndicatesAsyncArrowFunction
968     };
969
970     struct ExpressionErrorClassifier {
971         ExpressionErrorClassifier(Parser* parser)
972             : m_class(ErrorIndicatesNothing)
973             , m_previous(parser->m_expressionErrorClassifier)
974             , m_parser(parser)
975         {
976             m_parser->m_expressionErrorClassifier = this;
977         }
978
979         ~ExpressionErrorClassifier()
980         {
981             m_parser->m_expressionErrorClassifier = m_previous;
982         }
983
984         void classifyExpressionError(ExpressionErrorClass classification)
985         {
986             if (m_class != ErrorIndicatesNothing)
987                 return;
988             m_class = classification;
989         }
990
991         void forceClassifyExpressionError(ExpressionErrorClass classification)
992         {
993             m_class = classification;
994         }
995
996         void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
997         {
998             if (m_class != oldClassification)
999                 return;
1000             m_class = classification;
1001         }
1002
1003         void propagateExpressionErrorClass()
1004         {
1005             if (m_previous)
1006                 m_previous->m_class = m_class;
1007         }
1008
1009         bool indicatesPossiblePattern() const { return m_class == ErrorIndicatesPattern; }
1010         bool indicatesPossibleAsyncArrowFunction() const { return m_class == ErrorIndicatesAsyncArrowFunction; }
1011     private:
1012         ExpressionErrorClass m_class;
1013         ExpressionErrorClassifier* m_previous;
1014         Parser* m_parser;
1015     };
1016
1017     ALWAYS_INLINE void classifyExpressionError(ExpressionErrorClass classification)
1018     {
1019         if (m_expressionErrorClassifier)
1020             m_expressionErrorClassifier->classifyExpressionError(classification);
1021     }
1022
1023     ALWAYS_INLINE void forceClassifyExpressionError(ExpressionErrorClass classification)
1024     {
1025         if (m_expressionErrorClassifier)
1026             m_expressionErrorClassifier->forceClassifyExpressionError(classification);
1027     }
1028
1029     ALWAYS_INLINE void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
1030     {
1031         if (m_expressionErrorClassifier)
1032             m_expressionErrorClassifier->reclassifyExpressionError(oldClassification, classification);
1033     }
1034
1035     ALWAYS_INLINE DestructuringKind destructuringKindFromDeclarationType(DeclarationType type)
1036     {
1037         switch (type) {
1038         case DeclarationType::VarDeclaration:
1039             return DestructuringKind::DestructureToVariables;
1040         case DeclarationType::LetDeclaration:
1041             return DestructuringKind::DestructureToLet;
1042         case DeclarationType::ConstDeclaration:
1043             return DestructuringKind::DestructureToConst;
1044         }
1045
1046         RELEASE_ASSERT_NOT_REACHED();
1047         return DestructuringKind::DestructureToVariables;
1048     }
1049
1050     ALWAYS_INLINE const char* declarationTypeToVariableKind(DeclarationType type)
1051     {
1052         switch (type) {
1053         case DeclarationType::VarDeclaration:
1054             return "variable name";
1055         case DeclarationType::LetDeclaration:
1056         case DeclarationType::ConstDeclaration:
1057             return "lexical variable name";
1058         }
1059         RELEASE_ASSERT_NOT_REACHED();
1060         return "invalid";
1061     }
1062
1063     ALWAYS_INLINE AssignmentContext assignmentContextFromDeclarationType(DeclarationType type)
1064     {
1065         switch (type) {
1066         case DeclarationType::ConstDeclaration:
1067             return AssignmentContext::ConstDeclarationStatement;
1068         default:
1069             return AssignmentContext::DeclarationStatement;
1070         }
1071     }
1072
1073     ALWAYS_INLINE bool isEvalOrArguments(const Identifier* ident) { return isEvalOrArgumentsIdentifier(m_vm, ident); }
1074
1075     ScopeRef currentScope()
1076     {
1077         return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1);
1078     }
1079
1080     ScopeRef currentVariableScope()
1081     {
1082         unsigned i = m_scopeStack.size() - 1;
1083         ASSERT(i < m_scopeStack.size());
1084         while (!m_scopeStack[i].allowsVarDeclarations()) {
1085             i--;
1086             ASSERT(i < m_scopeStack.size());
1087         }
1088         return ScopeRef(&m_scopeStack, i);
1089     }
1090
1091     ScopeRef currentLexicalDeclarationScope()
1092     {
1093         unsigned i = m_scopeStack.size() - 1;
1094         ASSERT(i < m_scopeStack.size());
1095         while (!m_scopeStack[i].allowsLexicalDeclarations()) {
1096             i--;
1097             ASSERT(i < m_scopeStack.size());
1098         }
1099
1100         return ScopeRef(&m_scopeStack, i);
1101     }
1102
1103     ScopeRef currentFunctionScope()
1104     {
1105         unsigned i = m_scopeStack.size() - 1;
1106         ASSERT(i < m_scopeStack.size());
1107         while (i && !m_scopeStack[i].isFunctionBoundary()) {
1108             i--;
1109             ASSERT(i < m_scopeStack.size());
1110         }
1111         // When reaching the top level scope (it can be non function scope), we return it.
1112         return ScopeRef(&m_scopeStack, i);
1113     }
1114
1115     ScopeRef closestParentOrdinaryFunctionNonLexicalScope()
1116     {
1117         unsigned i = m_scopeStack.size() - 1;
1118         ASSERT(i < m_scopeStack.size() && m_scopeStack.size());
1119         while (i && (!m_scopeStack[i].isFunctionBoundary() || m_scopeStack[i].isGeneratorBoundary() || m_scopeStack[i].isArrowFunctionBoundary() || m_scopeStack[i].isAsyncFunctionBoundary()))
1120             i--;
1121         // When reaching the top level scope (it can be non ordinary function scope), we return it.
1122         return ScopeRef(&m_scopeStack, i);
1123     }
1124     
1125     ScopeRef pushScope()
1126     {
1127         bool isFunction = false;
1128         bool isStrict = false;
1129         bool isGenerator = false;
1130         bool isArrowFunction = false;
1131         bool isAsyncFunction = false;
1132         if (!m_scopeStack.isEmpty()) {
1133             isStrict = m_scopeStack.last().strictMode();
1134             isFunction = m_scopeStack.last().isFunction();
1135             isGenerator = m_scopeStack.last().isGenerator();
1136             isArrowFunction = m_scopeStack.last().isArrowFunction();
1137             isAsyncFunction = m_scopeStack.last().isAsyncFunction();
1138         }
1139         m_scopeStack.constructAndAppend(m_vm, isFunction, isGenerator, isStrict, isArrowFunction, isAsyncFunction);
1140         return currentScope();
1141     }
1142
1143     void popScopeInternal(ScopeRef& scope, bool shouldTrackClosedVariables)
1144     {
1145         ASSERT_UNUSED(scope, scope.index() == m_scopeStack.size() - 1);
1146         ASSERT(m_scopeStack.size() > 1);
1147         m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);
1148         
1149         if (m_scopeStack.last().isArrowFunction())
1150             m_scopeStack.last().setInnerArrowFunctionUsesEvalAndUseArgumentsIfNeeded();
1151
1152         if (!(m_scopeStack.last().isFunctionBoundary() && !m_scopeStack.last().isArrowFunctionBoundary()))
1153             m_scopeStack[m_scopeStack.size() - 2].mergeInnerArrowFunctionFeatures(m_scopeStack.last().innerArrowFunctionFeatures());
1154
1155         if (!m_scopeStack.last().isFunctionBoundary() && m_scopeStack.last().needsFullActivation())
1156             m_scopeStack[m_scopeStack.size() - 2].setNeedsFullActivation();
1157         m_scopeStack.removeLast();
1158     }
1159     
1160     ALWAYS_INLINE void popScope(ScopeRef& scope, bool shouldTrackClosedVariables)
1161     {
1162         popScopeInternal(scope, shouldTrackClosedVariables);
1163     }
1164     
1165     ALWAYS_INLINE void popScope(AutoPopScopeRef& scope, bool shouldTrackClosedVariables)
1166     {
1167         scope.setPopped();
1168         popScopeInternal(scope, shouldTrackClosedVariables);
1169     }
1170
1171     ALWAYS_INLINE void popScope(AutoCleanupLexicalScope& cleanupScope, bool shouldTrackClosedVariables)
1172     {
1173         RELEASE_ASSERT(cleanupScope.isValid());
1174         ScopeRef& scope = cleanupScope.scope();
1175         cleanupScope.setPopped();
1176         popScopeInternal(scope, shouldTrackClosedVariables);
1177     }
1178     
1179     DeclarationResultMask declareVariable(const Identifier* ident, DeclarationType type = DeclarationType::VarDeclaration, DeclarationImportType importType = DeclarationImportType::NotImported)
1180     {
1181         if (type == DeclarationType::VarDeclaration)
1182             return currentVariableScope()->declareVariable(ident);
1183
1184         ASSERT(type == DeclarationType::LetDeclaration || type == DeclarationType::ConstDeclaration);
1185         // Lexical variables declared at a top level scope that shadow arguments or vars are not allowed.
1186         if (m_statementDepth == 1 && (hasDeclaredParameter(*ident) || hasDeclaredVariable(*ident)))
1187             return DeclarationResult::InvalidDuplicateDeclaration;
1188
1189         return currentLexicalDeclarationScope()->declareLexicalVariable(ident, type == DeclarationType::ConstDeclaration, importType);
1190     }
1191
1192     std::pair<DeclarationResultMask, ScopeRef> declareFunction(const Identifier* ident)
1193     {
1194         if (m_statementDepth == 1 || (!strictMode() && !currentScope()->isFunction())) {
1195             // Functions declared at the top-most scope (both in sloppy and strict mode) are declared as vars
1196             // for backwards compatibility. This allows us to declare functions with the same name more than once.
1197             // In sloppy mode, we always declare functions as vars.
1198             bool declareAsVar = true;
1199             bool isSloppyModeHoistingCandidate = false;
1200             ScopeRef variableScope = currentVariableScope();
1201             return std::make_pair(variableScope->declareFunction(ident, declareAsVar, isSloppyModeHoistingCandidate), variableScope);
1202         }
1203
1204         if (!strictMode()) {
1205             ASSERT(currentScope()->isFunction());
1206
1207             // Functions declared inside a function inside a nested block scope in sloppy mode are subject to this
1208             // crazy rule defined inside Annex B.3.3 in the ES6 spec. It basically states that we will create
1209             // the function as a local block scoped variable, but when we evaluate the block that the function is
1210             // contained in, we will assign the function to a "var" variable only if declaring such a "var" wouldn't
1211             // be a syntax error and if there isn't a parameter with the same name. (It would only be a syntax error if
1212             // there are is a let/class/const with the same name). Note that this mean we only do the "var" hoisting 
1213             // binding if the block evaluates. For example, this means we wont won't perform the binding if it's inside
1214             // the untaken branch of an if statement.
1215             bool declareAsVar = false;
1216             bool isSloppyModeHoistingCandidate = true;
1217             ScopeRef lexicalVariableScope = currentLexicalDeclarationScope();
1218             ScopeRef varScope = currentVariableScope();
1219             varScope->addSloppyModeHoistableFunctionCandidate(ident);
1220             ASSERT(varScope != lexicalVariableScope);
1221             return std::make_pair(lexicalVariableScope->declareFunction(ident, declareAsVar, isSloppyModeHoistingCandidate), lexicalVariableScope);
1222         }
1223
1224         bool declareAsVar = false;
1225         bool isSloppyModeHoistingCandidate = false;
1226         ScopeRef lexicalVariableScope = currentLexicalDeclarationScope();
1227         return std::make_pair(lexicalVariableScope->declareFunction(ident, declareAsVar, isSloppyModeHoistingCandidate), lexicalVariableScope);
1228     }
1229
1230     NEVER_INLINE bool hasDeclaredVariable(const Identifier& ident)
1231     {
1232         unsigned i = m_scopeStack.size() - 1;
1233         ASSERT(i < m_scopeStack.size());
1234         while (!m_scopeStack[i].allowsVarDeclarations()) {
1235             i--;
1236             ASSERT(i < m_scopeStack.size());
1237         }
1238         return m_scopeStack[i].hasDeclaredVariable(ident);
1239     }
1240
1241     NEVER_INLINE bool hasDeclaredParameter(const Identifier& ident)
1242     {
1243         unsigned i = m_scopeStack.size() - 1;
1244         ASSERT(i < m_scopeStack.size());
1245         while (!m_scopeStack[i].allowsVarDeclarations()) {
1246             i--;
1247             ASSERT(i < m_scopeStack.size());
1248         }
1249         return m_scopeStack[i].hasDeclaredParameter(ident);
1250     }
1251     
1252     bool exportName(const Identifier& ident)
1253     {
1254         ASSERT(currentScope().index() == 0);
1255         return currentScope()->moduleScopeData().exportName(ident);
1256     }
1257
1258     ScopeStack m_scopeStack;
1259     
1260     const SourceProviderCacheItem* findCachedFunctionInfo(int openBracePos) 
1261     {
1262         return m_functionCache ? m_functionCache->get(openBracePos) : 0;
1263     }
1264
1265     Parser();
1266     String parseInner(const Identifier&, SourceParseMode);
1267
1268     void didFinishParsing(SourceElements*, DeclarationStacks::FunctionStack&&, VariableEnvironment&, UniquedStringImplPtrSet&&, CodeFeatures, int);
1269
1270     // Used to determine type of error to report.
1271     bool isFunctionMetadataNode(ScopeNode*) { return false; }
1272     bool isFunctionMetadataNode(FunctionMetadataNode*) { return true; }
1273
1274     ALWAYS_INLINE void next(unsigned lexerFlags = 0)
1275     {
1276         int lastLine = m_token.m_location.line;
1277         int lastTokenEnd = m_token.m_location.endOffset;
1278         int lastTokenLineStart = m_token.m_location.lineStartOffset;
1279         m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
1280         m_lexer->setLastLineNumber(lastLine);
1281         m_token.m_type = m_lexer->lex(&m_token, lexerFlags, strictMode());
1282     }
1283
1284     ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)
1285     {
1286         int lastLine = m_token.m_location.line;
1287         int lastTokenEnd = m_token.m_location.endOffset;
1288         int lastTokenLineStart = m_token.m_location.lineStartOffset;
1289         m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
1290         m_lexer->setLastLineNumber(lastLine);
1291         m_token.m_type = m_lexer->lexExpectIdentifier(&m_token, lexerFlags, strictMode());
1292     }
1293
1294     ALWAYS_INLINE bool nextTokenIsColon()
1295     {
1296         return m_lexer->nextTokenIsColon();
1297     }
1298
1299     ALWAYS_INLINE bool consume(JSTokenType expected, unsigned flags = 0)
1300     {
1301         bool result = m_token.m_type == expected;
1302         if (result)
1303             next(flags);
1304         return result;
1305     }
1306
1307     void printUnexpectedTokenText(WTF::PrintStream&);
1308     ALWAYS_INLINE StringView getToken() {
1309         SourceProvider* sourceProvider = m_source->provider();
1310         return sourceProvider->getRange(tokenStart(), tokenEndPosition().offset);
1311     }
1312     
1313     ALWAYS_INLINE bool match(JSTokenType expected)
1314     {
1315         return m_token.m_type == expected;
1316     }
1317     
1318     ALWAYS_INLINE bool matchContextualKeyword(const Identifier& identifier)
1319     {
1320         return m_token.m_type == IDENT && *m_token.m_data.ident == identifier;
1321     }
1322
1323     ALWAYS_INLINE bool matchIdentifierOrKeyword()
1324     {
1325         return isIdentifierOrKeyword(m_token);
1326     }
1327     
1328     ALWAYS_INLINE unsigned tokenStart()
1329     {
1330         return m_token.m_location.startOffset;
1331     }
1332     
1333     ALWAYS_INLINE const JSTextPosition& tokenStartPosition()
1334     {
1335         return m_token.m_startPosition;
1336     }
1337
1338     ALWAYS_INLINE int tokenLine()
1339     {
1340         return m_token.m_location.line;
1341     }
1342     
1343     ALWAYS_INLINE int tokenColumn()
1344     {
1345         return tokenStart() - tokenLineStart();
1346     }
1347
1348     ALWAYS_INLINE const JSTextPosition& tokenEndPosition()
1349     {
1350         return m_token.m_endPosition;
1351     }
1352     
1353     ALWAYS_INLINE unsigned tokenLineStart()
1354     {
1355         return m_token.m_location.lineStartOffset;
1356     }
1357     
1358     ALWAYS_INLINE const JSTokenLocation& tokenLocation()
1359     {
1360         return m_token.m_location;
1361     }
1362
1363     void setErrorMessage(const String& message)
1364     {
1365         m_errorMessage = message;
1366     }
1367     
1368     NEVER_INLINE void logError(bool);
1369     template <typename A> NEVER_INLINE void logError(bool, const A&);
1370     template <typename A, typename B> NEVER_INLINE void logError(bool, const A&, const B&);
1371     template <typename A, typename B, typename C> NEVER_INLINE void logError(bool, const A&, const B&, const C&);
1372     template <typename A, typename B, typename C, typename D> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&);
1373     template <typename A, typename B, typename C, typename D, typename E> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&);
1374     template <typename A, typename B, typename C, typename D, typename E, typename F> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&);
1375     template <typename A, typename B, typename C, typename D, typename E, typename F, typename G> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&, const G&);
1376     
1377     NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMessage, const String& name, const char* afterMessage)
1378     {
1379         m_errorMessage = makeString(beforeMessage, " '", name, "' ", afterMessage);
1380     }
1381     
1382     NEVER_INLINE void updateErrorMessage(const char* msg)
1383     {
1384         ASSERT(msg);
1385         m_errorMessage = String(msg);
1386         ASSERT(!m_errorMessage.isNull());
1387     }
1388     
1389     void startLoop() { currentScope()->startLoop(); }
1390     void endLoop() { currentScope()->endLoop(); }
1391     void startSwitch() { currentScope()->startSwitch(); }
1392     void endSwitch() { currentScope()->endSwitch(); }
1393     void setStrictMode() { currentScope()->setStrictMode(); }
1394     bool strictMode() { return currentScope()->strictMode(); }
1395     bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
1396     DeclarationResultMask declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
1397     bool declareRestOrNormalParameter(const Identifier&, const Identifier**);
1398
1399     bool breakIsValid()
1400     {
1401         ScopeRef current = currentScope();
1402         while (!current->breakIsValid()) {
1403             if (!current.hasContainingScope())
1404                 return false;
1405             current = current.containingScope();
1406         }
1407         return true;
1408     }
1409     bool continueIsValid()
1410     {
1411         ScopeRef current = currentScope();
1412         while (!current->continueIsValid()) {
1413             if (!current.hasContainingScope())
1414                 return false;
1415             current = current.containingScope();
1416         }
1417         return true;
1418     }
1419     void pushLabel(const Identifier* label, bool isLoop) { currentScope()->pushLabel(label, isLoop); }
1420     void popLabel(ScopeRef scope) { scope->popLabel(); }
1421     ScopeLabelInfo* getLabel(const Identifier* label)
1422     {
1423         ScopeRef current = currentScope();
1424         ScopeLabelInfo* result = 0;
1425         while (!(result = current->getLabel(label))) {
1426             if (!current.hasContainingScope())
1427                 return 0;
1428             current = current.containingScope();
1429         }
1430         return result;
1431     }
1432
1433     // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
1434     ALWAYS_INLINE bool isLETMaskedAsIDENT()
1435     {
1436         return match(LET) && !strictMode();
1437     }
1438
1439     // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
1440     ALWAYS_INLINE bool isYIELDMaskedAsIDENT(bool inGenerator)
1441     {
1442         return match(YIELD) && !strictMode() && !inGenerator;
1443     }
1444
1445     // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
1446     ALWAYS_INLINE bool matchSpecIdentifier(bool inGenerator)
1447     {
1448         return match(IDENT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator) || match(AWAIT);
1449     }
1450
1451     ALWAYS_INLINE bool matchSpecIdentifier()
1452     {
1453         return matchSpecIdentifier(currentScope()->isGenerator());
1454     }
1455
1456     template <class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&, SourceElementsMode);
1457     template <class TreeBuilder> TreeSourceElements parseGeneratorFunctionSourceElements(TreeBuilder&, SourceElementsMode);
1458     template <class TreeBuilder> TreeSourceElements parseAsyncFunctionSourceElements(TreeBuilder&, SourceParseMode, bool isArrowFunctionBodyExpression, SourceElementsMode);
1459     template <class TreeBuilder> TreeStatement parseStatementListItem(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength);
1460     template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength = 0);
1461     enum class ExportType { Exported, NotExported };
1462     template <class TreeBuilder> TreeStatement parseClassDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
1463     template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
1464     template <class TreeBuilder> TreeStatement parseFunctionDeclarationStatement(TreeBuilder&, bool isAsync, bool parentAllowsFunctionDeclarationAsStatement);
1465     template <class TreeBuilder> TreeStatement parseAsyncFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
1466     template <class TreeBuilder> TreeStatement parseVariableDeclaration(TreeBuilder&, DeclarationType, ExportType = ExportType::NotExported);
1467     template <class TreeBuilder> TreeStatement parseDoWhileStatement(TreeBuilder&);
1468     template <class TreeBuilder> TreeStatement parseWhileStatement(TreeBuilder&);
1469     template <class TreeBuilder> TreeStatement parseForStatement(TreeBuilder&);
1470     template <class TreeBuilder> TreeStatement parseBreakStatement(TreeBuilder&);
1471     template <class TreeBuilder> TreeStatement parseContinueStatement(TreeBuilder&);
1472     template <class TreeBuilder> TreeStatement parseReturnStatement(TreeBuilder&);
1473     template <class TreeBuilder> TreeStatement parseThrowStatement(TreeBuilder&);
1474     template <class TreeBuilder> TreeStatement parseWithStatement(TreeBuilder&);
1475     template <class TreeBuilder> TreeStatement parseSwitchStatement(TreeBuilder&);
1476     template <class TreeBuilder> TreeClauseList parseSwitchClauses(TreeBuilder&);
1477     template <class TreeBuilder> TreeClause parseSwitchDefaultClause(TreeBuilder&);
1478     template <class TreeBuilder> TreeStatement parseTryStatement(TreeBuilder&);
1479     template <class TreeBuilder> TreeStatement parseDebuggerStatement(TreeBuilder&);
1480     template <class TreeBuilder> TreeStatement parseExpressionStatement(TreeBuilder&);
1481     template <class TreeBuilder> TreeStatement parseExpressionOrLabelStatement(TreeBuilder&, bool allowFunctionDeclarationAsStatement);
1482     template <class TreeBuilder> TreeStatement parseIfStatement(TreeBuilder&);
1483     template <class TreeBuilder> TreeStatement parseBlockStatement(TreeBuilder&);
1484     template <class TreeBuilder> TreeExpression parseExpression(TreeBuilder&);
1485     template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&, ExpressionErrorClassifier&);
1486     template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&);
1487     template <class TreeBuilder> TreeExpression parseAssignmentExpressionOrPropagateErrorClass(TreeBuilder&);
1488     template <class TreeBuilder> TreeExpression parseYieldExpression(TreeBuilder&);
1489     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseConditionalExpression(TreeBuilder&);
1490     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseBinaryExpression(TreeBuilder&);
1491     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseUnaryExpression(TreeBuilder&);
1492     template <class TreeBuilder> NEVER_INLINE TreeExpression parseAwaitExpression(TreeBuilder&);
1493     template <class TreeBuilder> TreeExpression parseMemberExpression(TreeBuilder&);
1494     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parsePrimaryExpression(TreeBuilder&);
1495     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArrayLiteral(TreeBuilder&);
1496     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseObjectLiteral(TreeBuilder&);
1497     template <class TreeBuilder> NEVER_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
1498     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseFunctionExpression(TreeBuilder&);
1499     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseAsyncFunctionExpression(TreeBuilder&);
1500     template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&);
1501     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArgument(TreeBuilder&, ArgumentType&);
1502     template <class TreeBuilder> TreeProperty parseProperty(TreeBuilder&, bool strict);
1503     template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator, bool isAsyncMethod);
1504     template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind, bool isClassProperty);
1505     template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, SyntaxChecker&, const JSTokenLocation&, int, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, SuperBinding, FunctionBodyType, unsigned, SourceParseMode);
1506     template <class TreeBuilder> ALWAYS_INLINE bool parseFormalParameters(TreeBuilder&, TreeFormalParameterList, unsigned&);
1507     enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };
1508     template <class TreeBuilder> TreeExpression parseVariableDeclarationList(TreeBuilder&, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext, DeclarationType, ExportType, bool& forLoopConstDoesNotHaveInitializer);
1509     template <class TreeBuilder> TreeSourceElements parseArrowFunctionSingleExpressionBodySourceElements(TreeBuilder&);
1510     template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&, bool isAsync);
1511     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createBindingPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier&, JSToken, AssignmentContext, const Identifier** duplicateIdentifier);
1512     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createAssignmentElement(TreeBuilder&, TreeExpression&, const JSTextPosition&, const JSTextPosition&);
1513     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseBindingOrAssignmentElement(TreeBuilder& context, DestructuringKind, ExportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth);
1514     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseAssignmentElement(TreeBuilder& context, DestructuringKind, ExportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth);
1515     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseDestructuringPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier** duplicateIdentifier = nullptr, bool* hasDestructuringPattern = nullptr, AssignmentContext = AssignmentContext::DeclarationStatement, int depth = 0);
1516     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern tryParseDestructuringPatternExpression(TreeBuilder&, AssignmentContext);
1517     template <class TreeBuilder> NEVER_INLINE TreeExpression parseDefaultValueForDestructuringPattern(TreeBuilder&);
1518     template <class TreeBuilder> TreeSourceElements parseModuleSourceElements(TreeBuilder&, SourceParseMode);
1519     enum class ImportSpecifierType { NamespaceImport, NamedImport, DefaultImport };
1520     template <class TreeBuilder> typename TreeBuilder::ImportSpecifier parseImportClauseItem(TreeBuilder&, ImportSpecifierType);
1521     template <class TreeBuilder> typename TreeBuilder::ModuleName parseModuleName(TreeBuilder&);
1522     template <class TreeBuilder> TreeStatement parseImportDeclaration(TreeBuilder&);
1523     template <class TreeBuilder> typename TreeBuilder::ExportSpecifier parseExportSpecifier(TreeBuilder& context, Vector<const Identifier*>& maybeLocalNames, bool& hasKeywordForLocalBindings);
1524     template <class TreeBuilder> TreeStatement parseExportDeclaration(TreeBuilder&);
1525
1526     enum class FunctionDefinitionType { Expression, Declaration, Method };
1527     template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, SourceParseMode, bool nameIsInContainingScope, ConstructorKind, SuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>&, FunctionDefinitionType);
1528     
1529     ALWAYS_INLINE bool isArrowFunctionParameters();
1530     
1531     template <class TreeBuilder, class FunctionInfoType> NEVER_INLINE typename TreeBuilder::FormalParameterList parseFunctionParameters(TreeBuilder&, SourceParseMode, FunctionInfoType&);
1532     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::FormalParameterList createGeneratorParameters(TreeBuilder&);
1533
1534     template <class TreeBuilder> NEVER_INLINE TreeClassExpression parseClass(TreeBuilder&, FunctionRequirements, ParserClassInfo<TreeBuilder>&);
1535
1536     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateString parseTemplateString(TreeBuilder& context, bool isTemplateHead, typename LexerType::RawStringsBuildMode, bool& elementIsTail);
1537     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateLiteral parseTemplateLiteral(TreeBuilder&, typename LexerType::RawStringsBuildMode);
1538
1539     template <class TreeBuilder> ALWAYS_INLINE bool shouldCheckPropertyForUnderscoreProtoDuplicate(TreeBuilder&, const TreeProperty&);
1540
1541     ALWAYS_INLINE int isBinaryOperator(JSTokenType);
1542     bool allowAutomaticSemicolon();
1543     
1544     bool autoSemiColon()
1545     {
1546         if (m_token.m_type == SEMICOLON) {
1547             next();
1548             return true;
1549         }
1550         return allowAutomaticSemicolon();
1551     }
1552     
1553     bool canRecurse()
1554     {
1555         return m_vm->isSafeToRecurse();
1556     }
1557     
1558     const JSTextPosition& lastTokenEndPosition() const
1559     {
1560         return m_lastTokenEndPosition;
1561     }
1562
1563     bool hasError() const
1564     {
1565         return !m_errorMessage.isNull();
1566     }
1567
1568     bool isDisallowedIdentifierAwait(const JSToken& token)
1569     {
1570         return token.m_type == AWAIT && (currentScope()->isAsyncFunctionBoundary() || currentScope()->isModule() || !m_parserState.allowAwait);
1571     }
1572
1573     const char* disallowedIdentifierAwaitReason()
1574     {
1575         if (!m_parserState.allowAwait || currentScope()->isAsyncFunctionBoundary())
1576             return "in an async function";
1577         if (currentScope()->isModule())
1578             return "in a module";
1579         RELEASE_ASSERT_NOT_REACHED();
1580         return nullptr;
1581     }
1582
1583     enum class FunctionParsePhase { Parameters, Body };
1584     struct ParserState {
1585         int assignmentCount { 0 };
1586         int nonLHSCount { 0 };
1587         int nonTrivialExpressionCount { 0 };
1588         FunctionParsePhase functionParsePhase { FunctionParsePhase::Body };
1589         const Identifier* lastIdentifier { nullptr };
1590         const Identifier* lastFunctionName { nullptr };
1591         bool allowAwait { true };
1592     };
1593
1594     // If you're using this directly, you probably should be using
1595     // createSavePoint() instead.
1596     ALWAYS_INLINE ParserState internalSaveParserState()
1597     {
1598         return m_parserState;
1599     }
1600
1601     ALWAYS_INLINE void restoreParserState(const ParserState& state)
1602     {
1603         m_parserState = state;
1604     }
1605
1606     struct LexerState {
1607         int startOffset;
1608         unsigned oldLineStartOffset;
1609         unsigned oldLastLineNumber;
1610         unsigned oldLineNumber;
1611     };
1612
1613     // If you're using this directly, you probably should be using
1614     // createSavePoint() instead.
1615     // i.e, if you parse any kind of AssignmentExpression between
1616     // saving/restoring, you should definitely not be using this directly.
1617     ALWAYS_INLINE LexerState internalSaveLexerState()
1618     {
1619         LexerState result;
1620         result.startOffset = m_token.m_location.startOffset;
1621         result.oldLineStartOffset = m_token.m_location.lineStartOffset;
1622         result.oldLastLineNumber = m_lexer->lastLineNumber();
1623         result.oldLineNumber = m_lexer->lineNumber();
1624         return result;
1625     }
1626
1627     ALWAYS_INLINE void restoreLexerState(const LexerState& lexerState)
1628     {
1629         // setOffset clears lexer errors.
1630         m_lexer->setOffset(lexerState.startOffset, lexerState.oldLineStartOffset);
1631         next();
1632         m_lexer->setLastLineNumber(lexerState.oldLastLineNumber);
1633         m_lexer->setLineNumber(lexerState.oldLineNumber);
1634     }
1635
1636     struct SavePoint {
1637         ParserState parserState;
1638         LexerState lexerState;
1639     };
1640
1641     struct SavePointWithError : public SavePoint {
1642         bool lexerError;
1643         String lexerErrorMessage;
1644         String parserErrorMessage;
1645     };
1646
1647     ALWAYS_INLINE void internalSaveState(SavePoint& savePoint)
1648     {
1649         savePoint.parserState = internalSaveParserState();
1650         savePoint.lexerState = internalSaveLexerState();
1651     }
1652     
1653     ALWAYS_INLINE SavePointWithError createSavePointForError()
1654     {
1655         SavePointWithError savePoint;
1656         internalSaveState(savePoint);
1657         savePoint.lexerError = m_lexer->sawError();
1658         savePoint.lexerErrorMessage = m_lexer->getErrorMessage();
1659         savePoint.parserErrorMessage = m_errorMessage;
1660         return savePoint;
1661     }
1662     
1663     ALWAYS_INLINE SavePoint createSavePoint()
1664     {
1665         ASSERT(!hasError());
1666         SavePoint savePoint;
1667         internalSaveState(savePoint);
1668         return savePoint;
1669     }
1670
1671     ALWAYS_INLINE void internalRestoreState(const SavePoint& savePoint)
1672     {
1673         restoreLexerState(savePoint.lexerState);
1674         restoreParserState(savePoint.parserState);
1675     }
1676
1677     ALWAYS_INLINE void restoreSavePointWithError(const SavePointWithError& savePoint)
1678     {
1679         internalRestoreState(savePoint);
1680         m_lexer->setSawError(savePoint.lexerError);
1681         m_lexer->setErrorMessage(savePoint.lexerErrorMessage);
1682         m_errorMessage = savePoint.parserErrorMessage;
1683     }
1684
1685     ALWAYS_INLINE void restoreSavePoint(const SavePoint& savePoint)
1686     {
1687         internalRestoreState(savePoint);
1688         m_errorMessage = String();
1689     }
1690
1691     VM* m_vm;
1692     const SourceCode* m_source;
1693     ParserArena m_parserArena;
1694     std::unique_ptr<LexerType> m_lexer;
1695     FunctionParameters* m_parameters { nullptr };
1696
1697     ParserState m_parserState;
1698     
1699     bool m_hasStackOverflow;
1700     String m_errorMessage;
1701     JSToken m_token;
1702     RuntimeFlags m_runtimeFlags;
1703     bool m_allowsIn;
1704     JSTextPosition m_lastTokenEndPosition;
1705     bool m_syntaxAlreadyValidated;
1706     int m_statementDepth;
1707     RefPtr<SourceProviderCache> m_functionCache;
1708     SourceElements* m_sourceElements;
1709     bool m_parsingBuiltin;
1710     SuperBinding m_superBinding;
1711     ConstructorKind m_defaultConstructorKind;
1712     VariableEnvironment m_varDeclarations;
1713     DeclarationStacks::FunctionStack m_funcDeclarations;
1714     UniquedStringImplPtrSet m_sloppyModeHoistedFunctions;
1715     CodeFeatures m_features;
1716     int m_numConstants;
1717     ExpressionErrorClassifier* m_expressionErrorClassifier;
1718     bool m_isEvalContext;
1719     bool m_immediateParentAllowsFunctionDeclarationInStatement;
1720     
1721     struct DepthManager {
1722         DepthManager(int* depth)
1723         : m_originalDepth(*depth)
1724         , m_depth(depth)
1725         {
1726         }
1727         
1728         ~DepthManager()
1729         {
1730             *m_depth = m_originalDepth;
1731         }
1732         
1733     private:
1734         int m_originalDepth;
1735         int* m_depth;
1736     };
1737 };
1738
1739
1740 template <typename LexerType>
1741 template <class ParsedNode>
1742 std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode)
1743 {
1744     int errLine;
1745     String errMsg;
1746
1747     if (ParsedNode::scopeIsFunction)
1748         m_lexer->setIsReparsingFunction();
1749
1750     m_sourceElements = 0;
1751
1752     errLine = -1;
1753     errMsg = String();
1754
1755     JSTokenLocation startLocation(tokenLocation());
1756     ASSERT(m_source->startColumn() > 0);
1757     unsigned startColumn = m_source->startColumn() - 1;
1758
1759     String parseError = parseInner(calleeName, parseMode);
1760
1761     int lineNumber = m_lexer->lineNumber();
1762     bool lexError = m_lexer->sawError();
1763     String lexErrorMessage = lexError ? m_lexer->getErrorMessage() : String();
1764     ASSERT(lexErrorMessage.isNull() != lexError);
1765     m_lexer->clear();
1766
1767     if (!parseError.isNull() || lexError) {
1768         errLine = lineNumber;
1769         errMsg = !lexErrorMessage.isNull() ? lexErrorMessage : parseError;
1770         m_sourceElements = 0;
1771     }
1772
1773     std::unique_ptr<ParsedNode> result;
1774     if (m_sourceElements) {
1775         JSTokenLocation endLocation;
1776         endLocation.line = m_lexer->lineNumber();
1777         endLocation.lineStartOffset = m_lexer->currentLineStartOffset();
1778         endLocation.startOffset = m_lexer->currentOffset();
1779         unsigned endColumn = endLocation.startOffset - endLocation.lineStartOffset;
1780         result = std::make_unique<ParsedNode>(m_parserArena,
1781                                     startLocation,
1782                                     endLocation,
1783                                     startColumn,
1784                                     endColumn,
1785                                     m_sourceElements,
1786                                     m_varDeclarations,
1787                                     WTFMove(m_funcDeclarations),
1788                                     currentScope()->finalizeLexicalEnvironment(),
1789                                     WTFMove(m_sloppyModeHoistedFunctions),
1790                                     m_parameters,
1791                                     *m_source,
1792                                     m_features,
1793                                     currentScope()->innerArrowFunctionFeatures(),
1794                                     m_numConstants);
1795         result->setLoc(m_source->firstLine(), m_lexer->lineNumber(), m_lexer->currentOffset(), m_lexer->currentLineStartOffset());
1796         result->setEndOffset(m_lexer->currentOffset());
1797
1798         if (!isFunctionParseMode(parseMode)) {
1799             m_source->provider()->setSourceURLDirective(m_lexer->sourceURL());
1800             m_source->provider()->setSourceMappingURLDirective(m_lexer->sourceMappingURL());
1801         }
1802     } else {
1803         // We can never see a syntax error when reparsing a function, since we should have
1804         // reported the error when parsing the containing program or eval code. So if we're
1805         // parsing a function body node, we assume that what actually happened here is that
1806         // we ran out of stack while parsing. If we see an error while parsing eval or program
1807         // code we assume that it was a syntax error since running out of stack is much less
1808         // likely, and we are currently unable to distinguish between the two cases.
1809         if (isFunctionMetadataNode(static_cast<ParsedNode*>(0)) || m_hasStackOverflow)
1810             error = ParserError(ParserError::StackOverflow, ParserError::SyntaxErrorNone, m_token);
1811         else {
1812             ParserError::SyntaxErrorType errorType = ParserError::SyntaxErrorIrrecoverable;
1813             if (m_token.m_type == EOFTOK)
1814                 errorType = ParserError::SyntaxErrorRecoverable;
1815             else if (m_token.m_type & UnterminatedErrorTokenFlag) {
1816                 // Treat multiline capable unterminated literals as recoverable.
1817                 if (m_token.m_type == UNTERMINATED_MULTILINE_COMMENT_ERRORTOK || m_token.m_type == UNTERMINATED_TEMPLATE_LITERAL_ERRORTOK)
1818                     errorType = ParserError::SyntaxErrorRecoverable;
1819                 else
1820                     errorType = ParserError::SyntaxErrorUnterminatedLiteral;
1821             }
1822             
1823             if (isEvalNode<ParsedNode>())
1824                 error = ParserError(ParserError::EvalError, errorType, m_token, errMsg, errLine);
1825             else
1826                 error = ParserError(ParserError::SyntaxError, errorType, m_token, errMsg, errLine);
1827         }
1828     }
1829
1830     return result;
1831 }
1832
1833 template <class ParsedNode>
1834 std::unique_ptr<ParsedNode> parse(
1835     VM* vm, RuntimeFlags runtimeFlags, const SourceCode& source,
1836     const Identifier& name, JSParserBuiltinMode builtinMode,
1837     JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding,
1838     ParserError& error, JSTextPosition* positionBeforeLastNewline = nullptr,
1839     ConstructorKind defaultConstructorKind = ConstructorKind::None, DerivedContextType derivedContextType = DerivedContextType::None, EvalContextType evalContextType = EvalContextType::None)
1840 {
1841     ASSERT(!source.provider()->source().isNull());
1842     if (source.provider()->source().is8Bit()) {
1843         Parser<Lexer<LChar>> parser(vm, runtimeFlags, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
1844         std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
1845         if (positionBeforeLastNewline)
1846             *positionBeforeLastNewline = parser.positionBeforeLastNewline();
1847         if (builtinMode == JSParserBuiltinMode::Builtin) {
1848             if (!result)
1849                 WTF::dataLog("Error compiling builtin: ", error.message(), "\n");
1850         }
1851         return result;
1852     }
1853     ASSERT_WITH_MESSAGE(defaultConstructorKind == ConstructorKind::None, "BuiltinExecutables::createDefaultConstructor should always use a 8-bit string");
1854     Parser<Lexer<UChar>> parser(vm, runtimeFlags, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
1855     std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
1856     if (positionBeforeLastNewline)
1857         *positionBeforeLastNewline = parser.positionBeforeLastNewline();
1858     return result;
1859 }
1860
1861 } // namespace
1862 #endif