Parser: Introduce StatementList + NewStatementList()

src/preparser.cc

 // 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
@@ skipping 165 matching lines @@
 // it is used) are generally omitted.
 
 
 #define CHECK_OK  ok);                      \
   if (!*ok) return kUnknownSourceElements;  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
-PreParser::Statement PreParser::ParseSourceElement(bool* ok) {
+PreParserStatement PreParser::ParseSourceElement(bool* ok) {

[marja, 2014/04/24 15:31:10]

The same here.

   // (Ecma 262 5th Edition, clause 14):
   // SourceElement:
   //    Statement
   //    FunctionDeclaration
   //
   // In harmony mode we allow additionally the following productions
   // SourceElement:
   //    LetDeclaration
   //    ConstDeclaration
   //    GeneratorDeclaration
@@ skipping 13 matching lines @@
 PreParser::SourceElements PreParser::ParseSourceElements(int end_token,
                                                          bool* ok) {
   // SourceElements ::
   //   (Statement)* <end_token>
 
   bool directive_prologue = true;
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
-    Statement statement = ParseSourceElement(CHECK_OK);
+    PreParserStatement statement = ParseSourceElement(CHECK_OK);

[marja, 2014/04/24 15:31:10]

... and overall.

     if (directive_prologue) {
       if (statement.IsUseStrictLiteral()) {
         scope_->SetStrictMode(STRICT);
       } else if (!statement.IsStringLiteral()) {
         directive_prologue = false;
       }
     }
   }
   return kUnknownSourceElements;
 }
 
 
 #undef CHECK_OK
-#define CHECK_OK  ok);                   \
-  if (!*ok) return Statement::Default();  \
+#define CHECK_OK  ok);                            \
+  if (!*ok) return PreParserStatement::Default(); \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 
-PreParser::Statement PreParser::ParseStatement(bool* ok) {
+PreParserStatement PreParser::ParseStatement(bool* ok) {
   // Statement ::
   //   Block
   //   VariableStatement
   //   EmptyStatement
   //   ExpressionStatement
   //   IfStatement
   //   IterationStatement
   //   ContinueStatement
   //   BreakStatement
   //   ReturnStatement
@@ skipping 16 matching lines @@
     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();
+      return PreParserStatement::Default();
 
     case Token::IF:
       return ParseIfStatement(ok);
 
     case Token::DO:
       return ParseDoWhileStatement(ok);
 
     case Token::WHILE:
       return ParseWhileStatement(ok);
 
@@ skipping 16 matching lines @@
       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);
+      PreParserStatement statement = ParseFunctionDeclaration(CHECK_OK);
       Scanner::Location end_location = scanner()->location();
       if (strict_mode() == STRICT) {
         PreParserTraits::ReportMessageAt(start_location.beg_pos,
                                          end_location.end_pos,
                                          "strict_function",
                                          NULL);
         *ok = false;
-        return Statement::Default();
+        return PreParserStatement::Default();
       } else {
         return statement;
       }
     }
 
     case Token::DEBUGGER:
       return ParseDebuggerStatement(ok);
 
     default:
       return ParseExpressionOrLabelledStatement(ok);
   }
 }
 
 
-PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {
+PreParserStatement PreParser::ParseFunctionDeclaration(bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   bool is_generator = allow_generators() && Check(Token::MUL);
   bool is_strict_reserved = false;
   Identifier name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
   ParseFunctionLiteral(name,
                        scanner()->location(),
                        is_strict_reserved,
                        is_generator,
                        pos,
                        FunctionLiteral::DECLARATION,
                        CHECK_OK);
-  return Statement::FunctionDeclaration();
+  return PreParserStatement::FunctionDeclaration();
 }
 
 
-PreParser::Statement PreParser::ParseBlock(bool* ok) {
+PreParserStatement 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 (allow_harmony_scoping() && strict_mode() == STRICT) {
       ParseSourceElement(CHECK_OK);
     } else {
       ParseStatement(CHECK_OK);
     }
   }
   Expect(Token::RBRACE, ok);
-  return Statement::Default();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseVariableStatement(
+PreParserStatement PreParser::ParseVariableStatement(
     VariableDeclarationContext var_context,
     bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
-  Statement result = ParseVariableDeclarations(var_context,
-                                               NULL,
-                                               NULL,
-                                               CHECK_OK);
+    PreParserStatement 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(
+PreParserStatement 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 ::
@@ skipping 17 matching lines @@
     //
     // However disallowing const in sloppy mode will break compatibility with
     // existing pages. Therefore we keep allowing const with the old
     // non-harmony semantics in sloppy mode.
     Consume(Token::CONST);
     if (strict_mode() == STRICT) {
       if (allow_harmony_scoping()) {
         if (var_context != kSourceElement && var_context != kForStatement) {
           ReportMessageAt(scanner()->peek_location(), "unprotected_const");
           *ok = false;
-          return Statement::Default();
+          return PreParserStatement::Default();
         }
         require_initializer = true;
       } else {
         Scanner::Location location = scanner()->peek_location();
         ReportMessageAt(location, "strict_const");
         *ok = false;
-        return Statement::Default();
+        return PreParserStatement::Default();
       }
     }
   } 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.
     //
     // TODO(rossberg): make 'let' a legal identifier in sloppy mode.
     if (!allow_harmony_scoping() || strict_mode() == SLOPPY) {
       ReportMessageAt(scanner()->peek_location(), "illegal_let");
       *ok = false;
-      return Statement::Default();
+      return PreParserStatement::Default();
     }
     Consume(Token::LET);
     if (var_context != kSourceElement &&
         var_context != kForStatement) {
       ReportMessageAt(scanner()->peek_location(), "unprotected_let");
       *ok = false;
-      return Statement::Default();
+      return PreParserStatement::Default();
     }
   } else {
     *ok = false;
-    return Statement::Default();
+    return PreParserStatement::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);
     ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
     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();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseExpressionOrLabelledStatement(bool* ok) {
+PreParserStatement PreParser::ParseExpressionOrLabelledStatement(bool* ok) {
   // ExpressionStatement | LabelledStatement ::
   //   Expression ';'
   //   Identifier ':' Statement
 
   bool starts_with_identifier = peek_any_identifier();
   Expression expr = ParseExpression(true, CHECK_OK);
   // Even if the expression starts with an identifier, it is not necessarily an
   // identifier. For example, "foo + bar" starts with an identifier but is not
   // an identifier.
   if (starts_with_identifier && expr.IsIdentifier() && peek() == Token::COLON) {
     // Expression is a single identifier, and not, e.g., a parenthesized
     // identifier.
     ASSERT(!expr.AsIdentifier().IsFutureReserved());
     ASSERT(strict_mode() == SLOPPY ||
            (!expr.AsIdentifier().IsFutureStrictReserved() &&
             !expr.AsIdentifier().IsYield()));
     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);
+  return PreParserStatement::ExpressionStatement(expr);
 }
 
 
-PreParser::Statement PreParser::ParseIfStatement(bool* ok) {
+PreParserStatement 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();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseContinueStatement(bool* ok) {
+PreParserStatement 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) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
-  return Statement::Default();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseBreakStatement(bool* ok) {
+PreParserStatement 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) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
     ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
-  return Statement::Default();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseReturnStatement(bool* ok) {
+PreParserStatement PreParser::ParseReturnStatement(bool* ok) {
   // ReturnStatement ::
   //   'return' [no line terminator] Expression? ';'
 
   // Consume the return token. It is necessary to do 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();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseWithStatement(bool* ok) {
+PreParserStatement PreParser::ParseWithStatement(bool* ok) {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
   Expect(Token::WITH, CHECK_OK);
   if (strict_mode() == STRICT) {
     ReportMessageAt(scanner()->location(), "strict_mode_with");
     *ok = false;
-    return Statement::Default();
+    return PreParserStatement::Default();
   }
   Expect(Token::LPAREN, CHECK_OK);
   ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   PreParserScope with_scope(scope_, WITH_SCOPE);
   BlockState block_state(&scope_, &with_scope);
   ParseStatement(CHECK_OK);
-  return Statement::Default();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseSwitchStatement(bool* ok) {
+PreParserStatement 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();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseDoWhileStatement(bool* ok) {
+PreParserStatement 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();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseWhileStatement(bool* ok) {
+PreParserStatement 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();
+  return PreParserStatement::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) {
+PreParserStatement 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();
+        return PreParserStatement::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();
+        return PreParserStatement::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();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseThrowStatement(bool* ok) {
+PreParserStatement PreParser::ParseThrowStatement(bool* ok) {
   // ThrowStatement ::
   //   'throw' [no line terminator] Expression ';'
 
   Expect(Token::THROW, CHECK_OK);
   if (scanner()->HasAnyLineTerminatorBeforeNext()) {
     ReportMessageAt(scanner()->location(), "newline_after_throw");
     *ok = false;
-    return Statement::Default();
+    return PreParserStatement::Default();
   }
   ParseExpression(true, CHECK_OK);
   ExpectSemicolon(ok);
-  return Statement::Default();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseTryStatement(bool* ok) {
+PreParserStatement PreParser::ParseTryStatement(bool* ok) {
   // TryStatement ::
   //   'try' Block Catch
   //   'try' Block Finally
   //   'try' Block Catch Finally
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
   //
   // Finally ::
   //   'finally' Block
 
   Expect(Token::TRY, CHECK_OK);
 
   ParseBlock(CHECK_OK);
 
   Token::Value tok = peek();
   if (tok != Token::CATCH && tok != Token::FINALLY) {
     ReportMessageAt(scanner()->location(), "no_catch_or_finally");
     *ok = false;
-    return Statement::Default();
+    return PreParserStatement::Default();
   }
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
     Expect(Token::LPAREN, CHECK_OK);
     ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
     {
       PreParserScope with_scope(scope_, WITH_SCOPE);
       BlockState block_state(&scope_, &with_scope);
       ParseBlock(CHECK_OK);
     }
     tok = peek();
   }
   if (tok == Token::FINALLY) {
     Consume(Token::FINALLY);
     ParseBlock(CHECK_OK);
   }
-  return Statement::Default();
+  return PreParserStatement::Default();
 }
 
 
-PreParser::Statement PreParser::ParseDebuggerStatement(bool* ok) {
+PreParserStatement 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();
+  return PreParserStatement::Default();
 }
 
 
 #undef CHECK_OK
 #define CHECK_OK  ok);                     \
   if (!*ok) return Expression::Default();  \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
@@ skipping 128 matching lines @@
   ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
   ParseArguments(ok);
 
   return Expression::Default();
 }
 
 #undef CHECK_OK
 
 
 } }  // v8::internal