Revert "Implement structural function and array types"

src/types-inl.h

 // Copyright 2014 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.
 
 #ifndef V8_TYPES_INL_H_
 #define V8_TYPES_INL_H_
 
 #include "types.h"
 
 #include "factory.h"
 #include "handles-inl.h"
 
 namespace v8 {
 namespace internal {
 
-// -------------------------------------------------------------------------- //
-// TypeImpl
-
-template<class Config>
-TypeImpl<Config>::Iterator<i::Map> TypeImpl<Config>::Classes() {
-  if (this->IsBitset()) return Iterator<i::Map>();
-  return Iterator<i::Map>(Config::handle(this));
-}
-
-
-template<class Config>
-TypeImpl<Config>::Iterator<i::Object> TypeImpl<Config>::Constants() {
-  if (this->IsBitset()) return Iterator<i::Object>();
-  return Iterator<i::Object>(Config::handle(this));
-}
-
-
-template<class Config>
-TypeImpl<Config>* TypeImpl<Config>::cast(typename Config::Base* object) {
-  TypeImpl* t = static_cast<TypeImpl*>(object);
-  ASSERT(t->IsBitset() || t->IsClass() || t->IsConstant() ||
-         t->IsUnion() || t->IsArray() || t->IsFunction());
-  return t;
-}
-
-
 template<class Config>
 bool TypeImpl<Config>::NowContains(i::Object* value) {
   DisallowHeapAllocation no_allocation;
   if (this->IsAny()) return true;
   if (value->IsHeapObject()) {
     i::Map* map = i::HeapObject::cast(value)->map();
     for (Iterator<i::Map> it = this->Classes(); !it.Done(); it.Advance()) {
       if (*it.Current() == map) return true;
     }
   }
   return this->Contains(value);
 }
 
 
-// -------------------------------------------------------------------------- //
-// ZoneTypeConfig
-
-// static
-template<class T>
-T* ZoneTypeConfig::handle(T* type) {
-  return type;
-}
-
-
 // static
-template<class T>
-T* ZoneTypeConfig::cast(Type* type) {
-  return static_cast<T*>(type);
+Type* ZoneTypeConfig::handle(Type* type) {
+  return type;
 }
 
 
 // static
 bool ZoneTypeConfig::is_bitset(Type* type) {
   return reinterpret_cast<intptr_t>(type) & 1;
 }
 
 
 // static
-bool ZoneTypeConfig::is_struct(Type* type, int tag) {
-  return !is_bitset(type) && struct_tag(as_struct(type)) == tag;
+bool ZoneTypeConfig::is_struct(Type* type) {
+  return !is_bitset(type);
 }
 
 
 // static
 bool ZoneTypeConfig::is_class(Type* type) {
-  return is_struct(type, Type::StructuralType::kClassTag);
+  return is_struct(type) && struct_tag(as_struct(type)) == Type::kClassTag;
 }
 
 
 // static
 bool ZoneTypeConfig::is_constant(Type* type) {
-  return is_struct(type, Type::StructuralType::kConstantTag);
+  return is_struct(type) && struct_tag(as_struct(type)) == Type::kConstantTag;
 }
 
 
 // static
 int ZoneTypeConfig::as_bitset(Type* type) {
   ASSERT(is_bitset(type));
   return static_cast<int>(reinterpret_cast<intptr_t>(type) >> 1);
 }
 
 
 // static
 ZoneTypeConfig::Struct* ZoneTypeConfig::as_struct(Type* type) {
-  ASSERT(!is_bitset(type));
+  ASSERT(is_struct(type));
   return reinterpret_cast<Struct*>(type);
 }
 
 
 // static
 i::Handle<i::Map> ZoneTypeConfig::as_class(Type* type) {
   ASSERT(is_class(type));
   return i::Handle<i::Map>(static_cast<i::Map**>(as_struct(type)[3]));
 }
 
@@ skipping 20 matching lines @@
 
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_struct(Struct* structured) {
   return reinterpret_cast<Type*>(structured);
 }
 
 
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_class(
     i::Handle<i::Map> map, int lub, Zone* zone) {
-  Struct* structured = struct_create(Type::StructuralType::kClassTag, 2, zone);
+  Struct* structured = struct_create(Type::kClassTag, 2, zone);
   structured[2] = from_bitset(lub);
   structured[3] = map.location();
   return from_struct(structured);
 }
 
 
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_constant(
     i::Handle<i::Object> value, int lub, Zone* zone) {
-  Struct* structured =
-      struct_create(Type::StructuralType::kConstantTag, 2, zone);
+  Struct* structured = struct_create(Type::kConstantTag, 2, zone);
   structured[2] = from_bitset(lub);
   structured[3] = value.location();
   return from_struct(structured);
 }
 
 
 // static
 ZoneTypeConfig::Struct* ZoneTypeConfig::struct_create(
     int tag, int length, Zone* zone) {
   Struct* structured = reinterpret_cast<Struct*>(
@@ skipping 36 matching lines @@
   structured[2 + i] = type;
 }
 
 
 // static
 int ZoneTypeConfig::lub_bitset(Type* type) {
   ASSERT(is_class(type) || is_constant(type));
   return as_bitset(struct_get(as_struct(type), 0));
 }
 
-
 // -------------------------------------------------------------------------- //
-// HeapTypeConfig
 
 // static
-template<class T>
-i::Handle<T> HeapTypeConfig::handle(T* type) {
+i::Handle<HeapTypeConfig::Type> HeapTypeConfig::handle(Type* type) {
   return i::handle(type, i::HeapObject::cast(type)->GetIsolate());
 }
 
 
 // static
-template<class T>
-i::Handle<T> HeapTypeConfig::cast(i::Handle<Type> type) {
-  return i::Handle<T>::cast(type);
-}
-
-
-// static
 bool HeapTypeConfig::is_bitset(Type* type) {
   return type->IsSmi();
 }
 
 
 // static
 bool HeapTypeConfig::is_class(Type* type) {
   return type->IsMap();
 }
 
 
 // static
 bool HeapTypeConfig::is_constant(Type* type) {
   return type->IsBox();
 }
 
 
 // static
-bool HeapTypeConfig::is_struct(Type* type, int tag) {
-  return type->IsFixedArray() && struct_tag(as_struct(type)) == tag;
+bool HeapTypeConfig::is_struct(Type* type) {
+  return type->IsFixedArray();
 }
 
 
 // static
 int HeapTypeConfig::as_bitset(Type* type) {
-  return i::Smi::cast(type)->value();
+  return Smi::cast(type)->value();
 }
 
 
 // static
 i::Handle<i::Map> HeapTypeConfig::as_class(Type* type) {
   return i::handle(i::Map::cast(type));
 }
 
 
 // static
@@ skipping 87 matching lines @@
 
 
 // static
 int HeapTypeConfig::lub_bitset(Type* type) {
   return 0;  // kNone, which causes recomputation.
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_INL_H_