Add parsing for object types

src/ast/ast.h

Index: src/ast/ast.h
diff --git a/src/ast/ast.h b/src/ast/ast.h
index 28710d102284e49340f53227e503d2b80c32e6ae..121a349d0b8efc27131925936bccb2749c38fd5f 100644
--- a/src/ast/ast.h
+++ b/src/ast/ast.h
@@ -107,7 +107,8 @@ namespace internal {
   V(IntersectionType)           \
   V(ArrayType)                  \
   V(TupleType)                  \
-  V(FunctionType)               \
+  V(ObjectType)                 \
+  V(TypeMember)                 \
   V(TypeParameter)              \
   V(FormalParameter)            \
   V(TypeReference)              \
@@ -3136,34 +3137,6 @@ class FormalParameter : public AstNode {
 };
 
 
-// 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 {
@@ -3240,18 +3213,110 @@ class TypeOrParameters : public Type {
 };
 
 
+// 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;
 }
@@ -3263,6 +3328,8 @@ V8_INLINE Type* Type::Uncover(bool* ok) {
       return parameters->at(0)->type();
   } else if (IsTupleType()) {
     if (AsTupleType()->IsValidType()) return this;
+  } else if (IsObjectType()) {
+    if (AsObjectType()->IsValidType()) return this;
   } else {
     return this;
   }
@@ -3864,13 +3931,24 @@ class AstNodeFactory final BASE_EMBEDDED {
         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(
@@ -3920,6 +3998,24 @@ class AstNodeFactory final BASE_EMBEDDED {
         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.