refactor CallInternalMethodNode#createCall

Author: Nicolas Laurent

src/main/java/org/truffleruby/language/dispatch/DispatchNode.java

@@ -10,6 +10,7 @@
 package org.truffleruby.language.dispatch;
 
 import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.frame.MaterializedFrame;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.interop.TruffleObject;
@@ -199,17 +200,19 @@ protected RubySymbol nameToSymbol(String methodName) {
 
     /** This will be called from the {@link CallInternalMethodNode} child whenever it creates a new
      * {@link DirectCallNode}. */
-    public final void applySplittingInliningStrategy(InternalMethod method, DirectCallNode callNode) {
+    public final void applySplittingInliningStrategy(RootCallTarget callTarget, String methodName,
+            DirectCallNode callNode) {
+
 
         final Options options = getContext().getOptions();
 
         // The way that #method_missing is used is usually as an indirection to call some other method, and possibly to
         // modify the arguments. In both cases, but especially the latter, it makes a lot of sense to manually clone the
         // call target and to inline it.
-        final boolean isMethodMissing = method.getName().equals("method_missing");
+        final boolean isMethodMissing = methodName.equals("method_missing");
 
         if (callNode.isCallTargetCloningAllowed() &&
-                (((RubyRootNode) method.getCallTarget().getRootNode()).shouldAlwaysClone() ||
+                (((RubyRootNode) callTarget.getRootNode()).shouldAlwaysClone() ||
                         isMethodMissing && options.METHODMISSING_ALWAYS_CLONE)) {
             callNode.cloneCallTarget();
         }

src/main/java/org/truffleruby/language/methods/CallInternalMethodNode.java

@@ -40,7 +40,7 @@ public static CallInternalMethodNode create() {
     protected Object callMethodCached(InternalMethod method, Object[] frameArguments,
             @Cached("method.getCallTarget()") RootCallTarget cachedCallTarget,
             @Cached("method") InternalMethod cachedMethod,
-            @Cached("createCall(cachedMethod, cachedCallTarget)") DirectCallNode callNode) {
+            @Cached("createCall(cachedMethod.getName(), cachedCallTarget)") DirectCallNode callNode) {
         return callNode.call(frameArguments);
     }
 
@@ -58,11 +58,11 @@ protected int getCacheLimit() {
         return RubyLanguage.getCurrentContext().getOptions().DISPATCH_CACHE;
     }
 
-    protected DirectCallNode createCall(InternalMethod method, RootCallTarget callTarget) {
+    protected DirectCallNode createCall(String methodName, RootCallTarget callTarget) {
         DirectCallNode callNode = DirectCallNode.create(callTarget);
         final DispatchNode dispatch = NodeUtil.findParent(this, DispatchNode.class);
         if (dispatch != null) {
-            dispatch.applySplittingInliningStrategy(method, callNode);
+            dispatch.applySplittingInliningStrategy(callTarget, methodName, callNode);
         }
         return callNode;
     }