Minor clarifications and simplifications as well as additional checks.

src/types.cc

 // 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.
 
 #include "src/types.h"
 
 #include "src/string-stream.h"
 #include "src/types-inl.h"
 
 namespace v8 {
@@ skipping 244 matching lines @@
   DisallowHeapAllocation no_allocation;
 
   // Fast path for bitsets.
   if (this->IsNone()) return true;
   if (that->IsBitset()) {
     return (BitsetType::Lub(this) | that->AsBitset()) == that->AsBitset();
   }
   if (this->IsBitset() && SEMANTIC(this->AsBitset()) == BitsetType::kNone) {
     // Bitsets only have non-bitset supertypes along the representation axis.
     int that_bitset = that->BitsetGlb();
-    return (this->AsBitset() | that_bitset) == that_bitset;
+    return (BitsetType::Is(this->AsBitset(), that_bitset));
   }
 
   if (that->IsClass()) {
     return this->IsClass()
         && *this->AsClass()->Map() == *that->AsClass()->Map()
         && ((Config::is_class(that) && Config::is_class(this)) ||
             BitsetType::New(this->BitsetLub())->Is(
                 BitsetType::New(that->BitsetLub())));
   }
   if (that->IsConstant()) {
@@ skipping 30 matching lines @@
   if (this->IsUnion()) {
     UnionHandle unioned = handle(this->AsUnion());
     for (int i = 0; i < unioned->Length(); ++i) {
       if (!unioned->Get(i)->Is(that)) return false;
     }
     return true;
   }
 
   // T <= (T1 \/ ... \/ Tn)  <=>  (T <= T1) \/ ... \/ (T <= Tn)
   // (iff T is not a union)
-  ASSERT(!this->IsUnion());
-  if (that->IsUnion()) {
-    UnionHandle unioned = handle(that->AsUnion());
-    for (int i = 0; i < unioned->Length(); ++i) {
-      if (this->Is(unioned->Get(i))) return true;
-      if (this->IsBitset()) break;  // Fast fail, only first field is a bitset.
-    }
-    return false;
+  ASSERT(!this->IsUnion() && that->IsUnion());
+  UnionHandle unioned = handle(that->AsUnion());
+  for (int i = 0; i < unioned->Length(); ++i) {
+    if (this->Is(unioned->Get(i))) return true;
+    if (this->IsBitset()) break;  // Fast fail, only first field is a bitset.
   }
-
   return false;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::NowIs(TypeImpl* that) {
   DisallowHeapAllocation no_allocation;
 
   // TODO(rossberg): this is incorrect for
   //   Union(Constant(V), T)->NowIs(Class(M))
@@ skipping 39 matching lines @@
   // T overlaps (T1 \/ ... \/ Tn) <=> (T overlaps T1) \/ ... \/ (T overlaps Tn)
   if (that->IsUnion()) {
     UnionHandle unioned = handle(that->AsUnion());
     for (int i = 0; i < unioned->Length(); ++i) {
       if (this->Maybe(unioned->Get(i))) return true;
     }
     return false;
   }
 
   ASSERT(!this->IsUnion() && !that->IsUnion());
-  if (this->IsBitset()) {
-    return BitsetType::IsInhabited(this->AsBitset() & that->BitsetLub());
-  }
-  if (that->IsBitset()) {
-    return BitsetType::IsInhabited(this->BitsetLub() & that->AsBitset());
+  if (this->IsBitset() || that->IsBitset()) {
+    return BitsetType::IsInhabited(this->BitsetLub() & that->BitsetLub());
   }
   if (this->IsClass()) {
     return that->IsClass()
         && *this->AsClass()->Map() == *that->AsClass()->Map();
   }
   if (this->IsConstant()) {
     return that->IsConstant()
         && *this->AsConstant()->Value() == *that->AsConstant()->Value();
   }
   if (this->IsContext()) {
@@ skipping 34 matching lines @@
     }
   }
   return true;
 }
 
 
 // -----------------------------------------------------------------------------
 // Union and intersection
 
 template<class Config>
-typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Narrow(
+typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Rebound(
     int bitset, Region* region) {
   TypeHandle bound = BitsetType::New(bitset, region);
   if (this->IsClass()) {
     return ClassType::New(this->AsClass()->Map(), bound, region);
   } else if (this->IsConstant()) {
     return ConstantType::New(this->AsConstant()->Value(), bound, region);
   } else if (this->IsContext()) {
     return ContextType::New(this->AsContext()->Outer(), bound, region);
   } else if (this->IsArray()) {
     return ArrayType::New(this->AsArray()->Element(), bound, region);
@@ skipping 93 matching lines @@
       int i = type->IndexInUnion(new_bound, result, old_size);
       if (i == -1) {
         i = size++;
       } else if (result->Get(i)->IsBitset()) {
         return size;  // Already fully subsumed.
       } else {
         int type_i_bound = result->Get(i)->BitsetLub();
         new_bound |= type_i_bound;
         if (new_bound == type_i_bound) return size;
       }
-      if (new_bound != old_bound) type = type->Narrow(new_bound, region);
+      if (new_bound != old_bound) type = type->Rebound(new_bound, region);
       result->Set(i, type);
     }
   }
   return size;
 }
 
 
 // If bitset is subsumed by another entry in the result, remove it.
 // (Only bitsets with empty semantic axis can be subtypes of non-bitsets.)
 template<class Config>
 int TypeImpl<Config>::NormalizeUnion(UnionHandle result, int size, int bitset) {
   if (bitset != BitsetType::kNone && SEMANTIC(bitset) == BitsetType::kNone) {
     for (int i = 1; i < size; ++i) {
       int glb = result->Get(i)->BitsetGlb();
-      if ((bitset | glb) == glb) {
+      if (BitsetType::Is(bitset, glb)) {
         for (int j = 1; j < size; ++j) {
           result->Set(j - 1, result->Get(j));
         }
         --size;
         break;
       }
     }
   }
   return size;
 }
@@ skipping 384 matching lines @@
 template class TypeImpl<HeapTypeConfig>::Iterator<i::Object>;
 
 template TypeImpl<ZoneTypeConfig>::TypeHandle
   TypeImpl<ZoneTypeConfig>::Convert<HeapType>(
     TypeImpl<HeapTypeConfig>::TypeHandle, TypeImpl<ZoneTypeConfig>::Region*);
 template TypeImpl<HeapTypeConfig>::TypeHandle
   TypeImpl<HeapTypeConfig>::Convert<Type>(
     TypeImpl<ZoneTypeConfig>::TypeHandle, TypeImpl<HeapTypeConfig>::Region*);
 
 } }  // namespace v8::internal