Fix printing of types and do some cleanups.

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 <iomanip>
 
 #include "src/types.h"
 
 #include "src/ostreams.h"
 #include "src/types-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 // NOTE: If code is marked as being a "shortcut", this means that removing
 // the code won't affect the semantics of the surrounding function definition.
 
 
 // -----------------------------------------------------------------------------
 // Range-related helper functions.
 
-// The result may be invalid (max < min).
+template <class Config>
+bool TypeImpl<Config>::Limits::IsEmpty() {
+  return this->min > this->max;
+}
+
+
 template<class Config>
-typename TypeImpl<Config>::Limits TypeImpl<Config>::Intersect(
+typename TypeImpl<Config>::Limits TypeImpl<Config>::Limits::Intersect(
     Limits lhs, Limits rhs) {
   DisallowHeapAllocation no_allocation;
   Limits result(lhs);
   if (lhs.min < rhs.min) result.min = rhs.min;
   if (lhs.max > rhs.max) result.max = rhs.max;
   return result;
 }
 
 
 template <class Config>
-bool TypeImpl<Config>::IsEmpty(Limits lim) {
-  return lim.min > lim.max;
-}
-
-
-template <class Config>
-typename TypeImpl<Config>::Limits TypeImpl<Config>::Union(Limits lhs,
-                                                          Limits rhs) {
+typename TypeImpl<Config>::Limits TypeImpl<Config>::Limits::Union(
+    Limits lhs, Limits rhs) {
   DisallowHeapAllocation no_allocation;
-  if (IsEmpty(lhs)) return rhs;
-  if (IsEmpty(rhs)) return lhs;
+  if (lhs.IsEmpty()) return rhs;
+  if (rhs.IsEmpty()) return lhs;
   Limits result(lhs);
   if (lhs.min > rhs.min) result.min = rhs.min;
   if (lhs.max < rhs.max) result.max = rhs.max;
   return result;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::Overlap(
     typename TypeImpl<Config>::RangeType* lhs,
     typename TypeImpl<Config>::RangeType* rhs) {
   DisallowHeapAllocation no_allocation;
-  typename TypeImpl<Config>::Limits lim = Intersect(Limits(lhs), Limits(rhs));
-  return lim.min <= lim.max;
+  return !Limits::Intersect(Limits(lhs), Limits(rhs)).IsEmpty();
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::Contains(
     typename TypeImpl<Config>::RangeType* lhs,
     typename TypeImpl<Config>::RangeType* rhs) {
   DisallowHeapAllocation no_allocation;
   return lhs->Min() <= rhs->Min() && rhs->Max() <= lhs->Max();
 }
@@ skipping 724 matching lines @@
   if (!AddIsSafe(size1, size2)) return Any(region);
   int size = size1 + size2;
   if (!AddIsSafe(size, 2)) return Any(region);
   size += 2;
   UnionHandle result = UnionType::New(size, region);
   size = 0;
 
   // Deal with bitsets.
   result->Set(size++, BitsetType::New(bits, region));
 
-  Limits lims = Limits::Empty(region);
+  Limits lims = Limits::Empty();
   size = IntersectAux(type1, type2, result, size, &lims, region);
 
   // If the range is not empty, then insert it into the union and
   // remove the number bits from the bitset.
-  if (!IsEmpty(lims)) {
+  if (!lims.IsEmpty()) {
     size = UpdateRange(RangeType::New(lims, representation, region), result,
                        size, region);
 
     // Remove the number bits.
     bitset number_bits = BitsetType::NumberBits(bits);
     bits &= ~number_bits;
     result->Set(0, BitsetType::New(bits, region));
   }
   return NormalizeUnion(result, size, region);
 }
@@ skipping 21 matching lines @@
   return size;
 }
 
 
 template <class Config>
 typename TypeImpl<Config>::Limits TypeImpl<Config>::ToLimits(bitset bits,
                                                              Region* region) {
   bitset number_bits = BitsetType::NumberBits(bits);
 
   if (number_bits == BitsetType::kNone) {
-    return Limits::Empty(region);
+    return Limits::Empty();
   }
 
   return Limits(BitsetType::Min(number_bits), BitsetType::Max(number_bits));
 }
 
 
 template <class Config>
 typename TypeImpl<Config>::Limits TypeImpl<Config>::IntersectRangeAndBitset(
     TypeHandle range, TypeHandle bitset, Region* region) {
   Limits range_lims(range->AsRange());
   Limits bitset_lims = ToLimits(bitset->AsBitset(), region);
-  return Intersect(range_lims, bitset_lims);
+  return Limits::Intersect(range_lims, bitset_lims);
 }
 
 
 template <class Config>
 int TypeImpl<Config>::IntersectAux(TypeHandle lhs, TypeHandle rhs,
                                    UnionHandle result, int size, Limits* lims,
                                    Region* region) {
   if (lhs->IsUnion()) {
     for (int i = 0, n = lhs->AsUnion()->Length(); i < n; ++i) {
       size =
@@ skipping 10 matching lines @@
   }
 
   if (!BitsetType::SemanticIsInhabited(lhs->BitsetLub() & rhs->BitsetLub())) {
     return size;
   }
 
   if (lhs->IsRange()) {
     if (rhs->IsBitset()) {
       Limits lim = IntersectRangeAndBitset(lhs, rhs, region);
 
-      if (!IsEmpty(lim)) {
-        *lims = Union(lim, *lims);
+      if (!lim.IsEmpty()) {
+        *lims = Limits::Union(lim, *lims);
       }
       return size;
     }
     if (rhs->IsClass()) {
-      *lims = Union(Limits(lhs->AsRange()), *lims);
+      *lims = Limits::Union(Limits(lhs->AsRange()), *lims);
     }
     if (rhs->IsConstant() && Contains(lhs->AsRange(), rhs->AsConstant())) {
       return AddToUnion(rhs, result, size, region);
     }
     if (rhs->IsRange()) {
-      Limits lim = Intersect(Limits(lhs->AsRange()), Limits(rhs->AsRange()));
-      if (!IsEmpty(lim)) {
-        *lims = Union(lim, *lims);
+      Limits lim = Limits::Intersect(
+          Limits(lhs->AsRange()), Limits(rhs->AsRange()));
+      if (!lim.IsEmpty()) {
+        *lims = Limits::Union(lim, *lims);
       }
     }
     return size;
   }
   if (rhs->IsRange()) {
     // This case is handled symmetrically above.
     return IntersectAux(rhs, lhs, result, size, lims, region);
   }
   if (lhs->IsBitset() || rhs->IsBitset()) {
     return AddToUnion(lhs->IsBitset() ? rhs : lhs, result, size, region);
@@ skipping 89 matching lines @@
   size = 0;
 
   // Compute the new bitset.
   bitset new_bitset = SEMANTIC(type1->BitsetGlb() | type2->BitsetGlb());
 
   // Deal with ranges.
   TypeHandle range = None(region);
   RangeType* range1 = type1->GetRange();
   RangeType* range2 = type2->GetRange();
   if (range1 != NULL && range2 != NULL) {
-    Limits lims = Union(Limits(range1), Limits(range2));
+    Limits lims = Limits::Union(Limits(range1), Limits(range2));
     RangeHandle union_range = RangeType::New(lims, representation, region);
     range = NormalizeRangeAndBitset(union_range, &new_bitset, region);
   } else if (range1 != NULL) {
     range = NormalizeRangeAndBitset(handle(range1), &new_bitset, region);
   } else if (range2 != NULL) {
     range = NormalizeRangeAndBitset(handle(range2), &new_bitset, region);
   }
   new_bitset = SEMANTIC(new_bitset) | representation;
   TypeHandle bits = BitsetType::New(new_bitset, region);
   result->Set(size++, bits);
@@ skipping 229 matching lines @@
   switch (bits) {
     case REPRESENTATION(kAny): return "Any";
     #define RETURN_NAMED_REPRESENTATION_TYPE(type, value) \
     case REPRESENTATION(k##type): return #type;
     REPRESENTATION_BITSET_TYPE_LIST(RETURN_NAMED_REPRESENTATION_TYPE)
     #undef RETURN_NAMED_REPRESENTATION_TYPE
 
     #define RETURN_NAMED_SEMANTIC_TYPE(type, value) \
     case SEMANTIC(k##type): return #type;
     SEMANTIC_BITSET_TYPE_LIST(RETURN_NAMED_SEMANTIC_TYPE)
+    INTERNAL_BITSET_TYPE_LIST(RETURN_NAMED_SEMANTIC_TYPE)
     #undef RETURN_NAMED_SEMANTIC_TYPE
 
     default:
       return NULL;
   }
 }
 
 
 template <class Config>
 void TypeImpl<Config>::BitsetType::Print(std::ostream& os,  // NOLINT
@@ skipping 121 matching lines @@
 
 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 internal
 }  // namespace v8