Refine typing of addition, subtraction, multiplication, and division.

src/types.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_H_
 #define V8_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/handles.h"
@@ skipping 769 matching lines @@
 
 template<class Config>
 class TypeImpl<Config>::RangeType : public StructuralType {
  public:
   int BitsetLub() { return this->Get(0)->AsBitset(); }
   i::Handle<i::Object> Min() { return this->template GetValue<i::Object>(1); }
   i::Handle<i::Object> Max() { return this->template GetValue<i::Object>(2); }
 
   static RangeHandle New(
       i::Handle<i::Object> min, i::Handle<i::Object> max, Region* region) {
+    DCHECK(IsInteger(min->Number()) && IsInteger(max->Number()));
     DCHECK(min->Number() <= max->Number());
     RangeHandle type = Config::template cast<RangeType>(
         StructuralType::New(StructuralType::kRangeTag, 3, region));
     type->Set(0, BitsetType::New(
         BitsetType::Lub(min->Number(), max->Number()), region));
     type->SetValue(1, min);
     type->SetValue(2, max);
     return type;
   }
 
   static RangeHandle New(Limits lim, Region* region) {
     return New(lim.min, lim.max, region);
   }
 
+  // Returns the least integers-only supertype that's not a range.  If there is
+  // no such supertype, it returns Range(-inf, +inf) instead.
+  TypeHandle Weaken(Region* region) {
+    bitset lub = this->BitsetLub();
+    if (BitsetType::Is(SEMANTIC(BitsetType::kOtherNumber), lub)) {
+      return New(
+          Config::factory(region)->NewNumber(-V8_INFINITY),
+          Config::factory(region)->NewNumber(+V8_INFINITY), region);
+    }
+    return BitsetType::New(lub, region);
+  }
+
   static RangeType* cast(TypeImpl* type) {
     DCHECK(type->IsRange());
     return static_cast<RangeType*>(type);
   }
 };
 // TODO(neis): Also cache min and max values.
 // TODO(neis): Allow restricting the representation.
 
 
 // -----------------------------------------------------------------------------
@@ skipping 126 matching lines @@
   static inline Struct* struct_create(int tag, int length, Zone* zone);
   static inline void struct_shrink(Struct* structure, int length);
   static inline int struct_tag(Struct* structure);
   static inline int struct_length(Struct* structure);
   static inline Type* struct_get(Struct* structure, int i);
   static inline void struct_set(Struct* structure, int i, Type* type);
   template<class V>
   static inline i::Handle<V> struct_get_value(Struct* structure, int i);
   template<class V> static inline void struct_set_value(
       Struct* structure, int i, i::Handle<V> x);
+
+  static inline Factory* factory(Zone* zone) {
+    return zone->isolate()->factory();
+  }
 };
 
 typedef TypeImpl<ZoneTypeConfig> Type;
 
 
 // -----------------------------------------------------------------------------
 // Heap-allocated types; either smis for bitsets, maps for classes, boxes for
 // constants, or fixed arrays for unions.
 
 struct HeapTypeConfig {
@@ skipping 28 matching lines @@
   static inline int struct_length(i::Handle<Struct> structure);
   static inline i::Handle<Type> struct_get(i::Handle<Struct> structure, int i);
   static inline void struct_set(
       i::Handle<Struct> structure, int i, i::Handle<Type> type);
   template<class V>
   static inline i::Handle<V> struct_get_value(
       i::Handle<Struct> structure, int i);
   template<class V>
   static inline void struct_set_value(
       i::Handle<Struct> structure, int i, i::Handle<V> x);
+
+  static inline Factory* factory(Isolate* isolate) {
+    return isolate->factory();
+  }
 };
 
 typedef TypeImpl<HeapTypeConfig> HeapType;
 
 
 // -----------------------------------------------------------------------------
 // Type bounds. A simple struct to represent a pair of lower/upper types.
 
 template<class Config>
 struct BoundsImpl {
@@ skipping 48 matching lines @@
   bool Narrows(BoundsImpl that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_