TypeTest.java

package lambdas;

import sun.reflect.ConstantPool;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class TypeTest {
    @FunctionalInterface
    public static interface Block<A> {
        public void call(A arg);
    }

    private static final Method getConstantPool;

    static {
        try {
            getConstantPool = Class.class.getDeclaredMethod("getConstantPool");
            getConstantPool.setAccessible(true);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    public static <A> void instantitesLambdaArgBasedOnGenericType(Block<A> block) throws Exception {
        Type genericInterface = block.getClass().getGenericInterfaces()[0];
        if (genericInterface instanceof ParameterizedType) {
            Class<A> type = (Class<A>) ((ParameterizedType) genericInterface).getActualTypeArguments()[0];
            block.call(type.newInstance());
        } else {
            // Code from @danielbodart. AMAZING.
            ConstantPool constantPool = (ConstantPool) getConstantPool.invoke(block.getClass());
            String[] methodRef = constantPool.getMemberRefInfoAt(20);
            int argumentIndex = 0;
            String argumentType = jdk.internal.org.objectweb.asm.Type.getArgumentTypes(methodRef[2])[argumentIndex].getClassName();
            Class<A> type = (Class<A>) Class.forName(argumentType);
            block.call(type.newInstance());
        }
    }

    public static class Thing {
    }

    public static void main(String[] args) throws Exception {
        // Generic arg = class lambdas.TypeTest$Thing
        instantitesLambdaArgBasedOnGenericType((Thing message) -> System.out.println(message.getClass()));

        // Generic arg = class lambdas.TypeTest$Thing
        instantitesLambdaArgBasedOnGenericType((Block<Thing>) (Thing message) -> System.out.println(message.getClass()));

        // Generic arg = class lambdas.TypeTest$Thing
        instantitesLambdaArgBasedOnGenericType(new Block<Thing>() {
            @Override
            public void call(Thing message) {
                System.out.println(message.getClass());
            }
        });
    }
}

(Updated Links)
If the FunctionalInterface is Serializable there is also another way to get the signature of the SAM:

• https://github.com/javaslang/javaslang/blob/8f13bd0ccd0e5ac59a2aef461bde9d109886dd52/src/main/java/javaslang/λ.java#L69

Here is a sample application:

• https://github.com/javaslang/javaslang/blob/bf4dcdf576b00a2c579c6505a9ad762e8596e967/src/test/java/javaslang/control/MatchTest.java#L89

i've add similar functionality to typesafe-akka library, see my commit :
ktoso/akka@5e14c2d