Fix for #1378: super class private methods (GROOVY-8999, GROOVY-9851)

Author: eric-milles

base-test/org.eclipse.jdt.groovy.core.tests.builder/src/org/eclipse/jdt/core/groovy/tests/search/InferencingTests.java

@@ -1642,7 +1642,7 @@ public void testSuperClassMethod3() {
             "  protected void method() {}\n" +
             "}\n" +
             "class B extends A {\n" +
-            "  void something() {\n" +
+            "  void test() {\n" +
             "    method()\n" +
             "  }\n" +
             "}\n";
@@ -1656,7 +1656,7 @@ public void testSuperClassMethod4() {
             "  private void method() {}\n" +
             "}\n" +
             "class B extends A {\n" +
-            "  void something() {\n" +
+            "  void test() {\n" +
             "    method()\n" +
             "  }\n" +
             "}\n";
@@ -1670,25 +1670,29 @@ public void testSuperClassMethod4a() {
             "  private void method() {}\n" +
             "}\n" +
             "class B extends A {\n" +
-            "  void something() {\n" +
+            "  void test() {\n" +
             "    this.method()\n" +
             "  }\n" +
             "}\n";
         assertUnknown(contents, "method");
     }
 
-    @Test
+    @Test // https://github.com/groovy/groovy-eclipse/issues/1378
     public void testSuperClassMethod4b() {
         String contents =
             "class A {\n" +
             "  private void method() {}\n" +
             "}\n" +
             "class B extends A {\n" +
-            "  void something() {\n" +
-            "    super.method()\n" + // this is ok
+            "  void test() {\n" +
+            "    super.method()\n" + // GROOVY-9851
             "  }\n" +
             "}\n";
-        assertDeclaringType(contents, "method", "A");
+        if (isAtLeastGroovy(40)) {
+            assertUnknown(contents, "method");
+        } else {
+            assertDeclaringType(contents, "method", "A");
+        }
     }
 
     @Test
@@ -1698,11 +1702,11 @@ public void testSuperClassMethod4c() {
             "  private void method() {}\n" +
             "}\n" +
             "class B extends A {\n" +
-            "  void something() {\n" +
-            "    super.&method\n" + // GROOVY-8999: resolves to MethodClosure, but it NPEs when called
+            "  void test() {\n" +
+            "    super.&method\n" + // GROOVY-9851: resolves to MethodClosure, but it fails when called
             "  }\n" +
             "}\n";
-        assertDeclaringType(contents, "method", "A");
+        assertUnknown(contents, "method");
     }
 
     @Test

base/org.eclipse.jdt.groovy.core/src/org/eclipse/jdt/groovy/search/SimpleTypeLookup.java

@@ -397,7 +397,7 @@ protected TypeLookupResult findTypeForNameWithKnownObjectExpression(final String
                     if (isStaticObjectExpression && !field.isStatic()) {
                         confidence = TypeConfidence.UNKNOWN;
                     } else if (field.isPrivate()) {
-                        // "super.field" reference to private field yields MissingMethodException
+                        // "super.field" reference to private field yields MissingPropertyException
                         if (isSuperObjectExpression(scope)) {
                             confidence = TypeConfidence.UNKNOWN;
                         // "this.field" reference to private field of super class yields MissingPropertyException
@@ -417,9 +417,16 @@ protected TypeLookupResult findTypeForNameWithKnownObjectExpression(final String
                     MethodNode method = (MethodNode) declaration;
                     if (isStaticObjectExpression && !method.isStatic() && !isStaticReferenceToInstanceMethod(scope)) {
                         confidence = TypeConfidence.UNKNOWN;
-                    } else if (method.isPrivate() && isThisObjectExpression(scope) && isNotThisOrOuterClass(declaringType, resolvedDeclaringType)) {
-                        // "this.method()" reference to private method of super class yields MissingMethodException; "super.method()" is okay
-                        confidence = TypeConfidence.UNKNOWN;
+                    } else if (method.isPrivate()) {
+                        // "super.method()" reference to private method yields MissingMethodException
+                        if (isSuperObjectExpression(scope)) {
+                            if (scope.getEnclosingNode() instanceof MethodPointerExpression || // GROOVY-8999
+                                                GroovyUtils.getGroovyVersion().getMajor() > 3) // GROOVY-9851
+                                confidence = TypeConfidence.UNKNOWN;
+                        // "this.method()" reference to private method of super class yields MissingMethodException
+                        } else if (isThisObjectExpression(scope) && isNotThisOrOuterClass(declaringType, resolvedDeclaringType)) {
+                            confidence = TypeConfidence.UNKNOWN;
+                        }
                     } else if (method.getName().startsWith("is") && !name.startsWith("is") && !scope.isMethodCall() && isSuperObjectExpression(scope) && GroovyUtils.getGroovyVersion().getMajor() < 4) {
                         // GROOVY-1736, GROOVY-6097: "super.name" => "super.getName()" in AsmClassGenerator
                         String newName = "get" + MetaClassHelper.capitalize(name);
@@ -1102,6 +1109,9 @@ protected static Expression getObjectExpression(final VariableScope scope) {
         if (node instanceof MethodCallExpression) {
             return ((MethodCallExpression) node).getObjectExpression();
         }
+        if (node instanceof MethodPointerExpression) {
+            return ((MethodPointerExpression) node).getExpression();
+        }
         return null;
     }