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