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