Minor clarifications and simplifications as well as additional checks.

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/factory.h"
 #include "src/handles.h"
 #include "src/ostreams.h"
@@ skipping 50 matching lines @@
 // However, we also define a 'temporal' variant of the subtyping relation that
 // considers the _current_ state only, i.e., Constant(x) <_now Class(map(x)).
 //
 // REPRESENTATIONAL DIMENSION
 //
 // For the representation axis, the following holds:
 //
 //   None <= R
 //   R <= Any
 //
-//   UntaggedInt <= UntaggedInt8 \/ UntaggedInt16 \/ UntaggedInt32)
-//   UntaggedFloat <= UntaggedFloat32 \/ UntaggedFloat64
-//   UntaggedNumber <= UntaggedInt \/ UntaggedFloat
-//   Untagged <= UntaggedNumber \/ UntaggedPtr
-//   Tagged <= TaggedInt \/ TaggedPtr
+//   UntaggedInt = UntaggedInt1 \/ UntaggedInt8 \/
+//                 UntaggedInt16 \/ UntaggedInt32
+//   UntaggedFloat = UntaggedFloat32 \/ UntaggedFloat64
+//   UntaggedNumber = UntaggedInt \/ UntaggedFloat
+//   Untagged = UntaggedNumber \/ UntaggedPtr
+//   Tagged = TaggedInt \/ TaggedPtr
 //
 // Subtyping relates the two dimensions, for example:
 //
 //   Number <= Tagged \/ UntaggedNumber
 //   Object <= TaggedPtr \/ UntaggedPtr
 //
 // That holds because the semantic type constructors defined by the API create
 // types that allow for all possible representations, and dually, the ones for
 // representation types initially include all semantic ranges. Representations
 // can then e.g. be narrowed for a given semantic type using intersection:
@@ skipping 371 matching lines @@
   UnionType* AsUnion() { return UnionType::cast(this); }
 
   // Auxiliary functions.
 
   int BitsetGlb() { return BitsetType::Glb(this); }
   int BitsetLub() { return BitsetType::Lub(this); }
   int InherentBitsetLub() { return BitsetType::InherentLub(this); }
 
   bool SlowIs(TypeImpl* that);
 
-  TypeHandle Narrow(int bitset, Region* region);
+  TypeHandle Rebound(int bitset, Region* region);
   int BoundBy(TypeImpl* that);
   int IndexInUnion(int bound, UnionHandle unioned, int current_size);
   static int ExtendUnion(
       UnionHandle unioned, int current_size, TypeHandle t,
       TypeHandle other, bool is_intersect, Region* region);
   static int NormalizeUnion(UnionHandle unioned, int current_size, int bitset);
 };
 
 
 // -----------------------------------------------------------------------------
@@ skipping 17 matching lines @@
     return static_cast<BitsetType*>(Config::from_bitset(bitset));
   }
   static TypeHandle New(int bitset, Region* region) {
     return Config::from_bitset(bitset, region);
   }
 
   static bool IsInhabited(int bitset) {
     return (bitset & kRepresentation) && (bitset & kSemantic);
   }
 
+  static bool Is(int bitset1, int bitset2) {
+    return (bitset1 | bitset2) == bitset2;
+  }
+
   static int Glb(TypeImpl* type);  // greatest lower bound that's a bitset
   static int Lub(TypeImpl* type);  // least upper bound that's a bitset
   static int Lub(i::Object* value);
   static int Lub(double value);
   static int Lub(int32_t value);
   static int Lub(uint32_t value);
   static int Lub(i::Map* map);
   static int InherentLub(TypeImpl* type);
 
   static const char* Name(int bitset);
@@ skipping 90 matching lines @@
         : this->Get(0);
   }
   i::Handle<i::Map> Map() {
     return Config::is_class(this)
         ? Config::as_class(this)
         : this->template GetValue<i::Map>(1);
   }
 
   static ClassHandle New(
       i::Handle<i::Map> map, TypeHandle bound, Region* region) {
+    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*map)));
     ClassHandle type = Config::template cast<ClassType>(
         StructuralType::New(StructuralType::kClassTag, 2, region));
     type->Set(0, bound);
     type->SetValue(1, map);
     return type;
   }
 
   static ClassHandle New(i::Handle<i::Map> map, Region* region) {
     ClassHandle type =
         Config::template cast<ClassType>(Config::from_class(map, region));
@@ skipping 16 matching lines @@
 // Constant types.
 
 template<class Config>
 class TypeImpl<Config>::ConstantType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   i::Handle<i::Object> Value() { return this->template GetValue<i::Object>(1); }
 
   static ConstantHandle New(
       i::Handle<i::Object> value, TypeHandle bound, Region* region) {
+    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*value)));
     ConstantHandle type = Config::template cast<ConstantType>(
         StructuralType::New(StructuralType::kConstantTag, 2, region));
     type->Set(0, bound);
     type->SetValue(1, value);
     return type;
   }
 
   static ConstantHandle New(i::Handle<i::Object> value, Region* region) {
     TypeHandle bound = BitsetType::New(BitsetType::Lub(*value), region);
     return New(value, bound, region);
@@ skipping 11 matching lines @@
 
 template<class Config>
 class TypeImpl<Config>::RangeType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   double Min() { return this->template GetValue<i::HeapNumber>(1)->value(); }
   double Max() { return this->template GetValue<i::HeapNumber>(2)->value(); }
 
   static RangeHandle New(
       double min, double max, TypeHandle bound, Region* region) {
-    ASSERT(SEMANTIC(bound->AsBitset() | BitsetType::kNumber)
-           == SEMANTIC(BitsetType::kNumber));
+    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kNumber));
     ASSERT(!std::isnan(min) && !std::isnan(max) && min <= max);
     RangeHandle type = Config::template cast<RangeType>(
         StructuralType::New(StructuralType::kRangeTag, 3, region));
     type->Set(0, bound);
     Factory* factory = Config::isolate(region)->factory();
     Handle<HeapNumber> minV = factory->NewHeapNumber(min);
     Handle<HeapNumber> maxV = factory->NewHeapNumber(max);
     type->SetValue(1, minV);
     type->SetValue(2, maxV);
     return type;
@@ skipping 14 matching lines @@
 // -----------------------------------------------------------------------------
 // Context types.
 
 template<class Config>
 class TypeImpl<Config>::ContextType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   TypeHandle Outer() { return this->Get(1); }
 
   static ContextHandle New(TypeHandle outer, TypeHandle bound, Region* region) {
+    ASSERT(BitsetType::Is(
+        bound->AsBitset(), BitsetType::kInternal & BitsetType::kTaggedPtr));
     ContextHandle type = Config::template cast<ContextType>(
         StructuralType::New(StructuralType::kContextTag, 2, region));
     type->Set(0, bound);
     type->Set(1, outer);
     return type;
   }
 
   static ContextHandle New(TypeHandle outer, Region* region) {
     TypeHandle bound = BitsetType::New(
         BitsetType::kInternal & BitsetType::kTaggedPtr, region);
@@ skipping 10 matching lines @@
 // -----------------------------------------------------------------------------
 // Array types.
 
 template<class Config>
 class TypeImpl<Config>::ArrayType : public StructuralType {
  public:
   TypeHandle Bound() { return this->Get(0); }
   TypeHandle Element() { return this->Get(1); }
 
   static ArrayHandle New(TypeHandle element, TypeHandle bound, Region* region) {
-    ASSERT(SEMANTIC(bound->AsBitset()) == SEMANTIC(BitsetType::kArray));
+    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kArray));
     ArrayHandle type = Config::template cast<ArrayType>(
         StructuralType::New(StructuralType::kArrayTag, 2, region));
     type->Set(0, bound);
     type->Set(1, element);
     return type;
   }
 
   static ArrayHandle New(TypeHandle element, Region* region) {
     TypeHandle bound = BitsetType::New(BitsetType::kArray, region);
     return New(element, bound, region);
@@ skipping 16 matching lines @@
   TypeHandle Bound() { return this->Get(0); }
   TypeHandle Result() { return this->Get(1); }
   TypeHandle Receiver() { return this->Get(2); }
   TypeHandle Parameter(int i) { return this->Get(3 + i); }
 
   void InitParameter(int i, TypeHandle type) { this->Set(3 + i, type); }
 
   static FunctionHandle New(
       TypeHandle result, TypeHandle receiver, TypeHandle bound,
       int arity, Region* region) {
-    ASSERT(SEMANTIC(bound->AsBitset()) == SEMANTIC(BitsetType::kFunction));
+    ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kFunction));
     FunctionHandle type = Config::template cast<FunctionType>(
         StructuralType::New(StructuralType::kFunctionTag, 3 + arity, region));
     type->Set(0, bound);
     type->Set(1, result);
     type->Set(2, receiver);
     return type;
   }
 
   static FunctionHandle New(
       TypeHandle result, TypeHandle receiver, int arity, Region* region) {
@@ skipping 187 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_