Add parsing for object types

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 731 matching lines @@
 
   ExpressionT ParsePrimaryExpression(ExpressionClassifier* classifier,
                                      bool* ok);
   ExpressionT ParseExpression(bool accept_IN, bool* ok);
   ExpressionT ParseExpression(bool accept_IN, ExpressionClassifier* classifier,
                               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);
   typename Traits::Type::ExpressionList ParseArguments(
       Scanner::Location* first_spread_pos, ExpressionClassifier* classifier,
       bool* ok);
 
   ExpressionT ParseAssignmentExpression(bool accept_IN,
@@ skipping 75 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::TypeParameters ParseTypeParameters(bool* ok);
   typename TypeSystem::TypeList ParseTypeArguments(bool* ok);
   IdentifierListT ParsePropertyNameList(bool* ok);
+  typename TypeSystem::TypeMember ParseTypeMember(bool* ok);
 
   typename TypeSystem::Type ValidateType(typename TypeSystem::Type type,
                                          Scanner::Location location, bool* ok) {
     typename TypeSystem::Type result = type->Uncover(ok);
     if (*ok) {
       if (!result->IsStringLiteralType()) return result;
       *ok = false;
     }
     ReportMessageAt(location, MessageTemplate::kInvalidType);
     return type;
@@ skipping 729 matching lines @@
       break;
   }
 
   uint32_t index;
   return this->IsArrayIndex(*name, &index)
              ? factory()->NewNumberLiteral(index, pos)
              : factory()->NewStringLiteral(*name, pos);
 }
 
 
+// This is a simplified version of ParsePropertyName
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParsePropertyNameInType(bool* ok) {
+  Token::Value token = peek();
+  int pos = peek_position();
+  IdentifierT name = this->EmptyIdentifier();
+
+  // For non computed property names we normalize the name a bit:
+  //
+  //   "12" -> 12
+  //   12.3 -> "12.3"
+  //   12.30 -> "12.3"
+  //   identifier -> "identifier"
+  //
+  // This is important because we use the property name as a key in a hash
+  // table when we compute constant properties.
+  switch (token) {
+    case Token::STRING:
+      Consume(Token::STRING);
+      name = this->GetSymbol(scanner());
+      break;
+
+    case Token::SMI:
+      Consume(Token::SMI);
+      name = this->GetNumberAsSymbol(scanner());
+      break;
+
+    case Token::NUMBER:
+      Consume(Token::NUMBER);
+      name = this->GetNumberAsSymbol(scanner());
+      break;
+
+    default:
+      name = ParseIdentifierName(CHECK_OK);
+      break;
+  }
+
+  uint32_t index;
+  return this->IsArrayIndex(name, &index)
+             ? 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) {
   DCHECK(!in_class || is_static || has_seen_constructor != nullptr);
   ExpressionT value = this->EmptyExpression();
   bool is_get = false;
   bool is_set = false;
@@ skipping 1715 matching lines @@
             elements->Add(type_element, zone());
             valid_type = false;
             spread = true;
             break;
           }
           typename TypeSystem::Type type_element = ParseType(CHECK_OK_TYPE);
           elements->Add(type_element, zone());
           if (!type_element->IsValidType()) valid_type = false;
           if (!type_element->IsValidBindingIdentifierOrPattern())
             valid_binder = false;
-          if (peek() != Token::RBRACK) {  // Braces required here.
+          if (peek() != Token::RBRACK) {
             Expect(Token::COMMA, CHECK_OK_TYPE);
             trailing_comma = true;
           }
         } while (peek() != Token::RBRACK);
       }
       Consume(Token::RBRACK);
       type = factory()->NewTupleType(elements, valid_type && !trailing_comma,
                                      valid_binder, spread, pos);
       break;
     }
+    case Token::LBRACE: {
+      Consume(Token::LBRACE);
+      typename TypeSystem::TypeMembers members = this->EmptyTypeMembers();
+      bool valid_type = true, valid_binder = true;
+      while (peek() != Token::RBRACE) {
+        typename TypeSystem::TypeMember type_member =
+            ParseTypeMember(CHECK_OK_TYPE);
+        members->Add(type_member, zone());
+        if (!type_member->IsValidType()) valid_type = false;
+        if (!type_member->IsValidBindingIdentifierOrPattern())
+          valid_binder = false;
+        if (peek() != Token::RBRACE && !Check(Token::COMMA)) {
+          ExpectSemicolon(CHECK_OK_TYPE);
+          valid_binder = false;  // Semicolons not allowed in valid binders.
+        }
+      }
+      Consume(Token::RBRACE);
+      type = factory()->NewObjectType(members, valid_type, valid_binder, pos);
+      break;
+    }
     case Token::TYPEOF: {
       Consume(Token::TYPEOF);
       IdentifierT name = ParseIdentifierName(CHECK_OK_TYPE);
       IdentifierListT property_names = this->NullIdentifierList();
       if (peek() == Token::PERIOD) {  // Braces required here.
         property_names = ParsePropertyNameList(CHECK_OK_TYPE);
       }
       type = factory()->NewQueryType(name, property_names, pos);
       break;
     }
     case Token::VOID: {
       Consume(Token::VOID);
       type = factory()->NewPredefinedType(typesystem::PredefinedType::kVoidType,
                                           pos);
       break;
     }
     case Token::THIS: {
       Consume(Token::THIS);
       type = factory()->NewThisType(pos);
       break;
     }
-    // TODO(nikolaos): Missing object types.
     case Token::STRING: {
       Consume(Token::STRING);
       IdentifierT str = this->GetSymbol(scanner());
       type = factory()->NewStringLiteralType(str, pos);
       break;
     }
     default:
       ReportUnexpectedToken(Next());
       *ok = false;
       return type;
@@ skipping 20 matching lines @@
   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;
 }
 
 
+template <typename Traits>
+typename ParserBase<Traits>::TypeSystem::TypeMember
+ParserBase<Traits>::ParseTypeMember(bool* ok) {
+  int pos = peek_position();
+  bool valid_type = true, valid_binder = false;
+  // Parse index signature.
+  if (Check(Token::LBRACK)) {
+    int property_pos = peek_position();
+    IdentifierT property_name =
+        ParseIdentifierName(CHECK_OK_CUSTOM(EmptyTypeMember));
+    ExpressionT property =
+        factory()->NewStringLiteral(property_name, property_pos);
+    Expect(Token::COLON, CHECK_OK_CUSTOM(EmptyTypeMember));
+    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->EmptyTypeMember();
+    }
+    Expect(Token::RBRACK, CHECK_OK_CUSTOM(EmptyTypeMember));
+    // Parse optional result type
+    typename TypeSystem::Type type = this->EmptyType();
+    if (Check(Token::COLON)) {  // Braces required here.
+      type = ParseValidType(CHECK_OK_CUSTOM(EmptyTypeMember));
+    }
+    return factory()->NewTypeMember(property, index_type, type, pos);
+  }
+  // Parse property, method, call or constructor signatures.
+  ExpressionT property = this->EmptyExpression();
+  bool has_property = false;
+  bool optional = false;
+  bool has_new = Check(Token::NEW);
+  if (!has_new && peek() != Token::LT && peek() != Token::LPAREN) {
+    // Parse property name.
+    property = ParsePropertyNameInType(CHECK_OK_CUSTOM(EmptyTypeMember));
+    has_property = true;
+    optional = Check(Token::CONDITIONAL);
+    valid_binder = !optional;
+  }
+  // Parse optional type parameters.
+  typename TypeSystem::TypeParameters type_parameters =
+      this->NullTypeParameters();
+  if (peek() == Token::LT) {  // Braces required here.
+    type_parameters = ParseTypeParameters(CHECK_OK_CUSTOM(EmptyTypeMember));
+    valid_binder = false;
+  }
+  // Require formal parameters if type parameters are present
+  // or if no property was specified.
+  if ((!has_property || !this->IsNullTypeParameters(type_parameters)) &&
+      peek() != Token::LPAREN) {
+    Expect(Token::LPAREN, CHECK_OK_CUSTOM(EmptyTypeMember));
+    UNREACHABLE();
+  }
+  // Parse optional formal parameters.
+  typename TypeSystem::FormalParameters parameters =
+      this->NullFormalParameters();
+  if (peek() == Token::LPAREN) {
+    typename TypeSystem::Type type_params =
+        ParsePrimaryTypeOrParameterList(CHECK_OK_CUSTOM(EmptyTypeMember));
+    parameters = type_params->AsValidParameterList(
+        zone_, CHECK_OK_CUSTOM(EmptyTypeMember));
+    valid_binder = false;
+  }
+  // Parse optional property or result type or covered binding pattern.
+  typename TypeSystem::Type type = this->EmptyType();
+  if (Check(Token::COLON)) {
+    type = ParseType(CHECK_OK_CUSTOM(EmptyTypeMember));
+    if (!type->IsValidType()) valid_type = false;
+    if (!type->IsValidBindingIdentifierOrPattern()) valid_binder = false;
+  }
+  return factory()->NewTypeMember(property, optional, type_parameters,
+                                  parameters, type, valid_type, valid_binder,
+                                  pos, has_new);
+}
+
+
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 #undef CHECK_OK_TYPE
 
 
 template <typename Traits>
 void ParserBase<Traits>::ObjectLiteralChecker::CheckProperty(
     Token::Value property, PropertyKind type, bool is_static, bool is_generator,
     bool* ok) {
   DCHECK(!is_static);
@@ skipping 44 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H