GROOVY-3945, GROOVY-7490, GROOVY-8389, GROOVY-10329

Author: eric-milles

base-test/org.eclipse.jdt.groovy.core.tests.compiler/src/org/eclipse/jdt/groovy/core/tests/xform/StaticCompilationTests.java

@@ -1280,6 +1280,67 @@ public void testCompileStatic7363() {
         runConformTest(sources, "42");
     }
 
+    @Test
+    public void testCompileStatic7490() {
+        for (String imports : new String[] {"import static Pogo.callable_property; import static Pogo.closure_property", "import static Pogo.*"}) {
+            //@formatter:off
+            String[] sources = {
+                "Main.groovy",
+                imports + "\n" +
+                "@groovy.transform.CompileStatic\n" +
+                "void test() {\n" +
+                "  print callable_property('hello')\n" +
+                "  print closure_property(' world')\n" +
+                "}\n" +
+                "test()\n",
+
+                "Pogo.groovy",
+                "class Pogo {\n" +
+                "  static final WithCall callable_property = new WithCall()\n" +
+                "  static final Closure closure_property = { return it }\n" +
+                "}\n",
+
+                "WithCall.groovy",
+                "class WithCall {\n" +
+                "  String call(String input) {\n" +
+                "    return input\n" +
+                "  }\n" +
+                "}\n",
+            };
+            //@formatter:on
+
+            runConformTest(sources, "hello world");
+        }
+    }
+
+    @Test
+    public void testCompileStatic7490a() {
+        //@formatter:off
+        String[] sources = {
+            "Main.groovy",
+            "@groovy.transform.CompileStatic\n" +
+            "void test() {\n" +
+            "  print Pogo.callable_property.call('works')\n" + // TODO:5881,6324
+            "}\n" +
+            "test()\n",
+
+            "Pogo.groovy",
+            "class Pogo {\n" +
+            "  static final WithCall callable_property = new WithCall()\n" +
+            "}\n",
+
+            "WithCall.groovy",
+            "class WithCall {\n" +
+            "  String call(String input) {\n" +
+            "    return input\n" +
+            "  }\n" +
+            "}\n",
+        };
+        //@formatter:on
+
+        runConformTest(sources, "works");
+    }
+
     @Test
     public void testCompileStatic7526() {
         //@formatter:off
@@ -2047,27 +2108,28 @@ public void testCompileStatic8389() {
 
     @Test
     public void testCompileStatic8389a() {
-        //@formatter:off
-        String[] sources = {
-            "Main.groovy",
-            "import static Foo.bar\n" +
-            "import static Foo.baz\n" +
-            "class Foo {\n" +
-            "  static Closure<String> bar = { -> 'property' }\n" +
-            "  static Closure<String> baz = { -> 'property' }\n" +
-            "}\n" +
-            "String bar() {\n" +
-            "  'method'\n" +
-            "}\n" +
-            "@groovy.transform.CompileStatic\n" +
-            "def test() {\n" +
-            "  bar() + ':' + baz.call()\n" + // TODO: Should this work without ".call"?
-            "}\n" +
-            "print test()\n",
-        };
-        //@formatter:on
+        for (String imports : new String[] {"import static Foo.bar; import static Foo.baz", "import static Foo.*"}) {
+            //@formatter:off
+            String[] sources = {
+                "Main.groovy",
+                imports + "\n" +
+                "class Foo {\n" +
+                "  static Closure<String> bar = { -> 'property' }\n" +
+                "  static Closure<String> baz = { -> 'property' }\n" +
+                "}\n" +
+                "String bar() {\n" +
+                "  'method'\n" +
+                "}\n" +
+                "@groovy.transform.CompileStatic\n" +
+                "def test() {\n" +
+                "  bar() + ':' + baz()\n" +
+                "}\n" +
+                "print test()\n",
+            };
+            //@formatter:on
 
-        runConformTest(sources, "method:property");
+            runConformTest(sources, "method:property");
+        }
     }
 
     @Test

base/org.codehaus.groovy25/src/org/codehaus/groovy/control/StaticImportVisitor.java

@@ -480,8 +480,11 @@ private Expression findStaticMethodImportFromModule(Expression method, Expressio
             ImportNode importNode = importNodes.get(name);
             expression = findStaticMethod(importNode.getType(), importNode.getFieldName(), args);
             if (expression != null) return expression;
+            // GRECLIPSE add -- GROOVY-8389
+            if (isValidAccessorName(name)){
+            // GRECLIPSE end
             expression = findStaticPropertyAccessorGivenArgs(importNode.getType(), getPropNameForAccessor(importNode.getFieldName()), args);
-            if (expression != null) {
+            if (expression != null)
                 return newStaticMethodCallX(importNode.getType(), importNode.getFieldName(), args);
             }
         }
@@ -514,8 +517,11 @@ private Expression findStaticMethodImportFromModule(Expression method, Expressio
                 starImportType = importNode == null ? null : importNode.getType();
                 expression = findStaticMethod(starImportType, name, args);
                 if (expression != null) return expression;
+                // GRECLIPSE add -- GROOVY-8389
+                if (isValidAccessorName(name)){
+                // GRECLIPSE end
                 expression = findStaticPropertyAccessorGivenArgs(starImportType, getPropNameForAccessor(name), args);
-                if (expression != null) {
+                if (expression != null)
                     return newStaticMethodCallX(starImportType, name, args);
                 }
             }

base/org.codehaus.groovy30/src/org/codehaus/groovy/control/StaticImportVisitor.java

@@ -497,8 +497,11 @@ private Expression findStaticMethodImportFromModule(Expression method, Expressio
             ImportNode importNode = importNodes.get(name);
             expression = findStaticMethod(importNode.getType(), importNode.getFieldName(), args);
             if (expression != null) return expression;
+            // GRECLIPSE add -- GROOVY-8389
+            if (isValidAccessorName(name)){
+            // GRECLIPSE end
             expression = findStaticPropertyAccessorGivenArgs(importNode.getType(), getPropNameForAccessor(importNode.getFieldName()), args);
-            if (expression != null) {
+            if (expression != null)
                 return newStaticMethodCallX(importNode.getType(), importNode.getFieldName(), args);
             }
         }
@@ -531,8 +534,11 @@ private Expression findStaticMethodImportFromModule(Expression method, Expressio
                 starImportType = importNode == null ? null : importNode.getType();
                 expression = findStaticMethod(starImportType, name, args);
                 if (expression != null) return expression;
+                // GRECLIPSE add -- GROOVY-8389
+                if (isValidAccessorName(name)){
+                // GRECLIPSE end
                 expression = findStaticPropertyAccessorGivenArgs(starImportType, getPropNameForAccessor(name), args);
-                if (expression != null) {
+                if (expression != null)
                     return newStaticMethodCallX(starImportType, name, args);
                 }
             }

base/org.codehaus.groovy40/src/org/codehaus/groovy/control/StaticImportVisitor.java

@@ -205,9 +205,7 @@ protected Expression transformBinaryExpression(BinaryExpression be) {
             if (left instanceof StaticMethodCallExpression) {
                 StaticMethodCallExpression smce = (StaticMethodCallExpression) left;
                 StaticMethodCallExpression result = new StaticMethodCallExpression(smce.getOwnerType(), smce.getMethod(), right);
-                // GRECLIPSE add
                 result.copyNodeMetaData(smce);
-                // GRECLIPSE end
                 setSourcePosition(result, be);
                 return result;
             }
@@ -263,14 +261,6 @@ protected Expression transformMethodCallExpression(MethodCallExpression mce) {
                     setSourcePosition(result, mce);
                     return result;
                 }
-                if (name != null && !inLeftExpression) { // maybe a closure field
-                    result = findStaticFieldOrPropertyAccessorImportFromModule(name);
-                    if (result != null) {
-                        result = new MethodCallExpression(result, "call", args);
-                        result.setSourcePosition(mce);
-                        return result;
-                    }
-                }
             }
         } else if (currentMethod != null && currentMethod.isStatic() && isSuperExpression(object)) {
             Expression result = new MethodCallExpression(new ClassExpression(currentClass.getSuperClass()), method, args);
@@ -446,59 +436,91 @@ private Expression findStaticFieldOrPropertyAccessorImportFromModule(String name
     }
 
     private Expression findStaticMethodImportFromModule(Expression method, Expression args) {
-        ModuleNode module = currentClass.getModule();
-        if (module == null || !(method instanceof ConstantExpression)) return null;
-        Map<String, ImportNode> importNodes = module.getStaticImports();
-        ConstantExpression ce = (ConstantExpression) method;
+        if (currentClass.getModule() == null) return null;
+        if (!(method instanceof ConstantExpression)) return null;
+        if (!(((ConstantExpression) method).getValue() instanceof String)) return null;
+
         Expression expression;
-        Object value = ce.getValue();
-        // skip non-Strings, e.g. Integer
-        if (!(value instanceof String)) return null;
-        final String name = (String) value;
+        String name = method.getText();
+        Map<String, ImportNode> staticImports = currentClass.getModule().getStaticImports();
         // look for one of these:
-        //   import static SomeClass.method [as otherName]
-        // when resolving methodCall() or getProp() or setProp()
-        if (importNodes.containsKey(name)) {
-            ImportNode importNode = importNodes.get(name);
+        //   import static MyClass.field [as alias]
+        //   import static MyClass.method [as alias]
+        //   import static MyClass.property [as alias]
+        // when resolving implicit-this call name(args)
+        if (staticImports.containsKey(name)) {
+            ImportNode importNode = staticImports.get(name);
             expression = findStaticMethod(importNode.getType(), importNode.getFieldName(), args);
-            if (expression != null) return expression;
-            expression = findStaticPropertyAccessorGivenArgs(importNode.getType(), getPropNameForAccessor(importNode.getFieldName()), args);
             if (expression != null) {
-                return newStaticMethodCallX(importNode.getType(), importNode.getFieldName(), args);
+                return expression;
+            }
+            if (!inClosure && !inLeftExpression) {
+                expression = findStaticPropertyOrField(importNode.getType(), importNode.getFieldName());
+                if (expression != null) { // assume name refers to a callable static field/property
+                    MethodCallExpression call = new MethodCallExpression(expression, "call", args);
+                    call.setImplicitThis(false);
+                    return call;
+                }
             }
         }
         // look for one of these:
-        //   import static SomeClass.someProp [as otherName]
-        // when resolving getProp() or setProp()
-        if (isValidAccessorName(name)) {
-            String propName = getPropNameForAccessor(name);
-            if (importNodes.containsKey(propName)) {
-                ImportNode importNode = importNodes.get(propName);
-                ClassNode importClass = importNode.getType();
+        //   import static MyClass.property [as alias]
+        //   import static MyClass.isProperty [as alias]
+        //   import static MyClass.getProperty [as alias]
+        //   import static MyClass.setProperty [as alias]
+        // when resolving isName(), getName() or setName(args)
+        boolean accessor = isValidAccessorName(name);
+        if (accessor) {
+            ImportNode importNode = staticImports.get(name);
+            if (importNode != null) {
+                String propName = getPropNameForAccessor(importNode.getFieldName());
+                expression = findStaticPropertyAccessorGivenArgs(importNode.getType(), propName, args);
+                if (expression != null) { // expression may refer to getter or setter, so make new call
+                    return newStaticMethodCallX(importNode.getType(), importNode.getFieldName(), args);
+                }
+            }
+            importNode = staticImports.get(getPropNameForAccessor(name));
+            if (importNode != null) {
+                ClassNode importType = importNode.getType();
                 String importMember = importNode.getFieldName();
-                expression = findStaticMethod(importClass, prefix(name) + capitalize(importMember), args);
+                expression = findStaticMethod(importType, prefix(name) + capitalize(importMember), args);
                 if (expression != null) return expression;
-                expression = findStaticPropertyAccessorGivenArgs(importClass, importMember, args);
+                expression = findStaticPropertyAccessorGivenArgs(importType, importMember, args);
                 if (expression != null) {
-                    return newStaticMethodCallX(importClass, prefix(name) + capitalize(importMember), args);
+                    return newStaticMethodCallX(importType, prefix(name) + capitalize(importMember), args);
                 }
             }
         }
-        Map<String, ImportNode> starImports = module.getStaticStarImports();
-        ClassNode starImportType;
-        if (currentClass.isEnum() && starImports.containsKey(currentClass.getName())) {
-            ImportNode importNode = starImports.get(currentClass.getName());
-            starImportType = importNode == null ? null : importNode.getType();
-            expression = findStaticMethod(starImportType, name, args);
+
+        Map<String, ImportNode> staticStarImports = currentClass.getModule().getStaticStarImports();
+        if (currentClass.isEnum() && staticStarImports.containsKey(currentClass.getName())) {
+            ImportNode importNode = staticStarImports.get(currentClass.getName());
+            expression = findStaticMethod(importNode.getType(), name, args);
             return expression;
-        } else {
-            for (ImportNode importNode : starImports.values()) {
-                starImportType = importNode == null ? null : importNode.getType();
-                expression = findStaticMethod(starImportType, name, args);
-                if (expression != null) return expression;
-                expression = findStaticPropertyAccessorGivenArgs(starImportType, getPropNameForAccessor(name), args);
-                if (expression != null) {
-                    return newStaticMethodCallX(starImportType, name, args);
+        }
+        // look for one of these:
+        //   import static MyClass.*
+        // when resolving name(args), getName(), etc.
+        for (ImportNode importNode : staticStarImports.values()) {
+            ClassNode importType = importNode.getType();
+            expression = findStaticMethod(importType, name, args);
+            if (expression != null) return expression;
+            if (!inClosure && !inLeftExpression) { // GROOVY-10329
+                expression = findStaticPropertyOrField(importType, name);
+                if (expression != null) { // assume name refers to a callable static field/property
+                    MethodCallExpression call = new MethodCallExpression(expression, "call", args);
+                    call.setImplicitThis(false);
+                    // GRECLIPSE add
+                    expression.setSourcePosition(method);
+                    // GRECLIPSE end
+                    return call;
+                }
+            }
+            if (accessor) {
+                String propName = getPropNameForAccessor(name);
+                expression = findStaticPropertyAccessorGivenArgs(importType, propName, args);
+                if (expression != null) { // expression may refer to getter or setter, so ...
+                    return newStaticMethodCallX(importType, name, args);
                 }
             }
         }
@@ -591,14 +613,14 @@ private static Expression findStaticMethod(ClassNode staticImportType, String me
         return null;
     }
 
-    private static PropertyExpression newStaticPropertyX(ClassNode type, String name) {
-        return new PropertyExpression(new ClassExpression(type.getPlainNodeReference()), name);
-    }
-
     private static StaticMethodCallExpression newStaticMethodCallX(ClassNode type, String name, Expression args) {
         return new StaticMethodCallExpression(type.getPlainNodeReference(), name, args);
     }
 
+    private static PropertyExpression newStaticPropertyX(ClassNode type, String name) {
+        return new PropertyExpression(new ClassExpression(type.getPlainNodeReference()), name);
+    }
+
     @Override
     protected SourceUnit getSourceUnit() {
         return sourceUnit;