GROOVY-11842: avoid IndyInterface polluting trace (#2369)

* ensure the first call of invokedynamic is not polluting the stack trace

* IndyUsageTest will no longer work since there will be no IndyInterface lines in the trace anymore

* adding test for deprecated methods to help backwards compatibility

* cleanup in IndyInterface

(cherry picked from commit 53e1b68)

Author: blackdrag

src/main/java/org/codehaus/groovy/vmplugin/v8/IndyInterface.java

@@ -153,30 +153,31 @@ public int getOrderNumber() {
     public static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
 
     /**
-     * handle for the fromCache method
+     * handle for the fromCacheHandle method
      */
-    private static final MethodHandle FROM_CACHE_METHOD;
+    private static final MethodHandle FROM_CACHE_HANDLE_METHOD;
 
     /**
-     * handle for the selectMethod method
+     * handle for the selectMethodHandle method
      */
-    private static final MethodHandle SELECT_METHOD;
+    private static final MethodHandle SELECT_METHOD_HANDLE_METHOD;
+
+    /**
+     * shared invoker for cached method handles
+     */
+    private static final MethodHandle CACHED_INVOKER;
 
     static {
 
         try {
-            MethodType mt = MethodType.methodType(Object.class, CacheableCallSite.class, Class.class, String.class, int.class, Boolean.class, Boolean.class, Boolean.class, Object.class, Object[].class);
-            FROM_CACHE_METHOD = LOOKUP.findStatic(IndyInterface.class, "fromCache", mt);
+            MethodType handleMt = MethodType.methodType(MethodHandle.class, CacheableCallSite.class, Class.class, String.class, int.class, Boolean.class, Boolean.class, Boolean.class, Object.class, Object[].class);
+            FROM_CACHE_HANDLE_METHOD = LOOKUP.findStatic(IndyInterface.class, "fromCacheHandle", handleMt);
+            SELECT_METHOD_HANDLE_METHOD = LOOKUP.findStatic(IndyInterface.class, "selectMethodHandle", handleMt);
         } catch (Exception e) {
             throw new GroovyBugError(e);
         }
 
-        try {
-            MethodType mt = MethodType.methodType(Object.class, CacheableCallSite.class, Class.class, String.class, int.class, Boolean.class, Boolean.class, Boolean.class, Object.class, Object[].class);
-            SELECT_METHOD = LOOKUP.findStatic(IndyInterface.class, "selectMethod", mt);
-        } catch (Exception e) {
-            throw new GroovyBugError(e);
-        }
+        CACHED_INVOKER = MethodHandles.exactInvoker(MethodType.methodType(Object.class, Object[].class));
     }
 
     protected static SwitchPoint switchPoint = new SwitchPoint();
@@ -254,19 +255,39 @@ private static CallSite realBootstrap(MethodHandles.Lookup caller, String name,
      * Makes a fallback method for an invalidated method selection
      */
     protected static MethodHandle makeFallBack(MutableCallSite mc, Class<?> sender, String name, int callID, MethodType type, boolean safeNavigation, boolean thisCall, boolean spreadCall) {
-        return make(mc, sender, name, callID, type, safeNavigation, thisCall, spreadCall, SELECT_METHOD);
+        return makeBoothandle(mc, sender, name, callID, type, safeNavigation, thisCall, spreadCall, SELECT_METHOD_HANDLE_METHOD);
     }
 
     /**
      * Makes an adapter method for method selection, i.e. get the cached methodhandle(fast path) or fallback
      */
     private static MethodHandle makeAdapter(MutableCallSite mc, Class<?> sender, String name, int callID, MethodType type, boolean safeNavigation, boolean thisCall, boolean spreadCall) {
-        return make(mc, sender, name, callID, type, safeNavigation, thisCall, spreadCall, FROM_CACHE_METHOD);
+        return makeBoothandle(mc, sender, name, callID, type, safeNavigation, thisCall, spreadCall, FROM_CACHE_HANDLE_METHOD);
     }
 
-    private static MethodHandle make(MutableCallSite mc, Class<?> sender, String name, int callID, MethodType type, boolean safeNavigation, boolean thisCall, boolean spreadCall, MethodHandle originalMH) {
-        MethodHandle mh = MethodHandles.insertArguments(originalMH, 0, mc, sender, name, callID, safeNavigation, thisCall, spreadCall, /*dummy receiver:*/ 1);
-        return mh.asCollector(Object[].class, type.parameterCount()).asType(type);
+    private static MethodHandle makeBoothandle(MutableCallSite mc, Class<?> sender, String name, int callID, MethodType type, boolean safeNavigation, boolean thisCall, boolean spreadCall, MethodHandle handleReturningMh) {
+        // Step 1: bind site-constant arguments (incl dummy receiver marker)
+        MethodHandle fromCacheBound = MethodHandles.insertArguments(
+            handleReturningMh,
+            0, mc, sender, name, callID,
+            safeNavigation, thisCall, spreadCall,
+            /*dummy receiver*/ 1
+        );
+        // fromCacheBound: (Object receiver, Object[] args) → MethodHandle
+
+        // Step 2: fold into the shared invoker (MethodHandle, Object[]) → Object
+        MethodHandle boothandle = MethodHandles.foldArguments(
+            CACHED_INVOKER, // (MethodHandle, Object[]) → Object
+            fromCacheBound  // (Object, Object[]) → MethodHandle
+        );
+        // boothandle: (Object receiver, Object[] args) → Object
+
+        // Step 3: adapt to callsite type: collect all arguments into Object[] and then asType
+        boothandle = boothandle
+            .asCollector(Object[].class, type.parameterCount())
+            .asType(type);
+
+        return boothandle;
     }
 
     private static class FallbackSupplier {
@@ -304,8 +325,18 @@ MethodHandleWrapper get() {
 
     /**
      * Get the cached methodhandle. if the related methodhandle is not found in the inline cache, cache and return it.
+     * @deprecated Use the new boothandle-based approach instead.
      */
+    @Deprecated
     public static Object fromCache(CacheableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) throws Throwable {
+        MethodHandle mh = fromCacheHandle(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, dummyReceiver, arguments);
+        return mh.invokeExact(arguments);
+    }
+
+    /**
+     * Get the cached methodhandle. if the related methodhandle is not found in the inline cache, cache and return it.
+     */
+    private static MethodHandle fromCacheHandle(CacheableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) throws Throwable {
         FallbackSupplier fallbackSupplier = new FallbackSupplier(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, dummyReceiver, arguments);
 
         MethodHandleWrapper mhw =
@@ -341,7 +372,7 @@ public static Object fromCache(CacheableCallSite callSite, Class<?> sender, Stri
             mhw.resetLatestHitCount();
         }
 
-        return mhw.getCachedMethodHandle().invokeExact(arguments);
+        return mhw.getCachedMethodHandle();
     }
 
     private static boolean bypassCache(Boolean spreadCall, Object[] arguments) {
@@ -352,8 +383,18 @@ private static boolean bypassCache(Boolean spreadCall, Object[] arguments) {
 
     /**
      * Core method for indy method selection using runtime types.
+     * @deprecated Use the new boothandle-based approach instead.
      */
+    @Deprecated
     public static Object selectMethod(CacheableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) throws Throwable {
+        MethodHandle mh = selectMethodHandle(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, dummyReceiver, arguments);
+        return mh.invokeExact(arguments);
+    }
+
+    /**
+     * Core method for indy method selection using runtime types.
+     */
+    private static MethodHandle selectMethodHandle(CacheableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) throws Throwable {
         MethodHandleWrapper mhw = fallback(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, dummyReceiver, arguments);
 
         MethodHandle defaultTarget = callSite.getDefaultTarget();
@@ -370,7 +411,7 @@ public static Object selectMethod(CacheableCallSite callSite, Class<?> sender, S
             doWithCallSite(callSite, arguments, (cs, receiver) -> cs.put(receiver.getClass().getName(), mhw));
         }
 
-        return mhw.getCachedMethodHandle().invokeExact(arguments);
+        return mhw.getCachedMethodHandle();
     }
 
     private static MethodHandleWrapper fallback(CacheableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) {

src/test/groovy/indy/IndyUsageTest.groovy

@@ -0,0 +1,105 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.codehaus.groovy.vmplugin.v8
+
+import org.junit.jupiter.api.Test
+
+import java.lang.invoke.MethodHandles
+import java.lang.invoke.MethodType
+
+import static org.junit.jupiter.api.Assertions.assertEquals
+
+final class IndyInterfaceDeprecatedTest {
+
+    private String foo() {
+        return "foo-result"
+    }
+
+    @Test
+    void testSelectMethodDeprecatedInstanceFoo() {
+        // Prepare call site type: (IndyInterfaceDeprecatedTest) -> Object
+        MethodHandles.Lookup lookup = MethodHandles.lookup()
+        MethodType type = MethodType.methodType(Object, IndyInterfaceDeprecatedTest)
+        CacheableCallSite callSite = new CacheableCallSite(type, lookup)
+
+        // Provide non-null default/fallback targets (needed for guards in Selector)
+        def dummyTarget = MethodHandles.dropArguments(
+            MethodHandles.constant(Object, null), 0, type.parameterArray()
+        )
+        callSite.defaultTarget = dummyTarget
+        callSite.fallbackTarget = dummyTarget
+
+        // Prepare invocation arguments
+        def receiver = new IndyInterfaceDeprecatedTest()
+        Object[] args = [receiver] as Object[]
+
+        // Call deprecated selectMethod with the requested flags
+        int callID = IndyInterface.CallType.METHOD.getOrderNumber() // expected to be 0
+        Object result = IndyInterface.selectMethod(
+            callSite,
+            IndyInterfaceDeprecatedTest,        // sender
+            'foo',                              // methodName
+            callID,
+            Boolean.FALSE,                      // safeNavigation
+            Boolean.TRUE,                       // thisCall (instance method)
+            Boolean.FALSE,                      // spreadCall
+            1,                                  // dummyReceiver (marker only)
+            args
+        )
+
+        // Verify the local method foo was actually called
+        assertEquals(receiver.foo(), result)
+    }
+
+    @Test
+    void testFromCacheDeprecatedInstanceFoo() {
+        // Prepare call site type: (IndyInterfaceDeprecatedTest) -> Object
+        MethodHandles.Lookup lookup = MethodHandles.lookup()
+        MethodType type = MethodType.methodType(Object, IndyInterfaceDeprecatedTest)
+        CacheableCallSite callSite = new CacheableCallSite(type, lookup)
+
+        // Provide non-null default/fallback targets (needed for guards in Selector)
+        def dummyTarget = MethodHandles.dropArguments(
+            MethodHandles.constant(Object, null), 0, type.parameterArray()
+        )
+        callSite.defaultTarget = dummyTarget
+        callSite.fallbackTarget = dummyTarget
+
+        // Prepare invocation arguments
+        def receiver = new IndyInterfaceDeprecatedTest()
+        Object[] args = [receiver] as Object[]
+
+        // Call deprecated fromCache with the requested flags
+        int callID = IndyInterface.CallType.METHOD.getOrderNumber() // expected to be 0
+        Object result = IndyInterface.fromCache(
+            callSite,
+            IndyInterfaceDeprecatedTest,        // sender
+            'foo',                              // methodName
+            callID,
+            Boolean.FALSE,                      // safeNavigation
+            Boolean.TRUE,                       // thisCall (instance method)
+            Boolean.FALSE,                      // spreadCall
+            1,                                  // dummyReceiver (marker only)
+            args
+        )
+
+        // Verify the local method foo was actually called
+        assertEquals(receiver.foo(), result)
+    }
+}