Conflicting code reflection fields for method overrides

Reviewed-by: mcimadamore, psandoz

Author: asotona

src/java.base/share/classes/java/lang/reflect/Method.java

@@ -54,6 +54,7 @@
 import java.util.StringJoiner;
 
 import static java.lang.reflect.code.op.CoreOp.*;
+import java.lang.reflect.code.type.MethodRef;
 
 /**
  * A {@code Method} provides information about, and access to, a single method
@@ -277,7 +278,13 @@ public Optional<FuncOp> getCodeModel() {
 
     private Optional<FuncOp> createCodeModel() {
         Class<?> dc = getDeclaringClass();
-        String fieldName = getName() + "$" + "op";
+        char[] sig = MethodRef.method(this).toString().toCharArray();
+        for (int i = 0; i < sig.length; i++) {
+            switch (sig[i]) {
+                case '.', ';', '[', '/': sig[i] = '$';
+            }
+        }
+        String fieldName = new String(sig) + "$" + "op";
         Field f;
         try {
             f = dc.getDeclaredField(fieldName);

src/jdk.compiler/share/classes/com/sun/tools/javac/comp/ReflectMethods.java

@@ -191,7 +191,7 @@ public void visitMethodDef(JCMethodDecl tree) {
                 }
                 // create a static final field holding the op' string text.
                 // The name of the field is foo$op, where 'foo' is the name of the corresponding method.
-                classOps.add(opFieldDecl(tree.name, tree.getModifiers().flags, funcOp));
+                classOps.add(opFieldDecl(methodName(bodyScanner.symbolToErasedMethodRef(tree.sym)), tree.getModifiers().flags, funcOp));
             } catch (UnsupportedASTException ex) {
                 // whoops, some AST node inside the method body were not supported. Log it and move on.
                 log.note(ex.tree, Notes.MethodIrSkip(tree.sym.enclClass(), tree.sym, ex.tree.getTag().toString()));
@@ -354,6 +354,16 @@ Name lambdaName() {
         return names.fromString("lambda").append('$', names.fromString(String.valueOf(lambdaCount++)));
     }
 
+    Name methodName(MethodRef method) {
+        char[] sigCh = method.toString().toCharArray();
+        for (int i = 0; i < sigCh.length; i++) {
+            switch (sigCh[i]) {
+                case '.', ';', '[', '/' -> sigCh[i] = '$';
+            }
+        }
+        return names.fromChars(sigCh, 0, sigCh.length);
+    }
+
     private JCVariableDecl opFieldDecl(Name prefix, long flags, CoreOp.FuncOp op) {
         VarSymbol opFieldSym = new VarSymbol(flags | Flags.STATIC | Flags.FINAL | Flags.SYNTHETIC,
                 prefix.append('$', names.fromString("op")),

test/jdk/java/lang/reflect/code/TestOverloads.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2024, 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.
+ */
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+import org.testng.annotations.DataProvider;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.code.interpreter.Interpreter;
+import java.lang.reflect.code.op.CoreOp;
+import java.lang.runtime.CodeReflection;
+import java.util.*;
+import java.util.stream.Stream;
+
+/*
+ * @test
+ * @run testng TestOverloads
+ */
+
+public class TestOverloads {
+
+    @CodeReflection
+    static int f() {
+       return 0;
+    }
+
+    @CodeReflection
+    static int f(int i) {
+       return 1;
+    }
+
+    @CodeReflection
+    static int f(Integer i) {
+       return 2;
+    }
+
+    @CodeReflection
+    static int f(Object o) {
+       return 3;
+    }
+
+    @CodeReflection
+    static int f(List<Integer> l) {
+       return 4;
+    }
+
+    @CodeReflection
+    static int f(List<Integer> l, Object o) {
+       return 5;
+    }
+
+    @DataProvider(name = "testData")
+    public static Object[][]  testData() {
+        return new Object[][]{
+            new Object[] {new Class[]{}, new Object[]{}},
+            new Object[] {new Class[]{int.class}, new Object[]{-1}},
+            new Object[] {new Class[]{Integer.class}, new Object[]{-1}},
+            new Object[] {new Class[]{Object.class}, new Object[]{"hello"}},
+            new Object[] {new Class[]{List.class}, new Object[]{List.of()}},
+            new Object[] {new Class[]{List.class, Object.class}, new Object[]{List.of(), -1}}
+        };
+    }
+
+    @Test(dataProvider = "testData")
+    public static void testOverloads(Class<?>[] paramTypes, Object[] params) {
+        try {
+            Class<TestOverloads> clazz = TestOverloads.class;
+            Method method = clazz.getDeclaredMethod("f", paramTypes);
+            CoreOp.FuncOp f = method.getCodeModel().orElseThrow();
+            var res1 = Interpreter.invoke(MethodHandles.lookup(), f, params);
+            var res2 = method.invoke(null, params);
+
+            Assert.assertEquals(res1, res2);
+
+        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

test/jdk/java/lang/reflect/code/TestTryFinally.java

@@ -168,7 +168,7 @@ public static void finallyReturn(IntConsumer c) {
     }
 
     @Test
-    public void finallyReturn() {
+    public void testFinallyReturn() {
         CoreOp.FuncOp f = getFuncOp("finallyReturn");
 
         f.writeTo(System.out);

test/jdk/java/lang/reflect/code/bytecode/TestTryFinally.java

@@ -158,7 +158,7 @@ public static void finallyReturn(IntConsumer c) {
     }
 
     @Test
-    public void finallyReturn() {
+    public void testFinallyReturn() {
         CoreOp.FuncOp f = getFuncOp("finallyReturn");
 
         MethodHandle mh = generate(f);