Well, still trying to find out what the reason is, that core reflection's invoke behaves differently to MethodHandle's invokeWithArguments in one single case so far (using the method java.utli.Arrays.asList(...)).
Here is a little Java program that excercises reflective access to "java.util.Arrays.asList(T... a)" using core reflection, i.e. "Method.invoke(Object obj, Object... args)" and "MethodHandle.invokeWithArguments(Object... arguments)": import java.util.*; import java.lang.reflect.*; import java.lang.invoke.*; class DemoAsListProblem { public static void main (String args[]) { String arrNames[]=new String[] { "anne", "bert", "celine"}; System.out.println("[1] (main) arrNames=\""+arrNames+"\", .toString()=\""+arrNames.toString()+"\""); List listNames=Arrays.asList(arrNames); System.out.println("[2] (main) after invoking Arrays.asList(arrNames), listNames=\""+listNames+"\""); System.out.println("\ninvoking testReflective() ...\n"); testReflective(); } public static void testReflective() { String arrNames[]=new String[] { "anne", "bert", "celine"}; System.out.println("[3] (testReflective) arrNames=\""+arrNames+"\", .toString()=\""+arrNames.toString()+"\""); Method methAsList=null; List listNames=null; try { Class paramTypes[]=new Class[] { (new Object[0]).getClass() }; methAsList=Arrays.class.getDeclaredMethod("asList", paramTypes); System.out.println("--- (core reflection) Method object asList: "+methAsList); System.out.println("\n--- (core reflection) now invoking Arrays.asList() via Method.invoke(...):"); listNames=(List) methAsList.invoke( null, (Object[]) new Object[]{arrNames} ); // static method System.out.println("[4a] --- (CR) methAsList.invoke( null, (Object[]) new Object[]{arrNames} ) -> listNames=\""+listNames+"\""); listNames=(List) methAsList.invoke( null, (Object) new Object[]{arrNames} ); // static method System.out.println("[4b] --- (CR) methAsList.invoke( null, (Object) new Object[]{arrNames} ) -> listNames=\""+listNames+"\""); // "java.lang.IllegalArgumentException: wrong number of arguments": // listNames=(List) methAsList.invoke( null, (Object[]) arrNames ); // static method // System.out.println("[5a] --- (CR) methAsList.invoke( null, (Object[]) arrNames ) -> listNames=\""+listNames+"\""); listNames=(List) methAsList.invoke( null, (Object) arrNames ); // static method System.out.println("[5b] --- (CR) methAsList.invoke( null, (Object) arrNames ) -> listNames=\""+listNames+"\""); } catch (Throwable t) { System.err.println("oops #1: "+t); t.printStackTrace(); System.exit(-1); } System.out.println("\n--- (MH) now invoking Arrays.asList() via MethodHandle.invokeWithArguments(...):"); MethodHandles.Lookup lookup=MethodHandles.lookup(); MethodHandle mh=null; try { mh=lookup.unreflect(methAsList); System.out.println("--- (MH) unreflected MethodHandle mh: "+mh); listNames=(List) mh.invokeWithArguments( (Object[]) new Object[]{arrNames} ); System.out.println("[6a] --- (MH) mh.invokeWithArguments( (Object[]) new Object[]{arrNames} ) -> listNames=\""+listNames+"\""); listNames=(List) mh.invokeWithArguments( (Object) new Object[]{arrNames} ); System.out.println("[6b] --- (MH) mh.invokeWithArguments( (Object) new Object[]{arrNames} ) -> listNames=\""+listNames+"\""); listNames=(List) mh.invokeWithArguments( (Object[]) arrNames ); System.out.println("[7a] --- (MH) mh.invokeWithArguments( (Object[]) arrNames ) -> listNames=\""+listNames+"\""); listNames=(List) mh.invokeWithArguments( (Object) arrNames ); System.out.println("[7b] --- (MH) mh.invokeWithArguments( (Object) arrNames ) -> listNames=\""+listNames+"\""); } catch (Throwable t) { System.err.println("oops #2: "+t); t.printStackTrace(); System.exit(-2); } } } Compiling and running it under 9.0.4 yields the following output: [1] (main) arrNames="[Ljava.lang.String;@27ddd392", .toString()="[Ljava.lang.String;@27ddd392" [2] (main) after invoking Arrays.asList(arrNames), listNames="[anne, bert, celine]" invoking testReflective() ... [3] (testReflective) arrNames="[Ljava.lang.String;@2a18f23c", .toString()="[Ljava.lang.String;@2a18f23c" --- (core reflection) Method object asList: public static java.util.List java.util.Arrays.asList(java.lang.Object[]) --- (core reflection) now invoking Arrays.asList() via Method.invoke(...): [4a] --- (CR) methAsList.invoke( null, (Object[]) new Object[]{arrNames} ) -> listNames="[anne, bert, celine]" [4b] --- (CR) methAsList.invoke( null, (Object) new Object[]{arrNames} ) -> listNames="[[Ljava.lang.String;@2a18f23c]" [5b] --- (CR) methAsList.invoke( null, (Object) arrNames ) -> listNames="[anne, bert, celine]" --- (MH) now invoking Arrays.asList() via MethodHandle.invokeWithArguments(...): --- (MH) unreflected MethodHandle mh: MethodHandle(Object[])List [6a] --- (MH) mh.invokeWithArguments( (Object[]) new Object[]{arrNames} ) -> listNames="[[Ljava.lang.String;@2a18f23c]" [6b] --- (MH) mh.invokeWithArguments( (Object) new Object[]{arrNames} ) -> listNames="[[Ljava.lang.Object;@13a57a3b]" [7a] --- (MH) mh.invokeWithArguments( (Object[]) arrNames ) -> listNames="[anne, bert, celine]" [7b] --- (MH) mh.invokeWithArguments( (Object) arrNames ) -> listNames="[[Ljava.lang.String;@2a18f23c]" So a String array is turned into a List using Arrays.asList(strArray). Doing it with core reflection yields different results to doing it with invokeWithArguments(). I would have expected that [4a] and [6a] would behave the same. Using reflective invoke() and invokeWithArguments() has been working for my bridge for all the test units (using literally the same arguments in both cases) interchangeably, the one exception is Arrays.asList(). Maybe I am not seeing the obvious (having done too much "close-up tests" for quite some time now). So any hint, insight, help would be really appreciated! ---rony
_______________________________________________ mlvm-dev mailing list mlvm-dev@openjdk.java.net http://mail.openjdk.java.net/mailman/listinfo/mlvm-dev