[turbofan] Nuke the context types.

test/cctest/types-fuzz.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 137 matching lines @@
   ValueVector integers;  // "Integer" values used for range limits.
 
   Type* Of(Handle<i::Object> value) { return Type::Of(value, zone_); }
 
   Type* Constant(Handle<i::Object> value) {
     return Type::Constant(value, zone_);
   }
 
   Type* Range(double min, double max) { return Type::Range(min, max, zone_); }
 
-  Type* Context(Type* outer) { return Type::Context(outer, zone_); }
-
   Type* Array1(Type* element) { return Type::Array(element, zone_); }
 
   Type* Function0(Type* result, Type* receiver) {
     return Type::Function(result, receiver, 0, zone_);
   }
 
   Type* Function1(Type* result, Type* receiver, Type* arg) {
     Type* type = Type::Function(result, receiver, 1, zone_);
     type->AsFunction()->InitParameter(0, arg);
     return type;
@@ skipping 45 matching lines @@
         return Type::Constant(values[i], zone_);
       }
       case 2: {  // range
         int i = rng_->NextInt(static_cast<int>(integers.size()));
         int j = rng_->NextInt(static_cast<int>(integers.size()));
         double min = integers[i]->Number();
         double max = integers[j]->Number();
         if (min > max) std::swap(min, max);
         return Type::Range(min, max, zone_);
       }
-      case 3: {  // context
-        int depth = rng_->NextInt(3);
-        Type* type = Type::Internal();
-        for (int i = 0; i < depth; ++i) type = Type::Context(type, zone_);
-        return type;
-      }
-      case 4: {  // array
+      case 3: {  // array
         Type* element = Fuzz(depth / 2);
         return Type::Array(element, zone_);
       }
-      case 5:
-      case 6: {  // function
+      case 4:
+      case 5: {  // function
         Type* result = Fuzz(depth / 2);
         Type* receiver = Fuzz(depth / 2);
         int arity = rng_->NextInt(3);
         Type* type = Type::Function(result, receiver, arity, zone_);
         for (int i = 0; i < type->AsFunction()->Arity(); ++i) {
           Type* parameter = Fuzz(depth / 2);
           type->AsFunction()->InitParameter(i, parameter);
         }
         return type;
       }
@@ skipping 15 matching lines @@
  private:
   Zone* zone_;
   v8::base::RandomNumberGenerator* rng_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif