Fix for issue #166: build path access rules applied to types throughout

eric-milles · eric-milles · commit fb749304336b · 2017-01-29T15:40:46.000-06:00
diff --git a/base-test/org.eclipse.jdt.groovy.core.tests.builder/src/org/eclipse/jdt/core/groovy/tests/builder/BuildAccessRulesTests.java b/base-test/org.eclipse.jdt.groovy.core.tests.builder/src/org/eclipse/jdt/core/groovy/tests/builder/BuildAccessRulesTests.java
@@ -15,6 +15,9 @@
  */
 package org.eclipse.jdt.core.groovy.tests.builder;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import junit.framework.Test;
 
 import org.codehaus.groovy.eclipse.core.builder.GroovyClasspathContainer;
@@ -64,25 +67,143 @@ protected void setUp() throws Exception {
         env.createFolder(src);
     }
 
-    //
+    private void assertAccessRestriction(String source, String... types) {
+        IPath foo = env.addGroovyClass(src, "Foo", source);
+        fullBuild();
+
+        // read back contents in case of line delimeters change or package statement addition or ...
+        source = env.readTextFile(foo);
+
+        List<String> problems = new ArrayList<String>();
+        for (String type : types) {
+            int offset = -1;
+            while ((offset = source.indexOf(type.trim(), offset + 1)) != -1) {
+                problems.add("Problem : Access restriction: The type '" + type.trim() + "' is not API (restriction on required library '##')" +
+                    " [ resource : </Project/src/Foo.groovy> range : <" + offset + "," + (offset + type.length()) + "> category : <150> severity : <2>]");
+            }
+        }
+
+        expectingProblemsFor(foo, problems);
+    }
+
+    //--------------------------------------------------------------------------
+
+    public void testAccessForImport() {
+        String source = "import java.beans.BeanDescriptor";
+
+        assertAccessRestriction(source, "BeanDescriptor");
+    }
 
     public void testAccessForExtends() {
-        env.addGroovyClass(src, "Foo",
-            "import java.beans.*\n" +
-            "class Foo extends BeanDescriptor {}");
-        fullBuild();
+        String source = "import java.beans.*\n" +
+            "class Foo extends BeanDescriptor {}";
 
-        expectingProblemsFor(src.append("Foo.groovy"), "Problem : Access restriction: The type 'BeanDescriptor' is not API" +
-            " (restriction on required library '##') [ resource : </Project/src/Foo.groovy> range : <38,52> category : <150> severity : <2>]");
+        assertAccessRestriction(source, "BeanDescriptor");
     }
 
     public void testAccessForImplements() {
-        env.addGroovyClass(src, "Foo",
-            "import java.beans.*\n" +
-            "abstract class Foo implements BeanInfo {}");
-        fullBuild();
+        String source = "import java.beans.*\n" +
+            "abstract class Foo implements BeanInfo {}";
+
+        assertAccessRestriction(source, "BeanInfo "); // interface has +1 sloc...
+    }
+
+    public void testAccessForExtendsGenerics() {
+        String source = "import java.beans.*\n" +
+            "class Foo extends ArrayList<BeanDescriptor> {}";
+
+        assertAccessRestriction(source, "BeanDescriptor");
+    }
+
+    public void testAccessForImplementsGenerics() {
+        String source = "import java.beans.*\n" +
+            "abstract class Foo implements List<BeanInfo> {}";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForField() {
+        String source = "import java.beans.*\n" +
+            "class Foo { private BeanInfo info }";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForProperty() {
+        String source = "import java.beans.*\n" +
+            "class Foo { BeanInfo info }";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForFieldGenerics() {
+        String source = "import java.beans.*\n" +
+            "class Foo { private List<BeanInfo> info }";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForPropertyGenerics() {
+        String source = "import java.beans.*\n" +
+            "class Foo { List<BeanInfo> info }";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForLazyProperty() {
+        String source = "import java.beans.*\n" +
+            "abstract class Foo {\n" +
+            "  @Lazy BeanInfo info = init()\n" +
+            "  abstract def init()\n" +
+            "}";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForMethodParameter() {
+        String source = "import java.beans.*\n" +
+            "class Foo {\n" +
+            "  def meth(BeanInfo info) { }\n" +
+            "}";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForMethodReturnType() {
+        String source = "import java.beans.*\n" +
+            "class Foo {\n" +
+            "  BeanInfo meth() { }\n" +
+            "}";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForMethodParameterGenerics() {
+        String source = "import java.beans.*\n" +
+            "class Foo {\n" +
+            "  def meth(List<BeanInfo> info) { }\n" +
+            "  }";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForMethodReturnTypeGenerics() {
+        String source = "import java.beans.*\n" +
+            "class Foo {\n" +
+            "  List<BeanInfo> meth() { }\n" +
+            "}";
+
+        assertAccessRestriction(source, "BeanInfo");
+    }
+
+    public void testAccessForLocalVariable() {
+        String source = "import java.beans.*\n" +
+            "class Foo {\n" +
+            "  def meth() {\n" +
+            "    BeanInfo info = null\n" +
+            "  }\n" +
+            "}";
 
-        expectingProblemsFor(src.append("Foo.groovy"), "Problem : Access restriction: The type 'BeanInfo' is not API" +
-            " (restriction on required library '##') [ resource : </Project/src/Foo.groovy> range : <50,59> category : <150> severity : <2>]");
+        assertAccessRestriction(source, "BeanInfo");
     }
 }
diff --git a/base/org.eclipse.jdt.groovy.core/src/org/codehaus/jdt/groovy/internal/compiler/ast/JDTClassNode.java b/base/org.eclipse.jdt.groovy.core/src/org/codehaus/jdt/groovy/internal/compiler/ast/JDTClassNode.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2009-2016 the original author or authors.
+ * Copyright 2009-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -68,18 +68,16 @@
 import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
 
 /**
- * Groovy can use these to ask questions of JDT bindings. They are only built as required (as groovy references to java files are
- * resolved). They remain uninitialized until groovy starts digging into them - at that time the details are filled in (eg.
- * members).
- *
- * @author Andy Clement
+ * Groovy can use these to ask questions of JDT bindings. They are only built as
+ * required (as groovy references to java files are resolved). They remain
+ * uninitialized until groovy starts digging into them - at that time the details
+ * are filled in (eg. members).
  */
 public class JDTClassNode extends ClassNode implements JDTNode {
 
     private static final Parameter[] NO_PARAMETERS = new Parameter[0];
 
-    // arbitrary choice of first eight. Maintaining these as a constant array prevents 10000 strings called 'arg0' consuming
-    // memory
+    // arbitrary choice of first eight; maintaining these as a constant array prevents 10000 strings called 'arg0' consuming memory
     private final static String[] argNames = new String[] { "arg0", "arg1", "arg2", "arg3", "arg4", "arg5", "arg6", "arg7" };
 
     // The binding which this JDTClassNode represents
@@ -402,25 +400,17 @@ private Parameter makeParameter(TypeBinding parameterType, int paramNumber) {
     }
 
     /**
-     *
-     * @param type
-     * @param cl erasure of type
-     * @return
+     * @param t type
+     * @param c erasure of type
      */
     private ClassNode makeClassNode(TypeBinding t, TypeBinding c) {
-        // was:
-        // return resolver.convertToClassNode(type);
-        ClassNode back = null;
-        // This line would check the compile unit
-        // if (cu != null) back = cu.getClass(c.getName());
-        if (back == null)
-            back = resolver.convertToClassNode(c);// ClassHelper.make(c);
+        ClassNode back = resolver.convertToClassNode(c);
         if (!((t instanceof BinaryTypeBinding) || (t instanceof SourceTypeBinding))) {
             ClassNode front = JDTClassNodeBuilder.build(this.resolver, t);
             front.setRedirect(back);
             return front;
         }
-        return back;// .getPlainNodeReference();
+        return back;
     }
 
     public GenericsType[] getGenericsTypes() {
@@ -455,7 +445,6 @@ private ConstructorNode constructorBindingToConstructorNode(MethodBinding method
             }
         }
         ctorNode = new ConstructorNode(modifiers, parameters, thrownExceptions, null);
-
         ctorNode.setGenericsTypes(generics);
         return ctorNode;
     }
@@ -503,8 +492,6 @@ private FieldNode fieldBindingToFieldNode(FieldBinding fieldBinding, TypeDeclara
         return fNode;
     }
 
-    // FIXASC Need to override anything else from the supertype?
-
     @Override
     public boolean isReallyResolved() {
         return true;
diff --git a/base/org.eclipse.jdt.groovy.core/src/org/codehaus/jdt/groovy/internal/compiler/ast/JDTResolver.java b/base/org.eclipse.jdt.groovy.core/src/org/codehaus/jdt/groovy/internal/compiler/ast/JDTResolver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2009-2016 the original author or authors.
+ * Copyright 2009-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,7 +37,9 @@
 import org.codehaus.jdt.groovy.internal.compiler.ast.GroovyParser.GrapeAwareGroovyClassLoader;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.groovy.core.util.ReflectionUtils;
+import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
 
@@ -154,6 +156,16 @@ protected boolean resolveFromModule(ClassNode type, boolean testModuleImports) {
         if (DEBUG) {
             log("resolveFromModule", type, foundit);
         }
+        if (foundit) {
+            if (type.redirect() instanceof JDTClassNode && ((JDTClassNode) type.redirect()).getJdtBinding().hasRestrictedAccess()) {
+                TypeBinding binding = ((JDTClassNode) type.redirect()).getJdtBinding();
+                AccessRestriction restriction = activeScope.environment().getAccessRestriction(binding.erasure());
+                if (restriction != null) {
+                    SingleTypeReference ref = new SingleTypeReference(type.getNameWithoutPackage().toCharArray(), ((long) type.getStart() << 32 | (long) type.getEnd() - 1));
+                    activeScope.problemReporter().forbiddenReference(binding, ref, restriction.classpathEntryType, restriction.classpathEntryName, restriction.getProblemId());
+                }
+            }
+        }
         return foundit;
     }
 
@@ -435,11 +447,12 @@ private JDTClassNode checkForExisting(TypeBinding jdtBinding) {
     }
 
     /**
-     * Creates a Groovy ClassNode that represents the JDT TypeBinding. Build the basic structure, mark it as 'in progress' and then
-     * continue with initialization. This allows self referential generic declarations.
+     * Creates a Groovy ClassNode that represents the JDT TypeBinding. Steps
+     * include building the basic structure, marking node as 'in progress' and
+     * continuing with initialization. This allows self-referential generics.
      *
      * @param jdtBinding the JDT binding for which to create a ClassNode
-     * @return the new ClassNode, of type JDTClassNode
+     * @return a {@link JDTClassNode}
      */
     private ClassNode createJDTClassNode(TypeBinding jdtBinding) {
         JDTClassNodeBuilder cnb = new JDTClassNodeBuilder(this);
@@ -449,7 +462,8 @@ private ClassNode createJDTClassNode(TypeBinding jdtBinding) {
             assert !inProgress.containsKey(jdtBinding);
             inProgress.put(jdtBinding, jdtNode);
 
-            jdtNode.setupGenerics(); // for a BinaryTypeBinding this fixes up those generics
+            // fix up generics for BinaryTypeBinding
+            jdtNode.setupGenerics();
 
             assert nodeCache.get(jdtBinding) == null : "not unique";
             nodeCache.put(jdtBinding, jdtNode);
