Allow smis for singleton types

src/types.cc

 // 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 24 matching lines @@
   if (this->is_bitset()) {
     return this->as_bitset();
   } else if (this->is_union()) {
     Handle<Unioned> unioned = this->as_union();
     int bitset = kNone;
     for (int i = 0; i < unioned->length(); ++i) {
       bitset |= union_get(unioned, i)->LubBitset();
     }
     return bitset;
   } else {
-    Map* map =
-        this->is_class() ? *this->as_class() : this->as_constant()->map();
+    Map* map = NULL;
+    if (this->is_class()) {
+      map = *this->as_class();
+    } else {
+      Value* value = this->as_constant()->value();
+      if (value->IsSmi()) return kSmi;
+      map = HeapObject::cast(value)->map();
+    }
     switch (map->instance_type()) {
       case STRING_TYPE:
       case ASCII_STRING_TYPE:
       case CONS_STRING_TYPE:
       case CONS_ASCII_STRING_TYPE:
       case SLICED_STRING_TYPE:
       case EXTERNAL_STRING_TYPE:
       case EXTERNAL_ASCII_STRING_TYPE:
       case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
       case SHORT_EXTERNAL_STRING_TYPE:
@@ skipping 62 matching lines @@
 bool Type::Is(Handle<Type> that) {
   // Fast path for bitsets.
   if (that->is_bitset()) {
     return (this->LubBitset() | that->as_bitset()) == that->as_bitset();
   }
 
   if (that->is_class()) {
     return this->is_class() && *this->as_class() == *that->as_class();
   }
   if (that->is_constant()) {
-    return this->is_constant() && *this->as_constant() == *that->as_constant();
+    return this->is_constant() &&
+        this->as_constant()->value() == that->as_constant()->value();
   }
 
   // (T1 \/ ... \/ Tn) <= T  <=>  (T1 <= T) /\ ... /\ (Tn <= T)
   if (this->is_union()) {
     Handle<Unioned> unioned = this->as_union();
     for (int i = 0; i < unioned->length(); ++i) {
       Handle<Type> this_i = union_get(unioned, i);
       if (!this_i->Is(that)) return false;
     }
     return true;
@@ skipping 22 matching lines @@
     return (this->as_bitset() & that->LubBitset()) != 0;
   }
   if (that->is_bitset()) {
     return (this->LubBitset() & that->as_bitset()) != 0;
   }
 
   if (this->is_class()) {
     return that->is_class() && *this->as_class() == *that->as_class();
   }
   if (this->is_constant()) {
-    return that->is_constant() && *this->as_constant() == *that->as_constant();
+    return that->is_constant() &&
+        this->as_constant()->value() == that->as_constant()->value();
   }
 
   // (T1 \/ ... \/ Tn) overlaps T <=> (T1 overlaps T) \/ ... \/ (Tn overlaps T)
   if (this->is_union()) {
     Handle<Unioned> unioned = this->as_union();
     for (int i = 0; i < unioned->length(); ++i) {
       Handle<Type> this_i = union_get(unioned, i);
       if (this_i->Maybe(that)) return true;
     }
     return false;
@@ skipping 89 matching lines @@
 }
 
 
 Type* Type::Optional(Handle<Type> type) {
   return type->is_bitset()
       ? from_bitset(type->as_bitset() | kUndefined)
       : Union(type, Undefined()->handle_via_isolate_of(*type));
 }
 
 } }  // namespace v8::internal