Add parsing for ambient declarations

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 122 matching lines @@
       CheckStrictOctalLiteral(start_position, end_pos, &ok);
       if (!ok) return kPreParseSuccess;
     }
   }
   return kPreParseSuccess;
 }
 
 
 PreParserExpression PreParserTraits::ParseClassLiteral(
     PreParserIdentifier name, Scanner::Location class_name_location,
-    bool name_is_strict_reserved, int pos, bool* ok) {
-  return pre_parser_->ParseClassLiteral(name, class_name_location,
-                                        name_is_strict_reserved, pos, ok);
+    bool name_is_strict_reserved, int pos, bool ambient, bool* ok) {
+  return pre_parser_->ParseClassLiteral(
+      name, class_name_location, name_is_strict_reserved, pos, ambient, ok);
 }
 
 
 // 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.
 
 
-PreParser::Statement PreParser::ParseStatementListItem(bool* ok) {
+PreParser::Statement PreParser::ParseStatementListItem(bool top_level,
+                                                       bool* ok) {
   // ECMA 262 6th Edition
   // StatementListItem[Yield, Return] :
   //   Statement[?Yield, ?Return]
   //   Declaration[?Yield]
   //
   // Declaration[Yield] :
   //   HoistableDeclaration[?Yield]
   //   ClassDeclaration[?Yield]
   //   LexicalDeclaration[In, ?Yield]
   //
   // HoistableDeclaration[Yield, Default] :
   //   FunctionDeclaration[?Yield, ?Default]
   //   GeneratorDeclaration[?Yield, ?Default]
   //
   // LexicalDeclaration[In, Yield] :
   //   LetOrConst BindingList[?In, ?Yield] ;
 
+  // Allow ambient variable, function, and class declarations.
+  bool ambient =
+      scope_->typed() && CheckContextualKeyword(CStrVector("declare"));
+  if (ambient && !top_level) {
+    *ok = false;
+    ReportMessage(MessageTemplate::kIllegalDeclare);
+    return Statement::Default();
+  }
   switch (peek()) {
     case Token::FUNCTION:
-      return ParseFunctionDeclaration(ok);
+      return ParseFunctionDeclaration(ambient, ok);
     case Token::CLASS:
-      return ParseClassDeclaration(ok);
+      return ParseClassDeclaration(ambient, ok);
     case Token::CONST:
       if (allow_const()) {
-        return ParseVariableStatement(kStatementListItem, ok);
+        return ParseVariableStatement(kStatementListItem, ambient, ok);
       }
       break;
+    case Token::VAR:
+      return ParseVariableStatement(kStatementListItem, ambient, ok);
     case Token::LET:
       if (IsNextLetKeyword()) {
-        return ParseVariableStatement(kStatementListItem, ok);
+        return ParseVariableStatement(kStatementListItem, ambient, ok);
       }
       break;
     case Token::IDENTIFIER:
     case Token::FUTURE_STRICT_RESERVED_WORD: {
-      if (!scope_->typed()) break;
+      if (!scope_->typed() || ambient) break;
       int pos = peek_position();
       if (CheckContextualKeyword(CStrVector("type"))) {
         return ParseTypeAliasDeclaration(pos, ok);
       } else if (CheckContextualKeyword(CStrVector("interface"))) {
         return ParseInterfaceDeclaration(pos, ok);
       }
       break;
     }
-    // TODO(nikolaos): ambient
     default:
       break;
   }
+  if (ambient) {
+    *ok = false;
+    ReportMessageAt(scanner()->peek_location(),
+                    MessageTemplate::kBadAmbientDeclaration);
+    return Statement::Default();
+  }
   return ParseStatement(kAllowLabelledFunctionStatement, ok);
 }
 
 
-void PreParser::ParseStatementList(int end_token, bool* ok,
+void PreParser::ParseStatementList(int end_token, bool top_level, bool* ok,
                                    Scanner::BookmarkScope* bookmark) {
   // SourceElements ::
   //   (Statement)* <end_token>
 
   // Bookkeeping for trial parse if bookmark is set:
   DCHECK_IMPLIES(bookmark, bookmark->HasBeenSet());
   bool maybe_reset = bookmark != nullptr;
   int count_statements = 0;
 
   bool directive_prologue = true;
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
     bool starts_with_identifier = peek() == Token::IDENTIFIER;
     Scanner::Location token_loc = scanner()->peek_location();
-    Statement statement = ParseStatementListItem(ok);
+    Statement statement = ParseStatementListItem(top_level, ok);
     if (!*ok) return;
 
     if (directive_prologue) {
       bool use_strict_found = statement.IsUseStrictLiteral();
       bool use_types_found =
           statement.IsUseTypesLiteral() && allow_harmony_types();
 
       if (use_strict_found) {
         scope_->SetLanguageMode(
             static_cast<LanguageMode>(scope_->language_mode() | STRICT));
@@ skipping 58 matching lines @@
     return Statement::Default();
   }
   return ParseSubStatement(allow_function, ok);
 }
 
 PreParser::Statement PreParser::ParseScopedStatement(bool legacy, bool* ok) {
   if (is_strict(language_mode()) || peek() != Token::FUNCTION ||
       (legacy && allow_harmony_restrictive_declarations())) {
     return ParseSubStatement(kDisallowLabelledFunctionStatement, ok);
   } else {
-    return ParseFunctionDeclaration(CHECK_OK);
+    return ParseFunctionDeclaration(false, CHECK_OK);
   }
 }
 
 PreParser::Statement PreParser::ParseSubStatement(
     AllowLabelledFunctionStatement allow_function, bool* ok) {
   // Statement ::
   //   Block
   //   VariableStatement
   //   EmptyStatement
   //   ExpressionStatement
@@ skipping 68 matching lines @@
                       is_strict(language_mode())
                           ? MessageTemplate::kStrictFunction
                           : MessageTemplate::kSloppyFunction);
       *ok = false;
       return Statement::Default();
 
     case Token::DEBUGGER:
       return ParseDebuggerStatement(ok);
 
     case Token::VAR:
-      return ParseVariableStatement(kStatement, ok);
+      return ParseVariableStatement(kStatement, false, ok);
 
     default:
       return ParseExpressionOrLabelledStatement(allow_function, ok);
   }
 }
 
 
-PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {
+PreParser::Statement PreParser::ParseFunctionDeclaration(bool ambient,
+                                                         bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   bool is_generator = Check(Token::MUL);
   bool is_strict_reserved = false;
   Identifier name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
+  typesystem::TypeFlags type_flags =
+      ambient ? typesystem::kAmbient : typesystem::kAllowSignature;
   ParseFunctionLiteral(name, scanner()->location(),
                        is_strict_reserved ? kFunctionNameIsStrictReserved
                                           : kFunctionNameValidityUnknown,
                        is_generator ? FunctionKind::kGeneratorFunction
                                     : FunctionKind::kNormalFunction,
                        pos, FunctionLiteral::kDeclaration, language_mode(),
-                       typesystem::kAllowSignature, CHECK_OK);
+                       type_flags, CHECK_OK);
   return Statement::FunctionDeclaration();
 }
 
 
-PreParser::Statement PreParser::ParseClassDeclaration(bool* ok) {
+PreParser::Statement PreParser::ParseClassDeclaration(bool ambient, bool* ok) {
   Expect(Token::CLASS, CHECK_OK);
   if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
     ReportMessage(MessageTemplate::kSloppyLexical);
     *ok = false;
     return Statement::Default();
   }
 
   int pos = position();
   bool is_strict_reserved = false;
   Identifier name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
   ParseClassLiteral(name, scanner()->location(), is_strict_reserved, pos,
-                    CHECK_OK);
+                    ambient, CHECK_OK);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseBlock(bool* ok) {
   // Block ::
   //   '{' StatementList '}'
 
   Expect(Token::LBRACE, CHECK_OK);
   Statement final = Statement::Default();
   while (peek() != Token::RBRACE) {
-    final = ParseStatementListItem(CHECK_OK);
+    final = ParseStatementListItem(false, CHECK_OK);
   }
   Expect(Token::RBRACE, ok);
   return final;
 }
 
 
 PreParser::Statement PreParser::ParseVariableStatement(
-    VariableDeclarationContext var_context,
-    bool* ok) {
+    VariableDeclarationContext var_context, bool ambient, bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
-  Statement result = ParseVariableDeclarations(
-      var_context, nullptr, nullptr, nullptr, nullptr, nullptr, CHECK_OK);
+  Statement result =
+      ParseVariableDeclarations(var_context, nullptr, nullptr, nullptr, nullptr,
+                                nullptr, ambient, 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, int* num_decl, bool* is_lexical,
     bool* is_binding_pattern, Scanner::Location* first_initializer_loc,
-    Scanner::Location* bindings_loc, bool* ok) {
+    Scanner::Location* bindings_loc, bool ambient, 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
   //
@@ skipping 52 matching lines @@
       }
     }
 
     is_pattern = pattern.IsObjectLiteral() || pattern.IsArrayLiteral();
 
     // Parse optional type annotation.
     if (scope_->typed() && Check(Token::COLON)) {  // Braces required here.
       ParseValidType(CHECK_OK);
     }
 
+    // Skip initializers, for ambient declarations.

[rossberg, 2016/04/20 15:16:35]

Nit: maybe don't say "skip initializers", but "no initializers"?

[nickie, 2016/04/21 13:57:10]

Done.

+    if (ambient) {
+      nvars++;
+      continue;
+    }
+
     Scanner::Location variable_loc = scanner()->location();
     nvars++;
     if (Check(Token::ASSIGN)) {
       ExpressionClassifier classifier(this);
       ParseAssignmentExpression(var_context != kForStatement, &classifier,
                                 CHECK_OK);
       ValidateExpression(&classifier, CHECK_OK);
 
       variable_loc.end_pos = scanner()->location().end_pos;
       if (first_initializer_loc && !first_initializer_loc->IsValid()) {
@@ skipping 51 matching lines @@
   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())) {
       if (allow_function == kAllowLabelledFunctionStatement) {
-        return ParseFunctionDeclaration(ok);
+        return ParseFunctionDeclaration(false, ok);
       } else {
         return ParseScopedStatement(true, 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.
@@ skipping 133 matching lines @@
       ParseExpression(true, CHECK_OK);
     } else {
       Expect(Token::DEFAULT, CHECK_OK);
     }
     Expect(Token::COLON, CHECK_OK);
     token = peek();
     Statement statement = Statement::Jump();
     while (token != Token::CASE &&
            token != Token::DEFAULT &&
            token != Token::RBRACE) {
-      statement = ParseStatementListItem(CHECK_OK);
+      statement = ParseStatementListItem(false, CHECK_OK);
       token = peek();
     }
   }
   Expect(Token::RBRACE, ok);
   return Statement::Default();
 }
 
 
 PreParser::Statement PreParser::ParseDoWhileStatement(bool* ok) {
   // DoStatement ::
@@ skipping 34 matching lines @@
     ForEachStatement::VisitMode mode;
     if (peek() == Token::VAR || (peek() == Token::CONST && allow_const()) ||
         (peek() == Token::LET && IsNextLetKeyword())) {
       int decl_count;
       bool is_lexical;
       bool is_binding_pattern;
       Scanner::Location first_initializer_loc = Scanner::Location::invalid();
       Scanner::Location bindings_loc = Scanner::Location::invalid();
       ParseVariableDeclarations(kForStatement, &decl_count, &is_lexical,
                                 &is_binding_pattern, &first_initializer_loc,
-                                &bindings_loc, CHECK_OK);
+                                &bindings_loc, false, CHECK_OK);
       if (CheckInOrOf(&mode, ok)) {
         if (!*ok) return Statement::Default();
         if (decl_count != 1) {
           PreParserTraits::ReportMessageAt(
               bindings_loc, MessageTemplate::kForInOfLoopMultiBindings,
               ForEachStatement::VisitModeString(mode));
           *ok = false;
           return Statement::Default();
         }
         if (first_initializer_loc.IsValid() &&
@@ skipping 200 matching lines @@
   CheckArityRestrictions(formals.arity, kind, formals.has_rest, start_position,
                          formals_end_position, CHECK_OK);
 
   // See Parser::ParseFunctionLiteral for more information about lazy parsing
   // and lazy compilation.
   bool is_lazily_parsed =
       (outer_is_script_scope && allow_lazy() && !parenthesized_function_);
   parenthesized_function_ = false;
 
   // Parse optional type annotation.
-  if (scope_->typed() &&
-      !(type_flags & typesystem::kDisallowTypeAnnotation) &&
+  if (scope_->typed() && !(type_flags & typesystem::kDisallowTypeAnnotation) &&
       Check(Token::COLON)) {  // Braces required here.
     ParseValidType(CHECK_OK);
   }
 
-  // Allow for a function signature (i.e., a literal without body).
-  if (peek() != Token::LBRACE && scope_->typed() &&
-      (type_flags & typesystem::kAllowSignature)) {
+  // Allow or even enforce a function signature (i.e., literal without body),
+  // In that case, return a nullptr instead of a function literal.
+  if ((type_flags & typesystem::kDisallowBody) ||
+      (peek() != Token::LBRACE && scope_->typed() &&
+       (type_flags & typesystem::kAllowSignature))) {
     ExpectSemicolon(CHECK_OK);
     return this->EmptyExpression();
   }
 
   Expect(Token::LBRACE, CHECK_OK);
   if (is_lazily_parsed) {
     ParseLazyFunctionLiteralBody(CHECK_OK);
   } else {
-    ParseStatementList(Token::RBRACE, CHECK_OK);
+    ParseStatementList(Token::RBRACE, false, CHECK_OK);
   }
   Expect(Token::RBRACE, CHECK_OK);
 
   // Parsing the body may change the language mode in our scope.
   language_mode = function_scope->language_mode();
 
   // Validate name and parameter names. We can do this only after parsing the
   // function, since the function can declare itself strict.
   CheckFunctionName(language_mode, function_name, function_name_validity,
                     function_name_location, CHECK_OK);
   const bool allow_duplicate_parameters =
       is_sloppy(language_mode) && formals.is_simple && !IsConciseMethod(kind);
   ValidateFormalParameters(&formals_classifier, language_mode,
                            allow_duplicate_parameters, CHECK_OK);
 
   if (is_strict(language_mode)) {
     int end_position = scanner()->location().end_pos;
     CheckStrictOctalLiteral(start_position, end_position, CHECK_OK);
   }
 
   return Expression::Default();
 }
 
 
 void PreParser::ParseLazyFunctionLiteralBody(bool* ok,
                                              Scanner::BookmarkScope* bookmark) {
   int body_start = position();
-  ParseStatementList(Token::RBRACE, ok, bookmark);
+  ParseStatementList(Token::RBRACE, false, ok, bookmark);
   if (!*ok) return;
   if (bookmark && bookmark->HasBeenReset()) return;
 
   // Position right after terminal '}'.
   DCHECK_EQ(Token::RBRACE, scanner()->peek());
   int body_end = scanner()->peek_location().end_pos;
   log_->LogFunction(body_start, body_end,
                     function_state_->materialized_literal_count(),
                     function_state_->expected_property_count(), language_mode(),
                     scope_->uses_super_property(), scope_->calls_eval());
 }
 
 
 PreParserExpression PreParser::ParseClassLiteral(
     PreParserIdentifier name, Scanner::Location class_name_location,
-    bool name_is_strict_reserved, int pos, bool* ok) {
+    bool name_is_strict_reserved, int pos, bool ambient, bool* ok) {
   // All parts of a ClassDeclaration and ClassExpression are strict code.
   if (name_is_strict_reserved) {
     ReportMessageAt(class_name_location,
                     MessageTemplate::kUnexpectedStrictReserved);
     *ok = false;
     return EmptyExpression();
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments);
     *ok = false;
@@ skipping 35 matching lines @@
   while (peek() != Token::RBRACE) {
     if (Check(Token::SEMICOLON)) continue;
     const bool in_class = true;
     const bool is_static = false;
     bool is_computed_name = false;  // Classes do not care about computed
                                     // property names here.
     Identifier name;
     ExpressionClassifier classifier(this);
     ParsePropertyDefinition(&checker, in_class, has_extends, is_static,
                             &is_computed_name, &has_seen_constructor,
-                            &classifier, &name, CHECK_OK);
+                            &classifier, &name, ambient, CHECK_OK);
     ValidateExpression(&classifier, CHECK_OK);
   }
 
   Expect(Token::RBRACE, CHECK_OK);
 
   return Expression::Default();
 }
 
 
 PreParser::Expression PreParser::ParseV8Intrinsic(bool* ok) {
@@ skipping 19 matching lines @@
 
 PreParserExpression PreParser::ParseDoExpression(bool* ok) {
   // AssignmentExpression ::
   //     do '{' StatementList '}'
   Expect(Token::DO, CHECK_OK);
   Expect(Token::LBRACE, CHECK_OK);
   Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
   {
     BlockState block_state(&scope_, block_scope);
     while (peek() != Token::RBRACE) {
-      ParseStatementListItem(CHECK_OK);
+      ParseStatementListItem(false, CHECK_OK);
     }
     Expect(Token::RBRACE, CHECK_OK);
     return PreParserExpression::Default();
   }
 }
 
 #undef CHECK_OK
 
 
 }  // namespace internal
 }  // namespace v8