Zonify types in compiler frontend

test/cctest/test-types.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 108 matching lines @@
     return Type::Intersect(t1, t2, region_);
   }
 
  private:
   Region* region_;
 };
 
 
 // Testing auxiliaries (breaking the Type abstraction).
 struct ZoneRep {
-  static bool IsTagged(ZoneType* t, int tag) {
+  static bool IsTagged(Type* t, int tag) {
     return !IsBitset(t)
         && reinterpret_cast<intptr_t>(AsTagged(t)->at(0)) == tag;
   }
-  static bool IsBitset(ZoneType* t) {
-    return reinterpret_cast<intptr_t>(t) & 1;
-  }
-  static bool IsClass(ZoneType* t) { return IsTagged(t, 0); }
-  static bool IsConstant(ZoneType* t) { return IsTagged(t, 1); }
-  static bool IsUnion(ZoneType* t) { return IsTagged(t, 2); }
+  static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(t) & 1; }
+  static bool IsClass(Type* t) { return IsTagged(t, 0); }
+  static bool IsConstant(Type* t) { return IsTagged(t, 1); }
+  static bool IsUnion(Type* t) { return IsTagged(t, 2); }
 
-  static ZoneList<void*>* AsTagged(ZoneType* t) {
+  static ZoneList<void*>* AsTagged(Type* t) {
     return reinterpret_cast<ZoneList<void*>*>(t);
   }
-  static int AsBitset(ZoneType* t) {
+  static int AsBitset(Type* t) {
     return reinterpret_cast<intptr_t>(t) >> 1;
   }
-  static Map* AsClass(ZoneType* t) {
+  static Map* AsClass(Type* t) {
     return *reinterpret_cast<Map**>(AsTagged(t)->at(1));
   }
-  static Object* AsConstant(ZoneType* t) {
+  static Object* AsConstant(Type* t) {
     return *reinterpret_cast<Object**>(AsTagged(t)->at(1));
   }
-  static ZoneList<ZoneType*>* AsUnion(ZoneType* t) {
-    return reinterpret_cast<ZoneList<ZoneType*>*>(AsTagged(t));
+  static ZoneList<Type*>* AsUnion(Type* t) {
+    return reinterpret_cast<ZoneList<Type*>*>(AsTagged(t));
   }
 
   static Zone* Region(Zone* zone, Isolate* isolate) { return zone; }
 };
 
 
 struct HeapRep {
-  static bool IsBitset(Handle<Type> t) { return t->IsSmi(); }
-  static bool IsClass(Handle<Type> t) { return t->IsMap(); }
-  static bool IsConstant(Handle<Type> t) { return t->IsBox(); }
-  static bool IsUnion(Handle<Type> t) { return t->IsFixedArray(); }
+  static bool IsBitset(Handle<HeapType> t) { return t->IsSmi(); }
+  static bool IsClass(Handle<HeapType> t) { return t->IsMap(); }
+  static bool IsConstant(Handle<HeapType> t) { return t->IsBox(); }
+  static bool IsUnion(Handle<HeapType> t) { return t->IsFixedArray(); }
 
-  static int AsBitset(Handle<Type> t) { return Smi::cast(*t)->value(); }
-  static Map* AsClass(Handle<Type> t) { return Map::cast(*t); }
-  static Object* AsConstant(Handle<Type> t) { return Box::cast(*t)->value(); }
-  static FixedArray* AsUnion(Handle<Type> t) { return FixedArray::cast(*t); }
+  static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value(); }
+  static Map* AsClass(Handle<HeapType> t) { return Map::cast(*t); }
+  static Object* AsConstant(Handle<HeapType> t) {
+    return Box::cast(*t)->value();
+  }
+  static FixedArray* AsUnion(Handle<HeapType> t) {
+    return FixedArray::cast(*t);
+  }
 
   static Isolate* Region(Zone* zone, Isolate* isolate) { return isolate; }
 };
 
 
 template<class Type, class TypeHandle, class Region, class Rep>
 struct Tests : Rep {
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
@@ skipping 568 matching lines @@
                 T.Union(T.ArrayConstant1, T.ObjectConstant2))),
         T.Union(T.ObjectConstant2, T.ObjectConstant1));
     CheckEqual(
         T.Intersect(
             T.Union(T.ObjectConstant2, T.ArrayConstant1),
             T.Union(T.ObjectConstant1, T.ArrayConstant2)),
         T.ArrayConstant1);
   }
 };
 
-typedef Tests<ZoneType, ZoneType*, Zone, ZoneRep> ZoneTests;
-typedef Tests<Type, Handle<Type>, Isolate, HeapRep> HeapTests;
+typedef Tests<Type, Type*, Zone, ZoneRep> ZoneTests;
+typedef Tests<HeapType, Handle<HeapType>, Isolate, HeapRep> HeapTests;
 
 
 TEST(Bitset) {
   CcTest::InitializeVM();
   ZoneTests().Bitset();
   HeapTests().Bitset();
 }
 
 
 TEST(Class) {
@@ skipping 29 matching lines @@
   ZoneTests().Union();
   HeapTests().Union();
 }
 
 
 TEST(Intersect) {
   CcTest::InitializeVM();
   ZoneTests().Intersect();
   HeapTests().Intersect();
 }