Why can't I .invokeExact() here, even though the MethodType is OK?

Question

For one of my project I have to make dynamic invocations of constructor. But since this is Java 7, instead of the "classic" reflection API, I use java.lang.invoke. Code: ``` @ParametersAreNonnullByDefault public class PathMatcherProvider { private static final MethodHandles.Lookup LOOKUP = MethodHandles.publicLookup(); private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class, String.class); private final Map> classMap = new HashMap<>(); private final Map, MethodHandle> handleMap = new HashMap<>(); public PathMatcherProvider() { registerPathMatcher("glob", GlobPathMatcher.class); registerPathMatcher("regex", RegexPathMatcher.class); } public final PathMatcher getPathMatcher(final String name, final String arg) { Objects.requireNonNull(name); Objects.requireNonNull(arg); final Class c = classMap.get(name); if (c == null) throw new UnsupportedOperationException(); try { ret…

Accepted Answer

When the compiler emits the invokeExact call, it records Object as the expected return type. From the MethodHandle javadoc (emphasis mine):

As is usual with virtual methods, source-level calls to invokeExact and invoke compile to an invokevirtual instruction. More unusually, the compiler must record the actual argument types, and may not perform method invocation conversions on the arguments. Instead, it must push them on the stack according to their own unconverted types. The method handle object itself is pushed on the stack before the arguments. The compiler then calls the method handle with a symbolic type descriptor which describes the argument and return types.

To issue a complete symbolic type descriptor, the compiler must also determine the return type. This is based on a cast on the method invocation expression, if there is one, or else Object if the invocation is an expression or else void if the invocation is a statement. The cast may be to a primitive type (but not void).

At runtime the method handle actually returns RegexPathMatcher, so the invokeExact fails with WrongMethodTypeException.

You need to specify the return type explicitly with a (compile-time) cast:

```
return (RegexPathMatcher)handleMap.get(c).invokeExact(arg);
```

Except you need to be generic over different PathMatcher implementations, so you should convert your method handles to return PathMatcher using asType, then call with PathMatcher as the expected return type.

```
//in findConstructor
MethodHandle h = LOOKUP.findConstructor(matcherClass, CONSTRUCTOR_TYPE);
return h.asType(h.type().changeReturnType(PathMatcher.class));

//in getPathMatcher
return (PathMatcher)handleMap.get(c).invokeExact(arg);
```

Why can't I .invokeExact() here, even though the MethodType is OK?

Solution

Problem