Add a type for objects with typed properties.

src/types.h

 // Copyright 2014 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_TYPES_H_
 #define V8_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/handles.h"
@@ skipping 312 matching lines @@
   class BitsetType;         // Internal
   class StructuralType;     // Internal
   class UnionType;          // Internal
 
   class ClassType;
   class ConstantType;
   class RangeType;
   class ContextType;
   class ArrayType;
   class FunctionType;
+  class ObjectType;
 
   typedef typename Config::template Handle<TypeImpl>::type TypeHandle;
   typedef typename Config::template Handle<ClassType>::type ClassHandle;
   typedef typename Config::template Handle<ConstantType>::type ConstantHandle;
   typedef typename Config::template Handle<RangeType>::type RangeHandle;
   typedef typename Config::template Handle<ContextType>::type ContextHandle;
   typedef typename Config::template Handle<ArrayType>::type ArrayHandle;
   typedef typename Config::template Handle<FunctionType>::type FunctionHandle;
+  typedef typename Config::template Handle<ObjectType>::type ObjectHandle;
   typedef typename Config::template Handle<UnionType>::type UnionHandle;
   typedef typename Config::Region Region;
 
   // Constructors.
 
   #define DEFINE_TYPE_CONSTRUCTOR(type, value)                                \
     static TypeImpl* type() {                                                 \
       return BitsetType::New(BitsetType::k##type);                            \
     }                                                                         \
     static TypeHandle type(Region* region) {                                  \
@@ skipping 65 matching lines @@
   }
   static TypeHandle Function(TypeHandle result, int arity, TypeHandle* params,
                              Region* region) {
     FunctionHandle function = Function(result, Any(region), arity, region);
     for (int i = 0; i < arity; ++i) {
       function->InitParameter(i, params[i]);
     }
     return function;
   }
 
+  static TypeHandle Object(int capacity, Region* region) {
+    return ObjectType::New(capacity, region);
+  }
+
   static TypeHandle Union(TypeHandle type1, TypeHandle type2, Region* reg);
   static TypeHandle Intersect(TypeHandle type1, TypeHandle type2, Region* reg);
   static TypeImpl* Union(TypeImpl* type1, TypeImpl* type2) {
     return BitsetType::New(type1->AsBitset() | type2->AsBitset());
   }
   static TypeImpl* Intersect(TypeImpl* type1, TypeImpl* type2) {
     return BitsetType::New(type1->AsBitset() & type2->AsBitset());
   }
 
   static TypeHandle Of(double value, Region* region) {
@@ skipping 55 matching lines @@
   }
   bool IsContext() {
     return Config::is_struct(this, StructuralType::kContextTag);
   }
   bool IsArray() {
     return Config::is_struct(this, StructuralType::kArrayTag);
   }
   bool IsFunction() {
     return Config::is_struct(this, StructuralType::kFunctionTag);
   }
+  bool IsObject() {
+    return Config::is_struct(this, StructuralType::kObjectTag);
+  }
 
   ClassType* AsClass() { return ClassType::cast(this); }
   ConstantType* AsConstant() { return ConstantType::cast(this); }
   RangeType* AsRange() { return RangeType::cast(this); }
   ContextType* AsContext() { return ContextType::cast(this); }
   ArrayType* AsArray() { return ArrayType::cast(this); }
   FunctionType* AsFunction() { return FunctionType::cast(this); }
+  ObjectType* AsObject() { return ObjectType::cast(this); }
 
   // Minimum and maximum of a numeric type.
   // These functions do not distinguish between -0 and +0.  If the type equals
   // kNaN, they return NaN; otherwise kNaN is ignored.  Only call these
   // functions on subtypes of Number.
   double Min();
   double Max();
 
   // Extracts a range from the type. If the type is a range, it just
   // returns it; if it is a union, it returns the range component.
@@ skipping 199 matching lines @@
   template<class> friend class TypeImpl;
   friend struct ZoneTypeConfig;  // For tags.
   friend struct HeapTypeConfig;
 
   enum Tag {
     kClassTag,
     kConstantTag,
     kContextTag,
     kArrayTag,
     kFunctionTag,
+    kObjectTag,
     kUnionTag
   };
 
   int Length() {
     return Config::struct_length(Config::as_struct(this));
   }
   TypeHandle Get(int i) {
     DCHECK(0 <= i && i < this->Length());
     return Config::struct_get(Config::as_struct(this), i);
   }
@@ skipping 213 matching lines @@
   }
 
   static FunctionType* cast(TypeImpl* type) {
     DCHECK(type->IsFunction());
     return static_cast<FunctionType*>(type);
   }
 };
 
 
 // -----------------------------------------------------------------------------
+// Object types.
+// Structural type with the following layout:
+//   0 - Any type used when accessing unknown property.
+//   i * 2 + 1 - Name of the ith property.
+//   i * 2 + 2 - Type of the ith property.
+template <class Config>
+class TypeImpl<Config>::ObjectType : public StructuralType {
+ public:
+  typedef TypeImpl<Config> Type;
+  typedef typename Type::Region Region;
+
+  Handle<i::String> Name(int i) {
+    return this->template GetValue<i::String>(2 * i + 1);
+  }
+  TypeHandle Property(int i) { return this->Get(2 * i + 2); }
+  TypeHandle Property(Handle<i::String> name) {
+    for (int i = 0; i < Width(); ++i) {
+      if (name->Equals(*Name(i))) return Property(i);
+    }
+    return this->Get(0);
+  }
+  int Width() { return this->Length() / 2; }
+
+  static ObjectHandle New(int capacity, Region* region) {
+    ObjectHandle type = Config::template cast<ObjectType>(StructuralType::New(
+        StructuralType::kObjectTag, capacity * 2 + 1, region));
+    type->AsObject()->Set(0, Type::Any(region));
+    return type;
+  }
+
+  void InitProperty(int i, Handle<i::String> name, TypeHandle type) {
+    this->template SetValue<i::String>(2 * i + 1, name);
+    this->Set(2 * i + 2, type);
+  }
+
+  static ObjectType* cast(Type* type) {
+    DCHECK(type->IsObject());
+    return static_cast<ObjectType*>(type);
+  }
+};
+
+
+// -----------------------------------------------------------------------------
 // Type iterators.
 
 template<class Config> template<class T>
 class TypeImpl<Config>::Iterator {
  public:
   bool Done() const { return index_ < 0; }
   i::Handle<T> Current();
   void Advance();
 
  private:
@@ skipping 193 matching lines @@
   bool Narrows(BoundsImpl that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_