Remove now unnecessary checks from invokeExact intrinsic.

Also rewrote tests to make sure that MethodHandle-s created via
const-method-handle and Java API behave identically. They can
be slightly different even if lookup is done in the same class
for the same method as const-method-handle can target copied
methods.

Bug: 297147201
Test: ./art/test/testrunner/testrunner.py -b --host --64
Test: ./art/test/testrunner/testrunner.py -b --jvm

Change-Id: I69cdf2c44f2838ee0e57eaa2e93a6ed5276c39fb

1 files changed, 532 insertions, 0 deletions

diff --git a/test/2277-methodhandle-invokeexact/src/ConstMethodHandleTest.java b/test/2277-methodhandle-invokeexact/src/ConstMethodHandleTest.java
new file mode 100644
index 0000000000..38b7eeb10f
--- /dev/null
+++ b/test/2277-methodhandle-invokeexact/src/ConstMethodHandleTest.java
@@ -0,0 +1,532 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import annotations.ConstantMethodHandle;
+
+import java.lang.invoke.MethodHandle;
+
+public class ConstMethodHandleTest extends AbstractInvokeExactTest {
+
+  @Override
+  void $noinline$privateMethods() throws Throwable {
+    // TODO(b/378051428): can't create const-method-handle targeting private methods of
+    // inner classes.
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "java/util/Optional",
+    fieldOrMethodName = "get",
+    descriptor = "()Ljava/lang/Object;")
+  private static MethodHandle constOptionalGet() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle optionalGet() {
+    return constOptionalGet();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "A",
+    fieldOrMethodName = "voidMethod",
+    descriptor = "()V")
+  private static MethodHandle constVoidMethod() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle voidMethod() {
+    return constVoidMethod();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "A",
+    fieldOrMethodName = "returnInt",
+    descriptor = "()I")
+  private static MethodHandle constReturnInt() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle returnInt() {
+    return constReturnInt();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "A",
+    fieldOrMethodName = "returnDouble",
+    descriptor = "()D")
+  private static MethodHandle constReturnDouble() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle returnDouble() {
+    return constReturnDouble();
+  }
+
+   @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_INTERFACE,
+    owner = "I",
+    fieldOrMethodName = "defaultMethod",
+    descriptor = "()V",
+    ownerIsInterface = true)
+  private static MethodHandle constInterfaceDefaultMethod() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle interfaceDefaultMethod() {
+    return constInterfaceDefaultMethod();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_INTERFACE,
+    owner = "I",
+    fieldOrMethodName = "overrideMe",
+    descriptor = "()V",
+    ownerIsInterface = true)
+  private static MethodHandle constOverwrittenInterfaceDefaultMethod() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle overwrittenInterfaceDefaultMethod() {
+    return constOverwrittenInterfaceDefaultMethod();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "A",
+    fieldOrMethodName = "throwException",
+    descriptor = "()V")
+  private static MethodHandle constExceptionThrowingMethod() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle exceptionThrowingMethod() {
+    return constExceptionThrowingMethod();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_STATIC,
+    owner = "A",
+    fieldOrMethodName = "staticMethod",
+    descriptor = "(LA;)Ljava/lang/String;")
+  private static MethodHandle constStaticMethod() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle staticMethod() {
+    return constStaticMethod();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(I)I")
+  private static MethodHandle constSumI() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sumI() {
+    return constSumI();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(II)I")
+  private static MethodHandle constSum2I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum2I() {
+    return constSum2I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(III)I")
+  private static MethodHandle constSum3I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum3I() {
+    return constSum3I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IIII)I")
+  private static MethodHandle constSum4I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum4I() {
+    return constSum4I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IIIII)I")
+  private static MethodHandle constSum5I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum5I() {
+    return constSum5I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IIIIII)I")
+  private static MethodHandle constSum6I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum6I() {
+    return constSum6I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IIIIIII)I")
+  private static MethodHandle constSum7I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum7I() {
+    return constSum7I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IIIIIIII)I")
+  private static MethodHandle constSum8I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum8I() {
+    return constSum8I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IIIIIIIII)I")
+  private static MethodHandle constSum9I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum9I() {
+    return constSum9I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IIIIIIIIII)I")
+  private static MethodHandle constSum10I() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum10I() {
+    return constSum10I();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IJ)J")
+  private static MethodHandle constSumIJ() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sumIJ() {
+    return constSumIJ();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IJIJ)J")
+  private static MethodHandle constSum2IJ() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum2IJ() {
+    return constSum2IJ();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IJIJIJ)J")
+  private static MethodHandle constSum3IJ() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum3IJ() {
+    return constSum3IJ();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IJIJIJIJ)J")
+  private static MethodHandle constSum4IJ() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum4IJ() {
+    return constSum4IJ();
+  }
+
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "Sums",
+    fieldOrMethodName = "sum",
+    descriptor = "(IJIJIJIJIJ)J")
+  private static MethodHandle constSum5IJ() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle sum5IJ() {
+    return constSum5IJ();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_INTERFACE,
+    owner = "Foo",
+    fieldOrMethodName = "nonDefault",
+    descriptor = "()Ljava/lang/String;",
+    ownerIsInterface = true)
+  private static MethodHandle constFooNonDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooNonDefault() {
+    return constFooNonDefault();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "FooBarImpl",
+    fieldOrMethodName = "nonDefault",
+    descriptor = "()Ljava/lang/String;")
+  private static MethodHandle constFooBarImplNonDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooBarImplNonDefault() {
+    return constFooBarImplNonDefault();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_INTERFACE,
+    owner = "Bar",
+    fieldOrMethodName = "defaultToOverride",
+    descriptor = "()Ljava/lang/String;",
+    ownerIsInterface = true)
+  private static MethodHandle constBarDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle barDefault() {
+    return constBarDefault();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_INTERFACE,
+    owner = "Foo",
+    fieldOrMethodName = "defaultToOverride",
+    descriptor = "()Ljava/lang/String;",
+    ownerIsInterface = true)
+  private static MethodHandle constFooDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooDefault() {
+    return constFooDefault();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "FooBarImpl",
+    fieldOrMethodName = "defaultToOverride",
+    descriptor = "()Ljava/lang/String;")
+  private static MethodHandle constFooBarImplDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooBarImplDefault() {
+    return constFooBarImplDefault();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_INTERFACE,
+    owner = "Foo",
+    fieldOrMethodName = "nonOverriddenDefault",
+    descriptor = "()Ljava/lang/String;",
+    ownerIsInterface = true)
+  private static MethodHandle constFooNonOverriddenDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooNonOverriddenDefault() {
+    return constFooNonOverriddenDefault();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_INTERFACE,
+    owner = "Bar",
+    fieldOrMethodName = "nonOverriddenDefault",
+    descriptor = "()Ljava/lang/String;",
+    ownerIsInterface = true)
+  private static MethodHandle constBarNonOverriddenDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle barNonOverriddenDefault() {
+    return constBarNonOverriddenDefault();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "FooBar",
+    fieldOrMethodName = "definedInAbstract",
+    descriptor = "()Ljava/lang/String;")
+  private static MethodHandle constFooBarDefinedInAbstract() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooBarDefinedInAbstract() {
+    return constFooBarDefinedInAbstract();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "FooBarImpl",
+    fieldOrMethodName = "definedInAbstract",
+    descriptor = "()Ljava/lang/String;")
+  private static MethodHandle constFooBarImplDefinedInAbstract() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooBarImplDefinedInAbstract() {
+    return constFooBarImplDefinedInAbstract();
+  }
+
+  @ConstantMethodHandle(
+    kind = ConstantMethodHandle.INVOKE_VIRTUAL,
+    owner = "FooBar",
+    fieldOrMethodName = "nonDefault",
+    descriptor = "()Ljava/lang/String;")
+  private static MethodHandle constFooBarNonDefault() {
+    unreachable("should be replaced by const-method-handle");
+    return null;
+  }
+
+  @Override
+  public MethodHandle fooBarNonDefault() {
+    return constFooBarNonDefault();
+  }
+
+}