Type representation converter

src/types.h

 // 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 225 matching lines @@
     if (this->IsBitset()) return Iterator<i::Object>();
     return Iterator<i::Object>(Config::handle(this));
   }
 
   static TypeImpl* cast(typename Config::Base* object) {
     TypeImpl* t = static_cast<TypeImpl*>(object);
     ASSERT(t->IsBitset() || t->IsClass() || t->IsConstant() || t->IsUnion());
     return t;
   }
 
+  template<class OtherTypeImpl>
+  static TypeHandle Convert(
+      typename OtherTypeImpl::TypeHandle type, Region* region);
+
 #ifdef OBJECT_PRINT
   void TypePrint();
   void TypePrint(FILE* out);
 #endif
 
  private:
   template<class> friend class Iterator;
+  template<class> friend class TypeImpl;
 
   // A union is a fixed array containing types. Invariants:
   // - its length is at least 2
   // - at most one field is a bitset, and it must go into index 0
   // - no field is a union
   typedef typename Config::Unioned Unioned;
   typedef typename Config::template Handle<Unioned>::type UnionedHandle;
 
   enum {
     #define DECLARE_TYPE(type, value) k##type = (value),
     BITSET_TYPE_LIST(DECLARE_TYPE)
     #undef DECLARE_TYPE
     kUnusedEOL = 0
   };
 
   bool IsNone() { return this == None(); }
   bool IsAny() { return this == Any(); }
   bool IsBitset() { return Config::is_bitset(this); }
   bool IsUnion() { return Config::is_union(this); }
   int AsBitset() { return Config::as_bitset(this); }
   UnionedHandle AsUnion() { return Config::as_union(this); }
 
+  static int UnionLength(UnionedHandle unioned) {
+    return Config::union_length(unioned);
+  }
+  static TypeHandle UnionGet(UnionedHandle unioned, int i) {
+    return Config::union_get(unioned, i);
+  }
+
   bool SlowIs(TypeImpl* that);
 
   int LubBitset();  // least upper bound that's a bitset
   int GlbBitset();  // greatest lower bound that's a bitset
 
   static int LubBitset(i::Object* value);
   static int LubBitset(i::Map* map);
 
   bool InUnion(UnionedHandle unioned, int current_size);
   static int ExtendUnion(
@@ skipping 264 matching lines @@
     return BoundsImpl(lower, upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_