[turbofan] Nuke class types.

test/cctest/test-ast-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/factory.h"
 #include "src/heap/heap.h"
 #include "src/isolate.h"
 // FIXME(mstarzinger, marja): This is weird, but required because of the missing
 // (disallowed) include: src/factory.h -> src/objects-inl.h
 #include "src/ast/ast-types.h"
 #include "src/objects-inl.h"
 // FIXME(mstarzinger, marja): This is weird, but required because of the missing
 // (disallowed) include: src/type-feedback-vector.h ->
 // src/type-feedback-vector-inl.h
 #include "src/type-feedback-vector-inl.h"
 #include "test/cctest/ast-types-fuzz.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8::internal;
 
+namespace {
+
 // Testing auxiliaries (breaking the Type abstraction).
 
 static bool IsInteger(double x) {
   return nearbyint(x) == x && !i::IsMinusZero(x);  // Allows for infinities.
 }
 
 static bool IsInteger(i::Object* x) {
   return x->IsNumber() && IsInteger(x->Number());
 }
 
 typedef uint32_t bitset;
 
 struct Tests {
-  typedef Types::TypeVector::iterator TypeIterator;
-  typedef Types::MapVector::iterator MapIterator;
-  typedef Types::ValueVector::iterator ValueIterator;
+  typedef AstTypes::TypeVector::iterator TypeIterator;
+  typedef AstTypes::MapVector::iterator MapIterator;
+  typedef AstTypes::ValueVector::iterator ValueIterator;
 
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
-  Types T;
+  AstTypes T;
 
   Tests()
       : isolate(CcTest::InitIsolateOnce()),
         scope(isolate),
         zone(isolate->allocator()),
         T(&zone, isolate, isolate->random_number_generator()) {}
 
   bool IsBitset(AstType* type) { return type->IsBitsetForTesting(); }
   bool IsUnion(AstType* type) { return type->IsUnionForTesting(); }
   AstBitsetType::bitset AsBitset(AstType* type) {
@@ skipping 1783 matching lines @@
         AstType* type1 = *it1;
         AstType* type2 = *it2;
         HType htype1 = HType::FromType(type1);
         HType htype2 = HType::FromType(type2);
         CHECK(!type1->Is(type2) || htype1.IsSubtypeOf(htype2));
       }
     }
   }
 };
 
+}  // namespace
+
 TEST(AstIsSomeType_zone) { Tests().IsSomeType(); }
 
 TEST(AstPointwiseRepresentation_zone) { Tests().PointwiseRepresentation(); }
 
 TEST(AstBitsetType_zone) { Tests().Bitset(); }
 
 TEST(AstClassType_zone) { Tests().Class(); }
 
 TEST(AstConstantType_zone) { Tests().Constant(); }
 
@@ skipping 33 matching lines @@
 
 TEST(AstUnion4_zone) { Tests().Union4(); }
 
 TEST(AstIntersect_zone) { Tests().Intersect(); }
 
 TEST(AstDistributivity_zone) { Tests().Distributivity(); }
 
 TEST(AstGetRange_zone) { Tests().GetRange(); }
 
 TEST(AstHTypeFromType_zone) { Tests().HTypeFromType(); }