Allow constructor and method signatures in classes

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 880 matching lines @@
 
   class ObjectLiteralCheckerBase {
    public:
     explicit ObjectLiteralCheckerBase(ParserBase* parser) : parser_(parser) {}
 
     virtual void CheckProperty(Token::Value property, PropertyKind type,
                                bool is_static, bool is_generator, bool* ok) = 0;
 
     virtual ~ObjectLiteralCheckerBase() {}
 
+    virtual void JustSignature() = 0;
+
    protected:
     ParserBase* parser() const { return parser_; }
     Scanner* scanner() const { return parser_->scanner(); }
 
    private:
     ParserBase* parser_;
   };
 
   // Validation per ES6 object literals.
   class ObjectLiteralChecker : public ObjectLiteralCheckerBase {
    public:
     explicit ObjectLiteralChecker(ParserBase* parser)
         : ObjectLiteralCheckerBase(parser), has_seen_proto_(false) {}
 
     void CheckProperty(Token::Value property, PropertyKind type, bool is_static,
                        bool is_generator, bool* ok) override;
 
+    void JustSignature() override;
+
    private:
     bool IsProto() { return this->scanner()->LiteralMatches("__proto__", 9); }
 
     bool has_seen_proto_;
   };
 
   // Validation per ES6 class literals.
   class ClassLiteralChecker : public ObjectLiteralCheckerBase {
    public:
     explicit ClassLiteralChecker(ParserBase* parser)
         : ObjectLiteralCheckerBase(parser), has_seen_constructor_(false) {}
 
     void CheckProperty(Token::Value property, PropertyKind type, bool is_static,
                        bool is_generator, bool* ok) override;
 
+    void JustSignature() override;
+
    private:
     bool IsConstructor() {
       return this->scanner()->LiteralMatches("constructor", 11);
     }
     bool IsPrototype() {
       return this->scanner()->LiteralMatches("prototype", 9);
     }
 
     bool has_seen_constructor_;
   };
@@ skipping 867 matching lines @@
     typesystem::TypeFlags type_flags = (is_get || is_set)
                                            ? typesystem::kDisallowTypeParameters
                                            : 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;
 
     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(
@@ skipping 1971 matching lines @@
       this->parser()->ReportMessage(MessageTemplate::kDuplicateConstructor);
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
+template <typename Traits>
+void ParserBase<Traits>::ObjectLiteralChecker::JustSignature() {}
+
+
+template <typename Traits>
+void ParserBase<Traits>::ClassLiteralChecker::JustSignature() {
+  has_seen_constructor_ = false;
+}
+
+
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H