Steps towards unification of number bitset and range 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 "src/types.h"
 
 #include "src/factory.h"
 #include "src/handles-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // TypeImpl
 
+template <class Config>
+typename TypeImpl<Config>::bitset
+TypeImpl<Config>::BitsetType::SignedSmall() {
+  return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
+}
+
+
+template <class Config>
+typename TypeImpl<Config>::bitset
+TypeImpl<Config>::BitsetType::UnsignedSmall() {
+  return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
+}
+
+
 template<class Config>
 TypeImpl<Config>* TypeImpl<Config>::cast(typename Config::Base* object) {
   TypeImpl* t = static_cast<TypeImpl*>(object);
   DCHECK(t->IsBitset() || t->IsClass() || t->IsConstant() || t->IsRange() ||
          t->IsUnion() || t->IsArray() || t->IsFunction() || t->IsContext());
   return t;
 }
 
 
 // Most precise _current_ type of a value (usually its class).
@@ skipping 165 matching lines @@
 
 // static
 template<class V>
 void ZoneTypeConfig::struct_set_value(
     Struct* structure, int i, i::Handle<V> x) {
   DCHECK(0 <= i && i <= struct_length(structure));
   structure[2 + i] = x.location();
 }
 
 
+// static
+i::Isolate* ZoneTypeConfig::isolate(Zone* zone) { return zone->isolate(); }
+
 // -----------------------------------------------------------------------------
 // HeapTypeConfig
 
 // static
 template<class T>
 i::Handle<T> HeapTypeConfig::null_handle() {
   return i::Handle<T>();
 }
 
 
@@ skipping 127 matching lines @@
 }
 
 
 // static
 template<class V>
 void HeapTypeConfig::struct_set_value(
     i::Handle<Struct> structure, int i, i::Handle<V> x) {
   structure->set(i + 1, *x);
 }
 
+// static
+i::Isolate* HeapTypeConfig::isolate(Isolate* isolate) { return isolate; }
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_INL_H_