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