[turbofan] Nuke the context 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 30 matching lines @@
 //   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
-//   Context(T) < Internal
 //
 // 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, Function, or Context types
-// and respective Constant types, since these types cannot be reconstructed
+// 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
 //
@@ skipping 275 matching lines @@
 };
 
 // -----------------------------------------------------------------------------
 // Superclass for non-bitset types (internal).
 class TypeBase {
  protected:
   friend class Type;
 
   enum Kind {
     kConstant,
-    kContext,
     kArray,
     kFunction,
     kTuple,
     kUnion,
     kRange
   };
 
   Kind kind() const { return kind_; }
   explicit TypeBase(Kind kind) : kind_(kind) {}
 
@@ skipping 97 matching lines @@
   RangeType(BitsetType::bitset bitset, Limits limits)
       : TypeBase(kRange), bitset_(bitset), limits_(limits) {}
 
   BitsetType::bitset Lub() { return bitset_; }
 
   BitsetType::bitset bitset_;
   Limits limits_;
 };
 
 // -----------------------------------------------------------------------------
-// Context types.
-
-class ContextType : public TypeBase {
- public:
-  Type* Outer() { return outer_; }
-
- private:
-  friend class Type;
-
-  static Type* New(Type* outer, Zone* zone) {
-    return AsType(new (zone->New(sizeof(ContextType))) ContextType(outer));
-  }
-
-  static ContextType* cast(Type* type) {
-    DCHECK(IsKind(type, kContext));
-    return static_cast<ContextType*>(FromType(type));
-  }
-
-  explicit ContextType(Type* outer) : TypeBase(kContext), outer_(outer) {}
-
-  Type* outer_;
-};
-
-// -----------------------------------------------------------------------------
 // Array types.
 
 class ArrayType : public TypeBase {
  public:
   Type* Element() { return element_; }
 
  private:
   friend class Type;
 
   explicit ArrayType(Type* element) : TypeBase(kArray), element_(element) {}
@@ skipping 147 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* Context(Type* outer, Zone* zone) {
-    return ContextType::New(outer, 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) {
@@ skipping 59 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 IsContext() { return IsKind(TypeBase::kContext); }
   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); }
-  ContextType* AsContext() { return ContextType::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();
@@ skipping 150 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_