Add parsing for object types

src/ast/ast.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_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 89 matching lines @@
 
 // Optional type nodes are intentionally not in in AST_NODE_LIST.
 // Visitors should not have to worry about them.
 #define TYPESYSTEM_NODE_LIST(V) \
   V(PredefinedType)             \
   V(ThisType)                   \
   V(UnionType)                  \
   V(IntersectionType)           \
   V(ArrayType)                  \
   V(TupleType)                  \
-  V(FunctionType)               \
+  V(ObjectType)                 \
+  V(TypeMember)                 \
   V(TypeParameter)              \
   V(FormalParameter)            \
   V(TypeReference)              \
   V(StringLiteralType)          \
   V(QueryType)                  \
   V(TypeOrParameters)
 
 // Forward declarations
 class AstNodeFactory;
 class AstVisitor;
@@ skipping 3008 matching lines @@
   friend class Type;
 
  private:
   Type* binder_;
   bool optional_;
   bool spread_;
   Type* type_;
 };
 
 
-// Class for function and constructor types.
-class FunctionType : public Type {
- public:
-  DECLARE_NODE_TYPE(FunctionType)
-
-  bool IsConstructorType() const { return constructor_; }
-  ZoneList<TypeParameter*>* type_parameters() const { return type_parameters_; }
-  ZoneList<FormalParameter*>* parameters() const { return parameters_; }
-  Type* result_type() const { return result_type_; }
-
- protected:
-  FunctionType(Zone* zone, ZoneList<TypeParameter*>* type_parameters,
-               ZoneList<FormalParameter*>* parameters, Type* result_type,
-               int pos, bool constructor = false)
-      : Type(zone, pos),
-        type_parameters_(type_parameters),
-        parameters_(parameters),
-        result_type_(result_type),
-        constructor_(constructor) {}
-
- private:
-  ZoneList<TypeParameter*>* type_parameters_;
-  ZoneList<FormalParameter*>* parameters_;
-  Type* result_type_;
-  bool constructor_;
-};
-
-
 // Class for type references.
 // It also covers binding identifiers.
 class TypeReference : public Type {
  public:
   DECLARE_NODE_TYPE(TypeReference)
 
   const AstRawString* name() const { return name_; }
   ZoneList<Type*>* type_arguments() const { return type_arguments_; }
 
   bool IsValidBindingIdentifier() const {
@@ skipping 56 matching lines @@
 
  protected:
   TypeOrParameters(Zone* zone, ZoneList<FormalParameter*>* parameters, int pos)
       : Type(zone, pos), parameters_(parameters) {}
 
  private:
   ZoneList<FormalParameter*>* parameters_;
 };
 
 
+// Class for object type members.
+// It also covers binding properties.
+class TypeMember : public AstNode {
+ public:
+  DECLARE_NODE_TYPE(TypeMember)
+
+  enum IndexType {
+    kNoIndexType,
+    kNumberIndexType,
+    kStringIndexType
+  };
+
+  Expression* property() const { return property_; }
+  IndexType index_type() const { return index_type_; }
+  bool optional() const { return optional_; }

[rossberg, 2016/04/07 15:09:02]

Nit: is_optional, is_constructor?

[nickie, 2016/04/08 09:50:57]

Done.

+  bool constructor() const { return constructor_; }
+  ZoneList<TypeParameter*>* type_parameters() const { return type_parameters_; }
+  ZoneList<FormalParameter*>* parameters() const { return parameters_; }
+  Type* type() const { return type_; }
+  bool IsValidType() const { return valid_type_; }
+  bool IsValidBindingIdentifierOrPattern() const { return valid_binder_; }
+
+ protected:
+  TypeMember(Zone* zone, Expression* property, bool optional,
+             ZoneList<typesystem::TypeParameter*>* type_parameters,
+             ZoneList<typesystem::FormalParameter*>* parameters,
+             typesystem::Type* type, bool valid_type, bool valid_binder,
+             int pos, bool constructor = false)
+      : AstNode(pos),
+        property_(property),
+        index_type_(kNoIndexType),
+        optional_(optional),
+        constructor_(constructor),
+        valid_type_(valid_type),
+        valid_binder_(valid_binder),
+        type_parameters_(type_parameters),
+        parameters_(parameters),
+        type_(type) {}
+  TypeMember(Zone* zone, Expression* property,
+             typesystem::TypeMember::IndexType index_type,
+             typesystem::Type* type, int pos)
+      : AstNode(pos),
+        property_(property),
+        index_type_(index_type),
+        optional_(false),
+        constructor_(false),
+        valid_type_(true),
+        valid_binder_(false),
+        type_parameters_(nullptr),
+        parameters_(nullptr),
+        type_(type) {}
+
+ private:
+  Expression* property_;
+  IndexType index_type_;
+  bool optional_;
+  bool constructor_;
+  bool valid_type_;
+  bool valid_binder_;
+  ZoneList<typesystem::TypeParameter*>* type_parameters_;
+  ZoneList<typesystem::FormalParameter*>* parameters_;
+  typesystem::Type* type_;
+};
+
+
+// Class for object types.
+// It also covers binding object patterns.
+class ObjectType : public Type {
+ public:
+  DECLARE_NODE_TYPE(ObjectType)
+
+  ZoneList<TypeMember*>* members() const { return members_; }
+  bool IsValidType() const { return valid_type_; }
+  bool IsValidBindingPattern() const { return valid_binder_; }
+
+ protected:
+  ObjectType(Zone* zone, ZoneList<TypeMember*>* members, bool valid_type,
+             bool valid_binder, int pos)
+      : Type(zone, pos),
+        members_(members),
+        valid_type_(valid_type),
+        valid_binder_(valid_binder) {}
+
+ private:
+  ZoneList<TypeMember*>* members_;
+  bool valid_type_;
+  bool valid_binder_;
+};
+
+
 V8_INLINE bool Type::IsValidType() const {
   if (IsTypeOrParameters()) {
     ZoneList<FormalParameter*>* parameters = AsTypeOrParameters()->parameters();
     return parameters->length() == 1 && parameters->at(0)->IsValidType();
   }
   if (IsTupleType()) return AsTupleType()->IsValidType();
+  if (IsObjectType()) return AsObjectType()->IsValidType();
   return true;
 }
 
 V8_INLINE bool Type::IsValidBindingIdentifierOrPattern() const {
   if (IsTypeReference()) return AsTypeReference()->IsValidBindingIdentifier();
   if (IsTupleType()) return AsTupleType()->IsValidBindingPattern();
+  if (IsObjectType()) return AsObjectType()->IsValidBindingPattern();
   if (IsPredefinedType()) return AsPredefinedType()->IsValidBindingIdentifier();
   return false;
 }
 
 V8_INLINE Type* Type::Uncover(bool* ok) {
   if (IsTypeOrParameters()) {
     ZoneList<FormalParameter*>* parameters = AsTypeOrParameters()->parameters();
     if (parameters->length() == 1 && parameters->at(0)->IsValidType())
       return parameters->at(0)->type();
   } else if (IsTupleType()) {
     if (AsTupleType()->IsValidType()) return this;
+  } else if (IsObjectType()) {
+    if (AsObjectType()->IsValidType()) return this;
   } else {
     return this;
   }
   *ok = false;
   return nullptr;
 }
 
 V8_INLINE ZoneList<FormalParameter*>* Type::AsValidParameterList(
     Zone* zone, bool* ok) const {
   if (!IsTypeOrParameters()) {
@@ skipping 581 matching lines @@
     return new (local_zone_) typesystem::ArrayType(local_zone_, base, pos);
   }
 
   typesystem::TupleType* NewTupleType(ZoneList<typesystem::Type*>* elements,
                                       bool valid_type, bool valid_binder,
                                       bool spread, int pos) {
     return new (local_zone_) typesystem::TupleType(
         local_zone_, elements, valid_type, valid_binder, spread, pos);
   }
 
-  typesystem::FunctionType* NewFunctionType(
+  typesystem::ObjectType* NewObjectType(
+      ZoneList<typesystem::TypeMember*>* members, bool valid_type,
+      bool valid_binder, int pos) {
+    return new (local_zone_) typesystem::ObjectType(
+        local_zone_, members, valid_type, valid_binder, pos);
+  }
+
+  typesystem::ObjectType* NewFunctionType(
       ZoneList<typesystem::TypeParameter*>* type_parameters,
       ZoneList<typesystem::FormalParameter*>* parameters,
       typesystem::Type* result_type, int pos, bool constructor = false) {
+    ZoneList<typesystem::TypeMember*>* members =
+        new (local_zone_) ZoneList<typesystem::TypeMember*>(1, local_zone_);
+    members->Add(NewTypeMember(nullptr, false, type_parameters, parameters,
+                               result_type, true, false, pos, constructor),
+                 local_zone_);
     return new (local_zone_)
-        typesystem::FunctionType(local_zone_, type_parameters, parameters,
-                                 result_type, pos, constructor);
+        typesystem::ObjectType(local_zone_, members, true, false, pos);
   }
 
   typesystem::TypeReference* NewTypeReference(
       const AstRawString* name, ZoneList<typesystem::Type*>* type_arguments,
       int pos) {
     return new (local_zone_)
         typesystem::TypeReference(local_zone_, name, type_arguments, pos);
   }
 
   typesystem::StringLiteralType* NewStringLiteralType(
@@ skipping 29 matching lines @@
         typesystem::TypeOrParameters(local_zone_, parameters, pos);
   }
 
   typesystem::TypeParameter* NewTypeParameter(const AstRawString* name,
                                               typesystem::Type* extends,
                                               int pos) {
     return new (local_zone_)
         typesystem::TypeParameter(local_zone_, name, extends, pos);
   }
 
+  typesystem::TypeMember* NewTypeMember(
+      Expression* property, bool optional,
+      ZoneList<typesystem::TypeParameter*>* type_parameters,
+      ZoneList<typesystem::FormalParameter*>* parameters,
+      typesystem::Type* type, bool valid_type, bool valid_binder, int pos,
+      bool constructor = false) {
+    return new (local_zone_) typesystem::TypeMember(
+        local_zone_, property, optional, type_parameters, parameters, type,
+        valid_type, valid_binder, pos, constructor);
+  }
+
+  typesystem::TypeMember* NewTypeMember(
+      Expression* property, typesystem::TypeMember::IndexType index_type,
+      typesystem::Type* type, int pos) {
+    return new (local_zone_)
+        typesystem::TypeMember(local_zone_, property, index_type, type, pos);
+  }
+
   Zone* zone() const { return local_zone_; }
 
   // Handles use of temporary zones when parsing inner function bodies.
   class BodyScope {
    public:
     BodyScope(AstNodeFactory* factory, Zone* temp_zone, bool use_temp_zone)
         : factory_(factory), prev_zone_(factory->local_zone_) {
       if (use_temp_zone) {
         factory->local_zone_ = temp_zone;
       }
@@ skipping 72 matching lines @@
         : NULL;                                                               \
   }
 TYPESYSTEM_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_