[turbofan] Remove the TryLowerDirectJSCall hack from generic lowering.

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/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/typer.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 #define NATIVE_TYPES(V) \
   V(Int8)               \
   V(Uint8)              \
   V(Int16)              \
   V(Uint16)             \
   V(Int32)              \
   V(Uint32)             \
   V(Float32)            \
   V(Float64)
 
 enum LazyCachedType {
+  kAnyFunc0,
+  kAnyFunc1,
+  kAnyFunc2,
+  kAnyFunc3,
   kNumberFunc0,
   kNumberFunc1,
   kNumberFunc2,
   kImulFunc,
   kClz32Func,
   kArrayBufferFunc,
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   k##Type, k##Type##Array, k##Type##ArrayFunc,
   TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
@@ skipping 32 matching lines @@
       case kInt32:
         return CreateNative(Type::Signed32(), Type::UntaggedSigned32());
       case kUint32:
         return CreateNative(Type::Unsigned32(), Type::UntaggedUnsigned32());
       case kFloat32:
         return CreateNative(Type::Number(), Type::UntaggedFloat32());
       case kFloat64:
         return CreateNative(Type::Number(), Type::UntaggedFloat64());
       case kUint8Clamped:
         return Get(kUint8);
+      case kAnyFunc0:
+        return Type::Function(Type::Any(), zone());
+      case kAnyFunc1:
+        return Type::Function(Type::Any(), Type::Any(), zone());
+      case kAnyFunc2:
+        return Type::Function(Type::Any(), Type::Any(), Type::Any(), zone());
+      case kAnyFunc3:
+        return Type::Function(Type::Any(), Type::Any(), Type::Any(),
+                              Type::Any(), zone());
       case kNumberFunc0:
         return Type::Function(Type::Number(), zone());
       case kNumberFunc1:
         return Type::Function(Type::Number(), Type::Number(), zone());
       case kNumberFunc2:
         return Type::Function(Type::Number(), Type::Number(), Type::Number(),
                               zone());
       case kImulFunc:
         return Type::Function(Type::Signed32(), Type::Integral32(),
                               Type::Integral32(), zone());
@@ skipping 2295 matching lines @@
       } else if (*value == native->uint16_array_fun()) {
         return typer_->cache_->Get(kUint16ArrayFunc);
       } else if (*value == native->uint32_array_fun()) {
         return typer_->cache_->Get(kUint32ArrayFunc);
       } else if (*value == native->float32_array_fun()) {
         return typer_->cache_->Get(kFloat32ArrayFunc);
       } else if (*value == native->float64_array_fun()) {
         return typer_->cache_->Get(kFloat64ArrayFunc);
       }
     }
+    int const arity =
+        JSFunction::cast(*value)->shared()->internal_formal_parameter_count();
+    switch (arity) {
+      case 0:
+        return typer_->cache_->Get(kAnyFunc0);
+      case 1:
+        return typer_->cache_->Get(kAnyFunc1);
+      case 2:
+        return typer_->cache_->Get(kAnyFunc2);
+      case 3:
+        return typer_->cache_->Get(kAnyFunc3);
+      default: {
+        Type** const params = zone()->NewArray<Type*>(arity);
+        std::fill(&params[0], &params[arity], Type::Any(zone()));
+        return Type::Function(Type::Any(zone()), arity, params, zone());
+      }
+    }
   } else if (value->IsJSTypedArray()) {
     switch (JSTypedArray::cast(*value)->type()) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case kExternal##Type##Array:                          \
     return typer_->cache_->Get(k##Type##Array);
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8