Type handling for special cases and optimization

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 108 matching lines @@
   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* Undetectable() { return from_bitset(kUndetectable); }
   static Type* Array() { return from_bitset(kArray); }
   static Type* Function() { return from_bitset(kFunction); }
   static Type* RegExp() { return from_bitset(kRegExp); }
   static Type* Proxy() { return from_bitset(kProxy); }
+  static Type* Internal() { return from_bitset(kInternal); }
 
   static Type* Class(Handle<Map> map) { return from_handle(map); }
   static Type* Constant(Handle<HeapObject> value) {
     return Constant(value, value->GetIsolate());
   }
   static Type* Constant(Handle<v8::internal::Object> value, Isolate* isolate) {
     return from_handle(isolate->factory()->NewBox(value));
   }
 
   static Type* Union(Handle<Type> type1, Handle<Type> type2);
   static Type* Intersect(Handle<Type> type1, Handle<Type> type2);
   static Type* Optional(Handle<Type> type);  // type \/ Undefined
 
-  bool Is(Type* that);
+  bool Is(Type* that) { return (this == that) ? true : IsSlowCase(that); }
   bool Is(Handle<Type> that) { return this->Is(*that); }
   bool Maybe(Type* that);
   bool Maybe(Handle<Type> that) { return this->Maybe(*that); }
 
   bool IsClass() { return is_class(); }
   bool IsConstant() { return is_constant(); }
   Handle<Map> AsClass() { return as_class(); }
   Handle<v8::internal::Object> AsConstant() { return as_constant(); }
 
   int NumClasses();
@@ skipping 47 matching lines @@
     kDouble = 1 << 6,
     kSymbol = 1 << 7,
     kInternalizedString = 1 << 8,
     kOtherString = 1 << 9,
     kUndetectable = 1 << 10,
     kArray = 1 << 11,
     kFunction = 1 << 12,
     kRegExp = 1 << 13,
     kOtherObject = 1 << 14,
     kProxy = 1 << 15,
+    kInternal = 1 << 16,
 
     kOddball = kBoolean | kNull | kUndefined,
     kSigned32 = kSmi | kOtherSigned32,
     kNumber = kSigned32 | kUnsigned32 | kDouble,
     kString = kInternalizedString | kOtherString,
     kUniqueName = kSymbol | kInternalizedString,
     kName = kSymbol | kString,
     kNumberOrString = kNumber | kString,
     kObject = kUndetectable | kArray | kFunction | kRegExp | kOtherObject,
     kReceiver = kObject | kProxy,
     kAllocated = kDouble | kName | kReceiver,
-    kAny = kOddball | kNumber | kAllocated,
+    kAny = kOddball | kNumber | kAllocated | kInternal,
     kDetectable = kAllocated - kUndetectable,
     kNone = 0
   };
 
   bool is_bitset() { return this->IsSmi(); }
   bool is_class() { return this->IsMap(); }
   bool is_constant() { return this->IsBox(); }
   bool is_union() { return this->IsFixedArray(); }
 
+  bool IsSlowCase(Type* that);
+
   int as_bitset() { return Smi::cast(this)->value(); }
   Handle<Map> as_class() { return Handle<Map>::cast(handle()); }
   Handle<v8::internal::Object> as_constant() {
     Handle<Box> box = Handle<Box>::cast(handle());
     return v8::internal::handle(box->value(), box->GetIsolate());
   }
   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) {
@@ skipping 18 matching lines @@
   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);
   int ExtendIntersection(
       Handle<Unioned> unioned, Handle<Type> type, int current_size);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_