[GR-5496] Fix method overload selection with covariant return type overrides and bridge methods.

PullRequest: graal/405

Author: woess

truffle/src/com.oracle.truffle.api.interop.java.test/src/com/oracle/truffle/api/interop/java/test/OverloadedTest.java

@@ -138,6 +138,30 @@ public void testOverloadingNumber() throws InteropException {
         assertEquals("BigInteger", num.parameter);
     }
 
+    public interface Identity<T> {
+        T getId();
+    }
+
+    public interface SomeThingWithIdentity extends Identity<Integer> {
+        @Override
+        Integer getId();
+    }
+
+    public static class ActualRealThingWithIdentity implements SomeThingWithIdentity {
+        Integer id = 42;
+
+        @Override
+        public Integer getId() {
+            return id;
+        }
+    }
+
+    @Test
+    public void testGenericReturnTypeBridgeMethod() throws InteropException {
+        TruffleObject thing = JavaInterop.asTruffleObject(new ActualRealThingWithIdentity());
+        assertEquals(42, ForeignAccess.sendInvoke(Message.createInvoke(0).createNode(), thing, "getId"));
+    }
+
     @MessageResolution(receiverType = UnboxableToInt.class)
     public static final class UnboxableToInt implements TruffleObject {
 

truffle/src/com.oracle.truffle.api.interop.java/src/com/oracle/truffle/api/interop/java/JavaClassDesc.java

@@ -89,25 +89,9 @@ public JavaMethodDesc apply(JavaMethodDesc m1, JavaMethodDesc m2) {
             JavaMethodDesc ctor = null;
             JavaMethodDesc functionalInterfaceMethod = null;
 
-            if (Modifier.isPublic(type.getModifiers())) {
-                for (Method m : type.getMethods()) {
-                    if (!Modifier.isPublic(m.getDeclaringClass().getModifiers())) {
-                        /*
-                         * If a method is declared in a non-public direct superclass, there should
-                         * be a public bridge method in this class that provides access to it.
-                         *
-                         * In some more elaborate class hierarchies, or if the method is declared in
-                         * an interface (i.e. a default method), no bridge method is generated, so
-                         * search the whole inheritance hierarchy for accessible methods.
-                         */
-                        methodMap.clear();
-                        staticMethodMap.clear();
-                        collectPublicMethods(type, methodMap, staticMethodMap);
-                        break;
-                    }
-                    putMethod(m, methodMap, staticMethodMap);
-                }
+            collectPublicMethods(type, methodMap, staticMethodMap);
 
+            if (Modifier.isPublic(type.getModifiers())) {
                 boolean inheritedPublicInstanceFields = false;
                 boolean inheritedPublicInaccessibleFields = false;
                 for (Field f : type.getFields()) {
@@ -133,9 +117,6 @@ public JavaMethodDesc apply(JavaMethodDesc m1, JavaMethodDesc m2) {
                     collectPublicInstanceFields(type, fieldMap, inheritedPublicInaccessibleFields);
                 }
             } else {
-                // If the class is not public, look for inherited public methods.
-                collectPublicMethods(type, methodMap, staticMethodMap);
-
                 if (!Modifier.isInterface(type.getModifiers())) {
                     collectPublicInstanceFields(type, fieldMap, true);
                 }
@@ -177,6 +158,14 @@ private static void collectPublicMethods(Class<?> type, Map<String, JavaMethodDe
             if (isPublicType) {
                 for (Method m : type.getMethods()) {
                     if (!Modifier.isPublic(m.getDeclaringClass().getModifiers())) {
+                        /*
+                         * If a method is declared in a non-public direct superclass, there should
+                         * be a public bridge method in this class that provides access to it.
+                         *
+                         * In some more elaborate class hierarchies, or if the method is declared in
+                         * an interface (i.e. a default method), no bridge method is generated, so
+                         * search the whole inheritance hierarchy for accessible methods.
+                         */
                         allMethodsPublic = false;
                         continue;
                     } else if (Modifier.isStatic(m.getModifiers()) && (m.getDeclaringClass() != startType && Modifier.isInterface(m.getDeclaringClass().getModifiers()))) {
@@ -189,6 +178,10 @@ private static void collectPublicMethods(Class<?> type, Map<String, JavaMethodDe
                     }
                 }
             }
+            /*
+             * Look for inherited public methods if the class/interface is not public or if we have
+             * seen a public method declared in a non-public class (see above).
+             */
             if (!isPublicType || !allMethodsPublic) {
                 if (type.getSuperclass() != null) {
                     collectPublicMethods(type.getSuperclass(), methodMap, staticMethodMap, visited, startType);