[ES6] Support Generator Syntax
[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 "SourceProvider.h"
37 #include "SourceProviderCache.h"
38 #include "SourceProviderCacheItem.h"
39 #include "VariableEnvironment.h"
40 #include <wtf/Forward.h>
41 #include <wtf/Noncopyable.h>
42 #include <wtf/RefPtr.h>
43 namespace JSC {
44 struct Scope;
45 }
46
47 namespace WTF {
48 template <> struct VectorTraits<JSC::Scope> : SimpleClassVectorTraits {
49     static const bool canInitializeWithMemset = false; // Not all Scope data members initialize to 0.
50 };
51 }
52
53 namespace JSC {
54
55 class ExecState;
56 class FunctionMetadataNode;
57 class FunctionParameters;
58 class Identifier;
59 class VM;
60 class ProgramNode;
61 class SourceCode;
62
63 // Macros to make the more common TreeBuilder types a little less verbose
64 #define TreeStatement typename TreeBuilder::Statement
65 #define TreeExpression typename TreeBuilder::Expression
66 #define TreeFormalParameterList typename TreeBuilder::FormalParameterList
67 #define TreeSourceElements typename TreeBuilder::SourceElements
68 #define TreeClause typename TreeBuilder::Clause
69 #define TreeClauseList typename TreeBuilder::ClauseList
70 #define TreeArguments typename TreeBuilder::Arguments
71 #define TreeArgumentsList typename TreeBuilder::ArgumentsList
72 #define TreeFunctionBody typename TreeBuilder::FunctionBody
73 #if ENABLE(ES6_CLASS_SYNTAX)
74 #define TreeClassExpression typename TreeBuilder::ClassExpression
75 #endif
76 #define TreeProperty typename TreeBuilder::Property
77 #define TreePropertyList typename TreeBuilder::PropertyList
78 #define TreeDestructuringPattern typename TreeBuilder::DestructuringPattern
79
80 COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);
81
82 enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };
83 enum FunctionBodyType { ArrowFunctionBodyExpression, ArrowFunctionBodyBlock, StandardFunctionBodyBlock };
84 enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };
85
86 enum DestructuringKind {
87     DestructureToVariables,
88     DestructureToLet,
89     DestructureToConst,
90     DestructureToParameters,
91     DestructureToExpressions
92 };
93
94 enum class DeclarationType { 
95     VarDeclaration, 
96     LetDeclaration,
97     ConstDeclaration
98 };
99
100 enum class DeclarationImportType {
101     Imported,
102     ImportedNamespace,
103     NotImported
104 };
105
106 enum DeclarationResult {
107     Valid = 0,
108     InvalidStrictMode = 1 << 0,
109     InvalidDuplicateDeclaration = 1 << 1
110 };
111
112 typedef uint8_t DeclarationResultMask;
113
114
115 template <typename T> inline bool isEvalNode() { return false; }
116 template <> inline bool isEvalNode<EvalNode>() { return true; }
117
118 struct ScopeLabelInfo {
119     UniquedStringImpl* uid;
120     bool isLoop;
121 };
122
123 ALWAYS_INLINE static bool isArguments(const VM* vm, const Identifier* ident)
124 {
125     return vm->propertyNames->arguments == *ident;
126 }
127 ALWAYS_INLINE static bool isEval(const VM* vm, const Identifier* ident)
128 {
129     return vm->propertyNames->eval == *ident;
130 }
131 ALWAYS_INLINE static bool isEvalOrArgumentsIdentifier(const VM* vm, const Identifier* ident)
132 {
133     return isEval(vm, ident) || isArguments(vm, ident);
134 }
135 ALWAYS_INLINE static bool isIdentifierOrKeyword(const JSToken& token)
136 {
137     return token.m_type == IDENT || token.m_type & KeywordTokenFlag;
138 }
139
140 class ModuleScopeData : public RefCounted<ModuleScopeData> {
141 public:
142     static Ref<ModuleScopeData> create() { return adoptRef(*new ModuleScopeData); }
143
144     const IdentifierSet& exportedBindings() const { return m_exportedBindings; }
145
146     bool exportName(const Identifier& exportedName)
147     {
148         return m_exportedNames.add(exportedName.impl()).isNewEntry;
149     }
150
151     void exportBinding(const Identifier& localName)
152     {
153         m_exportedBindings.add(localName.impl());
154     }
155
156 private:
157     IdentifierSet m_exportedNames { };
158     IdentifierSet m_exportedBindings { };
159 };
160
161 struct Scope {
162     Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode)
163         : m_vm(vm)
164         , m_shadowsArguments(false)
165         , m_usesEval(false)
166         , m_needsFullActivation(false)
167         , m_hasDirectSuper(false)
168         , m_needsSuperBinding(false)
169         , m_allowsVarDeclarations(true)
170         , m_allowsLexicalDeclarations(true)
171         , m_strictMode(strictMode)
172         , m_isFunction(isFunction)
173         , m_isGenerator(isGenerator)
174         , m_isLexicalScope(false)
175         , m_isFunctionBoundary(false)
176         , m_isValidStrictMode(true)
177         , m_loopDepth(0)
178         , m_switchDepth(0)
179     {
180     }
181
182     Scope(const Scope& rhs)
183         : m_vm(rhs.m_vm)
184         , m_shadowsArguments(rhs.m_shadowsArguments)
185         , m_usesEval(rhs.m_usesEval)
186         , m_needsFullActivation(rhs.m_needsFullActivation)
187         , m_hasDirectSuper(rhs.m_hasDirectSuper)
188         , m_needsSuperBinding(rhs.m_needsSuperBinding)
189         , m_allowsVarDeclarations(rhs.m_allowsVarDeclarations)
190         , m_allowsLexicalDeclarations(rhs.m_allowsLexicalDeclarations)
191         , m_strictMode(rhs.m_strictMode)
192         , m_isFunction(rhs.m_isFunction)
193         , m_isGenerator(rhs.m_isGenerator)
194         , m_isLexicalScope(rhs.m_isLexicalScope)
195         , m_isFunctionBoundary(rhs.m_isFunctionBoundary)
196         , m_isValidStrictMode(rhs.m_isValidStrictMode)
197         , m_loopDepth(rhs.m_loopDepth)
198         , m_switchDepth(rhs.m_switchDepth)
199         , m_moduleScopeData(rhs.m_moduleScopeData)
200     {
201         if (rhs.m_labels) {
202             m_labels = std::make_unique<LabelStack>();
203
204             typedef LabelStack::const_iterator iterator;
205             iterator end = rhs.m_labels->end();
206             for (iterator it = rhs.m_labels->begin(); it != end; ++it)
207                 m_labels->append(ScopeLabelInfo { it->uid, it->isLoop });
208         }
209     }
210
211     void startSwitch() { m_switchDepth++; }
212     void endSwitch() { m_switchDepth--; }
213     void startLoop() { m_loopDepth++; }
214     void endLoop() { ASSERT(m_loopDepth); m_loopDepth--; }
215     bool inLoop() { return !!m_loopDepth; }
216     bool breakIsValid() { return m_loopDepth || m_switchDepth; }
217     bool continueIsValid() { return m_loopDepth; }
218
219     void pushLabel(const Identifier* label, bool isLoop)
220     {
221         if (!m_labels)
222             m_labels = std::make_unique<LabelStack>();
223         m_labels->append(ScopeLabelInfo { label->impl(), isLoop });
224     }
225
226     void popLabel()
227     {
228         ASSERT(m_labels);
229         ASSERT(m_labels->size());
230         m_labels->removeLast();
231     }
232
233     ScopeLabelInfo* getLabel(const Identifier* label)
234     {
235         if (!m_labels)
236             return 0;
237         for (int i = m_labels->size(); i > 0; i--) {
238             if (m_labels->at(i - 1).uid == label->impl())
239                 return &m_labels->at(i - 1);
240         }
241         return 0;
242     }
243
244     void setSourceParseMode(SourceParseMode mode)
245     {
246         switch (mode) {
247         case SourceParseMode::GeneratorMode:
248             setIsGenerator();
249             break;
250
251         case SourceParseMode::NormalFunctionMode:
252         case SourceParseMode::GetterMode:
253         case SourceParseMode::SetterMode:
254         case SourceParseMode::MethodMode:
255         case SourceParseMode::ArrowFunctionMode:
256             setIsFunction();
257             break;
258
259         case SourceParseMode::ProgramMode:
260             break;
261
262         case SourceParseMode::ModuleAnalyzeMode:
263         case SourceParseMode::ModuleEvaluateMode:
264             setIsModule();
265             break;
266         }
267     }
268
269     bool isFunction() const { return m_isFunction; }
270     bool isFunctionBoundary() const { return m_isFunctionBoundary; }
271     bool isGenerator() const { return m_isGenerator; }
272
273     void setIsLexicalScope() 
274     { 
275         m_isLexicalScope = true;
276         m_allowsLexicalDeclarations = true;
277     }
278     bool isLexicalScope() { return m_isLexicalScope; }
279
280     VariableEnvironment& declaredVariables() { return m_declaredVariables; }
281     VariableEnvironment& lexicalVariables() { return m_lexicalVariables; }
282     VariableEnvironment& finalizeLexicalEnvironment() 
283     { 
284         if (m_usesEval || m_needsFullActivation)
285             m_lexicalVariables.markAllVariablesAsCaptured();
286         else
287             computeLexicallyCapturedVariablesAndPurgeCandidates();
288
289         return m_lexicalVariables;
290     }
291
292     ModuleScopeData& moduleScopeData() const
293     {
294         ASSERT(m_moduleScopeData);
295         return *m_moduleScopeData;
296     }
297
298     void computeLexicallyCapturedVariablesAndPurgeCandidates()
299     {
300         // Because variables may be defined at any time in the range of a lexical scope, we must
301         // track lexical variables that might be captured. Then, when we're preparing to pop the top
302         // lexical scope off the stack, we should find which variables are truly captured, and which
303         // variable still may be captured in a parent scope.
304         if (m_lexicalVariables.size() && m_closedVariableCandidates.size()) {
305             auto end = m_closedVariableCandidates.end();
306             for (auto iter = m_closedVariableCandidates.begin(); iter != end; ++iter)
307                 m_lexicalVariables.markVariableAsCapturedIfDefined(iter->get());
308         }
309
310         // We can now purge values from the captured candidates because they're captured in this scope.
311         {
312             for (auto entry : m_lexicalVariables) {
313                 if (entry.value.isCaptured())
314                     m_closedVariableCandidates.remove(entry.key);
315             }
316         }
317     }
318
319     void declareCallee(const Identifier* ident)
320     {
321         auto addResult = m_declaredVariables.add(ident->impl());
322         // We want to track if callee is captured, but we don't want to act like it's a 'var'
323         // because that would cause the BytecodeGenerator to emit bad code.
324         addResult.iterator->value.clearIsVar();
325     }
326
327     DeclarationResultMask declareVariable(const Identifier* ident)
328     {
329         ASSERT(m_allowsVarDeclarations);
330         DeclarationResultMask result = DeclarationResult::Valid;
331         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
332         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
333         auto addResult = m_declaredVariables.add(ident->impl());
334         addResult.iterator->value.setIsVar();
335         if (!isValidStrictMode)
336             result |= DeclarationResult::InvalidStrictMode;
337         if (m_lexicalVariables.contains(ident->impl()))
338             result |= DeclarationResult::InvalidDuplicateDeclaration;
339         return result;
340     }
341
342     DeclarationResultMask declareLexicalVariable(const Identifier* ident, bool isConstant, DeclarationImportType importType = DeclarationImportType::NotImported)
343     {
344         ASSERT(m_allowsLexicalDeclarations);
345         DeclarationResultMask result = DeclarationResult::Valid;
346         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
347         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
348         auto addResult = m_lexicalVariables.add(ident->impl());
349         if (isConstant)
350             addResult.iterator->value.setIsConst();
351         else
352             addResult.iterator->value.setIsLet();
353
354         if (importType == DeclarationImportType::Imported)
355             addResult.iterator->value.setIsImported();
356         else if (importType == DeclarationImportType::ImportedNamespace) {
357             addResult.iterator->value.setIsImported();
358             addResult.iterator->value.setIsImportedNamespace();
359         }
360
361         if (!addResult.isNewEntry)
362             result |= DeclarationResult::InvalidDuplicateDeclaration;
363         if (!isValidStrictMode)
364             result |= DeclarationResult::InvalidStrictMode;
365
366         return result;
367     }
368
369     bool hasDeclaredVariable(const Identifier& ident)
370     {
371         return hasDeclaredVariable(ident.impl());
372     }
373
374     bool hasDeclaredVariable(const RefPtr<UniquedStringImpl>& ident)
375     {
376         return m_declaredVariables.contains(ident.get());
377     }
378
379     bool hasLexicallyDeclaredVariable(const RefPtr<UniquedStringImpl>& ident) const
380     {
381         return m_lexicalVariables.contains(ident.get());
382     }
383     
384     ALWAYS_INLINE bool hasDeclaredParameter(const Identifier& ident)
385     {
386         return hasDeclaredParameter(ident.impl());
387     }
388
389     bool hasDeclaredParameter(const RefPtr<UniquedStringImpl>& ident)
390     {
391         return m_declaredParameters.contains(ident) || m_declaredVariables.contains(ident.get());
392     }
393     
394     void declareWrite(const Identifier* ident)
395     {
396         ASSERT(m_strictMode);
397         m_writtenVariables.add(ident->impl());
398     }
399
400     void preventAllVariableDeclarations()
401     {
402         m_allowsVarDeclarations = false; 
403         m_allowsLexicalDeclarations = false;
404     }
405     void preventVarDeclarations() { m_allowsVarDeclarations = false; }
406     bool allowsVarDeclarations() const { return m_allowsVarDeclarations; }
407     bool allowsLexicalDeclarations() const { return m_allowsLexicalDeclarations; }
408
409     DeclarationResultMask declareParameter(const Identifier* ident)
410     {
411         ASSERT(m_allowsVarDeclarations);
412         DeclarationResultMask result = DeclarationResult::Valid;
413         bool isArgumentsIdent = isArguments(m_vm, ident);
414         auto addResult = m_declaredVariables.add(ident->impl());
415         addResult.iterator->value.clearIsVar();
416         bool isValidStrictMode = addResult.isNewEntry && m_vm->propertyNames->eval != *ident && !isArgumentsIdent;
417         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
418         m_declaredParameters.add(ident->impl());
419         if (!isValidStrictMode)
420             result |= DeclarationResult::InvalidStrictMode;
421         if (isArgumentsIdent)
422             m_shadowsArguments = true;
423         if (!addResult.isNewEntry)
424             result |= DeclarationResult::InvalidDuplicateDeclaration;
425
426         return result;
427     }
428     
429     enum BindingResult {
430         BindingFailed,
431         StrictBindingFailed,
432         BindingSucceeded
433     };
434     BindingResult declareBoundParameter(const Identifier* ident)
435     {
436         bool isArgumentsIdent = isArguments(m_vm, ident);
437         auto addResult = m_declaredVariables.add(ident->impl());
438         addResult.iterator->value.setIsVar(); // Treat destructuring parameters as "var"s.
439         bool isValidStrictMode = addResult.isNewEntry && !isEval(m_vm, ident) && !isArgumentsIdent;
440         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
441     
442         if (isArgumentsIdent)
443             m_shadowsArguments = true;
444         if (!addResult.isNewEntry)
445             return BindingFailed;
446         return isValidStrictMode ? BindingSucceeded : StrictBindingFailed;
447     }
448
449     void getUsedVariables(IdentifierSet& usedVariables)
450     {
451         usedVariables.swap(m_usedVariables);
452     }
453
454     void useVariable(const Identifier* ident, bool isEval)
455     {
456         m_usesEval |= isEval;
457         m_usedVariables.add(ident->impl());
458     }
459
460     void setNeedsFullActivation() { m_needsFullActivation = true; }
461     bool needsFullActivation() const { return m_needsFullActivation; }
462
463 #if ENABLE(ES6_CLASS_SYNTAX)
464     bool hasDirectSuper() { return m_hasDirectSuper; }
465 #else
466     bool hasDirectSuper() { return false; }
467 #endif
468     void setHasDirectSuper() { m_hasDirectSuper = true; }
469
470 #if ENABLE(ES6_CLASS_SYNTAX)
471     bool needsSuperBinding() { return m_needsSuperBinding; }
472 #else
473     bool needsSuperBinding() { return false; }
474 #endif
475     void setNeedsSuperBinding() { m_needsSuperBinding = true; }
476
477     void collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
478     {
479         if (nestedScope->m_usesEval)
480             m_usesEval = true;
481
482         {
483             IdentifierSet::iterator end = nestedScope->m_usedVariables.end();
484             for (IdentifierSet::iterator ptr = nestedScope->m_usedVariables.begin(); ptr != end; ++ptr) {
485                 if (nestedScope->m_declaredVariables.contains(*ptr) || nestedScope->m_lexicalVariables.contains(*ptr))
486                     continue;
487                 m_usedVariables.add(*ptr);
488                 // We don't want a declared variable that is used in an inner scope to be thought of as captured if
489                 // that inner scope is both a lexical scope and not a function. Only inner functions and "catch" 
490                 // statements can cause variables to be captured.
491                 if (shouldTrackClosedVariables && (nestedScope->m_isFunctionBoundary || !nestedScope->m_isLexicalScope))
492                     m_closedVariableCandidates.add(*ptr);
493             }
494         }
495         // Propagate closed variable candidates downwards within the same function.
496         // Cross function captures will be realized via m_usedVariables propagation.
497         if (shouldTrackClosedVariables && !nestedScope->m_isFunctionBoundary && nestedScope->m_closedVariableCandidates.size()) {
498             IdentifierSet::iterator end = nestedScope->m_closedVariableCandidates.end();
499             IdentifierSet::iterator begin = nestedScope->m_closedVariableCandidates.begin();
500             m_closedVariableCandidates.add(begin, end);
501         }
502
503         if (nestedScope->m_writtenVariables.size()) {
504             IdentifierSet::iterator end = nestedScope->m_writtenVariables.end();
505             for (IdentifierSet::iterator ptr = nestedScope->m_writtenVariables.begin(); ptr != end; ++ptr) {
506                 if (nestedScope->m_declaredVariables.contains(*ptr) || nestedScope->m_lexicalVariables.contains(*ptr))
507                     continue;
508                 m_writtenVariables.add(*ptr);
509             }
510         }
511     }
512     
513     void getCapturedVars(IdentifierSet& capturedVariables, bool& modifiedParameter, bool& modifiedArguments)
514     {
515         if (m_needsFullActivation || m_usesEval) {
516             modifiedParameter = true;
517             for (auto& entry : m_declaredVariables)
518                 capturedVariables.add(entry.key);
519             return;
520         }
521         for (IdentifierSet::iterator ptr = m_closedVariableCandidates.begin(); ptr != m_closedVariableCandidates.end(); ++ptr) {
522             if (!m_declaredVariables.contains(*ptr))
523                 continue;
524             capturedVariables.add(*ptr);
525         }
526         modifiedParameter = false;
527         if (shadowsArguments())
528             modifiedArguments = true;
529         if (m_declaredParameters.size()) {
530             IdentifierSet::iterator end = m_writtenVariables.end();
531             for (IdentifierSet::iterator ptr = m_writtenVariables.begin(); ptr != end; ++ptr) {
532                 if (*ptr == m_vm->propertyNames->arguments.impl())
533                     modifiedArguments = true;
534                 if (!m_declaredParameters.contains(*ptr))
535                     continue;
536                 modifiedParameter = true;
537                 break;
538             }
539         }
540     }
541     void setStrictMode() { m_strictMode = true; }
542     bool strictMode() const { return m_strictMode; }
543     bool isValidStrictMode() const { return m_isValidStrictMode; }
544     bool shadowsArguments() const { return m_shadowsArguments; }
545
546     void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<UniquedStringImpl>>& vector)
547     {
548         IdentifierSet::iterator end = capturedVariables.end();
549         for (IdentifierSet::iterator it = capturedVariables.begin(); it != end; ++it) {
550             if (m_declaredVariables.contains(*it) || m_lexicalVariables.contains(*it))
551                 continue;
552             vector.append(*it);
553         }
554     }
555
556     void fillParametersForSourceProviderCache(SourceProviderCacheItemCreationParameters& parameters)
557     {
558         ASSERT(m_isFunction);
559         parameters.usesEval = m_usesEval;
560         parameters.strictMode = m_strictMode;
561         parameters.needsFullActivation = m_needsFullActivation;
562         copyCapturedVariablesToVector(m_writtenVariables, parameters.writtenVariables);
563         copyCapturedVariablesToVector(m_usedVariables, parameters.usedVariables);
564     }
565
566     void restoreFromSourceProviderCache(const SourceProviderCacheItem* info)
567     {
568         ASSERT(m_isFunction);
569         m_usesEval = info->usesEval;
570         m_strictMode = info->strictMode;
571         m_needsFullActivation = info->needsFullActivation;
572         for (unsigned i = 0; i < info->usedVariablesCount; ++i)
573             m_usedVariables.add(info->usedVariables()[i]);
574         for (unsigned i = 0; i < info->writtenVariablesCount; ++i)
575             m_writtenVariables.add(info->writtenVariables()[i]);
576     }
577
578 private:
579     void setIsFunction()
580     {
581         m_isFunction = true;
582         m_isFunctionBoundary = true;
583         setIsLexicalScope();
584         m_isGenerator = false;
585     }
586
587     void setIsGenerator()
588     {
589         setIsFunction();
590         m_isGenerator = true;
591     }
592
593     void setIsModule()
594     {
595         m_moduleScopeData = ModuleScopeData::create();
596     }
597
598     const VM* m_vm;
599     bool m_shadowsArguments : 1;
600     bool m_usesEval : 1;
601     bool m_needsFullActivation : 1;
602     bool m_hasDirectSuper : 1;
603     bool m_needsSuperBinding : 1;
604     bool m_allowsVarDeclarations : 1;
605     bool m_allowsLexicalDeclarations : 1;
606     bool m_strictMode : 1;
607     bool m_isFunction : 1;
608     bool m_isGenerator : 1;
609     bool m_isLexicalScope : 1;
610     bool m_isFunctionBoundary : 1;
611     bool m_isValidStrictMode : 1;
612     int m_loopDepth;
613     int m_switchDepth;
614
615     typedef Vector<ScopeLabelInfo, 2> LabelStack;
616     std::unique_ptr<LabelStack> m_labels;
617     IdentifierSet m_declaredParameters;
618     VariableEnvironment m_declaredVariables;
619     VariableEnvironment m_lexicalVariables;
620     IdentifierSet m_usedVariables;
621     IdentifierSet m_closedVariableCandidates;
622     IdentifierSet m_writtenVariables;
623     RefPtr<ModuleScopeData> m_moduleScopeData { };
624 };
625
626 typedef Vector<Scope, 10> ScopeStack;
627
628 struct ScopeRef {
629     ScopeRef(ScopeStack* scopeStack, unsigned index)
630         : m_scopeStack(scopeStack)
631         , m_index(index)
632     {
633     }
634     Scope* operator->() { return &m_scopeStack->at(m_index); }
635     unsigned index() const { return m_index; }
636
637     bool hasContainingScope()
638     {
639         return m_index && !m_scopeStack->at(m_index).isFunctionBoundary();
640     }
641
642     ScopeRef containingScope()
643     {
644         ASSERT(hasContainingScope());
645         return ScopeRef(m_scopeStack, m_index - 1);
646     }
647
648 private:
649     ScopeStack* m_scopeStack;
650     unsigned m_index;
651 };
652
653 template <typename LexerType>
654 class Parser {
655     WTF_MAKE_NONCOPYABLE(Parser);
656     WTF_MAKE_FAST_ALLOCATED;
657
658 public:
659     Parser(
660         VM*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode,
661         ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode = ThisTDZMode::CheckIfNeeded);
662     ~Parser();
663
664     template <class ParsedNode>
665     std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, SourceParseMode);
666
667     JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }
668     JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }
669     Vector<RefPtr<UniquedStringImpl>>&& closedVariables() { return WTF::move(m_closedVariables); }
670
671 private:
672     struct AllowInOverride {
673         AllowInOverride(Parser* parser)
674             : m_parser(parser)
675             , m_oldAllowsIn(parser->m_allowsIn)
676         {
677             parser->m_allowsIn = true;
678         }
679         ~AllowInOverride()
680         {
681             m_parser->m_allowsIn = m_oldAllowsIn;
682         }
683         Parser* m_parser;
684         bool m_oldAllowsIn;
685     };
686
687     struct AutoPopScopeRef : public ScopeRef {
688         AutoPopScopeRef(Parser* parser, ScopeRef scope)
689         : ScopeRef(scope)
690         , m_parser(parser)
691         {
692         }
693         
694         ~AutoPopScopeRef()
695         {
696             if (m_parser)
697                 m_parser->popScope(*this, false);
698         }
699         
700         void setPopped()
701         {
702             m_parser = 0;
703         }
704         
705     private:
706         Parser* m_parser;
707     };
708
709     struct AutoCleanupLexicalScope {
710         // We can allocate this object on the stack without actually knowing beforehand if we're 
711         // going to create a new lexical scope. If we decide to create a new lexical scope, we
712         // can pass the scope into this obejct and it will take care of the cleanup for us if the parse fails.
713         // This is helpful if we may fail from syntax errors after creating a lexical scope conditionally.
714         AutoCleanupLexicalScope()
715             : m_scope(nullptr, UINT_MAX)
716             , m_parser(nullptr)
717         {
718         }
719
720         ~AutoCleanupLexicalScope()
721         {
722             // This should only ever be called if we fail from a syntax error. Otherwise
723             // it's the intention that a user of this class pops this scope manually on a 
724             // successful parse. 
725             if (isValid())
726                 m_parser->popScope(*this, false);
727         }
728
729         void setIsValid(ScopeRef& scope, Parser* parser)
730         {
731             RELEASE_ASSERT(scope->isLexicalScope());
732             m_scope = scope;
733             m_parser = parser;
734         }
735
736         bool isValid() const { return !!m_parser; }
737
738         void setPopped()
739         {
740             m_parser = nullptr;
741         }
742
743         ScopeRef& scope() { return m_scope; }
744
745     private:
746         ScopeRef m_scope;
747         Parser* m_parser;
748     };
749
750     ALWAYS_INLINE DestructuringKind destructuringKindFromDeclarationType(DeclarationType type)
751     {
752         switch (type) {
753         case DeclarationType::VarDeclaration:
754             return DestructureToVariables;
755         case DeclarationType::LetDeclaration:
756             return DestructureToLet;
757         case DeclarationType::ConstDeclaration:
758             return DestructureToConst;
759         }
760
761         RELEASE_ASSERT_NOT_REACHED();
762         return DestructureToVariables;
763     }
764
765     ALWAYS_INLINE AssignmentContext assignmentContextFromDeclarationType(DeclarationType type)
766     {
767         switch (type) {
768         case DeclarationType::ConstDeclaration:
769             return AssignmentContext::ConstDeclarationStatement;
770         default:
771             return AssignmentContext::DeclarationStatement;
772         }
773     }
774
775     ALWAYS_INLINE bool isEvalOrArguments(const Identifier* ident) { return isEvalOrArgumentsIdentifier(m_vm, ident); }
776
777     ScopeRef currentScope()
778     {
779         return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1);
780     }
781     
782     ScopeRef pushScope()
783     {
784         bool isFunction = false;
785         bool isStrict = false;
786         bool isGenerator = false;
787         if (!m_scopeStack.isEmpty()) {
788             isStrict = m_scopeStack.last().strictMode();
789             isFunction = m_scopeStack.last().isFunction();
790             isGenerator = m_scopeStack.last().isGenerator();
791         }
792         m_scopeStack.append(Scope(m_vm, isFunction, isGenerator, isStrict));
793         return currentScope();
794     }
795     
796     void popScopeInternal(ScopeRef& scope, bool shouldTrackClosedVariables)
797     {
798         ASSERT_UNUSED(scope, scope.index() == m_scopeStack.size() - 1);
799         ASSERT(m_scopeStack.size() > 1);
800         m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);
801         if (!m_scopeStack.last().isFunctionBoundary() && m_scopeStack.last().needsFullActivation())
802             m_scopeStack[m_scopeStack.size() - 2].setNeedsFullActivation();
803         m_scopeStack.removeLast();
804     }
805     
806     ALWAYS_INLINE void popScope(ScopeRef& scope, bool shouldTrackClosedVariables)
807     {
808         popScopeInternal(scope, shouldTrackClosedVariables);
809     }
810     
811     ALWAYS_INLINE void popScope(AutoPopScopeRef& scope, bool shouldTrackClosedVariables)
812     {
813         scope.setPopped();
814         popScopeInternal(scope, shouldTrackClosedVariables);
815     }
816
817     ALWAYS_INLINE void popScope(AutoCleanupLexicalScope& cleanupScope, bool shouldTrackClosedVariables)
818     {
819         RELEASE_ASSERT(cleanupScope.isValid());
820         ScopeRef& scope = cleanupScope.scope();
821         cleanupScope.setPopped();
822         popScopeInternal(scope, shouldTrackClosedVariables);
823     }
824     
825     DeclarationResultMask declareVariable(const Identifier* ident, DeclarationType type = DeclarationType::VarDeclaration, DeclarationImportType importType = DeclarationImportType::NotImported)
826     {
827         unsigned i = m_scopeStack.size() - 1;
828         ASSERT(i < m_scopeStack.size());
829
830         if (type == DeclarationType::VarDeclaration) {
831             while (!m_scopeStack[i].allowsVarDeclarations()) {
832                 i--;
833                 ASSERT(i < m_scopeStack.size());
834             }
835
836             return m_scopeStack[i].declareVariable(ident);
837         }
838
839         ASSERT(type == DeclarationType::LetDeclaration || type == DeclarationType::ConstDeclaration);
840
841         // Lexical variables declared at a top level scope that shadow arguments or vars are not allowed.
842         if (m_statementDepth == 1 && (hasDeclaredParameter(*ident) || hasDeclaredVariable(*ident)))
843             return DeclarationResult::InvalidDuplicateDeclaration;
844
845         while (!m_scopeStack[i].allowsLexicalDeclarations()) {
846             i--;
847             ASSERT(i < m_scopeStack.size());
848         }
849
850         return m_scopeStack[i].declareLexicalVariable(ident, type == DeclarationType::ConstDeclaration, importType);
851     }
852     
853     NEVER_INLINE bool hasDeclaredVariable(const Identifier& ident)
854     {
855         unsigned i = m_scopeStack.size() - 1;
856         ASSERT(i < m_scopeStack.size());
857         while (!m_scopeStack[i].allowsVarDeclarations()) {
858             i--;
859             ASSERT(i < m_scopeStack.size());
860         }
861         return m_scopeStack[i].hasDeclaredVariable(ident);
862     }
863
864     NEVER_INLINE bool hasDeclaredParameter(const Identifier& ident)
865     {
866         unsigned i = m_scopeStack.size() - 1;
867         ASSERT(i < m_scopeStack.size());
868         while (!m_scopeStack[i].allowsVarDeclarations()) {
869             i--;
870             ASSERT(i < m_scopeStack.size());
871         }
872         return m_scopeStack[i].hasDeclaredParameter(ident);
873     }
874     
875     void declareWrite(const Identifier* ident)
876     {
877         if (!m_syntaxAlreadyValidated || strictMode())
878             m_scopeStack.last().declareWrite(ident);
879     }
880
881     bool exportName(const Identifier& ident)
882     {
883         ASSERT(currentScope().index() == 0);
884         return currentScope()->moduleScopeData().exportName(ident);
885     }
886
887     ScopeStack m_scopeStack;
888     
889     const SourceProviderCacheItem* findCachedFunctionInfo(int openBracePos) 
890     {
891         return m_functionCache ? m_functionCache->get(openBracePos) : 0;
892     }
893
894     Parser();
895     String parseInner(const Identifier&, SourceParseMode);
896
897     void didFinishParsing(SourceElements*, DeclarationStacks::FunctionStack&, VariableEnvironment&, CodeFeatures, int, const Vector<RefPtr<UniquedStringImpl>>&&);
898
899     // Used to determine type of error to report.
900     bool isFunctionMetadataNode(ScopeNode*) { return false; }
901     bool isFunctionMetadataNode(FunctionMetadataNode*) { return true; }
902
903     ALWAYS_INLINE void next(unsigned lexerFlags = 0)
904     {
905         int lastLine = m_token.m_location.line;
906         int lastTokenEnd = m_token.m_location.endOffset;
907         int lastTokenLineStart = m_token.m_location.lineStartOffset;
908         m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
909         m_lexer->setLastLineNumber(lastLine);
910         m_token.m_type = m_lexer->lex(&m_token, lexerFlags, strictMode());
911     }
912
913     ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)
914     {
915         int lastLine = m_token.m_location.line;
916         int lastTokenEnd = m_token.m_location.endOffset;
917         int lastTokenLineStart = m_token.m_location.lineStartOffset;
918         m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
919         m_lexer->setLastLineNumber(lastLine);
920         m_token.m_type = m_lexer->lexExpectIdentifier(&m_token, lexerFlags, strictMode());
921     }
922
923     ALWAYS_INLINE bool nextTokenIsColon()
924     {
925         return m_lexer->nextTokenIsColon();
926     }
927
928     ALWAYS_INLINE bool consume(JSTokenType expected, unsigned flags = 0)
929     {
930         bool result = m_token.m_type == expected;
931         if (result)
932             next(flags);
933         return result;
934     }
935
936     void printUnexpectedTokenText(WTF::PrintStream&);
937     ALWAYS_INLINE String getToken() {
938         SourceProvider* sourceProvider = m_source->provider();
939         return sourceProvider->getRange(tokenStart(), tokenEndPosition().offset);
940     }
941     
942     ALWAYS_INLINE bool match(JSTokenType expected)
943     {
944         return m_token.m_type == expected;
945     }
946     
947     ALWAYS_INLINE bool matchContextualKeyword(const Identifier& identifier)
948     {
949         return m_token.m_type == IDENT && *m_token.m_data.ident == identifier;
950     }
951
952     ALWAYS_INLINE bool matchIdentifierOrKeyword()
953     {
954         return isIdentifierOrKeyword(m_token);
955     }
956     
957     ALWAYS_INLINE bool isEndOfArrowFunction()
958     {
959         return match(SEMICOLON) || match(COMMA) || match(CLOSEPAREN) || match(CLOSEBRACE) || match(CLOSEBRACKET) || match(EOFTOK) || m_lexer->prevTerminator();
960     }
961     
962     ALWAYS_INLINE bool isArrowFunctionParamters()
963     {
964 #if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
965         bool isArrowFunction = false;
966         
967         if (match(EOFTOK))
968             return isArrowFunction;
969         
970         SavePoint saveArrowFunctionPoint = createSavePoint();
971         
972         if (consume(OPENPAREN)) {
973             bool isArrowFunctionParamters = true;
974             
975             while (consume(IDENT)) {
976                 if (consume(COMMA)) {
977                     if (!match(IDENT)) {
978                         isArrowFunctionParamters = false;
979                         break;
980                     }
981                 } else
982                     break;
983             }
984             
985             if (isArrowFunctionParamters) {
986                 if (consume(CLOSEPAREN) && match(ARROWFUNCTION))
987                     isArrowFunction = true;
988             }
989         } else if (consume(IDENT) && match(ARROWFUNCTION))
990             isArrowFunction = true;
991
992         restoreSavePoint(saveArrowFunctionPoint);
993         
994         return isArrowFunction;
995 #else
996         return false;
997 #endif
998     }
999     
1000     ALWAYS_INLINE unsigned tokenStart()
1001     {
1002         return m_token.m_location.startOffset;
1003     }
1004     
1005     ALWAYS_INLINE const JSTextPosition& tokenStartPosition()
1006     {
1007         return m_token.m_startPosition;
1008     }
1009
1010     ALWAYS_INLINE int tokenLine()
1011     {
1012         return m_token.m_location.line;
1013     }
1014     
1015     ALWAYS_INLINE int tokenColumn()
1016     {
1017         return tokenStart() - tokenLineStart();
1018     }
1019
1020     ALWAYS_INLINE const JSTextPosition& tokenEndPosition()
1021     {
1022         return m_token.m_endPosition;
1023     }
1024     
1025     ALWAYS_INLINE unsigned tokenLineStart()
1026     {
1027         return m_token.m_location.lineStartOffset;
1028     }
1029     
1030     ALWAYS_INLINE const JSTokenLocation& tokenLocation()
1031     {
1032         return m_token.m_location;
1033     }
1034
1035     void setErrorMessage(const String& message)
1036     {
1037         m_errorMessage = message;
1038     }
1039     
1040     NEVER_INLINE void logError(bool);
1041     template <typename A> NEVER_INLINE void logError(bool, const A&);
1042     template <typename A, typename B> NEVER_INLINE void logError(bool, const A&, const B&);
1043     template <typename A, typename B, typename C> NEVER_INLINE void logError(bool, const A&, const B&, const C&);
1044     template <typename A, typename B, typename C, typename D> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&);
1045     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&);
1046     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&);
1047     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&);
1048     
1049     NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMessage, const String& name, const char* afterMessage)
1050     {
1051         m_errorMessage = makeString(beforeMessage, " '", name, "' ", afterMessage);
1052     }
1053     
1054     NEVER_INLINE void updateErrorMessage(const char* msg)
1055     {
1056         ASSERT(msg);
1057         m_errorMessage = String(msg);
1058         ASSERT(!m_errorMessage.isNull());
1059     }
1060     
1061     void startLoop() { currentScope()->startLoop(); }
1062     void endLoop() { currentScope()->endLoop(); }
1063     void startSwitch() { currentScope()->startSwitch(); }
1064     void endSwitch() { currentScope()->endSwitch(); }
1065     void setStrictMode() { currentScope()->setStrictMode(); }
1066     bool strictMode() { return currentScope()->strictMode(); }
1067     bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
1068     DeclarationResultMask declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
1069     Scope::BindingResult declareBoundParameter(const Identifier* ident) { return currentScope()->declareBoundParameter(ident); }
1070     bool breakIsValid()
1071     {
1072         ScopeRef current = currentScope();
1073         while (!current->breakIsValid()) {
1074             if (!current.hasContainingScope())
1075                 return false;
1076             current = current.containingScope();
1077         }
1078         return true;
1079     }
1080     bool continueIsValid()
1081     {
1082         ScopeRef current = currentScope();
1083         while (!current->continueIsValid()) {
1084             if (!current.hasContainingScope())
1085                 return false;
1086             current = current.containingScope();
1087         }
1088         return true;
1089     }
1090     void pushLabel(const Identifier* label, bool isLoop) { currentScope()->pushLabel(label, isLoop); }
1091     void popLabel(ScopeRef scope) { scope->popLabel(); }
1092     ScopeLabelInfo* getLabel(const Identifier* label)
1093     {
1094         ScopeRef current = currentScope();
1095         ScopeLabelInfo* result = 0;
1096         while (!(result = current->getLabel(label))) {
1097             if (!current.hasContainingScope())
1098                 return 0;
1099             current = current.containingScope();
1100         }
1101         return result;
1102     }
1103
1104     // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
1105     ALWAYS_INLINE bool isLETMaskedAsIDENT()
1106     {
1107         return match(LET) && !strictMode();
1108     }
1109
1110     // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
1111     ALWAYS_INLINE bool isYIELDMaskedAsIDENT(bool inGenerator)
1112     {
1113         return match(YIELD) && !strictMode() && !inGenerator;
1114     }
1115
1116     // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
1117     ALWAYS_INLINE bool matchSpecIdentifier(bool inGenerator)
1118     {
1119         return match(IDENT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator);
1120     }
1121
1122     ALWAYS_INLINE bool matchSpecIdentifier()
1123     {
1124         return matchSpecIdentifier(currentScope()->isGenerator());
1125     }
1126
1127     template <class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&, SourceElementsMode);
1128     template <class TreeBuilder> TreeStatement parseStatementListItem(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength);
1129     template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength = 0);
1130     enum class ExportType { Exported, NotExported };
1131 #if ENABLE(ES6_CLASS_SYNTAX)
1132     template <class TreeBuilder> TreeStatement parseClassDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
1133 #endif
1134     template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
1135     template <class TreeBuilder> TreeStatement parseVariableDeclaration(TreeBuilder&, DeclarationType, ExportType = ExportType::NotExported);
1136     template <class TreeBuilder> TreeStatement parseDoWhileStatement(TreeBuilder&);
1137     template <class TreeBuilder> TreeStatement parseWhileStatement(TreeBuilder&);
1138     template <class TreeBuilder> TreeStatement parseForStatement(TreeBuilder&);
1139     template <class TreeBuilder> TreeStatement parseBreakStatement(TreeBuilder&);
1140     template <class TreeBuilder> TreeStatement parseContinueStatement(TreeBuilder&);
1141     template <class TreeBuilder> TreeStatement parseReturnStatement(TreeBuilder&);
1142     template <class TreeBuilder> TreeStatement parseThrowStatement(TreeBuilder&);
1143     template <class TreeBuilder> TreeStatement parseWithStatement(TreeBuilder&);
1144     template <class TreeBuilder> TreeStatement parseSwitchStatement(TreeBuilder&);
1145     template <class TreeBuilder> TreeClauseList parseSwitchClauses(TreeBuilder&);
1146     template <class TreeBuilder> TreeClause parseSwitchDefaultClause(TreeBuilder&);
1147     template <class TreeBuilder> TreeStatement parseTryStatement(TreeBuilder&);
1148     template <class TreeBuilder> TreeStatement parseDebuggerStatement(TreeBuilder&);
1149     template <class TreeBuilder> TreeStatement parseExpressionStatement(TreeBuilder&);
1150     template <class TreeBuilder> TreeStatement parseExpressionOrLabelStatement(TreeBuilder&);
1151     template <class TreeBuilder> TreeStatement parseIfStatement(TreeBuilder&);
1152     template <class TreeBuilder> TreeStatement parseBlockStatement(TreeBuilder&);
1153     template <class TreeBuilder> TreeExpression parseExpression(TreeBuilder&);
1154     template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&);
1155     template <class TreeBuilder> TreeExpression parseYieldExpression(TreeBuilder&);
1156     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseConditionalExpression(TreeBuilder&);
1157     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseBinaryExpression(TreeBuilder&);
1158     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseUnaryExpression(TreeBuilder&);
1159     template <class TreeBuilder> TreeExpression parseMemberExpression(TreeBuilder&);
1160     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parsePrimaryExpression(TreeBuilder&);
1161     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArrayLiteral(TreeBuilder&);
1162     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseObjectLiteral(TreeBuilder&);
1163     template <class TreeBuilder> NEVER_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
1164     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseFunctionExpression(TreeBuilder&);
1165     enum SpreadMode { AllowSpread, DontAllowSpread };
1166     template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&, SpreadMode);
1167     template <class TreeBuilder> TreeProperty parseProperty(TreeBuilder&, bool strict);
1168     template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator);
1169     template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind = ConstructorKind::None, SuperBinding = SuperBinding::NotNeeded);
1170     template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, const JSTokenLocation&, int, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, FunctionBodyType, unsigned, SourceParseMode);
1171     template <class TreeBuilder> ALWAYS_INLINE bool parseFormalParameters(TreeBuilder&, TreeFormalParameterList, unsigned&);
1172     enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };
1173     template <class TreeBuilder> TreeExpression parseVariableDeclarationList(TreeBuilder&, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext, DeclarationType, ExportType, bool& forLoopConstDoesNotHaveInitializer);
1174     template <class TreeBuilder> TreeSourceElements parseArrowFunctionSingleExpressionBodySourceElements(TreeBuilder&);
1175     template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&);
1176     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createBindingPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier&, int depth, JSToken, AssignmentContext, const Identifier** duplicateIdentifier);
1177     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseDestructuringPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier** duplicateIdentifier = nullptr, bool* hasDestructuringPattern = nullptr, AssignmentContext = AssignmentContext::DeclarationStatement, int depth = 0);
1178     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern tryParseDestructuringPatternExpression(TreeBuilder&, AssignmentContext);
1179     template <class TreeBuilder> NEVER_INLINE TreeExpression parseDefaultValueForDestructuringPattern(TreeBuilder&);
1180     template <class TreeBuilder> TreeSourceElements parseModuleSourceElements(TreeBuilder&, SourceParseMode);
1181     enum class ImportSpecifierType { NamespaceImport, NamedImport, DefaultImport };
1182     template <class TreeBuilder> typename TreeBuilder::ImportSpecifier parseImportClauseItem(TreeBuilder&, ImportSpecifierType);
1183     template <class TreeBuilder> typename TreeBuilder::ModuleName parseModuleName(TreeBuilder&);
1184     template <class TreeBuilder> TreeStatement parseImportDeclaration(TreeBuilder&);
1185     template <class TreeBuilder> typename TreeBuilder::ExportSpecifier parseExportSpecifier(TreeBuilder& context, Vector<const Identifier*>& maybeLocalNames, bool& hasKeywordForLocalBindings);
1186     template <class TreeBuilder> TreeStatement parseExportDeclaration(TreeBuilder&);
1187
1188     enum class FunctionDefinitionType { Expression, Declaration, Method };
1189     template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, SourceParseMode, bool nameIsInContainingScope, ConstructorKind, SuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>&, FunctionDefinitionType);
1190     
1191     template <class TreeBuilder> NEVER_INLINE int parseFunctionParameters(TreeBuilder&, SourceParseMode, ParserFunctionInfo<TreeBuilder>&);
1192
1193 #if ENABLE(ES6_CLASS_SYNTAX)
1194     template <class TreeBuilder> NEVER_INLINE TreeClassExpression parseClass(TreeBuilder&, FunctionRequirements, ParserClassInfo<TreeBuilder>&);
1195 #endif
1196
1197 #if ENABLE(ES6_TEMPLATE_LITERAL_SYNTAX)
1198     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateString parseTemplateString(TreeBuilder& context, bool isTemplateHead, typename LexerType::RawStringsBuildMode, bool& elementIsTail);
1199     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateLiteral parseTemplateLiteral(TreeBuilder&, typename LexerType::RawStringsBuildMode);
1200 #endif
1201
1202     template <class TreeBuilder> ALWAYS_INLINE bool shouldCheckPropertyForUnderscoreProtoDuplicate(TreeBuilder&, const TreeProperty&);
1203
1204     ALWAYS_INLINE int isBinaryOperator(JSTokenType);
1205     bool allowAutomaticSemicolon();
1206     
1207     bool autoSemiColon()
1208     {
1209         if (m_token.m_type == SEMICOLON) {
1210             next();
1211             return true;
1212         }
1213         return allowAutomaticSemicolon();
1214     }
1215     
1216     void setEndOfStatement()
1217     {
1218         m_lexer->setTokenPosition(&m_token);
1219     }
1220
1221     bool canRecurse()
1222     {
1223         return m_vm->isSafeToRecurse();
1224     }
1225     
1226     const JSTextPosition& lastTokenEndPosition() const
1227     {
1228         return m_lastTokenEndPosition;
1229     }
1230
1231     bool hasError() const
1232     {
1233         return !m_errorMessage.isNull();
1234     }
1235
1236     struct SavePoint {
1237         int startOffset;
1238         unsigned oldLineStartOffset;
1239         unsigned oldLastLineNumber;
1240         unsigned oldLineNumber;
1241     };
1242     
1243     ALWAYS_INLINE SavePoint createSavePoint()
1244     {
1245         ASSERT(!hasError());
1246         SavePoint result;
1247         result.startOffset = m_token.m_location.startOffset;
1248         result.oldLineStartOffset = m_token.m_location.lineStartOffset;
1249         result.oldLastLineNumber = m_lexer->lastLineNumber();
1250         result.oldLineNumber = m_lexer->lineNumber();
1251         return result;
1252     }
1253     
1254     ALWAYS_INLINE void restoreSavePoint(const SavePoint& savePoint)
1255     {
1256         m_errorMessage = String();
1257         m_lexer->setOffset(savePoint.startOffset, savePoint.oldLineStartOffset);
1258         next();
1259         m_lexer->setLastLineNumber(savePoint.oldLastLineNumber);
1260         m_lexer->setLineNumber(savePoint.oldLineNumber);
1261     }
1262
1263     enum class FunctionParsePhase { Parameters, Body };
1264     struct ParserState {
1265         int assignmentCount;
1266         int nonLHSCount;
1267         int nonTrivialExpressionCount;
1268         FunctionParsePhase functionParsePhase;
1269     };
1270
1271     ALWAYS_INLINE ParserState saveState()
1272     {
1273         ParserState result;
1274         result.assignmentCount = m_assignmentCount;
1275         result.nonLHSCount = m_nonLHSCount;
1276         result.nonTrivialExpressionCount = m_nonTrivialExpressionCount;
1277         result.functionParsePhase = m_functionParsePhase;
1278         return result;
1279     }
1280
1281     ALWAYS_INLINE void restoreState(const ParserState& state)
1282     {
1283         m_assignmentCount = state.assignmentCount;
1284         m_nonLHSCount = state.nonLHSCount;
1285         m_nonTrivialExpressionCount = state.nonTrivialExpressionCount;
1286         m_functionParsePhase = state.functionParsePhase;
1287     }
1288
1289     VM* m_vm;
1290     const SourceCode* m_source;
1291     ParserArena m_parserArena;
1292     std::unique_ptr<LexerType> m_lexer;
1293     FunctionParameters* m_parameters { nullptr };
1294     
1295     bool m_hasStackOverflow;
1296     String m_errorMessage;
1297     JSToken m_token;
1298     bool m_allowsIn;
1299     JSTextPosition m_lastTokenEndPosition;
1300     int m_assignmentCount;
1301     int m_nonLHSCount;
1302     bool m_syntaxAlreadyValidated;
1303     int m_statementDepth;
1304     int m_nonTrivialExpressionCount;
1305     FunctionParsePhase m_functionParsePhase;
1306     const Identifier* m_lastIdentifier;
1307     const Identifier* m_lastFunctionName;
1308     RefPtr<SourceProviderCache> m_functionCache;
1309     SourceElements* m_sourceElements;
1310     bool m_parsingBuiltin;
1311     ConstructorKind m_defaultConstructorKind;
1312     ThisTDZMode m_thisTDZMode;
1313     VariableEnvironment m_varDeclarations;
1314     DeclarationStacks::FunctionStack m_funcDeclarations;
1315     Vector<RefPtr<UniquedStringImpl>> m_closedVariables;
1316     CodeFeatures m_features;
1317     int m_numConstants;
1318     
1319     struct DepthManager {
1320         DepthManager(int* depth)
1321         : m_originalDepth(*depth)
1322         , m_depth(depth)
1323         {
1324         }
1325         
1326         ~DepthManager()
1327         {
1328             *m_depth = m_originalDepth;
1329         }
1330         
1331     private:
1332         int m_originalDepth;
1333         int* m_depth;
1334     };
1335 };
1336
1337
1338 template <typename LexerType>
1339 template <class ParsedNode>
1340 std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode)
1341 {
1342     int errLine;
1343     String errMsg;
1344
1345     if (ParsedNode::scopeIsFunction)
1346         m_lexer->setIsReparsingFunction();
1347
1348     m_sourceElements = 0;
1349
1350     errLine = -1;
1351     errMsg = String();
1352
1353     JSTokenLocation startLocation(tokenLocation());
1354     ASSERT(m_source->startColumn() > 0);
1355     unsigned startColumn = m_source->startColumn() - 1;
1356
1357     String parseError = parseInner(calleeName, parseMode);
1358
1359     int lineNumber = m_lexer->lineNumber();
1360     bool lexError = m_lexer->sawError();
1361     String lexErrorMessage = lexError ? m_lexer->getErrorMessage() : String();
1362     ASSERT(lexErrorMessage.isNull() != lexError);
1363     m_lexer->clear();
1364
1365     if (!parseError.isNull() || lexError) {
1366         errLine = lineNumber;
1367         errMsg = !lexErrorMessage.isNull() ? lexErrorMessage : parseError;
1368         m_sourceElements = 0;
1369     }
1370
1371     std::unique_ptr<ParsedNode> result;
1372     if (m_sourceElements) {
1373         JSTokenLocation endLocation;
1374         endLocation.line = m_lexer->lineNumber();
1375         endLocation.lineStartOffset = m_lexer->currentLineStartOffset();
1376         endLocation.startOffset = m_lexer->currentOffset();
1377         unsigned endColumn = endLocation.startOffset - endLocation.lineStartOffset;
1378         result = std::make_unique<ParsedNode>(m_parserArena,
1379                                     startLocation,
1380                                     endLocation,
1381                                     startColumn,
1382                                     endColumn,
1383                                     m_sourceElements,
1384                                     m_varDeclarations,
1385                                     m_funcDeclarations,
1386                                     currentScope()->finalizeLexicalEnvironment(),
1387                                     m_parameters,
1388                                     *m_source,
1389                                     m_features,
1390                                     m_numConstants);
1391         result->setLoc(m_source->firstLine(), m_lexer->lineNumber(), m_lexer->currentOffset(), m_lexer->currentLineStartOffset());
1392         result->setEndOffset(m_lexer->currentOffset());
1393
1394         if (!isFunctionParseMode(parseMode)) {
1395             m_source->provider()->setSourceURLDirective(m_lexer->sourceURL());
1396             m_source->provider()->setSourceMappingURLDirective(m_lexer->sourceMappingURL());
1397         }
1398     } else {
1399         // We can never see a syntax error when reparsing a function, since we should have
1400         // reported the error when parsing the containing program or eval code. So if we're
1401         // parsing a function body node, we assume that what actually happened here is that
1402         // we ran out of stack while parsing. If we see an error while parsing eval or program
1403         // code we assume that it was a syntax error since running out of stack is much less
1404         // likely, and we are currently unable to distinguish between the two cases.
1405         if (isFunctionMetadataNode(static_cast<ParsedNode*>(0)) || m_hasStackOverflow)
1406             error = ParserError(ParserError::StackOverflow, ParserError::SyntaxErrorNone, m_token);
1407         else {
1408             ParserError::SyntaxErrorType errorType = ParserError::SyntaxErrorIrrecoverable;
1409             if (m_token.m_type == EOFTOK)
1410                 errorType = ParserError::SyntaxErrorRecoverable;
1411             else if (m_token.m_type & UnterminatedErrorTokenFlag) {
1412                 // Treat multiline capable unterminated literals as recoverable.
1413                 if (m_token.m_type == UNTERMINATED_MULTILINE_COMMENT_ERRORTOK || m_token.m_type == UNTERMINATED_TEMPLATE_LITERAL_ERRORTOK)
1414                     errorType = ParserError::SyntaxErrorRecoverable;
1415                 else
1416                     errorType = ParserError::SyntaxErrorUnterminatedLiteral;
1417             }
1418             
1419             if (isEvalNode<ParsedNode>())
1420                 error = ParserError(ParserError::EvalError, errorType, m_token, errMsg, errLine);
1421             else
1422                 error = ParserError(ParserError::SyntaxError, errorType, m_token, errMsg, errLine);
1423         }
1424     }
1425
1426     return result;
1427 }
1428
1429 template <class ParsedNode>
1430 std::unique_ptr<ParsedNode> parse(
1431     VM* vm, const SourceCode& source,
1432     const Identifier& name, JSParserBuiltinMode builtinMode,
1433     JSParserStrictMode strictMode, SourceParseMode parseMode,
1434     ParserError& error, JSTextPosition* positionBeforeLastNewline = nullptr,
1435     ConstructorKind defaultConstructorKind = ConstructorKind::None,
1436     ThisTDZMode thisTDZMode = ThisTDZMode::CheckIfNeeded)
1437 {
1438     SamplingRegion samplingRegion("Parsing");
1439
1440     ASSERT(!source.provider()->source().isNull());
1441     if (source.provider()->source().is8Bit()) {
1442         Parser<Lexer<LChar>> parser(vm, source, builtinMode, strictMode, parseMode, defaultConstructorKind, thisTDZMode);
1443         std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
1444         if (positionBeforeLastNewline)
1445             *positionBeforeLastNewline = parser.positionBeforeLastNewline();
1446         if (builtinMode == JSParserBuiltinMode::Builtin) {
1447             if (!result)
1448                 WTF::dataLog("Error compiling builtin: ", error.message(), "\n");
1449             RELEASE_ASSERT(result);
1450             result->setClosedVariables(parser.closedVariables());
1451         }
1452         return result;
1453     }
1454     ASSERT_WITH_MESSAGE(defaultConstructorKind == ConstructorKind::None, "BuiltinExecutables::createDefaultConstructor should always use a 8-bit string");
1455     Parser<Lexer<UChar>> parser(vm, source, builtinMode, strictMode, parseMode, defaultConstructorKind, thisTDZMode);
1456     std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
1457     if (positionBeforeLastNewline)
1458         *positionBeforeLastNewline = parser.positionBeforeLastNewline();
1459     return result;
1460 }
1461
1462 } // namespace
1463 #endif