Allow smis for singleton types

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 61 matching lines @@
 //
 // Typically, the latter should be used to check whether a specific case needs
 // handling (e.g., via T->Maybe(Number)).
 //
 // There is no functionality to discover whether a type is a leaf in the
 // lattice. That is intentional. It should always be possible to refine the
 // lattice (e.g., splitting up number types further) without invalidating any
 // existing assumptions or tests.
 //
 // Internally, all 'primitive' types, and their unions, are represented as
-// bitsets via smis. Class and Constant are heap pointers to the respective
-// argument. Only unions containing Class'es or Constant's require allocation.
+// bitsets via smis. Class is a heap pointer to the respective map. Only
+// Constant's, or unions containing Class'es or Constant's, require allocation.
 //
 // The type representation is heap-allocated, so cannot (currently) be used in
 // a parallel compilation context.
 
 class Type : public Object {
  public:
+  typedef v8::internal::Object Value;

[danno, 2013/06/06 15:36:03]

As discussed, I think the typedef is overkill here :-)

[rossberg, 2013/06/06 15:38:35]

Removed.

+
   static Type* None() { return from_bitset(kNone); }
   static Type* Any() { return from_bitset(kAny); }
 
   static Type* Oddball() { return from_bitset(kOddball); }
   static Type* Boolean() { return from_bitset(kBoolean); }
   static Type* Null() { return from_bitset(kNull); }
   static Type* Undefined() { return from_bitset(kUndefined); }
 
   static Type* Number() { return from_bitset(kNumber); }
   static Type* Smi() { return from_bitset(kSmi); }
   static Type* Double() { return from_bitset(kDouble); }
 
   static Type* Name() { return from_bitset(kName); }
   static Type* UniqueName() { return from_bitset(kUniqueName); }
   static Type* String() { return from_bitset(kString); }
   static Type* InternalizedString() { return from_bitset(kInternalizedString); }
   static Type* Symbol() { return from_bitset(kSymbol); }
 
   static Type* Receiver() { return from_bitset(kReceiver); }
   static Type* Object() { return from_bitset(kObject); }
   static Type* Array() { return from_bitset(kArray); }
   static Type* Function() { return from_bitset(kFunction); }
   static Type* Proxy() { return from_bitset(kProxy); }
 
   static Type* Class(Handle<Map> map) { return from_handle(map); }
   static Type* Constant(Handle<HeapObject> value) {
-    ASSERT(!value->IsMap() && !value->IsFixedArray());
-    return from_handle(value);
+    return Constant(value, value->GetIsolate());
+  }
+  static Type* Constant(Handle<Value> value, Isolate* isolate) {
+    return from_handle(isolate->factory()->NewBox(value));
   }
 
   static Type* Union(Handle<Type> type1, Handle<Type> type2);
   static Type* Optional(Handle<Type> type);  // type \/ Undefined
 
   bool Is(Handle<Type> that);
   bool Maybe(Handle<Type> that);
 
   // TODO(rossberg): method to iterate unions?
 
@@ skipping 24 matching lines @@
     kUniqueName = kSymbol | kInternalizedString,
     kName = kSymbol | kString,
     kObject = kArray | kFunction | kOtherObject,
     kReceiver = kObject | kProxy,
     kAny = kOddball | kNumber | kName | kReceiver,
     kNone = 0
   };
 
   bool is_bitset() { return this->IsSmi(); }
   bool is_class() { return this->IsMap(); }
-  bool is_constant() { return !(is_bitset() || is_class() || is_union()); }
+  bool is_constant() { return this->IsBox(); }
   bool is_union() { return this->IsFixedArray(); }
 
   int as_bitset() { return Smi::cast(this)->value(); }
   Handle<Map> as_class() { return Handle<Map>::cast(handle()); }
-  Handle<HeapObject> as_constant() {
-    ASSERT(is_constant());
-    return Handle<HeapObject>::cast(handle());
-  }
+  Handle<Box> as_constant() { return Handle<Box>::cast(handle()); }
   Handle<Unioned> as_union() { return Handle<Unioned>::cast(handle()); }
 
   Handle<Type> handle() { return handle_via_isolate_of(this); }
   Handle<Type> handle_via_isolate_of(Type* type) {
     ASSERT(type->IsHeapObject());
     return v8::internal::handle(this, HeapObject::cast(type)->GetIsolate());
   }
 
   static Type* from_bitset(int bitset) {
     return static_cast<Type*>(Object::cast(Smi::FromInt(bitset)));
@@ skipping 10 matching lines @@
 
   int LubBitset();  // least upper bound that's a bitset
   int GlbBitset();  // greatest lower bound that's a bitset
   bool InUnion(Handle<Unioned> unioned, int current_size);
   int ExtendUnion(Handle<Unioned> unioned, int current_size);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_