/deps/v8/src/preparser.cc - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/preparser.cc

     #include "unicode.h"
     #include "utils.h"
     #ifdef _MSC_VER
     #if V8_CC_MSVC && (_MSC_VER < 1800)
     namespace std {
     // Usually defined in math.h, but not in MSVC.
     // Usually defined in math.h, but not in MSVC until VS2013+.
     // Abstracted to work
     int isfinite(double value);
-...
     #endif
     namespace v8 {
     namespace preparser {
     namespace internal {
     PreParser::PreParseResult PreParser::PreParseLazyFunction(
         i::LanguageMode mode, bool is_generator, i::ParserRecorder* log) {
         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(i::Token::LBRACE, scanner_->current_token());
       ASSERT_EQ(Token::LBRACE, scanner()->current_token());
       bool ok = true;
       int start_position = scanner_->peek_location().beg_pos;
       int start_position = peek_position();
       ParseLazyFunctionLiteralBody(&ok);
       if (stack_overflow_) return kPreParseStackOverflow;
       if (stack_overflow()) return kPreParseStackOverflow;
       if (!ok) {
         ReportUnexpectedToken(scanner_->current_token());
         ReportUnexpectedToken(scanner()->current_token());
       } else {
         ASSERT_EQ(i::Token::RBRACE, scanner_->peek());
         ASSERT_EQ(Token::RBRACE, scanner()->peek());
         if (!is_classic_mode()) {
           int end_pos = scanner_->location().end_pos;
           int end_pos = scanner()->location().end_pos;
           CheckOctalLiteral(start_position, end_pos, &ok);
           if (ok) {
             CheckDelayedStrictModeViolation(start_position, end_pos, &ok);
-...
     // That means that contextual checks (like a label being declared where
     // it is used) are generally omitted.
     void PreParser::ReportUnexpectedToken(i::Token::Value token) {
     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 == i::Token::ILLEGAL && stack_overflow_) {
       if (token == Token::ILLEGAL && stack_overflow()) {
         return;
+      }
       i::Scanner::Location source_location = scanner_->location();
       Scanner::Location source_location = scanner()->location();
       // Four of the tokens are treated specially
       switch (token) {
       case i::Token::EOS:
       case Token::EOS:
         return ReportMessageAt(source_location, "unexpected_eos", NULL);
       case i::Token::NUMBER:
       case Token::NUMBER:
         return ReportMessageAt(source_location, "unexpected_token_number", NULL);
       case i::Token::STRING:
       case Token::STRING:
         return ReportMessageAt(source_location, "unexpected_token_string", NULL);
       case i::Token::IDENTIFIER:
       case Token::IDENTIFIER:
         return ReportMessageAt(source_location,
                                "unexpected_token_identifier", NULL);
       case i::Token::FUTURE_RESERVED_WORD:
       case Token::FUTURE_RESERVED_WORD:
         return ReportMessageAt(source_location, "unexpected_reserved", NULL);
       case i::Token::FUTURE_STRICT_RESERVED_WORD:
       case Token::FUTURE_STRICT_RESERVED_WORD:
         return ReportMessageAt(source_location,
                                "unexpected_strict_reserved", NULL);
       default:
         const char* name = i::Token::String(token);
         const char* name = Token::String(token);
         ReportMessageAt(source_location, "unexpected_token", name);
+      }
+    }
     // Checks whether octal literal last seen is between beg_pos and end_pos.
     // If so, reports an error.
     void PreParser::CheckOctalLiteral(int beg_pos, int end_pos, bool* ok) {
       i::Scanner::Location octal = scanner_->octal_position();
       if (beg_pos <= octal.beg_pos && octal.end_pos <= end_pos) {
         ReportMessageAt(octal, "strict_octal_literal", NULL);
         scanner_->clear_octal_position();
         *ok = false;
+      }
+    }
     #define CHECK_OK  ok);                      \
       if (!*ok) return kUnknownSourceElements;  \
       ((void)0
-...
       //    GeneratorDeclaration
       switch (peek()) {
         case i::Token::FUNCTION:
         case Token::FUNCTION:
           return ParseFunctionDeclaration(ok);
         case i::Token::LET:
         case i::Token::CONST:
         case Token::LET:
         case Token::CONST:
           return ParseVariableStatement(kSourceElement, ok);
         default:
           return ParseStatement(ok);
-...
         if (allow_directive_prologue) {
           if (statement.IsUseStrictLiteral()) {
             set_language_mode(allow_harmony_scoping() ?
                               i::EXTENDED_MODE : i::STRICT_MODE);
                               EXTENDED_MODE : STRICT_MODE);
           } else if (!statement.IsStringLiteral()) {
             allow_directive_prologue = false;
+          }
-...
       // Keep the source position of the statement
       switch (peek()) {
         case i::Token::LBRACE:
         case Token::LBRACE:
           return ParseBlock(ok);
         case i::Token::CONST:
         case i::Token::LET:
         case i::Token::VAR:
         case Token::CONST:
         case Token::LET:
         case Token::VAR:
           return ParseVariableStatement(kStatement, ok);
         case i::Token::SEMICOLON:
         case Token::SEMICOLON:
           Next();
           return Statement::Default();
         case i::Token::IF:
         case Token::IF:
           return ParseIfStatement(ok);
         case i::Token::DO:
         case Token::DO:
           return ParseDoWhileStatement(ok);
         case i::Token::WHILE:
         case Token::WHILE:
           return ParseWhileStatement(ok);
         case i::Token::FOR:
         case Token::FOR:
           return ParseForStatement(ok);
         case i::Token::CONTINUE:
         case Token::CONTINUE:
           return ParseContinueStatement(ok);
         case i::Token::BREAK:
         case Token::BREAK:
           return ParseBreakStatement(ok);
         case i::Token::RETURN:
         case Token::RETURN:
           return ParseReturnStatement(ok);
         case i::Token::WITH:
         case Token::WITH:
           return ParseWithStatement(ok);
         case i::Token::SWITCH:
         case Token::SWITCH:
           return ParseSwitchStatement(ok);
         case i::Token::THROW:
         case Token::THROW:
           return ParseThrowStatement(ok);
         case i::Token::TRY:
         case Token::TRY:
           return ParseTryStatement(ok);
         case i::Token::FUNCTION: {
           i::Scanner::Location start_location = scanner_->peek_location();
         case Token::FUNCTION: {
           Scanner::Location start_location = scanner()->peek_location();
           Statement statement = ParseFunctionDeclaration(CHECK_OK);
           i::Scanner::Location end_location = scanner_->location();
           Scanner::Location end_location = scanner()->location();
           if (!is_classic_mode()) {
             ReportMessageAt(start_location.beg_pos, end_location.end_pos,
                             "strict_function", NULL);
-...
+          }
+        }
         case i::Token::DEBUGGER:
         case Token::DEBUGGER:
           return ParseDebuggerStatement(ok);
         default:
-...
       // GeneratorDeclaration ::
       //   'function' '*' Identifier '(' FormalParameterListopt ')'
       //      '{' FunctionBody '}'
       Expect(i::Token::FUNCTION, CHECK_OK);
       Expect(Token::FUNCTION, CHECK_OK);
       bool is_generator = allow_generators_ && Check(i::Token::MUL);
       bool is_generator = allow_generators() && Check(Token::MUL);
       Identifier identifier = ParseIdentifier(CHECK_OK);
       i::Scanner::Location location = scanner_->location();
       Scanner::Location location = scanner()->location();
       Expression function_value = ParseFunctionLiteral(is_generator, CHECK_OK);
-...
       // Note that a Block does not introduce a new execution scope!
       // (ECMA-262, 3rd, 12.2)
       //
       Expect(i::Token::LBRACE, CHECK_OK);
       while (peek() != i::Token::RBRACE) {
       Expect(Token::LBRACE, CHECK_OK);
       while (peek() != Token::RBRACE) {
         if (is_extended_mode()) {
           ParseSourceElement(CHECK_OK);
         } else {
           ParseStatement(CHECK_OK);
+        }
+      }
       Expect(i::Token::RBRACE, ok);
       Expect(Token::RBRACE, ok);
       return Statement::Default();
+    }
-...
       // ConstBinding ::
       //   BindingPattern '=' AssignmentExpression
       bool require_initializer = false;
       if (peek() == i::Token::VAR) {
         Consume(i::Token::VAR);
       } else if (peek() == i::Token::CONST) {
       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)* ';'
-...
         // 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(i::Token::CONST);
         Consume(Token::CONST);
         switch (language_mode()) {
           case i::CLASSIC_MODE:
           case CLASSIC_MODE:
             break;
           case i::STRICT_MODE: {
             i::Scanner::Location location = scanner_->peek_location();
           case STRICT_MODE: {
             Scanner::Location location = scanner()->peek_location();
             ReportMessageAt(location, "strict_const", NULL);
             *ok = false;
             return Statement::Default();
+          }
           case i::EXTENDED_MODE:
           case EXTENDED_MODE:
             if (var_context != kSourceElement &&
                 var_context != kForStatement) {
               i::Scanner::Location location = scanner_->peek_location();
               Scanner::Location location = scanner()->peek_location();
               ReportMessageAt(location.beg_pos, location.end_pos,
                               "unprotected_const", NULL);
               *ok = false;
-...
             require_initializer = true;
             break;
+        }
       } else if (peek() == i::Token::LET) {
       } 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()) {
           i::Scanner::Location location = scanner_->peek_location();
           Scanner::Location location = scanner()->peek_location();
           ReportMessageAt(location.beg_pos, location.end_pos,
                           "illegal_let", NULL);
           *ok = false;
           return Statement::Default();
+        }
         Consume(i::Token::LET);
         Consume(Token::LET);
         if (var_context != kSourceElement &&
             var_context != kForStatement) {
           i::Scanner::Location location = scanner_->peek_location();
           Scanner::Location location = scanner()->peek_location();
           ReportMessageAt(location.beg_pos, location.end_pos,
                           "unprotected_let", NULL);
           *ok = false;
-...
       int nvars = 0;  // the number of variables declared
       do {
         // Parse variable name.
         if (nvars > 0) Consume(i::Token::COMMA);
         if (nvars > 0) Consume(Token::COMMA);
         Identifier identifier  = ParseIdentifier(CHECK_OK);
         if (!is_classic_mode() && !identifier.IsValidStrictVariable()) {
           StrictModeIdentifierViolation(scanner_->location(),
           StrictModeIdentifierViolation(scanner()->location(),
                                         "strict_var_name",
                                         identifier,
                                         ok);
           return Statement::Default();
+        }
         nvars++;
         if (peek() == i::Token::ASSIGN || require_initializer) {
           Expect(i::Token::ASSIGN, CHECK_OK);
         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() == i::Token::COMMA);
       } while (peek() == Token::COMMA);
       if (num_decl != NULL) *num_decl = nvars;
       return Statement::Default();
-...
         ASSERT(is_classic_mode() ||
                (!expr.AsIdentifier().IsFutureStrictReserved() &&
                 !expr.AsIdentifier().IsYield()));
         if (peek() == i::Token::COLON) {
           Consume(i::Token::COLON);
         if (peek() == Token::COLON) {
           Consume(Token::COLON);
           return ParseStatement(ok);
+        }
         // Preparsing is disabled for extensions (because the extension details
-...
       // IfStatement ::
       //   'if' '(' Expression ')' Statement ('else' Statement)?
       Expect(i::Token::IF, CHECK_OK);
       Expect(i::Token::LPAREN, CHECK_OK);
       Expect(Token::IF, CHECK_OK);
       Expect(Token::LPAREN, CHECK_OK);
       ParseExpression(true, CHECK_OK);
       Expect(i::Token::RPAREN, CHECK_OK);
       Expect(Token::RPAREN, CHECK_OK);
       ParseStatement(CHECK_OK);
       if (peek() == i::Token::ELSE) {
       if (peek() == Token::ELSE) {
         Next();
         ParseStatement(CHECK_OK);
+      }
-...
       // ContinueStatement ::
       //   'continue' [no line terminator] Identifier? ';'
       Expect(i::Token::CONTINUE, CHECK_OK);
       i::Token::Value tok = peek();
       if (!scanner_->HasAnyLineTerminatorBeforeNext() &&
           tok != i::Token::SEMICOLON &&
           tok != i::Token::RBRACE &&
           tok != i::Token::EOS) {
       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);
-...
       // BreakStatement ::
       //   'break' [no line terminator] Identifier? ';'
       Expect(i::Token::BREAK, CHECK_OK);
       i::Token::Value tok = peek();
       if (!scanner_->HasAnyLineTerminatorBeforeNext() &&
           tok != i::Token::SEMICOLON &&
           tok != i::Token::RBRACE &&
           tok != i::Token::EOS) {
       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);
-...
       // 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(i::Token::RETURN, CHECK_OK);
       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.
       i::Token::Value tok = peek();
       if (!scanner_->HasAnyLineTerminatorBeforeNext() &&
           tok != i::Token::SEMICOLON &&
           tok != i::Token::RBRACE &&
           tok != i::Token::EOS) {
       Token::Value tok = peek();
       if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
           tok != Token::SEMICOLON &&
           tok != Token::RBRACE &&
           tok != Token::EOS) {
         ParseExpression(true, CHECK_OK);
+      }
       ExpectSemicolon(CHECK_OK);
-...
     PreParser::Statement PreParser::ParseWithStatement(bool* ok) {
       // WithStatement ::
       //   'with' '(' Expression ')' Statement
       Expect(i::Token::WITH, CHECK_OK);
       Expect(Token::WITH, CHECK_OK);
       if (!is_classic_mode()) {
         i::Scanner::Location location = scanner_->location();
         Scanner::Location location = scanner()->location();
         ReportMessageAt(location, "strict_mode_with", NULL);
         *ok = false;
         return Statement::Default();
+      }
       Expect(i::Token::LPAREN, CHECK_OK);
       Expect(Token::LPAREN, CHECK_OK);
       ParseExpression(true, CHECK_OK);
       Expect(i::Token::RPAREN, CHECK_OK);
       Expect(Token::RPAREN, CHECK_OK);
       Scope::InsideWith iw(scope_);
       ParseStatement(CHECK_OK);
-...
       // SwitchStatement ::
       //   'switch' '(' Expression ')' '{' CaseClause* '}'
       Expect(i::Token::SWITCH, CHECK_OK);
       Expect(i::Token::LPAREN, CHECK_OK);
       Expect(Token::SWITCH, CHECK_OK);
       Expect(Token::LPAREN, CHECK_OK);
       ParseExpression(true, CHECK_OK);
       Expect(i::Token::RPAREN, CHECK_OK);
       Expect(Token::RPAREN, CHECK_OK);
       Expect(i::Token::LBRACE, CHECK_OK);
       i::Token::Value token = peek();
       while (token != i::Token::RBRACE) {
         if (token == i::Token::CASE) {
           Expect(i::Token::CASE, 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(i::Token::DEFAULT, CHECK_OK);
           Expect(Token::DEFAULT, CHECK_OK);
+        }
         Expect(i::Token::COLON, CHECK_OK);
         Expect(Token::COLON, CHECK_OK);
         token = peek();
         while (token != i::Token::CASE &&
                token != i::Token::DEFAULT &&
                token != i::Token::RBRACE) {
         while (token != Token::CASE &&
                token != Token::DEFAULT &&
                token != Token::RBRACE) {
           ParseStatement(CHECK_OK);
           token = peek();
+        }
+      }
       Expect(i::Token::RBRACE, ok);
       Expect(Token::RBRACE, ok);
       return Statement::Default();
+    }
-...
       // DoStatement ::
       //   'do' Statement 'while' '(' Expression ')' ';'
       Expect(i::Token::DO, CHECK_OK);
       Expect(Token::DO, CHECK_OK);
       ParseStatement(CHECK_OK);
       Expect(i::Token::WHILE, CHECK_OK);
       Expect(i::Token::LPAREN, CHECK_OK);
       Expect(Token::WHILE, CHECK_OK);
       Expect(Token::LPAREN, CHECK_OK);
       ParseExpression(true, CHECK_OK);
       Expect(i::Token::RPAREN, ok);
       if (peek() == i::Token::SEMICOLON) Consume(i::Token::SEMICOLON);
       Expect(Token::RPAREN, ok);
       if (peek() == Token::SEMICOLON) Consume(Token::SEMICOLON);
       return Statement::Default();
+    }
-...
       // WhileStatement ::
       //   'while' '(' Expression ')' Statement
       Expect(i::Token::WHILE, CHECK_OK);
       Expect(i::Token::LPAREN, CHECK_OK);
       Expect(Token::WHILE, CHECK_OK);
       Expect(Token::LPAREN, CHECK_OK);
       ParseExpression(true, CHECK_OK);
       Expect(i::Token::RPAREN, CHECK_OK);
       Expect(Token::RPAREN, CHECK_OK);
       ParseStatement(ok);
       return Statement::Default();
+    }
     bool PreParser::CheckInOrOf(bool accept_OF) {
       if (peek() == i::Token::IN ||
           (allow_for_of() && accept_OF && peek() == i::Token::IDENTIFIER &&
            scanner_->is_next_contextual_keyword(v8::internal::CStrVector("of")))) {
         Next();
       if (Check(Token::IN) ||
           (allow_for_of() && accept_OF &&
            CheckContextualKeyword(CStrVector("of")))) {
         return true;
+      }
       return false;
-...
       // ForStatement ::
       //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
       Expect(i::Token::FOR, CHECK_OK);
       Expect(i::Token::LPAREN, CHECK_OK);
       if (peek() != i::Token::SEMICOLON) {
         if (peek() == i::Token::VAR || peek() == i::Token::CONST ||
             peek() == i::Token::LET) {
           bool is_let = peek() == i::Token::LET;
       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(
-...
           bool accept_OF = !has_initializers;
           if (accept_IN && CheckInOrOf(accept_OF)) {
             ParseExpression(true, CHECK_OK);
             Expect(i::Token::RPAREN, CHECK_OK);
             Expect(Token::RPAREN, CHECK_OK);
             ParseStatement(CHECK_OK);
             return Statement::Default();
-...
           Expression lhs = ParseExpression(false, CHECK_OK);
           if (CheckInOrOf(lhs.IsIdentifier())) {
             ParseExpression(true, CHECK_OK);
             Expect(i::Token::RPAREN, CHECK_OK);
             Expect(Token::RPAREN, CHECK_OK);
             ParseStatement(CHECK_OK);
             return Statement::Default();
-...
+      }
       // Parsed initializer at this point.
       Expect(i::Token::SEMICOLON, CHECK_OK);
       Expect(Token::SEMICOLON, CHECK_OK);
       if (peek() != i::Token::SEMICOLON) {
       if (peek() != Token::SEMICOLON) {
         ParseExpression(true, CHECK_OK);
+      }
       Expect(i::Token::SEMICOLON, CHECK_OK);
       Expect(Token::SEMICOLON, CHECK_OK);
       if (peek() != i::Token::RPAREN) {
       if (peek() != Token::RPAREN) {
         ParseExpression(true, CHECK_OK);
+      }
       Expect(i::Token::RPAREN, CHECK_OK);
       Expect(Token::RPAREN, CHECK_OK);
       ParseStatement(ok);
       return Statement::Default();
-...
       // ThrowStatement ::
       //   'throw' [no line terminator] Expression ';'
       Expect(i::Token::THROW, CHECK_OK);
       if (scanner_->HasAnyLineTerminatorBeforeNext()) {
         i::Scanner::Location pos = scanner_->location();
       Expect(Token::THROW, CHECK_OK);
       if (scanner()->HasAnyLineTerminatorBeforeNext()) {
         Scanner::Location pos = scanner()->location();
         ReportMessageAt(pos, "newline_after_throw", NULL);
         *ok = false;
         return Statement::Default();
-...
       // In preparsing, allow any number of catch/finally blocks, including zero
       // of both.
       Expect(i::Token::TRY, CHECK_OK);
       Expect(Token::TRY, CHECK_OK);
       ParseBlock(CHECK_OK);
       bool catch_or_finally_seen = false;
       if (peek() == i::Token::CATCH) {
         Consume(i::Token::CATCH);
         Expect(i::Token::LPAREN, CHECK_OK);
       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(),
           StrictModeIdentifierViolation(scanner()->location(),
                                         "strict_catch_variable",
                                         id,
                                         ok);
           return Statement::Default();
+        }
         Expect(i::Token::RPAREN, CHECK_OK);
         Expect(Token::RPAREN, CHECK_OK);
         { Scope::InsideWith iw(scope_);
           ParseBlock(CHECK_OK);
+        }
         catch_or_finally_seen = true;
+      }
       if (peek() == i::Token::FINALLY) {
         Consume(i::Token::FINALLY);
       if (peek() == Token::FINALLY) {
         Consume(Token::FINALLY);
         ParseBlock(CHECK_OK);
         catch_or_finally_seen = true;
+      }
-...
       // DebuggerStatement ::
       //   'debugger' ';'
       Expect(i::Token::DEBUGGER, CHECK_OK);
       Expect(Token::DEBUGGER, CHECK_OK);
       ExpectSemicolon(ok);
       return Statement::Default();
+    }
-...
       //   Expression ',' AssignmentExpression
       Expression result = ParseAssignmentExpression(accept_IN, CHECK_OK);
       while (peek() == i::Token::COMMA) {
         Expect(i::Token::COMMA, CHECK_OK);
       while (peek() == Token::COMMA) {
         Expect(Token::COMMA, CHECK_OK);
         ParseAssignmentExpression(accept_IN, CHECK_OK);
         result = Expression::Default();
+      }
-...
       //   YieldExpression
       //   LeftHandSideExpression AssignmentOperator AssignmentExpression
       if (scope_->is_generator() && peek() == i::Token::YIELD) {
       if (scope_->is_generator() && peek() == Token::YIELD) {
         return ParseYieldExpression(ok);
+      }
       i::Scanner::Location before = scanner_->peek_location();
       Scanner::Location before = scanner()->peek_location();
       Expression expression = ParseConditionalExpression(accept_IN, CHECK_OK);
       if (!i::Token::IsAssignmentOp(peek())) {
       if (!Token::IsAssignmentOp(peek())) {
         // Parsed conditional expression only (no assignment).
         return expression;
+      }
-...
       if (!is_classic_mode() &&
           expression.IsIdentifier() &&
           expression.AsIdentifier().IsEvalOrArguments()) {
         i::Scanner::Location after = scanner_->location();
         Scanner::Location after = scanner()->location();
         ReportMessageAt(before.beg_pos, after.end_pos,
                         "strict_lhs_assignment", NULL);
         *ok = false;
         return Expression::Default();
+      }
       i::Token::Value op = Next();  // Get assignment operator.
       Token::Value op = Next();  // Get assignment operator.
       ParseAssignmentExpression(accept_IN, CHECK_OK);
       if ((op == i::Token::ASSIGN) && expression.IsThisProperty()) {
       if ((op == Token::ASSIGN) && expression.IsThisProperty()) {
         scope_->AddProperty();
+      }
-...
     PreParser::Expression PreParser::ParseYieldExpression(bool* ok) {
       // YieldExpression ::
       //   'yield' '*'? AssignmentExpression
       Consume(i::Token::YIELD);
       Check(i::Token::MUL);
       Consume(Token::YIELD);
       Check(Token::MUL);
       ParseAssignmentExpression(false, CHECK_OK);
-...
       // We start using the binary expression parser for prec >= 4 only!
       Expression expression = ParseBinaryExpression(4, accept_IN, CHECK_OK);
       if (peek() != i::Token::CONDITIONAL) return expression;
       Consume(i::Token::CONDITIONAL);
       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(i::Token::COLON, CHECK_OK);
       Expect(Token::COLON, CHECK_OK);
       ParseAssignmentExpression(accept_IN, CHECK_OK);
       return Expression::Default();
+    }
     int PreParser::Precedence(i::Token::Value tok, bool accept_IN) {
       if (tok == i::Token::IN && !accept_IN)
         return 0;  // 0 precedence will terminate binary expression parsing
       return i::Token::Precedence(tok);
+    }
     // Precedence >= 4
     PreParser::Expression PreParser::ParseBinaryExpression(int prec,
                                                            bool accept_IN,
-...
       //   '~' UnaryExpression
       //   '!' UnaryExpression
       i::Token::Value op = peek();
       if (i::Token::IsUnaryOp(op)) {
       Token::Value op = peek();
       if (Token::IsUnaryOp(op)) {
         op = Next();
         ParseUnaryExpression(ok);
         return Expression::Default();
       } else if (i::Token::IsCountOp(op)) {
       } else if (Token::IsCountOp(op)) {
         op = Next();
         i::Scanner::Location before = scanner_->peek_location();
         Scanner::Location before = scanner()->peek_location();
         Expression expression = ParseUnaryExpression(CHECK_OK);
         if (!is_classic_mode() &&
             expression.IsIdentifier() &&
             expression.AsIdentifier().IsEvalOrArguments()) {
           i::Scanner::Location after = scanner_->location();
           Scanner::Location after = scanner()->location();
           ReportMessageAt(before.beg_pos, after.end_pos,
                           "strict_lhs_prefix", NULL);
           *ok = false;
-...
       // PostfixExpression ::
       //   LeftHandSideExpression ('++' | '--')?
       i::Scanner::Location before = scanner_->peek_location();
       Scanner::Location before = scanner()->peek_location();
       Expression expression = ParseLeftHandSideExpression(CHECK_OK);
       if (!scanner_->HasAnyLineTerminatorBeforeNext() &&
           i::Token::IsCountOp(peek())) {
       if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
           Token::IsCountOp(peek())) {
         if (!is_classic_mode() &&
             expression.IsIdentifier() &&
             expression.AsIdentifier().IsEvalOrArguments()) {
           i::Scanner::Location after = scanner_->location();
           Scanner::Location after = scanner()->location();
           ReportMessageAt(before.beg_pos, after.end_pos,
                           "strict_lhs_postfix", NULL);
           *ok = false;
-...
       //   (NewExpression | MemberExpression) ...
       Expression result = Expression::Default();
       if (peek() == i::Token::NEW) {
       if (peek() == Token::NEW) {
         result = ParseNewExpression(CHECK_OK);
       } else {
         result = ParseMemberExpression(CHECK_OK);
-...
       while (true) {
         switch (peek()) {
           case i::Token::LBRACK: {
             Consume(i::Token::LBRACK);
           case Token::LBRACK: {
             Consume(Token::LBRACK);
             ParseExpression(true, CHECK_OK);
             Expect(i::Token::RBRACK, CHECK_OK);
             Expect(Token::RBRACK, CHECK_OK);
             if (result.IsThis()) {
               result = Expression::ThisProperty();
             } else {
-...
             break;
+          }
           case i::Token::LPAREN: {
           case Token::LPAREN: {
             ParseArguments(CHECK_OK);
             result = Expression::Default();
             break;
+          }
           case i::Token::PERIOD: {
             Consume(i::Token::PERIOD);
           case Token::PERIOD: {
             Consume(Token::PERIOD);
             ParseIdentifierName(CHECK_OK);
             if (result.IsThis()) {
               result = Expression::ThisProperty();
-...
       // lists as long as it has 'new' prefixes left
       unsigned new_count = 0;
       do {
         Consume(i::Token::NEW);
         Consume(Token::NEW);
         new_count++;
       } while (peek() == i::Token::NEW);
       } while (peek() == Token::NEW);
       return ParseMemberWithNewPrefixesExpression(new_count, ok);
+    }
-...
       // Parse the initial primary or function expression.
       Expression result = Expression::Default();
       if (peek() == i::Token::FUNCTION) {
         Consume(i::Token::FUNCTION);
       if (peek() == Token::FUNCTION) {
         Consume(Token::FUNCTION);
         bool is_generator = allow_generators_ && Check(i::Token::MUL);
         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(),
           StrictModeIdentifierViolation(scanner()->location(),
                                         "strict_function_name",
                                         identifier,
                                         ok);
-...
       while (true) {
         switch (peek()) {
           case i::Token::LBRACK: {
             Consume(i::Token::LBRACK);
           case Token::LBRACK: {
             Consume(Token::LBRACK);
             ParseExpression(true, CHECK_OK);
             Expect(i::Token::RBRACK, CHECK_OK);
             Expect(Token::RBRACK, CHECK_OK);
             if (result.IsThis()) {
               result = Expression::ThisProperty();
             } else {
-...
+            }
             break;
+          }
           case i::Token::PERIOD: {
             Consume(i::Token::PERIOD);
           case Token::PERIOD: {
             Consume(Token::PERIOD);
             ParseIdentifierName(CHECK_OK);
             if (result.IsThis()) {
               result = Expression::ThisProperty();
-...
+            }
             break;
+          }
           case i::Token::LPAREN: {
           case Token::LPAREN: {
             if (new_count == 0) return result;
             // Consume one of the new prefixes (already parsed).
             ParseArguments(CHECK_OK);
-...
       Expression result = Expression::Default();
       switch (peek()) {
         case i::Token::THIS: {
         case Token::THIS: {
           Next();
           result = Expression::This();
           break;
+        }
         case i::Token::FUTURE_RESERVED_WORD:
         case i::Token::FUTURE_STRICT_RESERVED_WORD:
         case i::Token::YIELD:
         case i::Token::IDENTIFIER: {
         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 i::Token::NULL_LITERAL:
         case i::Token::TRUE_LITERAL:
         case i::Token::FALSE_LITERAL:
         case i::Token::NUMBER: {
         case Token::NULL_LITERAL:
         case Token::TRUE_LITERAL:
         case Token::FALSE_LITERAL:
         case Token::NUMBER: {
           Next();
           break;
+        }
         case i::Token::STRING: {
         case Token::STRING: {
           Next();
           result = GetStringSymbol();
           break;
+        }
         case i::Token::ASSIGN_DIV:
         case Token::ASSIGN_DIV:
           result = ParseRegExpLiteral(true, CHECK_OK);
           break;
         case i::Token::DIV:
         case Token::DIV:
           result = ParseRegExpLiteral(false, CHECK_OK);
           break;
         case i::Token::LBRACK:
         case Token::LBRACK:
           result = ParseArrayLiteral(CHECK_OK);
           break;
         case i::Token::LBRACE:
         case Token::LBRACE:
           result = ParseObjectLiteral(CHECK_OK);
           break;
         case i::Token::LPAREN:
           Consume(i::Token::LPAREN);
           parenthesized_function_ = (peek() == i::Token::FUNCTION);
         case Token::LPAREN:
           Consume(Token::LPAREN);
           parenthesized_function_ = (peek() == Token::FUNCTION);
           result = ParseExpression(true, CHECK_OK);
           Expect(i::Token::RPAREN, CHECK_OK);
           Expect(Token::RPAREN, CHECK_OK);
           result = result.Parenthesize();
           break;
         case i::Token::MOD:
         case Token::MOD:
           result = ParseV8Intrinsic(CHECK_OK);
           break;
-...
     PreParser::Expression PreParser::ParseArrayLiteral(bool* ok) {
       // ArrayLiteral ::
       //   '[' Expression? (',' Expression?)* ']'
       Expect(i::Token::LBRACK, CHECK_OK);
       while (peek() != i::Token::RBRACK) {
         if (peek() != i::Token::COMMA) {
       Expect(Token::LBRACK, CHECK_OK);
       while (peek() != Token::RBRACK) {
         if (peek() != Token::COMMA) {
           ParseAssignmentExpression(true, CHECK_OK);
+        }
         if (peek() != i::Token::RBRACK) {
           Expect(i::Token::COMMA, CHECK_OK);
         if (peek() != Token::RBRACK) {
           Expect(Token::COMMA, CHECK_OK);
+        }
+      }
       Expect(i::Token::RBRACK, CHECK_OK);
       Expect(Token::RBRACK, CHECK_OK);
       scope_->NextMaterializedLiteralIndex();
       return Expression::Default();
+    }
     void PreParser::CheckDuplicate(DuplicateFinder* finder,
                                    i::Token::Value property,
                                    int type,
                                    bool* ok) {
       int old_type;
       if (property == i::Token::NUMBER) {
         old_type = finder->AddNumber(scanner_->literal_ascii_string(), type);
       } else if (scanner_->is_literal_ascii()) {
         old_type = finder->AddAsciiSymbol(scanner_->literal_ascii_string(),
                                           type);
       } else {
         old_type = finder->AddUtf16Symbol(scanner_->literal_utf16_string(), type);
+      }
       if (HasConflict(old_type, type)) {
         if (IsDataDataConflict(old_type, type)) {
           // Both are data properties.
           if (is_classic_mode()) return;
           ReportMessageAt(scanner_->location(),
                           "strict_duplicate_property", NULL);
         } else if (IsDataAccessorConflict(old_type, type)) {
           // Both a data and an accessor property with the same name.
           ReportMessageAt(scanner_->location(),
                           "accessor_data_property", NULL);
         } else {
           ASSERT(IsAccessorAccessorConflict(old_type, type));
           // Both accessors of the same type.
           ReportMessageAt(scanner_->location(),
                           "accessor_get_set", NULL);
+        }
         *ok = false;
+      }
+    }
     PreParser::Expression PreParser::ParseObjectLiteral(bool* ok) {
       // ObjectLiteral ::
-...
       //     | (('get' | 'set') (IdentifierName | String | Number) FunctionLiteral)
       //    )*[','] '}'
       Expect(i::Token::LBRACE, CHECK_OK);
       DuplicateFinder duplicate_finder(scanner_->unicode_cache());
       while (peek() != i::Token::RBRACE) {
         i::Token::Value next = peek();
       ObjectLiteralChecker checker(this, language_mode());
       Expect(Token::LBRACE, CHECK_OK);
       while (peek() != Token::RBRACE) {
         Token::Value next = peek();
         switch (next) {
           case i::Token::IDENTIFIER:
           case i::Token::FUTURE_RESERVED_WORD:
           case i::Token::FUTURE_STRICT_RESERVED_WORD: {
           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() != i::Token::COLON) {
                 i::Token::Value name = Next();
                 bool is_keyword = i::Token::IsKeyword(name);
                 if (name != i::Token::IDENTIFIER &&
                     name != i::Token::FUTURE_RESERVED_WORD &&
                     name != i::Token::FUTURE_STRICT_RESERVED_WORD &&
                     name != i::Token::NUMBER &&
                     name != i::Token::STRING &&
             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();
+                }
                 PropertyType type = is_getter ? kGetterProperty : kSetterProperty;
                 CheckDuplicate(&duplicate_finder, name, type, CHECK_OK);
                 PropertyKind type = is_getter ? kGetterProperty : kSetterProperty;
                 checker.CheckProperty(name, type, CHECK_OK);
                 ParseFunctionLiteral(false, CHECK_OK);
                 if (peek() != i::Token::RBRACE) {
                   Expect(i::Token::COMMA, CHECK_OK);
                 if (peek() != Token::RBRACE) {
                   Expect(Token::COMMA, CHECK_OK);
+                }
                 continue;  // restart the while
+            }
             CheckDuplicate(&duplicate_finder, next, kValueProperty, CHECK_OK);
             checker.CheckProperty(next, kValueProperty, CHECK_OK);
             break;
+          }
           case i::Token::STRING:
           case Token::STRING:
             Consume(next);
             CheckDuplicate(&duplicate_finder, next, kValueProperty, CHECK_OK);
             checker.CheckProperty(next, kValueProperty, CHECK_OK);
             GetStringSymbol();
             break;
           case i::Token::NUMBER:
           case Token::NUMBER:
             Consume(next);
             CheckDuplicate(&duplicate_finder, next, kValueProperty, CHECK_OK);
             checker.CheckProperty(next, kValueProperty, CHECK_OK);
             break;
           default:
             if (i::Token::IsKeyword(next)) {
             if (Token::IsKeyword(next)) {
               Consume(next);
               CheckDuplicate(&duplicate_finder, next, kValueProperty, CHECK_OK);
               checker.CheckProperty(next, kValueProperty, CHECK_OK);
             } else {
               // Unexpected token.
               *ok = false;
-...
+            }
+        }
         Expect(i::Token::COLON, CHECK_OK);
         Expect(Token::COLON, CHECK_OK);
         ParseAssignmentExpression(true, CHECK_OK);
         // TODO(1240767): Consider allowing trailing comma.
         if (peek() != i::Token::RBRACE) Expect(i::Token::COMMA, CHECK_OK);
         if (peek() != Token::RBRACE) Expect(Token::COMMA, CHECK_OK);
+      }
       Expect(i::Token::RBRACE, 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)) {
       if (!scanner()->ScanRegExpPattern(seen_equal)) {
         Next();
         ReportMessageAt(scanner_->location(), "unterminated_regexp", NULL);
         ReportMessageAt(scanner()->location(), "unterminated_regexp", NULL);
         *ok = false;
         return Expression::Default();
+      }
       scope_->NextMaterializedLiteralIndex();
       if (!scanner_->ScanRegExpFlags()) {
       if (!scanner()->ScanRegExpFlags()) {
         Next();
         ReportMessageAt(scanner_->location(), "invalid_regexp_flags", NULL);
         ReportMessageAt(scanner()->location(), "invalid_regexp_flags", NULL);
         *ok = false;
         return Expression::Default();
+      }
-...
       // Arguments ::
       //   '(' (AssignmentExpression)*[','] ')'
       Expect(i::Token::LPAREN, ok);
       Expect(Token::LPAREN, ok);
       if (!*ok) return -1;
       bool done = (peek() == i::Token::RPAREN);
       bool done = (peek() == Token::RPAREN);
       int argc = 0;
       while (!done) {
         ParseAssignmentExpression(true, ok);
         if (!*ok) return -1;
         argc++;
         done = (peek() == i::Token::RPAREN);
         done = (peek() == Token::RPAREN);
         if (!done) {
           Expect(i::Token::COMMA, ok);
           Expect(Token::COMMA, ok);
           if (!*ok) return -1;
+        }
+      }
       Expect(i::Token::RPAREN, ok);
       Expect(Token::RPAREN, ok);
       return argc;
+    }
-...
       function_scope.set_is_generator(is_generator);
       //  FormalParameterList ::
       //    '(' (Identifier)*[','] ')'
       Expect(i::Token::LPAREN, CHECK_OK);
       int start_position = scanner_->location().beg_pos;
       bool done = (peek() == i::Token::RPAREN);
       DuplicateFinder duplicate_finder(scanner_->unicode_cache());
       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(),
           StrictModeIdentifierViolation(scanner()->location(),
                                         "strict_param_name",
                                         id,
                                         CHECK_OK);
+        }
         int prev_value;
         if (scanner_->is_literal_ascii()) {
         if (scanner()->is_literal_ascii()) {
           prev_value =
               duplicate_finder.AddAsciiSymbol(scanner_->literal_ascii_string(), 1);
               duplicate_finder.AddAsciiSymbol(scanner()->literal_ascii_string(), 1);
         } else {
           prev_value =
               duplicate_finder.AddUtf16Symbol(scanner_->literal_utf16_string(), 1);
               duplicate_finder.AddUtf16Symbol(scanner()->literal_utf16_string(), 1);
+        }
         if (prev_value != 0) {
           SetStrictModeViolation(scanner_->location(),
           SetStrictModeViolation(scanner()->location(),
                                  "strict_param_dupe",
                                  CHECK_OK);
+        }
         done = (peek() == i::Token::RPAREN);
         done = (peek() == Token::RPAREN);
         if (!done) {
           Expect(i::Token::COMMA, CHECK_OK);
           Expect(Token::COMMA, CHECK_OK);
+        }
+      }
       Expect(i::Token::RPAREN, 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_ &&
                                  !inside_with && allow_lazy() &&
                                  !parenthesized_function_);
       parenthesized_function_ = false;
       Expect(i::Token::LBRACE, CHECK_OK);
       Expect(Token::LBRACE, CHECK_OK);
       if (is_lazily_compiled) {
         ParseLazyFunctionLiteralBody(CHECK_OK);
       } else {
         ParseSourceElements(i::Token::RBRACE, ok);
         ParseSourceElements(Token::RBRACE, ok);
+      }
       Expect(i::Token::RBRACE, CHECK_OK);
       Expect(Token::RBRACE, CHECK_OK);
       if (!is_classic_mode()) {
         int end_position = scanner_->location().end_pos;
         int end_position = scanner()->location().end_pos;
         CheckOctalLiteral(start_position, end_position, CHECK_OK);
         CheckDelayedStrictModeViolation(start_position, end_position, CHECK_OK);
         return Expression::StrictFunction();
-...
     void PreParser::ParseLazyFunctionLiteralBody(bool* ok) {
       int body_start = scanner_->location().beg_pos;
       int body_start = position();
       log_->PauseRecording();
       ParseSourceElements(i::Token::RBRACE, ok);
       ParseSourceElements(Token::RBRACE, ok);
       log_->ResumeRecording();
       if (!*ok) return;
       // Position right after terminal '}'.
       ASSERT_EQ(i::Token::RBRACE, scanner_->peek());
       int body_end = scanner_->peek_location().end_pos;
       ASSERT_EQ(Token::RBRACE, scanner()->peek());
       int body_end = scanner()->peek_location().end_pos;
       log_->LogFunction(body_start, body_end,
                         scope_->materialized_literal_count(),
                         scope_->expected_properties(),
-...
     PreParser::Expression PreParser::ParseV8Intrinsic(bool* ok) {
       // CallRuntime ::
       //   '%' Identifier Arguments
       Expect(i::Token::MOD, CHECK_OK);
       if (!allow_natives_syntax_) {
       Expect(Token::MOD, CHECK_OK);
       if (!allow_natives_syntax()) {
         *ok = false;
         return Expression::Default();
+      }
-...
     #undef CHECK_OK
     void PreParser::ExpectSemicolon(bool* ok) {
       // Check for automatic semicolon insertion according to
       // the rules given in ECMA-262, section 7.9, page 21.
       i::Token::Value tok = peek();
       if (tok == i::Token::SEMICOLON) {
         Next();
         return;
+      }
       if (scanner_->HasAnyLineTerminatorBeforeNext() ||
           tok == i::Token::RBRACE ||
           tok == i::Token::EOS) {
         return;
+      }
       Expect(i::Token::SEMICOLON, ok);
+    }
     void PreParser::LogSymbol() {
       int identifier_pos = scanner_->location().beg_pos;
       if (scanner_->is_literal_ascii()) {
         log_->LogAsciiSymbol(identifier_pos, scanner_->literal_ascii_string());
       int identifier_pos = position();
       if (scanner()->is_literal_ascii()) {
         log_->LogAsciiSymbol(identifier_pos, scanner()->literal_ascii_string());
       } else {
         log_->LogUtf16Symbol(identifier_pos, scanner_->literal_utf16_string());
         log_->LogUtf16Symbol(identifier_pos, scanner()->literal_utf16_string());
+      }
+    }
-...
       const int kUseStrictLength = 10;
       const char* kUseStrictChars = "use strict";
       LogSymbol();
       if (scanner_->is_literal_ascii() &&
           scanner_->literal_length() == kUseStrictLength &&
           !scanner_->literal_contains_escapes() &&
           !strncmp(scanner_->literal_ascii_string().start(), kUseStrictChars,
       if (scanner()->is_literal_ascii() &&
           scanner()->literal_length() == kUseStrictLength &&
           !scanner()->literal_contains_escapes() &&
           !strncmp(scanner()->literal_ascii_string().start(), kUseStrictChars,
                    kUseStrictLength)) {
         return Expression::UseStrictStringLiteral();
+      }
-...
     PreParser::Identifier PreParser::GetIdentifierSymbol() {
       LogSymbol();
       if (scanner_->current_token() == i::Token::FUTURE_RESERVED_WORD) {
       if (scanner()->current_token() == Token::FUTURE_RESERVED_WORD) {
         return Identifier::FutureReserved();
       } else if (scanner_->current_token() ==
                  i::Token::FUTURE_STRICT_RESERVED_WORD) {
       } else if (scanner()->current_token() ==
                  Token::FUTURE_STRICT_RESERVED_WORD) {
         return Identifier::FutureStrictReserved();
       } else if (scanner_->current_token() == i::Token::YIELD) {
       } else if (scanner()->current_token() == Token::YIELD) {
         return Identifier::Yield();
+      }
       if (scanner_->is_literal_ascii()) {
       if (scanner()->is_literal_ascii()) {
         // Detect strict-mode poison words.
         if (scanner_->literal_length() == 4 &&
             !strncmp(scanner_->literal_ascii_string().start(), "eval", 4)) {
         if (scanner()->literal_length() == 4 &&
             !strncmp(scanner()->literal_ascii_string().start(), "eval", 4)) {
           return Identifier::Eval();
+        }
         if (scanner_->literal_length() == 9 &&
             !strncmp(scanner_->literal_ascii_string().start(), "arguments", 9)) {
         if (scanner()->literal_length() == 9 &&
             !strncmp(scanner()->literal_ascii_string().start(), "arguments", 9)) {
           return Identifier::Arguments();
+        }
+      }
-...
     PreParser::Identifier PreParser::ParseIdentifier(bool* ok) {
       i::Token::Value next = Next();
       Token::Value next = Next();
       switch (next) {
         case i::Token::FUTURE_RESERVED_WORD: {
           i::Scanner::Location location = scanner_->location();
         case Token::FUTURE_RESERVED_WORD: {
           Scanner::Location location = scanner()->location();
           ReportMessageAt(location.beg_pos, location.end_pos,
                           "reserved_word", NULL);
           *ok = false;
           return GetIdentifierSymbol();
+        }
         case i::Token::YIELD:
         case Token::YIELD:
           if (scope_->is_generator()) {
             // 'yield' in a generator is only valid as part of a YieldExpression.
             ReportMessageAt(scanner_->location(), "unexpected_token", "yield");
             ReportMessageAt(scanner()->location(), "unexpected_token", "yield");
             *ok = false;
             return Identifier::Yield();
+          }
           // FALLTHROUGH
         case i::Token::FUTURE_STRICT_RESERVED_WORD:
         case Token::FUTURE_STRICT_RESERVED_WORD:
           if (!is_classic_mode()) {
             i::Scanner::Location location = scanner_->location();
             Scanner::Location location = scanner()->location();
             ReportMessageAt(location.beg_pos, location.end_pos,
                             "strict_reserved_word", NULL);
             *ok = false;
+          }
           // FALLTHROUGH
         case i::Token::IDENTIFIER:
         case Token::IDENTIFIER:
           return GetIdentifierSymbol();
         default:
           *ok = false;
-...
+    }
     void PreParser::SetStrictModeViolation(i::Scanner::Location location,
     void PreParser::SetStrictModeViolation(Scanner::Location location,
                                            const char* type,
                                            bool* ok) {
       if (!is_classic_mode()) {
-...
     void PreParser::CheckDelayedStrictModeViolation(int beg_pos,
                                                     int end_pos,
                                                     bool* ok) {
       i::Scanner::Location location = strict_mode_violation_location_;
       Scanner::Location location = strict_mode_violation_location_;
       if (location.IsValid() &&
           location.beg_pos > beg_pos && location.end_pos < end_pos) {
         ReportMessageAt(location, strict_mode_violation_type_, NULL);
-...
+    }
     void PreParser::StrictModeIdentifierViolation(i::Scanner::Location location,
     void PreParser::StrictModeIdentifierViolation(Scanner::Location location,
                                                   const char* eval_args_type,
                                                   Identifier identifier,
                                                   bool* ok) {
-...
     PreParser::Identifier PreParser::ParseIdentifierName(bool* ok) {
       i::Token::Value next = Next();
       if (i::Token::IsKeyword(next)) {
         int pos = scanner_->location().beg_pos;
         const char* keyword = i::Token::String(next);
         log_->LogAsciiSymbol(pos, i::Vector<const char>(keyword,
                                                         i::StrLength(keyword)));
       Token::Value next = Next();
       if (Token::IsKeyword(next)) {
         int pos = position();
         const char* keyword = Token::String(next);
         log_->LogAsciiSymbol(pos, Vector<const char>(keyword, StrLength(keyword)));
         return Identifier::Default();
+      }
       if (next == i::Token::IDENTIFIER ||
           next == i::Token::FUTURE_RESERVED_WORD ||
           next == i::Token::FUTURE_STRICT_RESERVED_WORD) {
       if (next == Token::IDENTIFIER ||

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff