/*
* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8035776
* @summary Ensure that invocation parameters are always cast to the instantiatedMethodType
*/
import java.lang.invoke.*;
import java.util.Arrays;
import static java.lang.invoke.MethodType.methodType;
public class MetafactoryParameterCastTest {
static final MethodHandles.Lookup lookup = MethodHandles.lookup();
public static class A {
}
public static class B extends A {
void instance0() {}
void instance1(B arg) {}
static void static1(B arg) {}
static void static2(B arg1, B arg2) {}
}
public static class C extends B {}
public static class NotC extends B {}
public interface ASink { void take(A arg); }
public interface BSink { void take(B arg); }
public static void main(String... args) throws Throwable {
new MetafactoryParameterCastTest().test();
}
void test() throws Throwable {
MethodType takeA = methodType(void.class, A.class);
MethodType takeB = methodType(void.class, B.class);
MethodType takeC = methodType(void.class, C.class);
Class<?>[] noCapture = {};
Class<?>[] captureB = { B.class };
MethodHandle[] oneBParam = { lookup.findVirtual(B.class, "instance0", methodType(void.class)),
lookup.findStatic(B.class, "static1", methodType(void.class, B.class)) };
MethodHandle[] twoBParams = { lookup.findVirtual(B.class, "instance1", methodType(void.class, B.class)),
lookup.findStatic(B.class, "static2", methodType(void.class, B.class, B.class)) };
for (MethodHandle mh : oneBParam) {
// sam
tryASink(invokeMetafactory(mh, ASink.class, "take", noCapture, takeC, takeA));
tryBSink(invokeMetafactory(mh, BSink.class, "take", noCapture, takeC, takeB));
tryASink(invokeAltMetafactory(mh, ASink.class, "take", noCapture, takeC, takeA));
tryBSink(invokeAltMetafactory(mh, BSink.class, "take", noCapture, takeC, takeB));
// bridge
tryASink(invokeAltMetafactory(mh, ASink.class, "take", noCapture, takeC, takeC, takeA));
tryBSink(invokeAltMetafactory(mh, BSink.class, "take", noCapture, takeC, takeC, takeB));
}
for (MethodHandle mh : twoBParams) {
// sam
tryCapASink(invokeMetafactory(mh, ASink.class, "take", captureB, takeC, takeA));
tryCapBSink(invokeMetafactory(mh, BSink.class, "take", captureB, takeC, takeB));
tryCapASink(invokeAltMetafactory(mh, ASink.class, "take", captureB, takeC, takeA));
tryCapBSink(invokeAltMetafactory(mh, BSink.class, "take", captureB, takeC, takeB));
// bridge
tryCapASink(invokeAltMetafactory(mh, ASink.class, "take", captureB, takeC, takeC, takeA));
tryCapBSink(invokeAltMetafactory(mh, BSink.class, "take", captureB, takeC, takeC, takeB));
}
}
void tryASink(CallSite cs) throws Throwable {
ASink sink = (ASink) cs.dynamicInvoker().invoke();
tryASink(sink);
}
void tryCapASink(CallSite cs) throws Throwable {
ASink sink = (ASink) cs.dynamicInvoker().invoke(new B());
tryASink(sink);
}
void tryBSink(CallSite cs) throws Throwable {
BSink sink = (BSink) cs.dynamicInvoker().invoke();
tryBSink(sink);
}
void tryCapBSink(CallSite cs) throws Throwable {
BSink sink = (BSink) cs.dynamicInvoker().invoke(new B());
tryBSink(sink);
}
void tryASink(ASink sink) {
try { sink.take(new C()); }
catch (ClassCastException e) {
throw new AssertionError("Unexpected cast failure: " + e + " " + lastMFParams());
}
try {
sink.take(new B());
throw new AssertionError("Missing cast from A to C: " + lastMFParams());
}
catch (ClassCastException e) { /* expected */ }
try {
sink.take(new NotC());
throw new AssertionError("Missing cast from A to C: " + lastMFParams());
}
catch (ClassCastException e) { /* expected */ }
}
void tryBSink(BSink sink) {
try { sink.take(new C()); }
catch (ClassCastException e) {
throw new AssertionError("Unexpected cast failure: " + e + " " + lastMFParams());
}
try {
sink.take(new B());
throw new AssertionError("Missing cast from B to C: " + lastMFParams());
}
catch (ClassCastException e) { /* expected */ }
try {
sink.take(new NotC());
throw new AssertionError("Missing cast from B to C: " + lastMFParams());
}
catch (ClassCastException e) { /* expected */ }
}
MethodHandle lastMH;
Class<?>[] lastCaptured;
MethodType lastInstMT;
MethodType lastSamMT;
MethodType[] lastBridgeMTs;
String lastMFParams() {
return "mh=" + lastMH +
", captured=" + Arrays.toString(lastCaptured) +
", instMT=" + lastInstMT +
", samMT=" + lastSamMT +
", bridgeMTs=" + Arrays.toString(lastBridgeMTs);
}
CallSite invokeMetafactory(MethodHandle mh, Class<?> sam, String methodName,
Class<?>[] captured, MethodType instMT, MethodType samMT) {
lastMH = mh;
lastCaptured = captured;
lastInstMT = instMT;
lastSamMT = samMT;
lastBridgeMTs = new MethodType[]{};
try {
return LambdaMetafactory.metafactory(lookup, methodName, methodType(sam, captured),
samMT, mh, instMT);
}
catch (LambdaConversionException e) {
// unexpected linkage error
throw new RuntimeException(e);
}
}
CallSite invokeAltMetafactory(MethodHandle mh, Class<?> sam, String methodName,
Class<?>[] captured, MethodType instMT,
MethodType samMT, MethodType... bridgeMTs) {
lastMH = mh;
lastCaptured = captured;
lastInstMT = instMT;
lastSamMT = samMT;
lastBridgeMTs = bridgeMTs;
try {
boolean bridge = bridgeMTs.length > 0;
Object[] args = new Object[bridge ? 5+bridgeMTs.length : 4];
args[0] = samMT;
args[1] = mh;
args[2] = instMT;
args[3] = bridge ? LambdaMetafactory.FLAG_BRIDGES : 0;
if (bridge) {
args[4] = bridgeMTs.length;
for (int i = 0; i < bridgeMTs.length; i++) args[5+i] = bridgeMTs[i];
}
return LambdaMetafactory.altMetafactory(lookup, methodName, methodType(sam, captured), args);
}
catch (LambdaConversionException e) {
// unexpected linkage error
throw new RuntimeException(e);
}
}
}