Replace HeapType with a non-templated FieldType class.

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/crankshaft/hydrogen-types.h"
 #include "src/types.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/types-fuzz.h"
@@ skipping 44 matching lines @@
 
   struct BitsetType : Type::BitsetType {
     using Type::BitsetType::New;
     using Type::BitsetType::Glb;
     using Type::BitsetType::Lub;
     using Type::BitsetType::IsInhabited;
   };
 };
 
 
-struct HeapRep {
-  typedef FixedArray Struct;
-
-  static bool IsStruct(Handle<HeapType> t, int tag) {
-    return t->IsFixedArray() && Smi::cast(AsStruct(t)->get(0))->value() == tag;
-  }
-  static bool IsBitset(Handle<HeapType> t) { return t->IsSmi(); }
-  // HACK: the number 5 below is the value of StructuralType::kUnionTag.
-  static bool IsUnion(Handle<HeapType> t) { return t->IsUnionForTesting(); }
-
-  static Struct* AsStruct(Handle<HeapType> t) { return FixedArray::cast(*t); }
-  static bitset AsBitset(Handle<HeapType> t) {
-    return static_cast<bitset>(reinterpret_cast<uintptr_t>(*t));
-  }
-  static Struct* AsUnion(Handle<HeapType> t) { return AsStruct(t); }
-  static int Length(Struct* structured) { return structured->length() - 1; }
-
-  static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; }
-
-  struct BitsetType : HeapType::BitsetType {
-    using HeapType::BitsetType::New;
-    using HeapType::BitsetType::Glb;
-    using HeapType::BitsetType::Lub;
-    using HeapType::BitsetType::IsInhabited;
-    static bitset Glb(Handle<HeapType> type) { return Glb(*type); }
-    static bitset Lub(Handle<HeapType> type) { return Lub(*type); }
-  };
-};
-
-
 template<class Type, class TypeHandle, class Region, class Rep>
 struct Tests : Rep {
   typedef Types<Type, TypeHandle, Region> TypesInstance;
   typedef typename TypesInstance::TypeVector::iterator TypeIterator;
   typedef typename TypesInstance::MapVector::iterator MapIterator;
   typedef typename TypesInstance::ValueVector::iterator ValueIterator;
 
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
@@ skipping 1841 matching lines @@
       TypeHandle type3 = T.template Convert<Type2>(type2);
       CheckEqual(type1, type3);
     }
   }
 
   void HTypeFromType() {
     for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
       for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) {
         TypeHandle type1 = *it1;
         TypeHandle type2 = *it2;
-        HType htype1 = HType::FromType<Type>(type1);
-        HType htype2 = HType::FromType<Type>(type2);
+        HType htype1 = HType::FromType(type1);
+        HType htype2 = HType::FromType(type2);
         CHECK(!type1->Is(type2) || htype1.IsSubtypeOf(htype2));
       }
     }
   }
 };
 
 typedef Tests<Type, Type*, Zone, ZoneRep> ZoneTests;
-typedef Tests<HeapType, Handle<HeapType>, Isolate, HeapRep> HeapTests;
 
 
 TEST(IsSomeType_zone) { ZoneTests().IsSomeType(); }
 
 
-TEST(IsSomeType_heap) { HeapTests().IsSomeType(); }
-
-
 TEST(PointwiseRepresentation_zone) { ZoneTests().PointwiseRepresentation(); }
 
 
-TEST(PointwiseRepresentation_heap) { HeapTests().PointwiseRepresentation(); }
-
-
 TEST(BitsetType_zone) { ZoneTests().Bitset(); }
 
 
-TEST(BitsetType_heap) { HeapTests().Bitset(); }
-
-
 TEST(ClassType_zone) { ZoneTests().Class(); }
 
 
-TEST(ClassType_heap) { HeapTests().Class(); }
-
-
 TEST(ConstantType_zone) { ZoneTests().Constant(); }
 
 
-TEST(ConstantType_heap) { HeapTests().Constant(); }
-
-
 TEST(RangeType_zone) { ZoneTests().Range(); }
 
 
-TEST(RangeType_heap) { HeapTests().Range(); }
-
-
 TEST(ArrayType_zone) { ZoneTests().Array(); }
 
 
-TEST(ArrayType_heap) { HeapTests().Array(); }
-
-
 TEST(FunctionType_zone) { ZoneTests().Function(); }
 
 
-TEST(FunctionType_heap) { HeapTests().Function(); }
-
-
 TEST(Of_zone) { ZoneTests().Of(); }
 
 
-TEST(Of_heap) { HeapTests().Of(); }
-
-
 TEST(NowOf_zone) { ZoneTests().NowOf(); }
 
 
-TEST(NowOf_heap) { HeapTests().NowOf(); }
-
-
 TEST(MinMax_zone) { ZoneTests().MinMax(); }
 
 
-TEST(MinMax_heap) { HeapTests().MinMax(); }
-
-
 TEST(BitsetGlb_zone) { ZoneTests().BitsetGlb(); }
 
 
-TEST(BitsetGlb_heap) { HeapTests().BitsetGlb(); }
-
-
 TEST(BitsetLub_zone) { ZoneTests().BitsetLub(); }
 
 
-TEST(BitsetLub_heap) { HeapTests().BitsetLub(); }
-
-
 TEST(Is1_zone) { ZoneTests().Is1(); }
 
 
-TEST(Is1_heap) { HeapTests().Is1(); }
-
-
 TEST(Is2_zone) { ZoneTests().Is2(); }
 
 
-TEST(Is2_heap) { HeapTests().Is2(); }
-
-
 TEST(NowIs_zone) { ZoneTests().NowIs(); }
 
 
-TEST(NowIs_heap) { HeapTests().NowIs(); }
-
-
 TEST(Contains_zone) { ZoneTests().Contains(); }
 
 
-TEST(Contains_heap) { HeapTests().Contains(); }
-
-
 TEST(NowContains_zone) { ZoneTests().NowContains(); }
 
 
-TEST(NowContains_heap) { HeapTests().NowContains(); }
-
-
 TEST(Maybe_zone) { ZoneTests().Maybe(); }
 
 
-TEST(Maybe_heap) { HeapTests().Maybe(); }
-
-
 TEST(Union1_zone) { ZoneTests().Union1(); }
 
 
-TEST(Union1_heap) { HeapTests().Union1(); }
-
-
 TEST(Union2_zone) { ZoneTests().Union2(); }
 
 
-TEST(Union2_heap) { HeapTests().Union2(); }
-
-
 TEST(Union3_zone) { ZoneTests().Union3(); }
 
 
-TEST(Union3_heap) { HeapTests().Union3(); }
-
-
 TEST(Union4_zone) { ZoneTests().Union4(); }
 
 
-TEST(Union4_heap) { HeapTests().Union4(); }
-
-
 TEST(Intersect_zone) { ZoneTests().Intersect(); }
 
 
-TEST(Intersect_heap) { HeapTests().Intersect(); }
-
-
 TEST(Distributivity_zone) { ZoneTests().Distributivity(); }
 
 
-TEST(Distributivity_heap) { HeapTests().Distributivity(); }
-
-
 TEST(GetRange_zone) { ZoneTests().GetRange(); }
 
 
-TEST(GetRange_heap) { HeapTests().GetRange(); }
-
-
-TEST(Convert_zone) {
-  ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
-}
-
-
-TEST(Convert_heap) { HeapTests().Convert<Type, Type*, Zone, ZoneRep>(); }
-
-
 TEST(HTypeFromType_zone) { ZoneTests().HTypeFromType(); }
-
-
-TEST(HTypeFromType_heap) { HeapTests().HTypeFromType(); }