[turbofan] Type::Contains() and Constants() is unnecessary.

src/compiler/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/compiler/types.h"
 
 #include "src/handles-inl.h"
 #include "src/ostreams.h"
@@ skipping 498 matching lines @@
 // Return the range in [this], or [NULL].
 Type* Type::GetRange() {
   DisallowHeapAllocation no_allocation;
   if (this->IsRange()) return this;
   if (this->IsUnion() && this->AsUnion()->Get(1)->IsRange()) {
     return this->AsUnion()->Get(1);
   }
   return NULL;
 }
 
-bool Type::Contains(i::Object* value) {
-  DisallowHeapAllocation no_allocation;
-  for (Iterator<i::Object> it = this->Constants(); !it.Done(); it.Advance()) {
-    if (*it.Current() == value) return true;
-  }
-  if (IsInteger(value)) {
-    Type* range = this->GetRange();
-    if (range != NULL && Contains(range->AsRange(), value)) return true;
-  }
-  return BitsetType::New(BitsetType::Lub(value))->Is(this);
-}
-
 bool UnionType::Wellformed() {
   DisallowHeapAllocation no_allocation;
   // This checks the invariants of the union representation:
   // 1. There are at least two elements.
   // 2. The first element is a bitset, no other element is a bitset.
   // 3. At most one element is a range, and it must be the second one.
   // 4. No element is itself a union.
   // 5. No element (except the bitset) is a subtype of any other.
   // 6. If there is a range, then the bitset type does not contain
   //    plain number bits.
@@ skipping 315 matching lines @@
     int result = 0;
     for (int i = 0, n = this->AsUnion()->Length(); i < n; ++i) {
       if (this->AsUnion()->Get(i)->IsConstant()) ++result;
     }
     return result;
   } else {
     return 0;
   }
 }
 
-template <class T>
-Type* Type::Iterator<T>::get_type() {
-  DCHECK(!Done());
-  return type_->IsUnion() ? type_->AsUnion()->Get(index_) : type_;
-}
-
-// C++ cannot specialise nested templates, so we have to go through this
-// contortion with an auxiliary template to simulate it.
-template <class T>
-struct TypeImplIteratorAux {
-  static bool matches(Type* type);
-  static i::Handle<T> current(Type* type);
-};
-
-template <>
-struct TypeImplIteratorAux<i::Object> {
-  static bool matches(Type* type) { return type->IsConstant(); }
-  static i::Handle<i::Object> current(Type* type) {
-    return type->AsConstant()->Value();
-  }
-};
-
-template <class T>
-bool Type::Iterator<T>::matches(Type* type) {
-  return TypeImplIteratorAux<T>::matches(type);
-}
-
-template <class T>
-i::Handle<T> Type::Iterator<T>::Current() {
-  return TypeImplIteratorAux<T>::current(get_type());
-}
-
-template <class T>
-void Type::Iterator<T>::Advance() {
-  DisallowHeapAllocation no_allocation;
-  ++index_;
-  if (type_->IsUnion()) {
-    for (int n = type_->AsUnion()->Length(); index_ < n; ++index_) {
-      if (matches(type_->AsUnion()->Get(index_))) return;
-    }
-  } else if (index_ == 0 && matches(type_)) {
-    return;
-  }
-  index_ = -1;
-}
-
 // -----------------------------------------------------------------------------
 // Printing.
 
 const char* BitsetType::Name(bitset bits) {
   switch (bits) {
 #define RETURN_NAMED_TYPE(type, value) \
   case k##type:                        \
     return #type;
     PROPER_BITSET_TYPE_LIST(RETURN_NAMED_TYPE)
     INTERNAL_BITSET_TYPE_LIST(RETURN_NAMED_TYPE)
@@ skipping 85 matching lines @@
 #endif
 
 BitsetType::bitset BitsetType::SignedSmall() {
   return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
 }
 
 BitsetType::bitset BitsetType::UnsignedSmall() {
   return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
 }
 
-// -----------------------------------------------------------------------------
-// Instantiations.
-
-template class Type::Iterator<i::Object>;
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8