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