GROOVY-11323: check interfaces for possible public method

3_0_X backport

Author: eric-milles

src/main/java/org/codehaus/groovy/ast/ClassNode.java

@@ -29,6 +29,7 @@
 import org.codehaus.groovy.ast.stmt.Statement;
 import org.codehaus.groovy.ast.tools.ParameterUtils;
 import org.codehaus.groovy.control.CompilePhase;
+import org.codehaus.groovy.runtime.DefaultGroovyMethods;
 import org.codehaus.groovy.transform.ASTTransformation;
 import org.codehaus.groovy.transform.GroovyASTTransformation;
 import org.codehaus.groovy.vmplugin.VMPluginFactory;
@@ -47,6 +48,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.stream.IntStream;
 
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.toList;
@@ -1276,21 +1278,16 @@ public boolean hasPossibleMethod(final String name, final Expression arguments)
     }
 
     public MethodNode tryFindPossibleMethod(final String name, final Expression arguments) {
-        if (!(arguments instanceof TupleExpression)) {
-            return null;
-        }
-
-        // TODO: this won't strictly be true when using list expansion in argument calls
-        TupleExpression args = (TupleExpression) arguments;
-        int nArgs = args.getExpressions().size();
+        List<Expression> args = arguments instanceof TupleExpression ? ((TupleExpression) arguments).getExpressions() : Collections.singletonList(arguments);
+        int nArgs = args.size(); // TODO: this isn't strictly accurate when using spread argument expansion
         MethodNode method = null;
 
         for (ClassNode cn = this; cn != null; cn = cn.getSuperClass()) {
             for (MethodNode mn : cn.getDeclaredMethods(name)) {
                 if (hasCompatibleNumberOfArgs(mn, nArgs)) {
                     boolean match = true;
                     for (int i = 0; i < nArgs; i += 1) {
-                        if (!hasCompatibleType(args, mn, i)) {
+                        if (!hasCompatibleType(args.get(i), mn, i)) {
                             match = false;
                             break;
                         }
@@ -1314,6 +1311,18 @@ public MethodNode tryFindPossibleMethod(final String name, final Expression argu
             }
         }
 
+faces:  if (method == null && DefaultGroovyMethods.asBoolean(getInterfaces())) { // GROOVY-11323
+            for (ClassNode cn : getAllInterfaces()) {
+                for (MethodNode mn : cn.getDeclaredMethods(name)) {
+                    if (mn.isPublic() && !mn.isStatic() && hasCompatibleNumberOfArgs(mn, nArgs) && (nArgs == 0
+                            || IntStream.range(0,nArgs).allMatch(i -> hasCompatibleType(args.get(i),mn,i)))) {
+                        method = mn;
+                        break faces;
+                    }
+                }
+            }
+        }
+
         return method;
     }
 
@@ -1323,10 +1332,10 @@ private static boolean hasExactMatchingCompatibleType(final MethodNode match, fi
                 || (i >= lastParamIndex && isPotentialVarArg(maybe, lastParamIndex) && match.getParameters()[i].getType().equals(maybe.getParameters()[lastParamIndex].getType().getComponentType()));
     }
 
-    private static boolean hasCompatibleType(final TupleExpression args, final MethodNode method, final int i) {
+    private static boolean hasCompatibleType(final Expression arg, final MethodNode method, final int i) {
         int lastParamIndex = method.getParameters().length - 1;
-        return (i <= lastParamIndex && args.getExpression(i).getType().isDerivedFrom(method.getParameters()[i].getType()))
-                || (i >= lastParamIndex && isPotentialVarArg(method, lastParamIndex) && args.getExpression(i).getType().isDerivedFrom(method.getParameters()[lastParamIndex].getType().getComponentType()));
+        return (i <= lastParamIndex && arg.getType().isDerivedFrom(method.getParameters()[i].getType()))
+                || (i >= lastParamIndex && isPotentialVarArg(method, lastParamIndex) && arg.getType().isDerivedFrom(method.getParameters()[lastParamIndex].getType().getComponentType()));
     }
 
     private static boolean hasCompatibleNumberOfArgs(final MethodNode method, final int nArgs) {

src/test/groovy/StaticImportTest.groovy

@@ -139,6 +139,26 @@ final class StaticImportTest extends groovy.test.GroovyTestCase {
         '''
     }
 
+    // GROOVY-11323
+    void testStaticImportAndInterfaceDefaultMethod() {
+        assertScript '''import static Bar.*
+            interface Foo {
+                default m() { 'Foo' }
+            }
+            class Bar {
+                static  m() { 'Bar' }
+            }
+
+            class Baz implements Foo {
+                void test() {
+                    assert m() == 'Foo'
+                }
+            }
+
+            new Baz().test()
+        '''
+    }
+
     void testStaticImportProperty() {
         for (imports in ['import static Foo.getX; import static Foo.setX', 'import static Foo.*']) {
             assertScript """$imports