Refactor InvokeMember node to support DSL inlining

Author: horakivo

src/main/java/org/truffleruby/interop/InteropNodes.java

@@ -92,15 +92,6 @@ public static Object execute(Object receiver, Object[] args, InteropLibrary rece
         }
     }
 
-    public static Object invoke(InteropLibrary receivers, Object receiver, String member, Object[] args,
-            TranslateInteropExceptionNode translateInteropExceptionNode) {
-        try {
-            return receivers.invokeMember(receiver, member, args);
-        } catch (InteropException e) {
-            throw translateInteropExceptionNode.executeInInvokeMember(e, receiver, args);
-        }
-    }
-
     public static Object readMember(InteropLibrary interop, Object receiver, String name,
             TranslateInteropExceptionNode translateInteropException) {
         try {
@@ -1468,41 +1459,15 @@ protected Nil remove(Object receiver, Object identifier,
         }
     }
 
-    @GenerateUncached
     @GenerateNodeFactory
     @CoreMethod(names = "invoke_member", onSingleton = true, required = 2, rest = true)
-    @NodeChild(value = "argumentNodes", type = RubyNode[].class)
-    public abstract static class InvokeMemberNode extends RubySourceNode {
-
-        @NeverDefault
-        public static InvokeMemberNode create() {
-            return InteropNodesFactory.InvokeMemberNodeFactory.create(null);
-        }
-
-        public static InvokeMemberNode create(RubyNode[] argumentNodes) {
-            return InteropNodesFactory.InvokeMemberNodeFactory.create(argumentNodes);
-        }
-
-        public abstract Object execute(Object receiver, Object identifier, Object[] args);
-
-        abstract RubyNode[] getArgumentNodes();
+    public abstract static class InteropInvokeMemberNode extends CoreMethodArrayArgumentsNode {
 
-        @Specialization(limit = "getInteropCacheLimit()")
-        protected Object invokeCached(Object receiver, Object identifier, Object[] args,
-                @Cached ToJavaStringNode toJavaStringNode,
-                @CachedLibrary("receiver") InteropLibrary receivers,
-                @Cached ForeignToRubyNode foreignToRubyNode,
-                @Cached TranslateInteropExceptionNode translateInteropException) {
-            final String name = toJavaStringNode.executeToJavaString(identifier);
-            final Object foreign = invoke(receivers, receiver, name, args, translateInteropException);
-            return foreignToRubyNode.executeConvert(foreign);
-        }
-
-        @Override
-        public RubyNode cloneUninitialized() {
-            return create(cloneUninitialized(getArgumentNodes())).copyFlags(this);
+        @Specialization
+        protected Object invokeMember(Object receiver, Object identifier, Object[] args,
+                @Cached InvokeMemberNode invokeMemberNode) {
+            return invokeMemberNode.execute(receiver, identifier, args);
         }
-
     }
 
     @CoreMethod(names = "member_readable?", onSingleton = true, required = 2)

src/main/java/org/truffleruby/interop/InvokeMemberNode.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.interop;
+
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.GenerateUncached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.interop.InteropException;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.library.CachedLibrary;
+import org.truffleruby.language.RubyBaseNode;
+
+@GenerateUncached
+public abstract class InvokeMemberNode extends RubyBaseNode {
+
+    private static Object invoke(InteropLibrary receivers, Object receiver, String member, Object[] args,
+            TranslateInteropExceptionNode translateInteropExceptionNode) {
+        try {
+            return receivers.invokeMember(receiver, member, args);
+        } catch (InteropException e) {
+            throw translateInteropExceptionNode.executeInInvokeMember(e, receiver, args);
+        }
+    }
+
+    public abstract Object execute(Object receiver, Object identifier, Object[] args);
+
+    @Specialization(limit = "getInteropCacheLimit()")
+    protected Object invokeCached(Object receiver, Object identifier, Object[] args,
+            @Cached ToJavaStringNode toJavaStringNode,
+            @CachedLibrary("receiver") InteropLibrary receivers,
+            @Cached ForeignToRubyNode foreignToRubyNode,
+            @Cached TranslateInteropExceptionNode translateInteropException) {
+        final String name = toJavaStringNode.executeToJavaString(identifier);
+        final Object foreign = invoke(receivers, receiver, name, args, translateInteropException);
+        return foreignToRubyNode.executeConvert(foreign);
+    }
+}

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

@@ -26,7 +26,7 @@
 import org.truffleruby.core.cast.ToSymbolNode;
 import org.truffleruby.core.numeric.RubyBignum;
 import org.truffleruby.core.proc.RubyProc;
-import org.truffleruby.interop.InteropNodes.InvokeMemberNode;
+import org.truffleruby.interop.InvokeMemberNode;
 import org.truffleruby.interop.InteropNodes.ReadMemberNode;
 import org.truffleruby.interop.InteropNodes.WriteMemberWithoutConversionNode;
 import org.truffleruby.interop.TranslateInteropExceptionNode;