[turbofan] Remove unused constructor function matching from typer.

src/compiler/typer.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 "src/compiler/typer.h"
 
 #include "src/base/flags.h"
 #include "src/base/lazy-instance.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
@@ skipping 47 matching lines @@
                                          Type::Any(), zone());
   Type* const kNumberFunc0 = Type::Function(Type::Number(), zone());
   Type* const kNumberFunc1 =
       Type::Function(Type::Number(), Type::Number(), zone());
   Type* const kNumberFunc2 =
       Type::Function(Type::Number(), Type::Number(), Type::Number(), zone());
   Type* const kImulFunc = Type::Function(Type::Signed32(), Type::Integral32(),
                                          Type::Integral32(), zone());
   Type* const kClz32Func =
       Type::Function(CreateRange(0, 32), Type::Number(), zone());
-  Type* const kArrayBufferFunc =
-      Type::Function(Type::Object(zone()), Type::Unsigned32(), zone());
 
 #define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size) \
-  Type* const k##TypeName##Array = CreateArray(k##TypeName);     \
-  Type* const k##TypeName##ArrayFunc = CreateArrayFunction(k##TypeName##Array);
+  Type* const k##TypeName##Array = CreateArray(k##TypeName);
   TYPED_ARRAYS(TYPED_ARRAY)
 #undef TYPED_ARRAY
 
  private:
   Type* CreateArray(Type* element) { return Type::Array(element, zone()); }
 
   Type* CreateArrayFunction(Type* array) {
     Type* arg1 = Type::Union(Type::Unsigned32(), Type::Object(), zone());
     Type* arg2 = Type::Union(Type::Unsigned32(), Type::Undefined(), zone());
     Type* arg3 = arg2;
@@ skipping 28 matching lines @@
 class Typer::Decorator final : public GraphDecorator {
  public:
   explicit Decorator(Typer* typer) : typer_(typer) {}
   void Decorate(Node* node) final;
 
  private:
   Typer* const typer_;
 };
 
 
-Typer::Typer(Isolate* isolate, Graph* graph, Type::FunctionType* function_type,
-             MaybeHandle<Context> context)
+Typer::Typer(Isolate* isolate, Graph* graph, Type::FunctionType* function_type)
     : isolate_(isolate),
       graph_(graph),
       function_type_(function_type),
-      context_(context),
       decorator_(nullptr),
       cache_(kCache.Get()) {
   Zone* zone = this->zone();
   Factory* const factory = isolate->factory();
 
   Type* infinity = Type::Constant(factory->infinity_value(), zone);
   Type* minus_infinity = Type::Constant(factory->minus_infinity_value(), zone);
   Type* truncating_to_zero =
       Type::Union(Type::Union(infinity, minus_infinity, zone),
                   Type::MinusZeroOrNaN(), zone);
@@ skipping 116 matching lines @@
       break;
     }
     UNREACHABLE();
     return Bounds();
   }
 
   Type* TypeConstant(Handle<Object> value);
 
  private:
   Typer* typer_;
-  MaybeHandle<Context> context_;
   ZoneSet<NodeId> weakened_nodes_;
 
 #define DECLARE_METHOD(x) inline Bounds Type##x(Node* node);
   DECLARE_METHOD(Start)
   DECLARE_METHOD(IfException)
   VALUE_OP_LIST(DECLARE_METHOD)
 #undef DECLARE_METHOD
 
   Bounds BoundsOrNone(Node* node) {
     return NodeProperties::IsTyped(node) ? NodeProperties::GetBounds(node)
                                          : Bounds(Type::None());
   }
 
   Bounds Operand(Node* node, int i) {
     Node* operand_node = NodeProperties::GetValueInput(node, i);
     return BoundsOrNone(operand_node);
   }
 
   Bounds WrapContextBoundsForInput(Node* node);
   Type* Weaken(Node* node, Type* current_type, Type* previous_type);
 
   Zone* zone() { return typer_->zone(); }
   Isolate* isolate() { return typer_->isolate(); }
   Graph* graph() { return typer_->graph(); }
-  MaybeHandle<Context> context() { return typer_->context(); }
 
   void SetWeakened(NodeId node_id) { weakened_nodes_.insert(node_id); }
   bool IsWeakened(NodeId node_id) {
     return weakened_nodes_.find(node_id) != weakened_nodes_.end();
   }
 
   typedef Type* (*UnaryTyperFun)(Type*, Typer* t);
   typedef Type* (*BinaryTyperFun)(Type*, Type*, Typer* t);
 
   Bounds TypeUnaryOp(Node* node, UnaryTyperFun);
@@ skipping 2030 matching lines @@
         case kMathMax:
         case kMathMin:
           return typer_->cache_.kNumberFunc2;
         case kMathImul:
           return typer_->cache_.kImulFunc;
         case kMathClz32:
           return typer_->cache_.kClz32Func;
         default:
           break;
       }
-    } else if (JSFunction::cast(*value)->IsBuiltin() && !context().is_null()) {
-      Handle<Context> native =
-          handle(context().ToHandleChecked()->native_context(), isolate());
-      if (*value == native->array_buffer_fun()) {
-        return typer_->cache_.kArrayBufferFunc;
-      } else if (*value == native->int8_array_fun()) {
-        return typer_->cache_.kInt8ArrayFunc;
-      } else if (*value == native->int16_array_fun()) {
-        return typer_->cache_.kInt16ArrayFunc;
-      } else if (*value == native->int32_array_fun()) {
-        return typer_->cache_.kInt32ArrayFunc;
-      } else if (*value == native->uint8_array_fun()) {
-        return typer_->cache_.kUint8ArrayFunc;
-      } else if (*value == native->uint16_array_fun()) {
-        return typer_->cache_.kUint16ArrayFunc;
-      } else if (*value == native->uint32_array_fun()) {
-        return typer_->cache_.kUint32ArrayFunc;
-      } else if (*value == native->float32_array_fun()) {
-        return typer_->cache_.kFloat32ArrayFunc;
-      } else if (*value == native->float64_array_fun()) {
-        return typer_->cache_.kFloat64ArrayFunc;
-      }
     }
     int const arity =
         JSFunction::cast(*value)->shared()->internal_formal_parameter_count();
     switch (arity) {
       case SharedFunctionInfo::kDontAdaptArgumentsSentinel:
         // Some smart optimization at work... &%$!&@+$!
         return Type::Any(zone());
       case 0:
         return typer_->cache_.kAnyFunc0;
       case 1:
@@ skipping 17 matching lines @@
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8