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