Add parsing for ambient declarations

src/parsing/parser.cc

 // Copyright 2012 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 "src/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 741 matching lines @@
     int function_token_position, FunctionLiteral::FunctionType type,
     LanguageMode language_mode, typesystem::TypeFlags type_flags, bool* ok) {
   return parser_->ParseFunctionLiteral(
       name, function_name_location, function_name_validity, kind,
       function_token_position, type, language_mode, type_flags, ok);
 }
 
 
 ClassLiteral* ParserTraits::ParseClassLiteral(
     const AstRawString* 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) {
   return parser_->ParseClassLiteral(name, class_name_location,
-                                    name_is_strict_reserved, pos, ok);
+                                    name_is_strict_reserved, pos, ambient, ok);
 }
 
 
 Parser::Parser(ParseInfo* info)
     : ParserBase<ParserTraits>(info->zone(), &scanner_, info->stack_limit(),
                                info->extension(), info->ast_value_factory(),
                                NULL, this),
       scanner_(info->unicode_cache()),
       reusable_preparser_(NULL),
       original_scope_(NULL),
@@ skipping 150 matching lines @@
     // Don't count the mode in the use counters--give the program a chance
     // to enable script/module-wide strict mode below.
     scope_->SetLanguageMode(info->language_mode());
     if (info->is_typed()) scope_->SetTyped();
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     if (info->is_module()) {
       ParseModuleItemList(body, &ok);
     } else {
-      ParseStatementList(body, Token::EOS, &ok);
+      ParseStatementList(body, Token::EOS, true, &ok);
     }
 
     // The parser will peek but not consume EOS.  Our scope logically goes all
     // the way to the EOS, though.
     scope->set_end_position(scanner()->peek_location().beg_pos);
 
     if (ok && is_strict(language_mode())) {
       CheckStrictOctalLiteral(beg_pos, scanner()->location().end_pos, &ok);
     }
     if (ok && is_sloppy(language_mode()) && allow_harmony_sloppy_function()) {
@@ skipping 204 matching lines @@
 
   if (result != NULL) {
     Handle<String> inferred_name(shared_info->inferred_name());
     result->set_inferred_name(inferred_name);
   }
   return result;
 }
 
 
 void* Parser::ParseStatementList(ZoneList<Statement*>* body, int end_token,
-                                 bool* ok) {
+                                 bool top_level, bool* ok) {
   // StatementList ::
   //   (StatementListItem)* <end_token>
 
   // Allocate a target stack to use for this set of source
   // elements. This way, all scripts and functions get their own
   // target stack thus avoiding illegal breaks and continues across
   // functions.
   TargetScope scope(&this->target_stack_);
 
   DCHECK(body != NULL);
   bool directive_prologue = true;     // Parsing directive prologue.
 
   while (peek() != end_token) {
     if (directive_prologue && peek() != Token::STRING) {
       directive_prologue = false;
     }
 
     Scanner::Location token_loc = scanner()->peek_location();
-    Statement* stat = ParseStatementListItem(CHECK_OK);
+    Statement* stat = ParseStatementListItem(top_level, CHECK_OK);
     if (stat == NULL || stat->IsEmpty()) {
       directive_prologue = false;   // End of directive prologue.
       continue;
     }
 
     if (directive_prologue) {
       // A shot at a directive.
       ExpressionStatement* e_stat;
       Literal* literal;
       // Still processing directive prologue?
@@ skipping 69 matching lines @@
       RaiseLanguageMode(SLOPPY);
     }
 
     body->Add(stat, zone());
   }
 
   return 0;
 }
 
 
-Statement* Parser::ParseStatementListItem(bool* ok) {
+Statement* Parser::ParseStatementListItem(bool top_level, bool* ok) {
   // (Ecma 262 6th Edition, 13.1):
   // StatementListItem:
   //    Statement
   //    Declaration
 
+  // Allow ambient variable, function, and class declarations.
+  bool ambient =
+      scope_->typed() && CheckContextualKeyword(CStrVector("declare"));
+  if (ambient && !top_level) {
+    *ok = false;
+    ReportMessage(MessageTemplate::kIllegalDeclare);
+    return nullptr;
+  }
   switch (peek()) {
     case Token::FUNCTION:
-      return ParseFunctionDeclaration(NULL, ok);
+      return ParseFunctionDeclaration(NULL, ambient, ok);
     case Token::CLASS:
       Consume(Token::CLASS);
-      return ParseClassDeclaration(NULL, ok);
+      return ParseClassDeclaration(NULL, ambient, ok);
     case Token::CONST:
       if (allow_const()) {
-        return ParseVariableStatement(kStatementListItem, NULL, ok);
+        return ParseVariableStatement(kStatementListItem, NULL, ambient, ok);
       }
       break;
     case Token::VAR:
-      return ParseVariableStatement(kStatementListItem, NULL, ok);
+      return ParseVariableStatement(kStatementListItem, NULL, ambient, ok);
     case Token::LET:
       if (IsNextLetKeyword()) {
-        return ParseVariableStatement(kStatementListItem, NULL, ok);
+        return ParseVariableStatement(kStatementListItem, NULL, 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 nullptr;
+  }
   return ParseStatement(NULL, kAllowLabelledFunctionStatement, ok);
 }
 
 
 Statement* Parser::ParseModuleItem(bool* ok) {
   // (Ecma 262 6th Edition, 15.2):
   // ModuleItem :
   //    ImportDeclaration
   //    ExportDeclaration
   //    StatementListItem
 
   switch (peek()) {
     case Token::IMPORT:
       return ParseImportDeclaration(ok);
     case Token::EXPORT:
       return ParseExportDeclaration(ok);
     default:
-      return ParseStatementListItem(ok);
+      return ParseStatementListItem(true, ok);
   }
 }
 
 
 void* Parser::ParseModuleItemList(ZoneList<Statement*>* body, bool* ok) {
   // (Ecma 262 6th Edition, 15.2):
   // Module :
   //    ModuleBody?
   //
   // ModuleBody :
@@ skipping 270 matching lines @@
   //    'export' 'default' ClassDeclaration
   //    'export' 'default' AssignmentExpression[In] ';'
 
   Expect(Token::DEFAULT, CHECK_OK);
   Scanner::Location default_loc = scanner()->location();
 
   const AstRawString* default_string = ast_value_factory()->default_string();
   ZoneList<const AstRawString*> names(1, zone());
   Statement* result = nullptr;
   Expression* default_export = nullptr;
+
+  // Allow ambient function and class declarations to be exported as default.
+  int ambient_pos = peek_position();
+  bool ambient =
+      scope_->typed() && CheckContextualKeyword(CStrVector("declare"));
+
   switch (peek()) {
     case Token::FUNCTION: {
       Consume(Token::FUNCTION);
       int pos = position();
       bool is_generator = Check(Token::MUL);
-      if (peek() == Token::LPAREN || (scope_->typed() && Check(Token::LT))) {
+      if (peek() == Token::LPAREN || (scope_->typed() && peek() == Token::LT)) {
         // FunctionDeclaration[+Default] ::
         //   'function' '(' FormalParameters ')' '{' FunctionBody '}'
         //
         // GeneratorDeclaration[+Default] ::
         //   'function' '*' '(' FormalParameters ')' '{' FunctionBody '}'
-        default_export = ParseFunctionLiteral(
-            default_string, Scanner::Location::invalid(),
-            kSkipFunctionNameCheck,
-            is_generator ? FunctionKind::kGeneratorFunction
-                         : FunctionKind::kNormalFunction,
-            pos, FunctionLiteral::kDeclaration, language_mode(),
-            typesystem::kAllowSignature, CHECK_OK);
+        typesystem::TypeFlags type_flags =
+            ambient ? typesystem::kAmbient : typesystem::kAllowSignature;
+        default_export =
+            ParseFunctionLiteral(default_string, Scanner::Location::invalid(),
+                                 kSkipFunctionNameCheck,
+                                 is_generator ? FunctionKind::kGeneratorFunction
+                                              : FunctionKind::kNormalFunction,
+                                 pos, FunctionLiteral::kDeclaration,
+                                 language_mode(), type_flags, CHECK_OK);
         result = factory()->NewEmptyStatement(RelocInfo::kNoPosition);
       } else {
-        result = ParseFunctionDeclaration(pos, is_generator, &names, CHECK_OK);
+        result = ParseFunctionDeclaration(pos, is_generator, &names, ambient,
+                                          CHECK_OK);
       }
       break;
     }
 
     case Token::CLASS:
       Consume(Token::CLASS);
       if (peek() == Token::EXTENDS || peek() == Token::LBRACE) {
         // ClassDeclaration[+Default] ::
         //   'class' ('extends' LeftHandExpression)? '{' ClassBody '}'
         default_export =
             ParseClassLiteral(default_string, Scanner::Location::invalid(),
-                              false, position(), CHECK_OK);
+                              false, position(), ambient, CHECK_OK);
         result = factory()->NewEmptyStatement(RelocInfo::kNoPosition);
       } else {
-        result = ParseClassDeclaration(&names, CHECK_OK);
+        result = ParseClassDeclaration(&names, ambient, CHECK_OK);
       }
       break;
 
     default: {
+      if (ambient) {
+        *ok = false;
+        ReportMessageAt(scanner()->peek_location(),
+                        MessageTemplate::kBadAmbientDeclaration);
+        return nullptr;
+      }
+
       int pos = peek_position();
       ExpressionClassifier classifier(this);
       Expression* expr = ParseAssignmentExpression(true, &classifier, CHECK_OK);
       RewriteNonPattern(&classifier, CHECK_OK);
 
       ExpectSemicolon(CHECK_OK);
       result = factory()->NewExpressionStatement(expr, pos);
       break;
     }
   }
 
+  // Exported ambients are not checked.
+  if (ambient) return factory()->NewEmptyStatement(ambient_pos);
+
   DCHECK_LE(names.length(), 1);
   if (names.length() == 1) {
     scope_->module()->AddLocalExport(default_string, names.first(), zone(), ok);
     if (!*ok) {
       ParserTraits::ReportMessageAt(
           default_loc, MessageTemplate::kDuplicateExport, default_string);
       return nullptr;
     }
   } else {
     // TODO(ES6): Assign result to a const binding with the name "*default*"
     // and add an export entry with "*default*" as the local name.
     USE(default_export);
   }
 
   return result;
 }
 
 
 Statement* Parser::ParseExportDeclaration(bool* ok) {
   // ExportDeclaration:
   //    'export' '*' 'from' ModuleSpecifier ';'
   //    'export' ExportClause ('from' ModuleSpecifier)? ';'
   //    'export' VariableStatement
   //    'export' Declaration
   //    'export' 'default' ... (handled in ParseExportDefault)
 
   int pos = peek_position();
   Expect(Token::EXPORT, CHECK_OK);
 
+  // Allow exported ambient variable, function, and class declarations.
+  bool ambient =
+      scope_->typed() && CheckContextualKeyword(CStrVector("declare"));
+
   Statement* result = NULL;
   ZoneList<const AstRawString*> names(1, zone());
+  if (ambient && (peek() == Token::DEFAULT || peek() == Token::MUL ||
+                  peek() == Token::LBRACE)) {
+    *ok = false;
+    ReportMessageAt(scanner()->peek_location(),
+                    MessageTemplate::kBadAmbientDeclaration);
+    return nullptr;
+  }
   switch (peek()) {
     case Token::DEFAULT:
       return ParseExportDefault(ok);
 
     case Token::MUL: {
       Consume(Token::MUL);
       ExpectContextualKeyword(CStrVector("from"), CHECK_OK);
       const AstRawString* module_specifier = ParseModuleSpecifier(CHECK_OK);
       scope_->module()->AddModuleRequest(module_specifier, zone());
       // TODO(ES6): scope_->module()->AddStarExport(...)
@@ skipping 47 matching lines @@
         scope_->module()->AddModuleRequest(indirect_export_module_specifier,
                                            zone());
         for (int i = 0; i < length; ++i) {
           // TODO(ES6): scope_->module()->AddIndirectExport(...);(
         }
       }
       return factory()->NewEmptyStatement(pos);
     }
 
     case Token::FUNCTION:
-      result = ParseFunctionDeclaration(&names, CHECK_OK);
+      result = ParseFunctionDeclaration(&names, ambient, CHECK_OK);
       break;
 
     case Token::CLASS:
       Consume(Token::CLASS);
-      result = ParseClassDeclaration(&names, CHECK_OK);
+      result = ParseClassDeclaration(&names, ambient, CHECK_OK);
       break;
 
     case Token::VAR:
     case Token::LET:
     case Token::CONST:
-      result = ParseVariableStatement(kStatementListItem, &names, CHECK_OK);
+      result =
+          ParseVariableStatement(kStatementListItem, &names, ambient, CHECK_OK);
       break;
 
     default:
       *ok = false;
       ReportUnexpectedToken(scanner()->current_token());
       return NULL;
   }
 
+  // Exported ambients are not checked.
+  if (ambient) return factory()->NewEmptyStatement(pos);
+
   // Extract declared names into export declarations.
   ModuleDescriptor* descriptor = scope_->module();
   for (int i = 0; i < names.length(); ++i) {
     descriptor->AddLocalExport(names[i], names[i], zone(), ok);
     if (!*ok) {
       // TODO(adamk): Possibly report this error at the right place.
       ParserTraits::ReportMessage(MessageTemplate::kDuplicateExport, names[i]);
       return NULL;
     }
   }
@@ skipping 97 matching lines @@
                       is_strict(language_mode())
                           ? MessageTemplate::kStrictFunction
                           : MessageTemplate::kSloppyFunction);
       *ok = false;
       return nullptr;
 
     case Token::DEBUGGER:
       return ParseDebuggerStatement(ok);
 
     case Token::VAR:
-      return ParseVariableStatement(kStatement, NULL, ok);
+      return ParseVariableStatement(kStatement, NULL, false, ok);
 
     default:
       return ParseExpressionOrLabelledStatement(labels, allow_function, ok);
   }
 }
 
 Statement* Parser::ParseStatementAsUnlabelled(
     ZoneList<const AstRawString*>* labels, bool* ok) {
   switch (peek()) {
     case Token::CONTINUE:
@@ skipping 222 matching lines @@
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   NativeFunctionLiteral* lit = factory()->NewNativeFunctionLiteral(
       name, extension_, RelocInfo::kNoPosition);
   return factory()->NewExpressionStatement(
       factory()->NewAssignment(Token::INIT, proxy, lit, RelocInfo::kNoPosition),
       pos);
 }
 
 
 Statement* Parser::ParseFunctionDeclaration(
-    ZoneList<const AstRawString*>* names, bool* ok) {
+    ZoneList<const AstRawString*>* names, bool ambient, bool* ok) {
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
   bool is_generator = Check(Token::MUL);
-  return ParseFunctionDeclaration(pos, is_generator, names, ok);
+  return ParseFunctionDeclaration(pos, is_generator, names, ambient, ok);
 }
 
 
 Statement* Parser::ParseFunctionDeclaration(
     int pos, bool is_generator, ZoneList<const AstRawString*>* names,
-    bool* ok) {
+    bool ambient, bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameters ')' '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameters ')' '{' FunctionBody '}'
   //
   // 'function' and '*' (if present) have been consumed by the caller.
   bool is_strict_reserved = false;
   const AstRawString* name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
 
   FuncNameInferrer::State fni_state(fni_);
   if (fni_ != NULL) fni_->PushEnclosingName(name);
+  typesystem::TypeFlags type_flags =
+      ambient ? typesystem::kAmbient : typesystem::kAllowSignature;
   FunctionLiteral* fun =
       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 no function declaration if just the signature was given.
   EmptyStatement* empty = factory()->NewEmptyStatement(RelocInfo::kNoPosition);
   if (fun == nullptr) return empty;
 
   // Even if we're not at the top-level of the global or a function
   // scope, we treat it as such and introduce the function with its
   // initial value upon entering the corresponding scope.
   // In ES6, a function behaves as a lexical binding, except in
   // a script scope, or the initial scope of eval or another function.
   VariableMode mode =
@@ skipping 12 matching lines @@
         factory()->NewSloppyBlockFunctionStatement(empty, scope_);
     scope_->DeclarationScope()->sloppy_block_function_map()->Declare(name,
                                                                      delegate);
     return delegate;
   }
   return empty;
 }
 
 
 Statement* Parser::ParseClassDeclaration(ZoneList<const AstRawString*>* names,
-                                         bool* ok) {
+                                         bool ambient, bool* ok) {
   // ClassDeclaration ::
   //   'class' Identifier ('extends' LeftHandExpression)? '{' ClassBody '}'
   //
   // 'class' is expected to be consumed by the caller.
   //
   // A ClassDeclaration
   //
   //   class C { ... }
   //
   // has the same semantics as:
   //
   //   let C = class C { ... };
   //
   // so rewrite it as such.
 
   if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
     ReportMessage(MessageTemplate::kSloppyLexical);
     *ok = false;
     return NULL;
   }
 
   int pos = position();
   bool is_strict_reserved = false;
   const AstRawString* name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
-  ClassLiteral* value = ParseClassLiteral(name, scanner()->location(),
-                                          is_strict_reserved, pos, CHECK_OK);
+  ClassLiteral* value = ParseClassLiteral(
+      name, scanner()->location(), is_strict_reserved, pos, ambient, CHECK_OK);
+  // Return no class declaration in case of an ambient.
+  if (ambient) return factory()->NewEmptyStatement(RelocInfo::kNoPosition);
 
   VariableProxy* proxy = NewUnresolved(name, LET);
   Declaration* declaration =
       factory()->NewVariableDeclaration(proxy, LET, scope_, pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, true, CHECK_OK);
   proxy->var()->set_initializer_position(position());
   Assignment* assignment =
       factory()->NewAssignment(Token::INIT, proxy, value, pos);
   Statement* assignment_statement =
       factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition);
@@ skipping 14 matching lines @@
       factory()->NewBlock(labels, 16, false, RelocInfo::kNoPosition);
   Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
 
   // Parse the statements and collect escaping labels.
   Expect(Token::LBRACE, CHECK_OK);
   block_scope->set_start_position(scanner()->location().beg_pos);
   { BlockState block_state(&scope_, block_scope);
     Target target(&this->target_stack_, body);
 
     while (peek() != Token::RBRACE) {
-      Statement* stat = ParseStatementListItem(CHECK_OK);
+      Statement* stat = ParseStatementListItem(false, CHECK_OK);
       if (stat && !stat->IsEmpty()) {
         body->statements()->Add(stat, zone());
       }
     }
   }
   Expect(Token::RBRACE, CHECK_OK);
   block_scope->set_end_position(scanner()->location().end_pos);
   if (finalize_block_scope) {
     block_scope = block_scope->FinalizeBlockScope();
   }
@@ skipping 14 matching lines @@
   for (auto declaration : declarations) {
     PatternRewriter::DeclareAndInitializeVariables(
         result, &descriptor, &declaration, names, CHECK_OK);
   }
   return result;
 }
 
 
 Block* Parser::ParseVariableStatement(VariableDeclarationContext var_context,
                                       ZoneList<const AstRawString*>* names,
-                                      bool* ok) {
+                                      bool ambient, bool* ok) {
   // VariableStatement ::
   //   VariableDeclarations ';'
 
   // 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). Thus we can
   // transform a source-level var/const declaration into a (Function)
   // Scope declaration, and rewrite the source-level initialization into an
   // assignment statement. We use a block to collect multiple assignments.
   //
   // We mark the block as initializer block because we don't want the
   // rewriter to add a '.result' assignment to such a block (to get compliant
   // behavior for code such as print(eval('var x = 7')), and for cosmetic
   // reasons when pretty-printing. Also, unless an assignment (initialization)
   // is inside an initializer block, it is ignored.
 
   DeclarationParsingResult parsing_result;
-  Block* result =
-      ParseVariableDeclarations(var_context, &parsing_result, names, CHECK_OK);
+  Block* result = ParseVariableDeclarations(var_context, &parsing_result, names,
+                                            ambient, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
   return result;
 }
 
 Block* Parser::ParseVariableDeclarations(
     VariableDeclarationContext var_context,
     DeclarationParsingResult* parsing_result,
-    ZoneList<const AstRawString*>* names, bool* ok) {
+    ZoneList<const AstRawString*>* names, bool ambient, bool* ok) {
   // VariableDeclarations ::
   //   ('var' | 'const' | 'let') (Identifier ('=' AssignmentExpression)?)+[',']
   //
   // The ES6 Draft Rev3 specifies the following grammar for const declarations
   //
   // ConstDeclaration ::
   //   const ConstBinding (',' ConstBinding)* ';'
   // ConstBinding ::
   //   Identifier '=' AssignmentExpression
   //
@@ skipping 51 matching lines @@
       }
     }
 
     // Parse optional type annotation.
     typename TypeSystem::Type type = this->EmptyType();
     if (scope_->typed() && Check(Token::COLON)) {  // Braces required here.
       type = ParseValidType(CHECK_OK);
     }
     USE(type);  // TODO(nikolaos): really use it!
 
+    // Skip initializers, for ambient declarations.
+    if (ambient) {
+      first_declaration = false;
+      continue;
+    }
+
     Scanner::Location variable_loc = scanner()->location();
     const AstRawString* single_name =
         pattern->IsVariableProxy() ? pattern->AsVariableProxy()->raw_name()
                                    : nullptr;
     if (single_name != nullptr) {
       if (fni_ != NULL) fni_->PushVariableName(single_name);
     }
 
     Expression* value = NULL;
     int initializer_position = RelocInfo::kNoPosition;
@@ skipping 137 matching lines @@
     }
     labels->Add(label, zone());
     // Remove the "ghost" variable that turned out to be a label
     // from the top scope. This way, we don't try to resolve it
     // during the scope processing.
     scope_->RemoveUnresolved(var);
     Expect(Token::COLON, CHECK_OK);
     // ES#sec-labelled-function-declarations Labelled Function Declarations
     if (peek() == Token::FUNCTION && is_sloppy(language_mode())) {
       if (allow_function == kAllowLabelledFunctionStatement) {
-        return ParseFunctionDeclaration(labels, ok);
+        return ParseFunctionDeclaration(labels, false, ok);
       } else {
         return ParseScopedStatement(labels, true, ok);
       }
     }
     return ParseStatement(labels, kDisallowLabelledFunctionStatement, ok);
   }
 
   // If we have an extension, we allow a native function declaration.
   // A native function declaration starts with "native function" with
   // no line-terminator between the two words.
@@ skipping 249 matching lines @@
     *default_seen_ptr = true;
   }
   Expect(Token::COLON, CHECK_OK);
   int pos = position();
   ZoneList<Statement*>* statements =
       new(zone()) ZoneList<Statement*>(5, zone());
   Statement* stat = NULL;
   while (peek() != Token::CASE &&
          peek() != Token::DEFAULT &&
          peek() != Token::RBRACE) {
-    stat = ParseStatementListItem(CHECK_OK);
+    stat = ParseStatementListItem(false, CHECK_OK);
     statements->Add(stat, zone());
   }
   return factory()->NewCaseClause(label, statements, pos);
 }
 
 
 Statement* Parser::ParseSwitchStatement(ZoneList<const AstRawString*>* labels,
                                         bool* ok) {
   // SwitchStatement ::
   //   'switch' '(' Expression ')' '{' CaseClause* '}'
@@ skipping 214 matching lines @@
 
           Block* init_block =
               factory()->NewBlock(nullptr, 8, true, RelocInfo::kNoPosition);
           PatternRewriter::DeclareAndInitializeVariables(
               init_block, &descriptor, &decl, nullptr, CHECK_OK);
           catch_block->statements()->Add(init_block, zone());
         }
 
         Expect(Token::LBRACE, CHECK_OK);
         while (peek() != Token::RBRACE) {
-          Statement* stat = ParseStatementListItem(CHECK_OK);
+          Statement* stat = ParseStatementListItem(false, CHECK_OK);
           if (stat && !stat->IsEmpty()) {
             catch_block->statements()->Add(stat, zone());
           }
         }
         Consume(Token::RBRACE);
       }
       block_scope->set_end_position(scanner()->location().end_pos);
       block_scope = block_scope->FinalizeBlockScope();
       catch_block->set_scope(block_scope);
     }
@@ skipping 477 matching lines @@
     return ParseSubStatement(labels, kDisallowLabelledFunctionStatement, ok);
   } else {
     if (legacy) {
       ++use_counts_[v8::Isolate::kLegacyFunctionDeclaration];
     }
     // Make a block around the statement for a lexical binding
     // is introduced by a FunctionDeclaration.
     Scope* body_scope = NewScope(scope_, BLOCK_SCOPE);
     BlockState block_state(&scope_, body_scope);
     Block* block = factory()->NewBlock(NULL, 1, false, RelocInfo::kNoPosition);
-    Statement* body = ParseFunctionDeclaration(NULL, CHECK_OK);
+    Statement* body = ParseFunctionDeclaration(NULL, false, CHECK_OK);
     block->statements()->Add(body, zone());
     body_scope->set_end_position(scanner()->location().end_pos);
     body_scope = body_scope->FinalizeBlockScope();
     block->set_scope(body_scope);
     return block;
   }
 }
 
 Statement* Parser::ParseForStatement(ZoneList<const AstRawString*>* labels,
                                      bool* ok) {
   int stmt_pos = peek_position();
   Statement* init = NULL;
   ZoneList<const AstRawString*> lexical_bindings(1, zone());
 
   // Create an in-between scope for let-bound iteration variables.
   Scope* for_scope = NewScope(scope_, BLOCK_SCOPE);
 
   BlockState block_state(&scope_, for_scope);
   Expect(Token::FOR, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   for_scope->set_start_position(scanner()->location().beg_pos);
   bool is_let_identifier_expression = false;
   DeclarationParsingResult parsing_result;
   if (peek() != Token::SEMICOLON) {
     if (peek() == Token::VAR || (peek() == Token::CONST && allow_const()) ||
         (peek() == Token::LET && IsNextLetKeyword())) {
-      ParseVariableDeclarations(kForStatement, &parsing_result, nullptr,
+      ParseVariableDeclarations(kForStatement, &parsing_result, nullptr, false,
                                 CHECK_OK);
 
       ForEachStatement::VisitMode mode = ForEachStatement::ENUMERATE;
       int each_beg_pos = scanner()->location().beg_pos;
       int each_end_pos = scanner()->location().end_pos;
 
       if (CheckInOrOf(&mode, ok)) {
         if (!*ok) return nullptr;
         if (parsing_result.declarations.length() != 1) {
           ParserTraits::ReportMessageAt(
@@ skipping 617 matching lines @@
 
     // Parse optional type annotation.
     typename TypeSystem::Type result_type = this->EmptyType();
     if (scope_->typed() &&
         !(type_flags & typesystem::kDisallowTypeAnnotation) &&
         Check(Token::COLON)) {  // Braces required here.
       result_type = ParseValidType(CHECK_OK);
     }
     USE(result_type);  // TODO(nikolaos): really use it!
 
-    // Allow for a function signature (i.e., a literal without body).
+    // Allow or even enforce a function signature (i.e., literal without body),
     // In that case, return a nullptr instead of a function literal.
-    if (peek() != Token::LBRACE && scope_->typed() &&
-        (type_flags & typesystem::kAllowSignature)) {
+    if ((type_flags & typesystem::kDisallowBody) ||
+        (peek() != Token::LBRACE && scope_->typed() &&
+         (type_flags & typesystem::kAllowSignature))) {
       ExpectSemicolon(CHECK_OK);
       return nullptr;
     }
 
     Expect(Token::LBRACE, CHECK_OK);
 
     // Don't include the rest parameter into the function's formal parameter
     // count (esp. the SharedFunctionInfo::internal_formal_parameter_count,
     // which says whether we need to create an arguments adaptor frame).
     if (formals.has_rest) arity--;
@@ skipping 425 matching lines @@
             Token::INIT, init_proxy, allocation, RelocInfo::kNoPosition);
         VariableProxy* get_proxy = factory()->NewVariableProxy(
             function_state_->generator_object_variable());
         Yield* yield =
             factory()->NewYield(get_proxy, assignment, RelocInfo::kNoPosition);
         try_block->statements()->Add(
             factory()->NewExpressionStatement(yield, RelocInfo::kNoPosition),
             zone());
       }
 
-      ParseStatementList(try_block->statements(), Token::RBRACE, CHECK_OK);
+      ParseStatementList(try_block->statements(), Token::RBRACE, false,
+                         CHECK_OK);
 
       Statement* final_return = factory()->NewReturnStatement(
           BuildIteratorResult(nullptr, true), RelocInfo::kNoPosition);
       try_block->statements()->Add(final_return, zone());
 
       Block* finally_block =
           factory()->NewBlock(nullptr, 1, false, RelocInfo::kNoPosition);
       ZoneList<Expression*>* args =
           new (zone()) ZoneList<Expression*>(1, zone());
       VariableProxy* call_proxy = factory()->NewVariableProxy(
           function_state_->generator_object_variable());
       args->Add(call_proxy, zone());
       Expression* call = factory()->NewCallRuntime(
           Runtime::kGeneratorClose, args, RelocInfo::kNoPosition);
       finally_block->statements()->Add(
           factory()->NewExpressionStatement(call, RelocInfo::kNoPosition),
           zone());
 
       body->Add(factory()->NewTryFinallyStatement(try_block, finally_block,
                                                   RelocInfo::kNoPosition),
                 zone());
     } else {
-      ParseStatementList(body, Token::RBRACE, CHECK_OK);
+      ParseStatementList(body, Token::RBRACE, false, CHECK_OK);
     }
 
     if (IsSubclassConstructor(kind)) {
       body->Add(
           factory()->NewReturnStatement(
               this->ThisExpression(scope_, factory(), RelocInfo::kNoPosition),
               RelocInfo::kNoPosition),
               zone());
     }
   }
@@ skipping 89 matching lines @@
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
 
 ClassLiteral* Parser::ParseClassLiteral(const AstRawString* name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
-                                        bool* ok) {
+                                        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 NULL;
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, MessageTemplate::kStrictEvalArguments);
     *ok = false;
@@ skipping 66 matching lines @@
     if (Check(Token::SEMICOLON)) continue;
     FuncNameInferrer::State fni_state(fni_);
     const bool in_class = true;
     const bool is_static = false;
     bool is_computed_name = false;  // Classes do not care about computed
                                     // property names here.
     ExpressionClassifier classifier(this);
     const AstRawString* property_name = nullptr;
     ObjectLiteral::Property* property = ParsePropertyDefinition(
         &checker, in_class, has_extends, is_static, &is_computed_name,
-        &has_seen_constructor, &classifier, &property_name, CHECK_OK);
-    // Ignore member variable declarations in typed mode.
+        &has_seen_constructor, &classifier, &property_name, ambient, CHECK_OK);
+    // Ignore member variable declarations, method signatures and members of
+    // ambients in typed mode.
     if (property == nullptr) continue;
     RewriteNonPattern(&classifier, CHECK_OK);
 
     if (has_seen_constructor && constructor == NULL) {
       constructor = GetPropertyValue(property)->AsFunctionLiteral();
       DCHECK_NOT_NULL(constructor);
       constructor->set_raw_name(
           name != nullptr ? name : ast_value_factory()->empty_string());
     } else {
       properties->Add(property, zone());
@@ skipping 2098 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8