minor refactor

Author: eric-milles

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

@@ -53,55 +53,50 @@ public class IndyInterface {
     private static final long INDY_FALLBACK_CUTOFF = SystemUtil.getLongSafe("groovy.indy.fallback.cutoff", 100L);
 
     /**
-     * flags for method and property calls
+     * Flags for method and property calls.
      */
-    public static final int
-            SAFE_NAVIGATION = 1, THIS_CALL = 2,
-            GROOVY_OBJECT = 4, IMPLICIT_THIS = 8,
-            SPREAD_CALL = 16, UNCACHED_CALL = 32;
+    public static final int SAFE_NAVIGATION=1, THIS_CALL=2, GROOVY_OBJECT=4, IMPLICIT_THIS=8, SPREAD_CALL=16, UNCACHED_CALL=32;
+
     private static final MethodHandleWrapper NULL_METHOD_HANDLE_WRAPPER = MethodHandleWrapper.getNullMethodHandleWrapper();
 
     /**
-     * Enum for easy differentiation between call types
+     * Enum for easy differentiation between call types.
      */
     public enum CallType {
         /**
-         * Method invocation type
+         * Method invocation type.
          */
-        METHOD("invoke", 0),
+        METHOD("invoke"),
         /**
-         * Constructor invocation type
+         * Constructor invocation type.
          */
-        INIT("init", 1),
+        INIT("init"),
         /**
-         * Get property invocation type
+         * Get property invocation type.
          */
-        GET("getProperty", 2),
+        GET("getProperty"),
         /**
-         * Set property invocation type
+         * Set property invocation type.
          */
-        SET("setProperty", 3),
+        SET("setProperty"),
         /**
-         * Cast invocation type
+         * Cast invocation type.
          */
-        CAST("cast", 4),
-
+        CAST("cast"),
         /**
-         * call to interface method
+         * Interface method invocation type.
          */
-        INTERFACE("interface", 5);
+        INTERFACE("interface");
 
-        private static final Map<String, CallType> NAME_CALLTYPE_MAP =
-                Stream.of(CallType.values()).collect(Collectors.toMap(CallType::getCallSiteName, Function.identity()));
+        private static final Map<String, CallType> NAME_CALLTYPE_MAP = Stream.of(CallType.values())
+            .collect(Collectors.toUnmodifiableMap(CallType::getCallSiteName, Function.identity()));
 
         /**
-         * The name of the call site type
+         * The call site type name.
          */
         private final String name;
-        private final int orderNumber;
 
-        CallType(String callSiteName, int orderNumber) {
-            this.orderNumber = orderNumber;
+        CallType(String callSiteName) {
             this.name = callSiteName;
         }
 
@@ -117,16 +112,16 @@ public static CallType fromCallSiteName(String callSiteName) {
         }
 
         public int getOrderNumber() {
-            return this.orderNumber;
+            return ordinal();
         }
     }
 
     /**
-     * Logger
+     * Logger.
      */
     protected static final Logger LOG;
     /**
-     * boolean to indicate if logging for indy is enabled
+     * Indicates if indy logging is enabled.
      */
     protected static final boolean LOG_ENABLED;
 
@@ -152,6 +147,11 @@ public int getOrderNumber() {
      */
     public static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
 
+    /**
+     * shared invoker for cached method handles
+     */
+    private static final MethodHandle CACHED_INVOKER = MethodHandles.exactInvoker(MethodType.methodType(Object.class, Object[].class));
+
     /**
      * handle for the fromCacheHandle method
      */
@@ -162,22 +162,15 @@ public int getOrderNumber() {
      */
     private static final MethodHandle SELECT_METHOD_HANDLE_METHOD;
 
-    /**
-     * shared invoker for cached method handles
-     */
-    private static final MethodHandle CACHED_INVOKER;
-
     static {
-
         try {
-            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);
+            MethodType mt = 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", mt);
+            SELECT_METHOD_HANDLE_METHOD = LOOKUP.findStatic(IndyInterface.class, "selectMethodHandle", mt);
         } catch (Exception e) {
             throw new GroovyBugError(e);
         }
-
-        CACHED_INVOKER = MethodHandles.exactInvoker(MethodType.methodType(Object.class, Object[].class));
     }
 
     protected static SwitchPoint switchPoint = new SwitchPoint();
@@ -202,41 +195,32 @@ protected static void invalidateSwitchPoints() {
     }
 
     /**
-     * bootstrap method for method calls from Groovy compiled code with indy
-     * enabled. This method gets a flags parameter which uses the following
-     * encoding:<ul>
-     * <li>{@value #SAFE_NAVIGATION} is the flag value for safe navigation see {@link #SAFE_NAVIGATION}</li>
-     * <li>{@value #THIS_CALL} is the flag value for a call on this see {@link #THIS_CALL}</li>
-     * </ul>
+     * Bootstrap method for method calls from Groovy-compiled code with indy.
      *
      * @param caller   - the caller
-     * @param callType - the type of the call
-     * @param type     - the call site type
+     * @param callType - the type of call
+     * @param type     - the parameter(s) and return type specification
      * @param name     - the real method name
-     * @param flags    - call flags
-     * @return the produced CallSite
-     * @since Groovy 2.1.0
+     * @param flags    - call flags <ul>
+     *                   <li>{@value #SAFE_NAVIGATION} is the flag value for safe navigation; see {@link #SAFE_NAVIGATION}</li>
+     *                   <li>{@value #THIS_CALL} is the flag value for a call on this; see {@link #THIS_CALL}</li>
+     *                   <li>{@value #SPREAD_CALL} is the flag value for a spread call; see {@link #SPREAD_CALL}</li>
+     *                   </ul>
+     * @since 2.1.0
      */
-    public static CallSite bootstrap(MethodHandles.Lookup caller, String callType, MethodType type, String name, int flags) {
+    public static CallSite bootstrap(final MethodHandles.Lookup caller, final String callType, final MethodType type, final String name, final int flags) {
         CallType ct = CallType.fromCallSiteName(callType);
         if (null == ct) throw new GroovyBugError("Unknown call type: " + callType);
 
         int callID = ct.getOrderNumber();
-        boolean safe = (flags & SAFE_NAVIGATION) != 0;
-        boolean thisCall = (flags & THIS_CALL) != 0;
-        boolean spreadCall = (flags & SPREAD_CALL) != 0;
+        boolean safe       = (flags & SAFE_NAVIGATION) != 0;
+        boolean thisCall   = (flags & THIS_CALL      ) != 0;
+        boolean spreadCall = (flags & SPREAD_CALL    ) != 0;
 
-        return realBootstrap(caller, name, callID, type, safe, thisCall, spreadCall);
-    }
-
-    /**
-     * backing bootstrap method with all parameters
-     */
-    private static CallSite realBootstrap(MethodHandles.Lookup caller, String name, int callID, MethodType type, boolean safe, boolean thisCall, boolean spreadCall) {
         // first produce a dummy call site, since indy doesn't give the runtime types;
         // the site then changes to the target when INDY_OPTIMIZE_THRESHOLD is reached
         // that does the method selection including the direct call to the real method
-        CacheableCallSite mc = new CacheableCallSite(type, caller);
+        var mc = new CacheableCallSite(type, caller);
         Class<?> sender = caller.lookupClass();
         if (thisCall) {
             while (GeneratedClosure.class.isAssignableFrom(sender)) {
@@ -252,40 +236,45 @@ private static CallSite realBootstrap(MethodHandles.Lookup caller, String name,
     }
 
     /**
-     * Makes a fallback method for an invalidated method selection
+     * 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 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
+     * Makes an adapter method for method selection, i.e. get the cached method handle (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 makeBootHandle(mc, sender, name, callID, type, safeNavigation, thisCall, spreadCall, FROM_CACHE_HANDLE_METHOD);
     }
 
-    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
+    private static MethodHandle makeBootHandle(MutableCallSite mc, Class<?> sender, String name, int callID, MethodType type, boolean safeNavigation, boolean thisCall, boolean spreadCall, MethodHandle fromCacheOrSelectMethod) {
+        final Object dummyReceiver = 1;
+        // Step 1: bind site-constant arguments
+        MethodHandle boundHandle = MethodHandles.insertArguments(
+            fromCacheOrSelectMethod,
+            0, // insert start index
+            mc,
+            sender,
+            name,
+            callID,
+            safeNavigation,
+            thisCall,
+            spreadCall,
+            dummyReceiver
         );
-        // fromCacheBound: (Object receiver, Object[] args) → MethodHandle
+        // boundHandle: (Object receiver, Object[] arguments) → MethodHandle
 
         // Step 2: fold into the shared invoker (MethodHandle, Object[]) → Object
         MethodHandle bootHandle = MethodHandles.foldArguments(
             CACHED_INVOKER, // (MethodHandle, Object[]) → Object
-            fromCacheBound  // (Object, Object[]) → MethodHandle
+            boundHandle  // (Object, Object[]) → MethodHandle
         );
-        // bootHandle: (Object receiver, Object[] args) → Object
+        // bootHandle: (Object receiver, Object[] arguments) → Object
 
-        // Step 3: adapt to callsite type: collect all arguments into Object[] and then asType
-        bootHandle = bootHandle
-            .asCollector(Object[].class, type.parameterCount())
-            .asType(type);
+        // Step 3: adapt to call site type: collect all arguments into Object[] and then asType
+        bootHandle = bootHandle.asCollector(Object[].class, type.parameterCount()).asType(type);
 
         return bootHandle;
     }