Add a type for objects with typed properties.

test/cctest/test-types.cc

 // Copyright 2013 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.
 
 #include <vector>
 
 #include "src/hydrogen-types.h"
 #include "src/types.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/types-fuzz.h"
@@ skipping 571 matching lines @@
           CHECK(Equal(function01, function02) == Equal(type2, type3));
           CHECK(Equal(function01, function03) == Equal(type1, type3));
           CHECK(Equal(function11, function12) == Equal(type2, type3));
           CHECK(Equal(function21, function22) == Equal(type2, type3));
           CHECK(Equal(function21, function23) == Equal(type2, type3));
         }
       }
     }
   }
 
+  void Object() {
+    // Constructor, InitProperty, and Property.
+    for (int i = 0; i < 20; ++i) {
+      for (int j = 0; j < 20; ++j) {
+        TypeHandle object0 = T.ExplicitObject(20);
+        TypeHandle object1 = T.ExplicitObject(20);
+        TypeHandle types[20];
+        for (int k = 0; k < 20; ++k) {
+          types[k] = T.Random();
+        }
+        for (int k = 0; k < 20; ++k) {
+          ScopedVector<char> name(20);
+          SNPrintF(name, "foo%d", k);
+          Handle<i::String> sname =
+              isolate->factory()->InternalizeUtf8String(name.start());
+          object0->AsObject()->InitProperty(k, sname, types[k]);
+          object1->AsObject()->InitProperty(k, sname, types[19 - k]);
+        }
+        for (int k = 0; k < 20; ++k) {
+          ScopedVector<char> name(20);
+          SNPrintF(name, "foo%d", k);
+          Handle<i::String> sname =
+              isolate->factory()->InternalizeUtf8String(name.start());
+          CheckEqual(types[k], object0->AsObject()->Property(sname));
+          CheckEqual(types[19 - k], object1->AsObject()->Property(sname));
+        }
+        CHECK(object0->IsObject());
+        CHECK(object1->IsObject());
+        Handle<i::String> bar =
+            isolate->factory()->InternalizeUtf8String("bar");
+        CheckEqual(T.ExplicitAny(), object0->AsObject()->Property(bar));
+        CheckEqual(T.ExplicitAny(), object1->AsObject()->Property(bar));
+      }
+    }
+  }
+
   void Of() {
     // Constant(V)->Is(Of(V))
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       Handle<i::Object> value = *vt;
       TypeHandle const_type = T.Constant(value);
       TypeHandle of_type = T.Of(value);
       CHECK(const_type->Is(of_type));
     }
 
     // If Of(V)->Is(T), then Constant(V)->Is(T)
@@ skipping 1404 matching lines @@
 
 TEST(ArrayType_heap) { HeapTests().Array(); }
 
 
 TEST(FunctionType_zone) { ZoneTests().Function(); }
 
 
 TEST(FunctionType_heap) { HeapTests().Function(); }
 
 
+TEST(ObjectType_zone) { ZoneTests().Object(); }
+
+
+TEST(ObjectType_heap) { HeapTests().Object(); }
+
+
 TEST(Of_zone) { ZoneTests().Of(); }
 
 
 TEST(Of_heap) { HeapTests().Of(); }
 
 
 TEST(NowOf_zone) { ZoneTests().NowOf(); }
 
 
 TEST(NowOf_heap) { HeapTests().NowOf(); }
@@ skipping 100 matching lines @@
 }
 
 
 TEST(Convert_heap) { HeapTests().Convert<Type, Type*, Zone, ZoneRep>(); }
 
 
 TEST(HTypeFromType_zone) { ZoneTests().HTypeFromType(); }
 
 
 TEST(HTypeFromType_heap) { HeapTests().HTypeFromType(); }