Add parsing for interface 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 840 matching lines @@
   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::Type ParseObjectType(bool* ok);
   typename TypeSystem::TypeMember ParseTypeMember(bool* ok);
   StatementT ParseTypeAliasDeclaration(int pos, bool* ok);
+  StatementT ParseInterfaceDeclaration(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) {
       if (!result->IsStringLiteralType()) return result;
       *ok = false;
     }
     ReportMessageAt(location, MessageTemplate::kInvalidType);
     return type;
@@ skipping 2618 matching lines @@
             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);
+      type = ParseObjectType(CHECK_OK_TYPE);
       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);
@@ skipping 57 matching lines @@
   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::Type
+ParserBase<Traits>::ParseObjectType(bool* ok) {
+  int pos = peek_position();
+  Expect(Token::LBRACE, CHECK_OK_TYPE);
+  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);
+  return factory()->NewObjectType(members, valid_type, valid_binder, pos);
+}
+
+
+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 =
@@ skipping 91 matching lines @@
   if (!*ok) return empty;
   ExpectSemicolon(ok);
   if (!*ok) return empty;
   USE(name);  // TODO(nikolaos): really use them!
   USE(type_parameters);
   USE(type);
   return empty;
 }
 
 
+template <typename Traits>
+typename ParserBase<Traits>::StatementT
+ParserBase<Traits>::ParseInterfaceDeclaration(int pos, bool* ok) {
+  // InterfaceDeclaration ::
+  //   'interface' BindingIdentifier [ TypeParameters ]
+  //      [ InterfaceExtendsClause ] ObjectType ';'
+  // InterfaceExtendsClause ::
+  //   'extends' (TypeReference // ',')+
+  typename ParserBase<Traits>::StatementT empty =
+      factory()->NewEmptyStatement(pos);
+  IdentifierT name = ParseIdentifierName(ok);
+  if (!*ok) return empty;
+  // Parse optional type parameters.
+  typename TypeSystem::TypeParameters type_parameters =
+      this->NullTypeParameters();
+  if (peek() == Token::LT) {
+    type_parameters = ParseTypeParameters(ok);
+    if (!*ok) return empty;
+  }
+  // Parse optional extends clause.
+  typename TypeSystem::TypeList extends = this->NullTypeList();
+  if (Check(Token::EXTENDS)) {
+    extends = this->EmptyTypeList();
+    do {
+      typename TypeSystem::Type class_or_interface = ParseTypeReference(ok);
+      if (!*ok) return empty;
+      extends->Add(class_or_interface, zone());
+    } while (Check(Token::COMMA));
+  }
+  // Parse object type.
+  Scanner::Location type_location = scanner()->peek_location();
+  typename TypeSystem::Type type = ParseObjectType(ok);
+  if (!*ok) return empty;
+  type = ValidateType(type, type_location, ok);
+  if (!*ok) return empty;
+  USE(name);  // TODO(nikolaos): really use them!
+  USE(type_parameters);
+  USE(extends);
+  USE(type);
+  return empty;
+}
+
+
 #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