Implement ES2015 labelled function declaration restrictions

src/parsing/preparser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 176 matching lines @@
       }
       break;
     case Token::LET:
       if (IsNextLetKeyword()) {
         return ParseVariableStatement(kStatementListItem, ok);
       }
       break;
     default:
       break;
   }
-  return ParseStatement(ok);
+  return ParseStatement(kAllowLabelledFunctionStatement, ok);
 }
 
 
 void PreParser::ParseStatementList(int end_token, bool* ok,
                                    Scanner::BookmarkScope* bookmark) {
   // SourceElements ::
   //   (Statement)* <end_token>
 
   // Bookkeeping for trial parse if bookmark is set:
   DCHECK_IMPLIES(bookmark, bookmark->HasBeenSet());
@@ skipping 48 matching lines @@
   }
 }
 
 
 #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) {
+PreParser::Statement PreParser::ParseStatement(
+    AllowLabelledFunctionStatement allow_labelled_function_statement,
+    bool* ok) {
   // Statement ::
   //   EmptyStatement
   //   ...
 
   if (peek() == Token::SEMICOLON) {
     Next();
     return Statement::Default();
   }
-  return ParseSubStatement(ok);
+  return ParseSubStatement(allow_labelled_function_statement, ok);
 }
 
 PreParser::Statement PreParser::ParseScopedStatement(bool legacy, bool* ok) {
   if (is_strict(language_mode()) || peek() != Token::FUNCTION ||
       (legacy && allow_harmony_restrictive_declarations())) {
-    return ParseSubStatement(ok);
+    return ParseSubStatement(kDisallowLabelledFunctionStatement, ok);
   } else {
     return ParseFunctionDeclaration(CHECK_OK);
   }
 }
 
-PreParser::Statement PreParser::ParseSubStatement(bool* ok) {
+PreParser::Statement PreParser::ParseSubStatement(
+    AllowLabelledFunctionStatement allow_labelled_function_statement,
+    bool* ok) {
   // Statement ::
   //   Block
   //   VariableStatement
   //   EmptyStatement
   //   ExpressionStatement
   //   IfStatement
   //   IterationStatement
   //   ContinueStatement
   //   BreakStatement
   //   ReturnStatement
@@ skipping 75 matching lines @@
     case Token::CONST:
       // In ES6 CONST is not allowed as a Statement, only as a
       // LexicalDeclaration, however we continue to allow it in sloppy mode for
       // backwards compatibility.
       if (is_sloppy(language_mode()) && allow_legacy_const()) {
         return ParseVariableStatement(kStatement, ok);
       }
 
     // Fall through.
     default:
-      return ParseExpressionOrLabelledStatement(ok);
+      return ParseExpressionOrLabelledStatement(
+          allow_labelled_function_statement, ok);
   }
 }
 
 
 PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
@@ skipping 163 matching lines @@
     *bindings_loc =
         Scanner::Location(bindings_start, scanner()->location().end_pos);
   }
 
   if (num_decl != nullptr) *num_decl = nvars;
   if (is_lexical != nullptr) *is_lexical = lexical;
   if (is_binding_pattern != nullptr) *is_binding_pattern = is_pattern;
   return Statement::Default();
 }
 
-
-PreParser::Statement PreParser::ParseExpressionOrLabelledStatement(bool* ok) {
+PreParser::Statement PreParser::ParseExpressionOrLabelledStatement(
+    AllowLabelledFunctionStatement allow_labelled_function_statement,
+    bool* ok) {
   // ExpressionStatement | LabelledStatement ::
   //   Expression ';'
   //   Identifier ':' Statement
 
   switch (peek()) {
     case Token::FUNCTION:
     case Token::LBRACE:
       UNREACHABLE();  // Always handled by the callers.
     case Token::CLASS:
       ReportUnexpectedToken(Next());
@@ skipping 14 matching lines @@
   // an identifier.
   if (starts_with_identifier && expr.IsIdentifier() && peek() == Token::COLON) {
     // Expression is a single identifier, and not, e.g., a parenthesized
     // identifier.
     DCHECK(!expr.AsIdentifier().IsFutureReserved());
     DCHECK(is_sloppy(language_mode()) ||
            !IsFutureStrictReserved(expr.AsIdentifier()));
     Consume(Token::COLON);
     // ES#sec-labelled-function-declarations Labelled Function Declarations
     if (peek() == Token::FUNCTION && is_sloppy(language_mode())) {
-      return ParseFunctionDeclaration(ok);
+      if (allow_labelled_function_statement ==
+          kAllowLabelledFunctionStatement) {
+        return ParseFunctionDeclaration(ok);
+      } else {
+        return ParseScopedStatement(true, ok);
+      }
     }
-    Statement statement = ParseStatement(ok);
+    Statement statement =
+        ParseStatement(kDisallowLabelledFunctionStatement, ok);
     return statement.IsJumpStatement() ? Statement::Default() : statement;
     // 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.
   // Detect attempts at 'let' declarations in sloppy mode.
   if (!allow_harmony_sloppy_let() && peek() == Token::IDENTIFIER &&
       is_sloppy(language_mode()) && expr.IsIdentifier() &&
       expr.AsIdentifier().IsLet()) {
@@ skipping 539 matching lines @@
     Expect(Token::RBRACE, CHECK_OK);
     return PreParserExpression::Default();
   }
 }
 
 #undef CHECK_OK
 
 
 }  // namespace internal
 }  // namespace v8