Add parsing for class 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 443 matching lines @@
 
   bool peek_any_identifier() {
     Token::Value next = peek();
     return next == Token::IDENTIFIER || next == Token::FUTURE_RESERVED_WORD ||
            next == Token::FUTURE_STRICT_RESERVED_WORD || next == Token::LET ||
            next == Token::STATIC || next == Token::YIELD;
   }
 
   bool CheckContextualKeyword(Vector<const char> keyword) {
     if (PeekContextualKeyword(keyword)) {
-      Consume(Token::IDENTIFIER);
+      Next();
       return true;
     }
     return false;
   }
 
   bool PeekContextualKeyword(Vector<const char> keyword) {
-    return peek() == Token::IDENTIFIER &&
+    return (peek() == Token::IDENTIFIER ||
+            peek() == Token::FUTURE_RESERVED_WORD ||
+            peek() == Token::FUTURE_STRICT_RESERVED_WORD) &&
            scanner()->is_next_contextual_keyword(keyword);
   }
 
   void ExpectMetaProperty(Vector<const char> property_name,
                           const char* full_name, int pos, bool* ok);
 
   void ExpectContextualKeyword(Vector<const char> keyword, bool* ok) {
-    Expect(Token::IDENTIFIER, ok);
-    if (!*ok) return;
-    if (!scanner()->is_literal_contextual_keyword(keyword)) {
+    Token::Value next = Next();
+    if (next != Token::IDENTIFIER && next != Token::FUTURE_RESERVED_WORD &&
+        next != Token::FUTURE_STRICT_RESERVED_WORD) {
+      ReportUnexpectedToken(next);
+      *ok = false;
+    } else if (!scanner()->is_literal_contextual_keyword(keyword)) {
       ReportUnexpectedToken(scanner()->current_token());
       *ok = false;
     }
   }
 
   bool CheckInOrOf(ForEachStatement::VisitMode* visit_mode, bool* ok) {
     if (Check(Token::IN)) {
       *visit_mode = ForEachStatement::ENUMERATE;
       return true;
     } else if (CheckContextualKeyword(CStrVector("of"))) {
@@ skipping 350 matching lines @@
     }
   }
 
   // Parsing optional types.
   typename TypeSystem::Type ParseValidType(bool* ok);
   typename TypeSystem::Type ParseValidTypeOrStringLiteral(bool* ok);
   typename TypeSystem::Type ParseType(bool* ok);
   typename TypeSystem::Type ParseUnionOrIntersectionOrPrimaryType(bool* ok);
   typename TypeSystem::Type ParseIntersectionOrPrimaryType(bool* ok);
   typename TypeSystem::Type ParsePrimaryTypeOrParameterList(bool* ok);
+  typename TypeSystem::Type ParseTypeReference(bool* ok);
   typename TypeSystem::TypeParameters ParseTypeParameters(bool* ok);
   typename TypeSystem::TypeList ParseTypeArguments(bool* ok);
   IdentifierListT ParsePropertyNameList(bool* ok);
   typename TypeSystem::TypeMember ParseTypeMember(bool* ok);
   StatementT ParseTypeAliasDeclaration(int pos, bool* ok);
 
   typename TypeSystem::Type ValidateType(typename TypeSystem::Type type,
                                          Scanner::Location location, bool* ok) {
     typename TypeSystem::Type result = type->Uncover(ok);
     if (*ok) {
@@ skipping 786 matching lines @@
 }
 
 
 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) {
   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.

[rossberg, 2016/04/18 11:03:08]

Interesting. That's probably going to be a problem for TypeScript, too. I wonder
how they'll resolve it...

[nickie, 2016/04/19 14:55:30]

I suppose index member declarations can be distinguished from computed
properties if you look ahead past the identifier.  The former have a colon
there, which is not legal in the latter.  (I don't believe that an
AssignmentExpression can begin by an identifier followed by a colon.)

We can do it here too, but we need 3 look-ahead symbols, unless we somehow merge
this with the ParsePropertyName in line 1711 (this will become ugly, IMO).

+  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 =
+        factory()->NewStringLiteral(property_name, property_pos);
+    Expect(Token::COLON, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+    typesystem::TypeMember::IndexType index_type =
+        typesystem::TypeMember::kNoIndexType;
+    if (peek() == Token::IDENTIFIER) {
+      if (CheckContextualKeyword(CStrVector("number"))) {
+        index_type = typesystem::TypeMember::kNumberIndexType;
+      } else if (CheckContextualKeyword(CStrVector("string"))) {
+        index_type = typesystem::TypeMember::kStringIndexType;
+      }
+    }
+    if (index_type == typesystem::TypeMember::kNoIndexType) {
+      Scanner::Location next_location = scanner()->peek_location();
+      ReportMessageAt(next_location, MessageTemplate::kBadIndexType);
+      *ok = false;
+      return this->EmptyObjectLiteralProperty();
+    }
+    Expect(Token::RBRACK, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+    // Parse optional result type
+    typename TypeSystem::Type type = this->EmptyType();
+    if (Check(Token::COLON)) {  // Braces required here.
+      type = ParseValidType(CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
+    }
+    USE(property);  // TODO(nikolaos): really use these!
+    USE(index_type);
+    USE(type);
+    return this->EmptyObjectLiteralProperty();
+  }
+
   ExpressionT value = this->EmptyExpression();
   bool is_get = false;
   bool is_set = false;
   bool is_generator = Check(Token::MUL);
 
   Token::Value name_token = peek();
   int next_beg_pos = scanner()->peek_location().beg_pos;
   int next_end_pos = scanner()->peek_location().end_pos;
   ExpressionT name_expression =
       ParsePropertyName(name, &is_get, &is_set, is_computed_name, classifier,
@@ skipping 158 matching lines @@
       name_expression =
           factory()->NewStringLiteral(*name, name_expression->position());
     }
 
     return factory()->NewObjectLiteralProperty(
         name_expression, value,
         is_get ? ObjectLiteralProperty::GETTER : ObjectLiteralProperty::SETTER,
         is_static, *is_computed_name);
   }
 
+  // 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)) {
+      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();
+  }
+
   Token::Value next = Next();
   ReportUnexpectedToken(next);
   *ok = false;
   return this->EmptyObjectLiteralProperty();
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT ParserBase<Traits>::ParseObjectLiteral(
     ExpressionClassifier* classifier, bool* ok) {
@@ skipping 1533 matching lines @@
             typesystem::PredefinedType::kBooleanType, pos);
       } else if (CheckContextualKeyword(CStrVector("number"))) {
         type = factory()->NewPredefinedType(
             typesystem::PredefinedType::kNumberType, pos);
       } else if (CheckContextualKeyword(CStrVector("string"))) {
         type = factory()->NewPredefinedType(
             typesystem::PredefinedType::kStringType, pos);
       } else if (CheckContextualKeyword(CStrVector("symbol"))) {
         type = factory()->NewPredefinedType(
             typesystem::PredefinedType::kSymbolType, pos);
-      } else {
-        IdentifierT name = ParseIdentifierName(CHECK_OK_TYPE);
-        typename TypeSystem::TypeList type_arguments = this->NullTypeList();
-        if (peek() == Token::LT) {  // Braces required here.
-          type_arguments = ParseTypeArguments(CHECK_OK_TYPE);
-        }
-        type = factory()->NewTypeReference(name, type_arguments, pos);
+      } else {  // Braces required here.
+        type = ParseTypeReference(CHECK_OK_TYPE);
       }
       break;
     }
     case Token::LBRACK: {
       Consume(Token::LBRACK);
       typename TypeSystem::TypeList elements = this->EmptyTypeList();
       bool valid_type = false, valid_binder = true, spread = false;
       bool trailing_comma = false;
       if (peek() != Token::RBRACK) {
         valid_type = true;
@@ skipping 91 matching lines @@
       Expect(Token::RBRACK, CHECK_OK_TYPE);
       type = factory()->NewArrayType(type, pos);
     }
   }
 
   return type;
 }
 
 
 template <typename Traits>
+typename ParserBase<Traits>::TypeSystem::Type
+ParserBase<Traits>::ParseTypeReference(bool* ok) {
+  int pos = peek_position();
+  IdentifierT name = ParseIdentifierName(CHECK_OK_TYPE);
+  typename TypeSystem::TypeList type_arguments = this->NullTypeList();
+  if (peek() == Token::LT) {  // Braces required here.
+    type_arguments = ParseTypeArguments(CHECK_OK_TYPE);
+  }
+  return factory()->NewTypeReference(name, type_arguments, pos);
+}
+
+
+template <typename Traits>
 typename ParserBase<Traits>::IdentifierListT
 ParserBase<Traits>::ParsePropertyNameList(bool* ok) {
   Expect(Token::PERIOD, CHECK_OK_CUSTOM(NullIdentifierList));
   IdentifierListT property_names = this->EmptyIdentifierList();
   do {
     IdentifierT property_name =
         ParseIdentifierName(CHECK_OK_CUSTOM(NullIdentifierList));
     property_names->Add(property_name, zone());
   } while (Check(Token::PERIOD));
   return property_names;
@@ skipping 169 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H