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