Add parsing for ambient declarations

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 56 matching lines @@
 //     typedef Identifier;
 //     typedef Expression;
 //     typedef FunctionLiteral;
 //     typedef ClassLiteral;
 //     typedef ObjectLiteralProperty;
 //     typedef Literal;
 //     typedef ExpressionList;
 //     typedef PropertyList;
 //     typedef FormalParameter;
 //     typedef FormalParameters;
+//     typedef Statement;
+//     typedef StatementList;
 //     // For constructing objects returned by the traversing functions.
 //     typedef Factory;
+//     // For classifying and validating expressions.
+//     typedef ExpressionClassifier.
+//     // A struct with extra types for the optional type system.
+//     struct TypeSystem {
+//       typedef Type;
+//       typedef TypeList;
+//       typedef TypeParameter;
+//       typedef TypeParameters;
+//       typedef FormalParameter;
+//       typedef FormalParameters;
+//       typedef TypeMember;
+//       typedef TypeMembers;
+//     };
 //   };
 //   // ...
 // };
 
 template <typename Traits>
 class ParserBase : public Traits {
  public:
   // Shorten type names defined by Traits.
   typedef typename Traits::Type::Expression ExpressionT;
   typedef typename Traits::Type::Identifier IdentifierT;
@@ skipping 677 matching lines @@
                               bool* ok);
   ExpressionT ParseArrayLiteral(ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParsePropertyName(IdentifierT* name, bool* is_get, bool* is_set,
                                 bool* is_computed_name,
                                 ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParsePropertyNameInType(bool* ok);
   ExpressionT ParseObjectLiteral(ExpressionClassifier* classifier, bool* ok);
   ObjectLiteralPropertyT ParsePropertyDefinition(
       ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
       bool is_static, bool* is_computed_name, bool* has_seen_constructor,
-      ExpressionClassifier* classifier, IdentifierT* name, bool* ok);
+      ExpressionClassifier* classifier, IdentifierT* name, bool ambient,
+      bool* ok);
   typename Traits::Type::ExpressionList ParseArguments(
       Scanner::Location* first_spread_pos, ExpressionClassifier* classifier,
       bool* ok);
 
   ExpressionT ParseAssignmentExpression(bool accept_IN,
                                         ExpressionClassifier* classifier,
                                         bool* ok);
   ExpressionT ParseYieldExpression(ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseConditionalExpression(bool accept_IN,
                                          ExpressionClassifier* classifier,
@@ skipping 610 matching lines @@
       IdentifierT name = this->EmptyIdentifier();
       bool is_strict_reserved_name = false;
       Scanner::Location class_name_location = Scanner::Location::invalid();
       if (peek_any_identifier()) {
         name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
                                                    CHECK_OK);
         class_name_location = scanner()->location();
       }
       return this->ParseClassLiteral(name, class_name_location,
                                      is_strict_reserved_name,
-                                     class_token_position, ok);
+                                     class_token_position, false, ok);
     }
 
     case Token::TEMPLATE_SPAN:
     case Token::TEMPLATE_TAIL:
       BindingPatternUnexpectedToken(classifier);
       return this->ParseTemplateLiteral(Traits::NoTemplateTag(), beg_pos,
                                         classifier, ok);
 
     case Token::MOD:
       if (allow_natives() || extension_ != NULL) {
@@ skipping 254 matching lines @@
              ? factory()->NewNumberLiteral(index, pos)
              : factory()->NewStringLiteral(name, pos);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ObjectLiteralPropertyT
 ParserBase<Traits>::ParsePropertyDefinition(
     ObjectLiteralCheckerBase* checker, bool in_class, bool has_extends,
     bool is_static, bool* is_computed_name, bool* has_seen_constructor,
-    ExpressionClassifier* classifier, IdentifierT* name, bool* ok) {
+    ExpressionClassifier* classifier, IdentifierT* name, bool ambient,
+    bool* ok) {
   DCHECK(!in_class || is_static || has_seen_constructor != nullptr);
 
   // Parse index member declarations in typed mode.
   // We implicitly disallow computed property names, in this case,
   // i.e., class C { [42](x) {} } does not work in typed mode.
   if (in_class && !is_static && scope_->typed() && Check(Token::LBRACK)) {
     int property_pos = peek_position();
     IdentifierT property_name =
         ParseIdentifierName(CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     ExpressionT property =
@@ skipping 137 matching lines @@
                                            : typesystem::kNormalTypes;
 
     if (in_class && !is_static && this->IsConstructor(*name)) {
       *has_seen_constructor = true;
       kind = has_extends ? FunctionKind::kSubclassConstructor
                          : FunctionKind::kBaseConstructor;
       type_flags = typesystem::kConstructorTypes;
     }
     // Allow signatures when in a class.
     if (in_class) type_flags |= typesystem::kAllowSignature;
+    if (ambient) type_flags |= typesystem::kAmbient;
 
     value = this->ParseFunctionLiteral(
         *name, scanner()->location(), kSkipFunctionNameCheck, kind,
         RelocInfo::kNoPosition, FunctionLiteral::kAccessorOrMethod,
         language_mode(), type_flags,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     // Return no property definition if just the signature was given.
     if (this->IsEmptyExpression(value)) {
       // Don't count constructor signature as a constructor.
       if (in_class && !is_static && this->IsConstructor(*name)) {
         // Note: we don't really need to unset has_seen_constructor
         checker->JustSignature();
       }
       return this->EmptyObjectLiteralProperty();
     }
 
     return factory()->NewObjectLiteralProperty(name_expression, value,
                                                ObjectLiteralProperty::COMPUTED,
                                                is_static, *is_computed_name);
   }
 
   if (in_class && name_token == Token::STATIC && !is_static) {
     // ClassElement (static)
     //    'static' MethodDefinition
     *name = this->EmptyIdentifier();
     ObjectLiteralPropertyT property = ParsePropertyDefinition(
         checker, true, has_extends, true, is_computed_name, nullptr, classifier,
-        name, ok);
+        name, ambient, ok);
     Traits::RewriteNonPattern(classifier, ok);
     return property;
   }
 
   if (is_get || is_set) {
     // MethodDefinition (Accessors)
     //    get PropertyName '(' ')' '{' FunctionBody '}'
     //    set PropertyName '(' PropertySetParameterList ')' '{' FunctionBody '}'
+    if (ambient) {
+      *ok = false;
+      ReportMessage(MessageTemplate::kAmbientGetOrSet);
+      return this->EmptyObjectLiteralProperty();
+    }
+
     *name = this->EmptyIdentifier();
     bool dont_care = false;
     name_token = peek();
 
     name_expression = ParsePropertyName(
         name, &dont_care, &dont_care, is_computed_name, classifier,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kAccessorProperty, is_static,
@@ skipping 24 matching lines @@
 
   // Allow member variable declarations in typed mode.
   if (in_class && scope_->typed()) {
     // Parse optional type annotation.
     typename TypeSystem::Type type = this->EmptyType();
     if (Check(Token::COLON)) {  // Braces required here.
       type = ParseValidType(CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
     USE(type);  // TODO(nikolaos): really use it!
     // Parse optional initializer.
-    if (Check(Token::ASSIGN)) {
+    if (!ambient && Check(Token::ASSIGN)) {
       ExpressionClassifier rhs_classifier(this);
       ExpressionT rhs = this->ParseAssignmentExpression(
           true, &rhs_classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       Traits::RewriteNonPattern(&rhs_classifier,
                                 CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       classifier->Accumulate(&rhs_classifier,
                              ExpressionClassifier::ExpressionProductions);
       USE(rhs);  // TODO(nikolaos): really use it!
     }
     return this->EmptyObjectLiteralProperty();
@@ skipping 24 matching lines @@
   while (peek() != Token::RBRACE) {
     FuncNameInferrer::State fni_state(fni_);
 
     const bool in_class = false;
     const bool is_static = false;
     const bool has_extends = false;
     bool is_computed_name = false;
     IdentifierT name = this->EmptyIdentifier();
     ObjectLiteralPropertyT property = this->ParsePropertyDefinition(
         &checker, in_class, has_extends, is_static, &is_computed_name, NULL,
-        classifier, &name, CHECK_OK);
+        classifier, &name, false, CHECK_OK);
 
     if (is_computed_name) {
       has_computed_names = true;
     }
 
     // Count CONSTANT or COMPUTED properties to maintain the enumeration order.
     if (!has_computed_names && this->IsBoilerplateProperty(property)) {
       number_of_boilerplate_properties++;
     }
     properties->Add(property, zone());
@@ skipping 1875 matching lines @@
 template <typename Traits>
 void ParserBase<Traits>::ClassLiteralChecker::JustSignature() {
   has_seen_constructor_ = false;
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H