Remove unnecesssary auxiliary definitions.

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/isolate-inl.h"
 #include "src/types.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8::internal;
 
 // Testing auxiliaries (breaking the Type abstraction).
 struct ZoneRep {
   typedef void* Struct;
 
   static bool IsStruct(Type* t, int tag) {
     return !IsBitset(t) && reinterpret_cast<intptr_t>(AsStruct(t)[0]) == tag;
   }
   static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(t) & 1; }
-  static bool IsClass(Type* t) { return IsStruct(t, 0); }
-  static bool IsConstant(Type* t) { return IsStruct(t, 1); }
-  static bool IsRange(Type* t) { return IsStruct(t, 2); }
-  static bool IsContext(Type* t) { return IsStruct(t, 3); }
-  static bool IsArray(Type* t) { return IsStruct(t, 4); }
-  static bool IsFunction(Type* t) { return IsStruct(t, 5); }
   static bool IsUnion(Type* t) { return IsStruct(t, 6); }
 
   static Struct* AsStruct(Type* t) {
     return reinterpret_cast<Struct*>(t);
   }
   static int AsBitset(Type* t) {
     return static_cast<int>(reinterpret_cast<intptr_t>(t) >> 1);
   }
-  static Map* AsClass(Type* t) {
-    return *static_cast<Map**>(AsStruct(t)[3]);
-  }
-  static Object* AsConstant(Type* t) {
-    return *static_cast<Object**>(AsStruct(t)[3]);
-  }
-  static Type* AsContext(Type* t) {
-    return *static_cast<Type**>(AsStruct(t)[2]);
-  }
   static Struct* AsUnion(Type* t) {
     return AsStruct(t);
   }
   static int Length(Struct* structured) {
     return static_cast<int>(reinterpret_cast<intptr_t>(structured[1]));
   }
 
   static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; }
 
   struct BitsetType : Type::BitsetType {
     using Type::BitsetType::New;
     using Type::BitsetType::Glb;
     using Type::BitsetType::Lub;
     using Type::BitsetType::InherentLub;
   };
 };
 
 
 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(); }
-  static bool IsClass(Handle<HeapType> t) {
-    return t->IsMap() || IsStruct(t, 0);
-  }
-  static bool IsConstant(Handle<HeapType> t) { return IsStruct(t, 1); }
-  static bool IsRange(Handle<HeapType> t) { return IsStruct(t, 2); }
-  static bool IsContext(Handle<HeapType> t) { return IsStruct(t, 3); }
-  static bool IsArray(Handle<HeapType> t) { return IsStruct(t, 4); }
-  static bool IsFunction(Handle<HeapType> t) { return IsStruct(t, 5); }
   static bool IsUnion(Handle<HeapType> t) { return IsStruct(t, 6); }
 
   static Struct* AsStruct(Handle<HeapType> t) { return FixedArray::cast(*t); }
   static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value(); }
-  static Map* AsClass(Handle<HeapType> t) {
-    return t->IsMap() ? Map::cast(*t) : Map::cast(AsStruct(t)->get(2));
-  }
-  static Object* AsConstant(Handle<HeapType> t) { return AsStruct(t)->get(2); }
-  static HeapType* AsContext(Handle<HeapType> t) {
-    return HeapType::cast(AsStruct(t)->get(1));
-  }
   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::InherentLub;
@@ skipping 255 matching lines @@
 
   Tests() :
       isolate(CcTest::i_isolate()),
       scope(isolate),
       zone(isolate),
       T(Rep::ToRegion(&zone, isolate), isolate) {
   }
 
   bool Equal(TypeHandle type1, TypeHandle type2) {
     return
-        type1->Is(type2) && type2->Is(type1) &&
+        type1->Equals(type2) &&
         Rep::IsBitset(type1) == Rep::IsBitset(type2) &&
-        Rep::IsClass(type1) == Rep::IsClass(type2) &&

[rossberg, 2014/07/24 09:38:30]

I don't think these should be removed, but they should use the public
predicates.

-        Rep::IsConstant(type1) == Rep::IsConstant(type2) &&
-        Rep::IsRange(type1) == Rep::IsRange(type2) &&
-        Rep::IsContext(type1) == Rep::IsContext(type2) &&
-        Rep::IsArray(type1) == Rep::IsArray(type2) &&
-        Rep::IsFunction(type1) == Rep::IsFunction(type2) &&
         Rep::IsUnion(type1) == Rep::IsUnion(type2) &&
         type1->NumClasses() == type2->NumClasses() &&
         type1->NumConstants() == type2->NumConstants() &&
         (!Rep::IsBitset(type1) ||
           Rep::AsBitset(type1) == Rep::AsBitset(type2)) &&
-        (!Rep::IsClass(type1) ||

[rossberg, 2014/07/24 09:38:30]

Similarly here: use the public getters.

-          Rep::AsClass(type1) == Rep::AsClass(type2)) &&
-        (!Rep::IsConstant(type1) ||
-          Rep::AsConstant(type1) == Rep::AsConstant(type2)) &&
-        (!Rep::IsRange(type1) ||
-          (type1->AsRange()->Min() == type2->AsRange()->Min() &&
-           type1->AsRange()->Max() == type2->AsRange()->Max())) &&
-          // TODO(rossberg): Check details of arrays, functions, bounds.
+        // TODO(rossberg): Check details of arrays, functions, bounds.

[rossberg, 2014/07/24 09:38:30]

If you want, please also feel free to flesh out this comment. :)

         (!Rep::IsUnion(type1) ||
           Rep::Length(Rep::AsUnion(type1)) == Rep::Length(Rep::AsUnion(type2)));
   }
 
   void CheckEqual(TypeHandle type1, TypeHandle type2) {
     CHECK(Equal(type1, type2));
   }
 
   void CheckSub(TypeHandle type1, TypeHandle type2) {
     CHECK(type1->Is(type2));
@@ skipping 99 matching lines @@
         }
       }
     }
   }
 
   void Class() {
     // Constructor
     for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
       Handle<i::Map> map = *mt;
       TypeHandle type = T.Class(map);
-      CHECK(this->IsClass(type));
+      CHECK(type->IsClass());
     }
 
     // Map attribute
     for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
       Handle<i::Map> map = *mt;
       TypeHandle type = T.Class(map);
       CHECK(*map == *type->AsClass()->Map());
     }
 
     // Functionality & Injectivity: Class(M1) = Class(M2) iff M1 = M2
     for (MapIterator mt1 = T.maps.begin(); mt1 != T.maps.end(); ++mt1) {
       for (MapIterator mt2 = T.maps.begin(); mt2 != T.maps.end(); ++mt2) {
         Handle<i::Map> map1 = *mt1;
         Handle<i::Map> map2 = *mt2;
         TypeHandle type1 = T.Class(map1);
         TypeHandle type2 = T.Class(map2);
         CHECK(Equal(type1, type2) == (*map1 == *map2));
       }
     }
   }
 
   void Constant() {
     // Constructor
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       Handle<i::Object> value = *vt;
       TypeHandle type = T.Constant(value);
-      CHECK(this->IsConstant(type));
+      CHECK(type->IsConstant());
     }
 
     // Value attribute
     for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
       Handle<i::Object> value = *vt;
       TypeHandle type = T.Constant(value);
       CHECK(*value == *type->AsConstant()->Value());
     }
 
     // Functionality & Injectivity: Constant(V1) = Constant(V2) iff V1 = V2
@@ skipping 47 matching lines @@
     CHECK(T.Constant(fac->NewNumber(-V8_INFINITY))->Is(T.OtherNumber));
   }
 
   void Range() {
     // Constructor
     for (DoubleIterator i = T.doubles.begin(); i != T.doubles.end(); ++i) {
       for (DoubleIterator j = T.doubles.begin(); j != T.doubles.end(); ++j) {
         double min = std::min(*i, *j);
         double max = std::max(*i, *j);
         TypeHandle type = T.Range(min, max);
-        CHECK(this->IsRange(type));
+        CHECK(type->IsRange());
       }
     }
 
     // Range attributes
     for (DoubleIterator i = T.doubles.begin(); i != T.doubles.end(); ++i) {
       for (DoubleIterator j = T.doubles.begin(); j != T.doubles.end(); ++j) {
         double min = std::min(*i, *j);
         double max = std::max(*i, *j);
         printf("RangeType: min, max = %f, %f\n", min, max);
         TypeHandle type = T.Range(min, max);
@@ skipping 24 matching lines @@
 //      }
 //    }
 //  }
   }
 
   void Array() {
     // Constructor
     for (int i = 0; i < 20; ++i) {
       TypeHandle type = T.Random();
       TypeHandle array = T.Array1(type);
-      CHECK(this->IsArray(array));
+      CHECK(array->IsArray());
     }
 
     // Attributes
     for (int i = 0; i < 20; ++i) {
       TypeHandle type = T.Random();
       TypeHandle array = T.Array1(type);
       CheckEqual(type, array->AsArray()->Element());
     }
 
     // Functionality & Injectivity: Array(T1) = Array(T2) iff T1 = T2
@@ skipping 1333 matching lines @@
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }
 
 
 TEST(HTypeFromType) {
   CcTest::InitializeVM();
   ZoneTests().HTypeFromType();
   HeapTests().HTypeFromType();
 }