diff --git a/src/types.cc b/src/types.cc
index db638ed141..8b68a7d0ea 100644
--- a/src/types.cc
+++ b/src/types.cc
@@ -262,7 +262,7 @@ bool TypeImpl<Config>::SlowIs(TypeImpl* that) {
   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()) {
@@ -313,16 +313,12 @@ bool TypeImpl<Config>::SlowIs(TypeImpl* that) {
 
   // 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;
 }
 
@@ -382,11 +378,8 @@ bool TypeImpl<Config>::Maybe(TypeImpl* that) {
   }
 
   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()
@@ -444,6 +437,7 @@ template<class Config>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Narrow(
     int bitset, Region* region) {
   TypeHandle bound = BitsetType::New(bitset, region);
+  ASSERT(!this->IsBitset() && this->Is(bound));
   if (this->IsClass()) {
     return ClassType::New(this->AsClass()->Map(), bound, region);
   } else if (this->IsConstant()) {
@@ -570,7 +564,7 @@ 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));
         }
diff --git a/src/types.h b/src/types.h
index d316fa19aa..7a6d545db5 100644
--- a/src/types.h
+++ b/src/types.h
@@ -68,11 +68,12 @@ namespace internal {
 //   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:
 //
@@ -502,6 +503,10 @@ class TypeImpl<Config>::BitsetType : public TypeImpl<Config> {
     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);
@@ -612,6 +617,7 @@ class TypeImpl<Config>::ClassType : public StructuralType {
 
   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);
@@ -648,6 +654,7 @@ class TypeImpl<Config>::ConstantType : public StructuralType {
 
   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);
@@ -679,8 +686,7 @@ class TypeImpl<Config>::RangeType : public StructuralType {
 
   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));
@@ -715,6 +721,8 @@ class TypeImpl<Config>::ContextType : public StructuralType {
   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);
@@ -745,7 +753,7 @@ class TypeImpl<Config>::ArrayType : public StructuralType {
   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);
@@ -782,7 +790,7 @@ class TypeImpl<Config>::FunctionType : public StructuralType {
   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);