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