CSE2410 Fall 2014 Bounce

// Copyright 2011 the V8 project authors. All rights reserved.

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

//       copyright notice, this list of conditions and the following

//       disclaimer in the documentation and/or other materials provided

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include <cmath>

#include "../include/v8stdint.h"

#include "allocation.h"

#include "checks.h"

#include "conversions.h"

#include "conversions-inl.h"

#include "globals.h"

#include "hashmap.h"

#include "list.h"

#include "preparse-data-format.h"

#include "preparse-data.h"

#include "preparser.h"

#include "unicode.h"

#include "utils.h"

#if V8_CC_MSVC && (_MSC_VER < 1800)

namespace std {

// Usually defined in math.h, but not in MSVC until VS2013+.

// Abstracted to work

int isfinite(double value);

}  // namespace std

#endif

namespace v8 {

namespace internal {

PreParser::PreParseResult PreParser::PreParseLazyFunction(

    LanguageMode mode, bool is_generator, ParserRecorder* log) {

  log_ = log;

  // Lazy functions always have trivial outer scopes (no with/catch scopes).

  Scope top_scope(&scope_, kTopLevelScope);

  set_language_mode(mode);

  Scope function_scope(&scope_, kFunctionScope);

  function_scope.set_is_generator(is_generator);

  ASSERT_EQ(Token::LBRACE, scanner()->current_token());

  bool ok = true;

  int start_position = peek_position();

  ParseLazyFunctionLiteralBody(&ok);

  if (stack_overflow()) return kPreParseStackOverflow;

  if (!ok) {

    ReportUnexpectedToken(scanner()->current_token());

  } else {

    ASSERT_EQ(Token::RBRACE, scanner()->peek());

    if (!is_classic_mode()) {

      int end_pos = scanner()->location().end_pos;

      CheckOctalLiteral(start_position, end_pos, &ok);

      if (ok) {

        CheckDelayedStrictModeViolation(start_position, end_pos, &ok);

      }

    }

  }

  return kPreParseSuccess;

}

// Preparsing checks a JavaScript program and emits preparse-data that helps

// a later parsing to be faster.

// See preparser-data.h for the data.

// The PreParser checks that the syntax follows the grammar for JavaScript,

// and collects some information about the program along the way.

// The grammar check is only performed in order to understand the program

// sufficiently to deduce some information about it, that can be used

// to speed up later parsing. Finding errors is not the goal of pre-parsing,

// rather it is to speed up properly written and correct programs.

// That means that contextual checks (like a label being declared where

// it is used) are generally omitted.

void PreParser::ReportUnexpectedToken(Token::Value token) {

  // We don't report stack overflows here, to avoid increasing the

  // stack depth even further.  Instead we report it after parsing is

  // over, in ParseProgram.

  if (token == Token::ILLEGAL && stack_overflow()) {

    return;

  }

  Scanner::Location source_location = scanner()->location();

  // Four of the tokens are treated specially

  switch (token) {

  case Token::EOS:

    return ReportMessageAt(source_location, "unexpected_eos", NULL);

  case Token::NUMBER:

    return ReportMessageAt(source_location, "unexpected_token_number", NULL);

  case Token::STRING:

    return ReportMessageAt(source_location, "unexpected_token_string", NULL);

  case Token::IDENTIFIER:

    return ReportMessageAt(source_location,

                           "unexpected_token_identifier", NULL);

  case Token::FUTURE_RESERVED_WORD:

    return ReportMessageAt(source_location, "unexpected_reserved", NULL);

  case Token::FUTURE_STRICT_RESERVED_WORD:

    return ReportMessageAt(source_location,

                           "unexpected_strict_reserved", NULL);

  default:

    const char* name = Token::String(token);

    ReportMessageAt(source_location, "unexpected_token", name);

  }

}

#define CHECK_OK  ok);                      \

  if (!*ok) return kUnknownSourceElements;  \

  ((void)0

#define DUMMY )  // to make indentation work

#undef DUMMY

PreParser::Statement PreParser::ParseSourceElement(bool* ok) {

  // (Ecma 262 5th Edition, clause 14):

  // SourceElement:

  //    Statement

  //    FunctionDeclaration

  //

  // In harmony mode we allow additionally the following productions

  // SourceElement:

  //    LetDeclaration

  //    ConstDeclaration

  //    GeneratorDeclaration

  switch (peek()) {

    case Token::FUNCTION:

      return ParseFunctionDeclaration(ok);

    case Token::LET:

    case Token::CONST:

      return ParseVariableStatement(kSourceElement, ok);

    default:

      return ParseStatement(ok);

  }

}

PreParser::SourceElements PreParser::ParseSourceElements(int end_token,

                                                         bool* ok) {

  // SourceElements ::

  //   (Statement)* <end_token>

  bool allow_directive_prologue = true;

  while (peek() != end_token) {

    Statement statement = ParseSourceElement(CHECK_OK);

    if (allow_directive_prologue) {

      if (statement.IsUseStrictLiteral()) {

        set_language_mode(allow_harmony_scoping() ?

                          EXTENDED_MODE : STRICT_MODE);

      } else if (!statement.IsStringLiteral()) {

        allow_directive_prologue = false;

      }

    }

  }

  return kUnknownSourceElements;

}

#undef CHECK_OK

#define CHECK_OK  ok);                   \

  if (!*ok) return Statement::Default();  \

  ((void)0

#define DUMMY )  // to make indentation work

#undef DUMMY

PreParser::Statement PreParser::ParseStatement(bool* ok) {

  // Statement ::

  //   Block

  //   VariableStatement

  //   EmptyStatement

  //   ExpressionStatement

  //   IfStatement

  //   IterationStatement

  //   ContinueStatement

  //   BreakStatement

  //   ReturnStatement

  //   WithStatement

  //   LabelledStatement

  //   SwitchStatement

  //   ThrowStatement

  //   TryStatement

  //   DebuggerStatement

  // Note: Since labels can only be used by 'break' and 'continue'

  // statements, which themselves are only valid within blocks,

  // iterations or 'switch' statements (i.e., BreakableStatements),

  // labels can be simply ignored in all other cases; except for

  // trivial labeled break statements 'label: break label' which is

  // parsed into an empty statement.

  // Keep the source position of the statement

  switch (peek()) {

    case Token::LBRACE:

      return ParseBlock(ok);

    case Token::CONST:

    case Token::LET:

    case Token::VAR:

      return ParseVariableStatement(kStatement, ok);

    case Token::SEMICOLON:

      Next();

      return Statement::Default();

    case Token::IF:

      return ParseIfStatement(ok);

    case Token::DO:

      return ParseDoWhileStatement(ok);

    case Token::WHILE:

      return ParseWhileStatement(ok);

    case Token::FOR:

      return ParseForStatement(ok);

    case Token::CONTINUE:

      return ParseContinueStatement(ok);

    case Token::BREAK:

      return ParseBreakStatement(ok);

    case Token::RETURN:

      return ParseReturnStatement(ok);

    case Token::WITH:

      return ParseWithStatement(ok);

    case Token::SWITCH:

      return ParseSwitchStatement(ok);

    case Token::THROW:

      return ParseThrowStatement(ok);

    case Token::TRY:

      return ParseTryStatement(ok);

    case Token::FUNCTION: {

      Scanner::Location start_location = scanner()->peek_location();

      Statement statement = ParseFunctionDeclaration(CHECK_OK);

      Scanner::Location end_location = scanner()->location();

      if (!is_classic_mode()) {

        ReportMessageAt(start_location.beg_pos, end_location.end_pos,

                        "strict_function", NULL);

        *ok = false;

        return Statement::Default();

      } else {

        return statement;

      }

    }

    case Token::DEBUGGER:

      return ParseDebuggerStatement(ok);

    default:

      return ParseExpressionOrLabelledStatement(ok);

  }

}

PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {

  // FunctionDeclaration ::

  //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'

  // GeneratorDeclaration ::

  //   'function' '*' Identifier '(' FormalParameterListopt ')'

  //      '{' FunctionBody '}'

  Expect(Token::FUNCTION, CHECK_OK);

  bool is_generator = allow_generators() && Check(Token::MUL);

  Identifier identifier = ParseIdentifier(CHECK_OK);

  Scanner::Location location = scanner()->location();

  Expression function_value = ParseFunctionLiteral(is_generator, CHECK_OK);

  if (function_value.IsStrictFunction() &&

      !identifier.IsValidStrictVariable()) {

    // Strict mode violation, using either reserved word or eval/arguments

    // as name of strict function.

    const char* type = "strict_function_name";

    if (identifier.IsFutureStrictReserved() || identifier.IsYield()) {

      type = "strict_reserved_word";

    }

    ReportMessageAt(location, type, NULL);

    *ok = false;

  }

  return Statement::FunctionDeclaration();

}

PreParser::Statement PreParser::ParseBlock(bool* ok) {

  // Block ::

  //   '{' Statement* '}'

  // Note that a Block does not introduce a new execution scope!

  // (ECMA-262, 3rd, 12.2)

  //

  Expect(Token::LBRACE, CHECK_OK);

  while (peek() != Token::RBRACE) {

    if (is_extended_mode()) {

      ParseSourceElement(CHECK_OK);

    } else {

      ParseStatement(CHECK_OK);

    }

  }

  Expect(Token::RBRACE, ok);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseVariableStatement(

    VariableDeclarationContext var_context,

    bool* ok) {

  // VariableStatement ::

  //   VariableDeclarations ';'

  Statement result = ParseVariableDeclarations(var_context,

                                               NULL,

                                               NULL,

                                               CHECK_OK);

  ExpectSemicolon(CHECK_OK);

  return result;

}

// If the variable declaration declares exactly one non-const

// variable, then *var is set to that variable. In all other cases,

// *var is untouched; in particular, it is the caller's responsibility

// to initialize it properly. This mechanism is also used for the parsing

// of 'for-in' loops.

PreParser::Statement PreParser::ParseVariableDeclarations(

    VariableDeclarationContext var_context,

    VariableDeclarationProperties* decl_props,

    int* num_decl,

    bool* ok) {

  // VariableDeclarations ::

  //   ('var' | 'const') (Identifier ('=' AssignmentExpression)?)+[',']

  //

  // The ES6 Draft Rev3 specifies the following grammar for const declarations

  //

  // ConstDeclaration ::

  //   const ConstBinding (',' ConstBinding)* ';'

  // ConstBinding ::

  //   Identifier '=' AssignmentExpression

  //

  // TODO(ES6):

  // ConstBinding ::

  //   BindingPattern '=' AssignmentExpression

  bool require_initializer = false;

  if (peek() == Token::VAR) {

    Consume(Token::VAR);

  } else if (peek() == Token::CONST) {

    // TODO(ES6): The ES6 Draft Rev4 section 12.2.2 reads:

    //

    // ConstDeclaration : const ConstBinding (',' ConstBinding)* ';'

    //

    // * It is a Syntax Error if the code that matches this production is not

    //   contained in extended code.

    //

    // However disallowing const in classic mode will break compatibility with

    // existing pages. Therefore we keep allowing const with the old

    // non-harmony semantics in classic mode.

    Consume(Token::CONST);

    switch (language_mode()) {

      case CLASSIC_MODE:

        break;

      case STRICT_MODE: {

        Scanner::Location location = scanner()->peek_location();

        ReportMessageAt(location, "strict_const", NULL);

        *ok = false;

        return Statement::Default();

      }

      case EXTENDED_MODE:

        if (var_context != kSourceElement &&

            var_context != kForStatement) {

          Scanner::Location location = scanner()->peek_location();

          ReportMessageAt(location.beg_pos, location.end_pos,

                          "unprotected_const", NULL);

          *ok = false;

          return Statement::Default();

        }

        require_initializer = true;

        break;

    }

  } else if (peek() == Token::LET) {

    // ES6 Draft Rev4 section 12.2.1:

    //

    // LetDeclaration : let LetBindingList ;

    //

    // * It is a Syntax Error if the code that matches this production is not

    //   contained in extended code.

    if (!is_extended_mode()) {

      Scanner::Location location = scanner()->peek_location();

      ReportMessageAt(location.beg_pos, location.end_pos,

                      "illegal_let", NULL);

      *ok = false;

      return Statement::Default();

    }

    Consume(Token::LET);

    if (var_context != kSourceElement &&

        var_context != kForStatement) {

      Scanner::Location location = scanner()->peek_location();

      ReportMessageAt(location.beg_pos, location.end_pos,

                      "unprotected_let", NULL);

      *ok = false;

      return Statement::Default();

    }

  } else {

    *ok = false;

    return Statement::Default();

  }

  // The scope of a var/const declared variable anywhere inside a function

  // is the entire function (ECMA-262, 3rd, 10.1.3, and 12.2). The scope

  // of a let declared variable is the scope of the immediately enclosing

  // block.

  int nvars = 0;  // the number of variables declared

  do {

    // Parse variable name.

    if (nvars > 0) Consume(Token::COMMA);

    Identifier identifier  = ParseIdentifier(CHECK_OK);

    if (!is_classic_mode() && !identifier.IsValidStrictVariable()) {

      StrictModeIdentifierViolation(scanner()->location(),

                                    "strict_var_name",

                                    identifier,

                                    ok);

      return Statement::Default();

    }

    nvars++;

    if (peek() == Token::ASSIGN || require_initializer) {

      Expect(Token::ASSIGN, CHECK_OK);

      ParseAssignmentExpression(var_context != kForStatement, CHECK_OK);

      if (decl_props != NULL) *decl_props = kHasInitializers;

    }

  } while (peek() == Token::COMMA);

  if (num_decl != NULL) *num_decl = nvars;

  return Statement::Default();

}

PreParser::Statement PreParser::ParseExpressionOrLabelledStatement(bool* ok) {

  // ExpressionStatement | LabelledStatement ::

  //   Expression ';'

  //   Identifier ':' Statement

  Expression expr = ParseExpression(true, CHECK_OK);

  if (expr.IsRawIdentifier()) {

    ASSERT(!expr.AsIdentifier().IsFutureReserved());

    ASSERT(is_classic_mode() ||

           (!expr.AsIdentifier().IsFutureStrictReserved() &&

            !expr.AsIdentifier().IsYield()));

    if (peek() == Token::COLON) {

      Consume(Token::COLON);

      return ParseStatement(ok);

    }

    // Preparsing is disabled for extensions (because the extension details

    // aren't passed to lazily compiled functions), so we don't

    // accept "native function" in the preparser.

  }

  // Parsed expression statement.

  ExpectSemicolon(CHECK_OK);

  return Statement::ExpressionStatement(expr);

}

PreParser::Statement PreParser::ParseIfStatement(bool* ok) {

  // IfStatement ::

  //   'if' '(' Expression ')' Statement ('else' Statement)?

  Expect(Token::IF, CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  ParseExpression(true, CHECK_OK);

  Expect(Token::RPAREN, CHECK_OK);

  ParseStatement(CHECK_OK);

  if (peek() == Token::ELSE) {

    Next();

    ParseStatement(CHECK_OK);

  }

  return Statement::Default();

}

PreParser::Statement PreParser::ParseContinueStatement(bool* ok) {

  // ContinueStatement ::

  //   'continue' [no line terminator] Identifier? ';'

  Expect(Token::CONTINUE, CHECK_OK);

  Token::Value tok = peek();

  if (!scanner()->HasAnyLineTerminatorBeforeNext() &&

      tok != Token::SEMICOLON &&

      tok != Token::RBRACE &&

      tok != Token::EOS) {

    ParseIdentifier(CHECK_OK);

  }

  ExpectSemicolon(CHECK_OK);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseBreakStatement(bool* ok) {

  // BreakStatement ::

  //   'break' [no line terminator] Identifier? ';'

  Expect(Token::BREAK, CHECK_OK);

  Token::Value tok = peek();

  if (!scanner()->HasAnyLineTerminatorBeforeNext() &&

      tok != Token::SEMICOLON &&

      tok != Token::RBRACE &&

      tok != Token::EOS) {

    ParseIdentifier(CHECK_OK);

  }

  ExpectSemicolon(CHECK_OK);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseReturnStatement(bool* ok) {

  // ReturnStatement ::

  //   'return' [no line terminator] Expression? ';'

  // Consume the return token. It is necessary to do the before

  // reporting any errors on it, because of the way errors are

  // reported (underlining).

  Expect(Token::RETURN, CHECK_OK);

  // An ECMAScript program is considered syntactically incorrect if it

  // contains a return statement that is not within the body of a

  // function. See ECMA-262, section 12.9, page 67.

  // This is not handled during preparsing.

  Token::Value tok = peek();

  if (!scanner()->HasAnyLineTerminatorBeforeNext() &&

      tok != Token::SEMICOLON &&

      tok != Token::RBRACE &&

      tok != Token::EOS) {

    ParseExpression(true, CHECK_OK);

  }

  ExpectSemicolon(CHECK_OK);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseWithStatement(bool* ok) {

  // WithStatement ::

  //   'with' '(' Expression ')' Statement

  Expect(Token::WITH, CHECK_OK);

  if (!is_classic_mode()) {

    Scanner::Location location = scanner()->location();

    ReportMessageAt(location, "strict_mode_with", NULL);

    *ok = false;

    return Statement::Default();

  }

  Expect(Token::LPAREN, CHECK_OK);

  ParseExpression(true, CHECK_OK);

  Expect(Token::RPAREN, CHECK_OK);

  Scope::InsideWith iw(scope_);

  ParseStatement(CHECK_OK);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseSwitchStatement(bool* ok) {

  // SwitchStatement ::

  //   'switch' '(' Expression ')' '{' CaseClause* '}'

  Expect(Token::SWITCH, CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  ParseExpression(true, CHECK_OK);

  Expect(Token::RPAREN, CHECK_OK);

  Expect(Token::LBRACE, CHECK_OK);

  Token::Value token = peek();

  while (token != Token::RBRACE) {

    if (token == Token::CASE) {

      Expect(Token::CASE, CHECK_OK);

      ParseExpression(true, CHECK_OK);

    } else {

      Expect(Token::DEFAULT, CHECK_OK);

    }

    Expect(Token::COLON, CHECK_OK);

    token = peek();

    while (token != Token::CASE &&

           token != Token::DEFAULT &&

           token != Token::RBRACE) {

      ParseStatement(CHECK_OK);

      token = peek();

    }

  }

  Expect(Token::RBRACE, ok);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseDoWhileStatement(bool* ok) {

  // DoStatement ::

  //   'do' Statement 'while' '(' Expression ')' ';'

  Expect(Token::DO, CHECK_OK);

  ParseStatement(CHECK_OK);

  Expect(Token::WHILE, CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  ParseExpression(true, CHECK_OK);

  Expect(Token::RPAREN, ok);

  if (peek() == Token::SEMICOLON) Consume(Token::SEMICOLON);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseWhileStatement(bool* ok) {

  // WhileStatement ::

  //   'while' '(' Expression ')' Statement

  Expect(Token::WHILE, CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  ParseExpression(true, CHECK_OK);

  Expect(Token::RPAREN, CHECK_OK);

  ParseStatement(ok);

  return Statement::Default();

}

bool PreParser::CheckInOrOf(bool accept_OF) {

  if (Check(Token::IN) ||

      (allow_for_of() && accept_OF &&

       CheckContextualKeyword(CStrVector("of")))) {

    return true;

  }

  return false;

}

PreParser::Statement PreParser::ParseForStatement(bool* ok) {

  // ForStatement ::

  //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement

  Expect(Token::FOR, CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  if (peek() != Token::SEMICOLON) {

    if (peek() == Token::VAR || peek() == Token::CONST ||

        peek() == Token::LET) {

      bool is_let = peek() == Token::LET;

      int decl_count;

      VariableDeclarationProperties decl_props = kHasNoInitializers;

      ParseVariableDeclarations(

          kForStatement, &decl_props, &decl_count, CHECK_OK);

      bool has_initializers = decl_props == kHasInitializers;

      bool accept_IN = decl_count == 1 && !(is_let && has_initializers);

      bool accept_OF = !has_initializers;

      if (accept_IN && CheckInOrOf(accept_OF)) {

        ParseExpression(true, CHECK_OK);

        Expect(Token::RPAREN, CHECK_OK);

        ParseStatement(CHECK_OK);

        return Statement::Default();

      }

    } else {

      Expression lhs = ParseExpression(false, CHECK_OK);

      if (CheckInOrOf(lhs.IsIdentifier())) {

        ParseExpression(true, CHECK_OK);

        Expect(Token::RPAREN, CHECK_OK);

        ParseStatement(CHECK_OK);

        return Statement::Default();

      }

    }

  }

  // Parsed initializer at this point.

  Expect(Token::SEMICOLON, CHECK_OK);

  if (peek() != Token::SEMICOLON) {

    ParseExpression(true, CHECK_OK);

  }

  Expect(Token::SEMICOLON, CHECK_OK);

  if (peek() != Token::RPAREN) {

    ParseExpression(true, CHECK_OK);

  }

  Expect(Token::RPAREN, CHECK_OK);

  ParseStatement(ok);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseThrowStatement(bool* ok) {

  // ThrowStatement ::

  //   'throw' [no line terminator] Expression ';'

  Expect(Token::THROW, CHECK_OK);

  if (scanner()->HasAnyLineTerminatorBeforeNext()) {

    Scanner::Location pos = scanner()->location();

    ReportMessageAt(pos, "newline_after_throw", NULL);

    *ok = false;

    return Statement::Default();

  }

  ParseExpression(true, CHECK_OK);

  ExpectSemicolon(ok);

  return Statement::Default();

}

PreParser::Statement PreParser::ParseTryStatement(bool* ok) {

  // TryStatement ::

  //   'try' Block Catch

  //   'try' Block Finally

  //   'try' Block Catch Finally

  //

  // Catch ::

  //   'catch' '(' Identifier ')' Block

  //

  // Finally ::

  //   'finally' Block

  // In preparsing, allow any number of catch/finally blocks, including zero

  // of both.

  Expect(Token::TRY, CHECK_OK);

  ParseBlock(CHECK_OK);

  bool catch_or_finally_seen = false;

  if (peek() == Token::CATCH) {

    Consume(Token::CATCH);

    Expect(Token::LPAREN, CHECK_OK);

    Identifier id = ParseIdentifier(CHECK_OK);

    if (!is_classic_mode() && !id.IsValidStrictVariable()) {

      StrictModeIdentifierViolation(scanner()->location(),

                                    "strict_catch_variable",

                                    id,

                                    ok);

      return Statement::Default();

    }

    Expect(Token::RPAREN, CHECK_OK);

    { Scope::InsideWith iw(scope_);

      ParseBlock(CHECK_OK);

    }

    catch_or_finally_seen = true;

  }

  if (peek() == Token::FINALLY) {

    Consume(Token::FINALLY);

    ParseBlock(CHECK_OK);

    catch_or_finally_seen = true;

  }

  if (!catch_or_finally_seen) {

    *ok = false;

  }

  return Statement::Default();

}

PreParser::Statement PreParser::ParseDebuggerStatement(bool* ok) {

  // In ECMA-262 'debugger' is defined as a reserved keyword. In some browser

  // contexts this is used as a statement which invokes the debugger as if a

  // break point is present.

  // DebuggerStatement ::

  //   'debugger' ';'

  Expect(Token::DEBUGGER, CHECK_OK);

  ExpectSemicolon(ok);

  return Statement::Default();

}

#undef CHECK_OK

#define CHECK_OK  ok);                     \

  if (!*ok) return Expression::Default();  \

  ((void)0

#define DUMMY )  // to make indentation work

#undef DUMMY

// Precedence = 1

PreParser::Expression PreParser::ParseExpression(bool accept_IN, bool* ok) {

  // Expression ::

  //   AssignmentExpression

  //   Expression ',' AssignmentExpression

  Expression result = ParseAssignmentExpression(accept_IN, CHECK_OK);

  while (peek() == Token::COMMA) {

    Expect(Token::COMMA, CHECK_OK);

    ParseAssignmentExpression(accept_IN, CHECK_OK);

    result = Expression::Default();

  }

  return result;

}

// Precedence = 2

PreParser::Expression PreParser::ParseAssignmentExpression(bool accept_IN,

                                                           bool* ok) {

  // AssignmentExpression ::

  //   ConditionalExpression

  //   YieldExpression

  //   LeftHandSideExpression AssignmentOperator AssignmentExpression

  if (scope_->is_generator() && peek() == Token::YIELD) {

    return ParseYieldExpression(ok);

  }

  Scanner::Location before = scanner()->peek_location();

  Expression expression = ParseConditionalExpression(accept_IN, CHECK_OK);

  if (!Token::IsAssignmentOp(peek())) {

    // Parsed conditional expression only (no assignment).

    return expression;

  }

  if (!is_classic_mode() &&

      expression.IsIdentifier() &&

      expression.AsIdentifier().IsEvalOrArguments()) {

    Scanner::Location after = scanner()->location();

    ReportMessageAt(before.beg_pos, after.end_pos,

                    "strict_lhs_assignment", NULL);

    *ok = false;

    return Expression::Default();

  }

  Token::Value op = Next();  // Get assignment operator.

  ParseAssignmentExpression(accept_IN, CHECK_OK);

  if ((op == Token::ASSIGN) && expression.IsThisProperty()) {

    scope_->AddProperty();

  }

  return Expression::Default();

}

// Precedence = 3

PreParser::Expression PreParser::ParseYieldExpression(bool* ok) {

  // YieldExpression ::

  //   'yield' '*'? AssignmentExpression

  Consume(Token::YIELD);

  Check(Token::MUL);

  ParseAssignmentExpression(false, CHECK_OK);

  return Expression::Default();

}

// Precedence = 3

PreParser::Expression PreParser::ParseConditionalExpression(bool accept_IN,

                                                            bool* ok) {

  // ConditionalExpression ::

  //   LogicalOrExpression

  //   LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression

  // We start using the binary expression parser for prec >= 4 only!

  Expression expression = ParseBinaryExpression(4, accept_IN, CHECK_OK);

  if (peek() != Token::CONDITIONAL) return expression;

  Consume(Token::CONDITIONAL);

  // In parsing the first assignment expression in conditional

  // expressions we always accept the 'in' keyword; see ECMA-262,

  // section 11.12, page 58.

  ParseAssignmentExpression(true, CHECK_OK);

  Expect(Token::COLON, CHECK_OK);

  ParseAssignmentExpression(accept_IN, CHECK_OK);

  return Expression::Default();

}

// Precedence >= 4

PreParser::Expression PreParser::ParseBinaryExpression(int prec,

                                                       bool accept_IN,

                                                       bool* ok) {

  Expression result = ParseUnaryExpression(CHECK_OK);

  for (int prec1 = Precedence(peek(), accept_IN); prec1 >= prec; prec1--) {

    // prec1 >= 4

    while (Precedence(peek(), accept_IN) == prec1) {

      Next();

      ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_OK);

      result = Expression::Default();

    }

  }

  return result;

}

PreParser::Expression PreParser::ParseUnaryExpression(bool* ok) {

  // UnaryExpression ::

  //   PostfixExpression

  //   'delete' UnaryExpression

  //   'void' UnaryExpression

  //   'typeof' UnaryExpression

  //   '++' UnaryExpression

  //   '--' UnaryExpression

  //   '+' UnaryExpression

  //   '-' UnaryExpression

  //   '~' UnaryExpression

  //   '!' UnaryExpression

  Token::Value op = peek();

  if (Token::IsUnaryOp(op)) {

    op = Next();

    ParseUnaryExpression(ok);

    return Expression::Default();

  } else if (Token::IsCountOp(op)) {

    op = Next();

    Scanner::Location before = scanner()->peek_location();

    Expression expression = ParseUnaryExpression(CHECK_OK);

    if (!is_classic_mode() &&

        expression.IsIdentifier() &&

        expression.AsIdentifier().IsEvalOrArguments()) {

      Scanner::Location after = scanner()->location();

      ReportMessageAt(before.beg_pos, after.end_pos,

                      "strict_lhs_prefix", NULL);

      *ok = false;

    }

    return Expression::Default();

  } else {

    return ParsePostfixExpression(ok);

  }

}

PreParser::Expression PreParser::ParsePostfixExpression(bool* ok) {

  // PostfixExpression ::

  //   LeftHandSideExpression ('++' | '--')?

  Scanner::Location before = scanner()->peek_location();

  Expression expression = ParseLeftHandSideExpression(CHECK_OK);

  if (!scanner()->HasAnyLineTerminatorBeforeNext() &&

      Token::IsCountOp(peek())) {

    if (!is_classic_mode() &&

        expression.IsIdentifier() &&

        expression.AsIdentifier().IsEvalOrArguments()) {

      Scanner::Location after = scanner()->location();

      ReportMessageAt(before.beg_pos, after.end_pos,

                      "strict_lhs_postfix", NULL);

      *ok = false;

      return Expression::Default();

    }

    Next();

    return Expression::Default();

  }

  return expression;

}

PreParser::Expression PreParser::ParseLeftHandSideExpression(bool* ok) {

  // LeftHandSideExpression ::

  //   (NewExpression | MemberExpression) ...

  Expression result = Expression::Default();

  if (peek() == Token::NEW) {

    result = ParseNewExpression(CHECK_OK);

  } else {

    result = ParseMemberExpression(CHECK_OK);

  }

  while (true) {

    switch (peek()) {

      case Token::LBRACK: {

        Consume(Token::LBRACK);

        ParseExpression(true, CHECK_OK);

        Expect(Token::RBRACK, CHECK_OK);

        if (result.IsThis()) {

          result = Expression::ThisProperty();

        } else {

          result = Expression::Default();

        }

        break;

      }

      case Token::LPAREN: {

        ParseArguments(CHECK_OK);

        result = Expression::Default();

        break;

      }

      case Token::PERIOD: {

        Consume(Token::PERIOD);

        ParseIdentifierName(CHECK_OK);

        if (result.IsThis()) {

          result = Expression::ThisProperty();

        } else {

          result = Expression::Default();

        }

        break;

      }

      default:

        return result;

    }

  }

}

PreParser::Expression PreParser::ParseNewExpression(bool* ok) {

  // NewExpression ::

  //   ('new')+ MemberExpression

  // The grammar for new expressions is pretty warped. The keyword

  // 'new' can either be a part of the new expression (where it isn't

  // followed by an argument list) or a part of the member expression,

  // where it must be followed by an argument list. To accommodate

  // this, we parse the 'new' keywords greedily and keep track of how

  // many we have parsed. This information is then passed on to the

  // member expression parser, which is only allowed to match argument

  // lists as long as it has 'new' prefixes left

  unsigned new_count = 0;

  do {

    Consume(Token::NEW);

    new_count++;

  } while (peek() == Token::NEW);

  return ParseMemberWithNewPrefixesExpression(new_count, ok);

}

PreParser::Expression PreParser::ParseMemberExpression(bool* ok) {

  return ParseMemberWithNewPrefixesExpression(0, ok);

}

PreParser::Expression PreParser::ParseMemberWithNewPrefixesExpression(

    unsigned new_count, bool* ok) {

  // MemberExpression ::

  //   (PrimaryExpression | FunctionLiteral)

  //     ('[' Expression ']' | '.' Identifier | Arguments)*

  // Parse the initial primary or function expression.

  Expression result = Expression::Default();

  if (peek() == Token::FUNCTION) {

    Consume(Token::FUNCTION);

    bool is_generator = allow_generators() && Check(Token::MUL);

    Identifier identifier = Identifier::Default();

    if (peek_any_identifier()) {

      identifier = ParseIdentifier(CHECK_OK);

    }

    result = ParseFunctionLiteral(is_generator, CHECK_OK);

    if (result.IsStrictFunction() && !identifier.IsValidStrictVariable()) {

      StrictModeIdentifierViolation(scanner()->location(),

                                    "strict_function_name",

                                    identifier,

                                    ok);

      return Expression::Default();

    }

  } else {

    result = ParsePrimaryExpression(CHECK_OK);

  }

  while (true) {

    switch (peek()) {

      case Token::LBRACK: {

        Consume(Token::LBRACK);

        ParseExpression(true, CHECK_OK);

        Expect(Token::RBRACK, CHECK_OK);

        if (result.IsThis()) {

          result = Expression::ThisProperty();

        } else {

          result = Expression::Default();

        }

        break;

      }

      case Token::PERIOD: {

        Consume(Token::PERIOD);

        ParseIdentifierName(CHECK_OK);

        if (result.IsThis()) {

          result = Expression::ThisProperty();

        } else {

          result = Expression::Default();

        }

        break;

      }

      case Token::LPAREN: {

        if (new_count == 0) return result;

        // Consume one of the new prefixes (already parsed).

        ParseArguments(CHECK_OK);

        new_count--;

        result = Expression::Default();

        break;

      }

      default:

        return result;

    }

  }

}

PreParser::Expression PreParser::ParsePrimaryExpression(bool* ok) {

  // PrimaryExpression ::

  //   'this'

  //   'null'

  //   'true'

  //   'false'

  //   Identifier

  //   Number

  //   String

  //   ArrayLiteral

  //   ObjectLiteral

  //   RegExpLiteral

  //   '(' Expression ')'

  Expression result = Expression::Default();

  switch (peek()) {

    case Token::THIS: {

      Next();

      result = Expression::This();

      break;

    }

    case Token::FUTURE_RESERVED_WORD:

    case Token::FUTURE_STRICT_RESERVED_WORD:

    case Token::YIELD:

    case Token::IDENTIFIER: {

      Identifier id = ParseIdentifier(CHECK_OK);

      result = Expression::FromIdentifier(id);

      break;

    }

    case Token::NULL_LITERAL:

    case Token::TRUE_LITERAL:

    case Token::FALSE_LITERAL:

    case Token::NUMBER: {

      Next();

      break;

    }

    case Token::STRING: {

      Next();

      result = GetStringSymbol();

      break;

    }

    case Token::ASSIGN_DIV:

      result = ParseRegExpLiteral(true, CHECK_OK);

      break;

    case Token::DIV:

      result = ParseRegExpLiteral(false, CHECK_OK);

      break;

    case Token::LBRACK:

      result = ParseArrayLiteral(CHECK_OK);

      break;

    case Token::LBRACE:

      result = ParseObjectLiteral(CHECK_OK);

      break;

    case Token::LPAREN:

      Consume(Token::LPAREN);

      parenthesized_function_ = (peek() == Token::FUNCTION);

      result = ParseExpression(true, CHECK_OK);

      Expect(Token::RPAREN, CHECK_OK);

      result = result.Parenthesize();

      break;

    case Token::MOD:

      result = ParseV8Intrinsic(CHECK_OK);

      break;

    default: {

      Next();

      *ok = false;

      return Expression::Default();

    }

  }

  return result;

}

PreParser::Expression PreParser::ParseArrayLiteral(bool* ok) {

  // ArrayLiteral ::

  //   '[' Expression? (',' Expression?)* ']'

  Expect(Token::LBRACK, CHECK_OK);

  while (peek() != Token::RBRACK) {

    if (peek() != Token::COMMA) {

      ParseAssignmentExpression(true, CHECK_OK);

    }

    if (peek() != Token::RBRACK) {

      Expect(Token::COMMA, CHECK_OK);

    }

  }

  Expect(Token::RBRACK, CHECK_OK);

  scope_->NextMaterializedLiteralIndex();

  return Expression::Default();

}

PreParser::Expression PreParser::ParseObjectLiteral(bool* ok) {

  // ObjectLiteral ::

  //   '{' (

  //       ((IdentifierName | String | Number) ':' AssignmentExpression)

  //     | (('get' | 'set') (IdentifierName | String | Number) FunctionLiteral)

  //    )*[','] '}'

  ObjectLiteralChecker checker(this, language_mode());

  Expect(Token::LBRACE, CHECK_OK);

  while (peek() != Token::RBRACE) {

    Token::Value next = peek();

    switch (next) {

      case Token::IDENTIFIER:

      case Token::FUTURE_RESERVED_WORD:

      case Token::FUTURE_STRICT_RESERVED_WORD: {

        bool is_getter = false;

        bool is_setter = false;

        ParseIdentifierNameOrGetOrSet(&is_getter, &is_setter, CHECK_OK);

        if ((is_getter || is_setter) && peek() != Token::COLON) {

            Token::Value name = Next();

            bool is_keyword = Token::IsKeyword(name);

            if (name != Token::IDENTIFIER &&

                name != Token::FUTURE_RESERVED_WORD &&

                name != Token::FUTURE_STRICT_RESERVED_WORD &&

                name != Token::NUMBER &&

                name != Token::STRING &&

                !is_keyword) {

              *ok = false;

              return Expression::Default();

            }

            if (!is_keyword) {

              LogSymbol();

            }

            PropertyKind type = is_getter ? kGetterProperty : kSetterProperty;

            checker.CheckProperty(name, type, CHECK_OK);

            ParseFunctionLiteral(false, CHECK_OK);

            if (peek() != Token::RBRACE) {

              Expect(Token::COMMA, CHECK_OK);

            }

            continue;  // restart the while

        }

        checker.CheckProperty(next, kValueProperty, CHECK_OK);

        break;

      }

      case Token::STRING:

        Consume(next);

        checker.CheckProperty(next, kValueProperty, CHECK_OK);

        GetStringSymbol();

        break;

      case Token::NUMBER:

        Consume(next);

        checker.CheckProperty(next, kValueProperty, CHECK_OK);

        break;

      default:

        if (Token::IsKeyword(next)) {

          Consume(next);

          checker.CheckProperty(next, kValueProperty, CHECK_OK);

        } else {

          // Unexpected token.

          *ok = false;

          return Expression::Default();

        }

    }

    Expect(Token::COLON, CHECK_OK);

    ParseAssignmentExpression(true, CHECK_OK);

    // TODO(1240767): Consider allowing trailing comma.

    if (peek() != Token::RBRACE) Expect(Token::COMMA, CHECK_OK);

  }

  Expect(Token::RBRACE, CHECK_OK);

  scope_->NextMaterializedLiteralIndex();

  return Expression::Default();

}

PreParser::Expression PreParser::ParseRegExpLiteral(bool seen_equal,

                                                    bool* ok) {

  if (!scanner()->ScanRegExpPattern(seen_equal)) {

    Next();

    ReportMessageAt(scanner()->location(), "unterminated_regexp", NULL);

    *ok = false;

    return Expression::Default();

  }

  scope_->NextMaterializedLiteralIndex();

  if (!scanner()->ScanRegExpFlags()) {

    Next();

    ReportMessageAt(scanner()->location(), "invalid_regexp_flags", NULL);

    *ok = false;

    return Expression::Default();

  }

  Next();

  return Expression::Default();

}

PreParser::Arguments PreParser::ParseArguments(bool* ok) {

  // Arguments ::

  //   '(' (AssignmentExpression)*[','] ')'

  Expect(Token::LPAREN, ok);

  if (!*ok) return -1;

  bool done = (peek() == Token::RPAREN);

  int argc = 0;

  while (!done) {

    ParseAssignmentExpression(true, ok);

    if (!*ok) return -1;

    argc++;

    done = (peek() == Token::RPAREN);

    if (!done) {

      Expect(Token::COMMA, ok);

      if (!*ok) return -1;

    }

  }

  Expect(Token::RPAREN, ok);

  return argc;

}

PreParser::Expression PreParser::ParseFunctionLiteral(bool is_generator,

                                                      bool* ok) {

  // Function ::

  //   '(' FormalParameterList? ')' '{' FunctionBody '}'

  // Parse function body.

  ScopeType outer_scope_type = scope_->type();

  bool inside_with = scope_->IsInsideWith();

  Scope function_scope(&scope_, kFunctionScope);

  function_scope.set_is_generator(is_generator);

  //  FormalParameterList ::

  //    '(' (Identifier)*[','] ')'

  Expect(Token::LPAREN, CHECK_OK);

  int start_position = position();

  bool done = (peek() == Token::RPAREN);

  DuplicateFinder duplicate_finder(scanner()->unicode_cache());

  while (!done) {

    Identifier id = ParseIdentifier(CHECK_OK);

    if (!id.IsValidStrictVariable()) {

      StrictModeIdentifierViolation(scanner()->location(),

                                    "strict_param_name",

                                    id,

                                    CHECK_OK);

    }

    int prev_value;

    if (scanner()->is_literal_ascii()) {

      prev_value =

          duplicate_finder.AddAsciiSymbol(scanner()->literal_ascii_string(), 1);

    } else {

      prev_value =

          duplicate_finder.AddUtf16Symbol(scanner()->literal_utf16_string(), 1);

    }

    if (prev_value != 0) {

      SetStrictModeViolation(scanner()->location(),

                             "strict_param_dupe",

                             CHECK_OK);

    }

    done = (peek() == Token::RPAREN);

    if (!done) {

      Expect(Token::COMMA, CHECK_OK);

    }

  }

  Expect(Token::RPAREN, CHECK_OK);

  // Determine if the function will be lazily compiled.

  // Currently only happens to top-level functions.

  // Optimistically assume that all top-level functions are lazily compiled.

  bool is_lazily_compiled = (outer_scope_type == kTopLevelScope &&

                             !inside_with && allow_lazy() &&

                             !parenthesized_function_);

  parenthesized_function_ = false;

  Expect(Token::LBRACE, CHECK_OK);

  if (is_lazily_compiled) {

    ParseLazyFunctionLiteralBody(CHECK_OK);

  } else {

    ParseSourceElements(Token::RBRACE, ok);

  }

  Expect(Token::RBRACE, CHECK_OK);

  if (!is_classic_mode()) {

    int end_position = scanner()->location().end_pos;