[turbofan] Also nuke Array and Function types.

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/conversions.h"
 #include "src/handles.h"
 #include "src/objects.h"
@@ skipping 21 matching lines @@
 //   None <= T
 //   T <= Any
 //
 //   Number = Signed32 \/ Unsigned32 \/ Double
 //   Smi <= Signed32
 //   Name = String \/ Symbol
 //   UniqueName = InternalizedString \/ Symbol
 //   InternalizedString < String
 //
 //   Receiver = Object \/ Proxy
-//   Array < Object
-//   Function < Object
 //   RegExp < Object
 //   OtherUndetectable < Object
 //   DetectableReceiver = Receiver - OtherUndetectable
 //
 //   Constant(x) < T  iff instance_type(map(x)) < T
-//   Array(T) < Array
-//   Function(R, S, T0, T1, ...) < Function
-//
-// Both structural Array and Function types are invariant in all parameters;
-// relaxing this would make Union and Intersect operations more involved.
-// There is no subtyping relation between Array or Function types and
-// respective Constant types, since these types cannot be reconstructed
-// for arbitrary heap values.
 //
 //
 // REPRESENTATIONAL DIMENSION
 //
 // For the representation axis, the following holds:
 //
 //   None <= R
 //   R <= Any
 //
 //   UntaggedInt = UntaggedInt1 \/ UntaggedInt8 \/
@@ skipping 274 matching lines @@
 };
 
 // -----------------------------------------------------------------------------
 // Superclass for non-bitset types (internal).
 class TypeBase {
  protected:
   friend class Type;
 
   enum Kind {
     kConstant,
-    kArray,
-    kFunction,
     kTuple,
     kUnion,
     kRange
   };
 
   Kind kind() const { return kind_; }
   explicit TypeBase(Kind kind) : kind_(kind) {}
 
   static bool IsKind(Type* type, Kind kind) {
     if (BitsetType::IsBitset(type)) return false;
@@ skipping 95 matching lines @@
   RangeType(BitsetType::bitset bitset, Limits limits)
       : TypeBase(kRange), bitset_(bitset), limits_(limits) {}
 
   BitsetType::bitset Lub() { return bitset_; }
 
   BitsetType::bitset bitset_;
   Limits limits_;
 };
 
 // -----------------------------------------------------------------------------
-// Array types.
-
-class ArrayType : public TypeBase {
- public:
-  Type* Element() { return element_; }
-
- private:
-  friend class Type;
-
-  explicit ArrayType(Type* element) : TypeBase(kArray), element_(element) {}
-
-  static Type* New(Type* element, Zone* zone) {
-    return AsType(new (zone->New(sizeof(ArrayType))) ArrayType(element));
-  }
-
-  static ArrayType* cast(Type* type) {
-    DCHECK(IsKind(type, kArray));
-    return static_cast<ArrayType*>(FromType(type));
-  }
-
-  Type* element_;
-};
-
-// -----------------------------------------------------------------------------
 // Superclass for types with variable number of type fields.
 class StructuralType : public TypeBase {
  public:
   int LengthForTesting() { return Length(); }
 
  protected:
   friend class Type;
 
   int Length() { return length_; }
 
@@ skipping 16 matching lines @@
       : TypeBase(kind), length_(length) {
     elements_ = reinterpret_cast<Type**>(zone->New(sizeof(Type*) * length));
   }
 
  private:
   int length_;
   Type** elements_;
 };
 
 // -----------------------------------------------------------------------------
-// Function types.
-
-class FunctionType : public StructuralType {
- public:
-  int Arity() { return this->Length() - 2; }
-  Type* Result() { return this->Get(0); }
-  Type* Receiver() { return this->Get(1); }
-  Type* Parameter(int i) { return this->Get(2 + i); }
-
-  void InitParameter(int i, Type* type) { this->Set(2 + i, type); }
-
- private:
-  friend class Type;
-
-  FunctionType(Type* result, Type* receiver, int arity, Zone* zone)
-      : StructuralType(kFunction, 2 + arity, zone) {
-    Set(0, result);
-    Set(1, receiver);
-  }
-
-  static Type* New(Type* result, Type* receiver, int arity, Zone* zone) {
-    return AsType(new (zone->New(sizeof(FunctionType)))
-                      FunctionType(result, receiver, arity, zone));
-  }
-
-  static FunctionType* cast(Type* type) {
-    DCHECK(IsKind(type, kFunction));
-    return static_cast<FunctionType*>(FromType(type));
-  }
-};
-
-// -----------------------------------------------------------------------------
 // Tuple types.
 
 class TupleType : public StructuralType {
  public:
   int Arity() { return this->Length(); }
   Type* Element(int i) { return this->Get(i); }
 
   void InitElement(int i, Type* type) { this->Set(i, type); }
 
  private:
@@ skipping 55 matching lines @@
   }
 
   static Type* Constant(i::Handle<i::Object> value, Zone* zone) {
     return ConstantType::New(value, zone);
   }
   static Type* Range(double min, double max, Zone* zone) {
     return RangeType::New(min, max, REPRESENTATION(BitsetType::kTagged |
                                                    BitsetType::kUntaggedNumber),
                           zone);
   }
-  static Type* Array(Type* element, Zone* zone) {
-    return ArrayType::New(element, zone);
-  }
-  static Type* Function(Type* result, Type* receiver, int arity, Zone* zone) {
-    return FunctionType::New(result, receiver, arity, zone);
-  }
-  static Type* Function(Type* result, Zone* zone) {
-    return Function(result, Any(), 0, zone);
-  }
-  static Type* Function(Type* result, Type* param0, Zone* zone) {
-    Type* function = Function(result, Any(), 1, zone);
-    function->AsFunction()->InitParameter(0, param0);
-    return function;
-  }
-  static Type* Function(Type* result, Type* param0, Type* param1, Zone* zone) {
-    Type* function = Function(result, Any(), 2, zone);
-    function->AsFunction()->InitParameter(0, param0);
-    function->AsFunction()->InitParameter(1, param1);
-    return function;
-  }
-  static Type* Function(Type* result, Type* param0, Type* param1, Type* param2,
-                        Zone* zone) {
-    Type* function = Function(result, Any(), 3, zone);
-    function->AsFunction()->InitParameter(0, param0);
-    function->AsFunction()->InitParameter(1, param1);
-    function->AsFunction()->InitParameter(2, param2);
-    return function;
-  }
-  static Type* Function(Type* result, int arity, Type** params, Zone* zone) {
-    Type* function = Function(result, Any(), arity, zone);
-    for (int i = 0; i < arity; ++i) {
-      function->AsFunction()->InitParameter(i, params[i]);
-    }
-    return function;
-  }
   static Type* Tuple(Type* first, Type* second, Type* third, Zone* zone) {
     Type* tuple = TupleType::New(3, zone);
     tuple->AsTuple()->InitElement(0, first);
     tuple->AsTuple()->InitElement(1, second);
     tuple->AsTuple()->InitElement(2, third);
     return tuple;
   }
 
   static Type* Union(Type* type1, Type* type2, Zone* zone);
   static Type* Intersect(Type* type1, Type* type2, Zone* zone);
@@ skipping 24 matching lines @@
   bool Maybe(Type* that);
   bool Equals(Type* that) { return this->Is(that) && that->Is(this); }
 
   // Equivalent to Constant(val)->Is(this), but avoiding allocation.
   bool Contains(i::Object* val);
   bool Contains(i::Handle<i::Object> val) { return this->Contains(*val); }
 
   // Inspection.
   bool IsRange() { return IsKind(TypeBase::kRange); }
   bool IsConstant() { return IsKind(TypeBase::kConstant); }
-  bool IsArray() { return IsKind(TypeBase::kArray); }
-  bool IsFunction() { return IsKind(TypeBase::kFunction); }
   bool IsTuple() { return IsKind(TypeBase::kTuple); }
 
   ConstantType* AsConstant() { return ConstantType::cast(this); }
   RangeType* AsRange() { return RangeType::cast(this); }
-  ArrayType* AsArray() { return ArrayType::cast(this); }
-  FunctionType* AsFunction() { return FunctionType::cast(this); }
   TupleType* AsTuple() { return TupleType::cast(this); }
 
   // Minimum and maximum of a numeric type.
   // These functions do not distinguish between -0 and +0.  If the type equals
   // kNaN, they return NaN; otherwise kNaN is ignored.  Only call these
   // functions on subtypes of Number.
   double Min();
   double Max();
 
   // Extracts a range from the type: if the type is a range or a union
@@ skipping 148 matching lines @@
   }
 
   bool Narrows(Bounds that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TYPES_H_