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