[ 
https://issues.apache.org/jira/browse/GROOVY-11916?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18145903#comment-18145903
 ] 

ASF GitHub Bot commented on GROOVY-11916:
-----------------------------------------

blackdrag commented on code in PR #3227:
URL: https://github.com/apache/groovy/pull/3227#discussion_r4591254029


##########
src/main/java/org/codehaus/groovy/control/ResolveVisitor.java:
##########
@@ -1195,6 +1310,144 @@ protected Expression transformPropertyExpression(final 
PropertyExpression pe) {
         return isTopLevelProperty ? correctClassClassChain(xe) : xe;
     }
 
+    /**
+     * Whether a type found through a star import, a module import, or a 
default
+     * import is accessible from {@link #currentClass}.
+     * <p>
+     * Public types are visible. A package-private type stays visible in its 
own
+     * package, a protected member type stays visible to subclasses of its 
enclosing
+     * type, and a private member type stays visible inside the enclosing 
nest. A
+     * public member of an inaccessible enclosing type is not visible, so a 
star
+     * import cannot bind it.
+     * <p>
+     * Single-type imports are not filtered. An explicit {@code import 
p.Hidden}
+     * or a fully-qualified name still resolves, matching long-standing Groovy
+     * behaviour, and {@code Class.forName} is unaffected. Static field imports
+     * already apply an access check ({@link StaticImportVisitor}, since 
Groovy 5).
+     *
+     * @param type a resolved candidate
+     * @param knownOuter the type named by {@code import some.Type.*} or
+     *                   {@code import static some.Type.*}. Null for a package
+     *                   star, a default import, and the recursive walk. Binary
+     *                   member types are not {@link InnerClassNode}, so
+     *                   {@link ClassNode#getOuterClass()} is null for them and
+     *                   this argument is what names the enclosing type.
+     *                   {@code ConstructedNestedClass} does not supply it: 
that
+     *                   node is already redirected when this method runs.
+     * @return {@code true} if the star import may bind {@code type}
+     */
+    private boolean isStarImportAccessible(final ClassNode type, final 
ClassNode knownOuter) {
+        // getOuterClass() follows redirect and is non-null only for a source
+        // InnerClassNode. resolve() has already redirected a 
ConstructedNestedClass
+        // onto the loaded class, and a member type read from bytecode does not
+        // carry the link. knownOuter is the enclosing type from the import.
+        ClassNode outer = type.getOuterClass();
+        if (outer == null) {
+            outer = knownOuter;
+        }
+        if (outer == null) {
+            outer = binaryEnclosing(type);
+        }
+        // The enclosing node is not a ClassHelper.make placeholder. A source
+        // outer is the enclosing class from the parse. A binary outer is the
+        // resolved import type or the class the resolver returned, so its
+        // access flags come from the class file. isResolved() may still be
+        // false for a source class and for a decompiled class; that does not
+        // mean the modifier is the public default of an unresolved name.
+        if (outer != null && outer != type && !isStarImportAccessible(outer, 
null)) {
+            return false;
+        }
+        ClassNode owner = outer != null ? outer : type;
+        int modifiers = type.getModifiers();
+        if (effectivelyPublic(type)) {
+            return true;
+        }
+        if (currentClass == null) {
+            return false;
+        }
+        if (currentClass.equals(owner) || 
currentClass.getOuterClasses().contains(owner)) {
+            return true;
+        }
+        if (!Modifier.isPrivate(modifiers) && 
Objects.equals(type.getPackageName(), currentClass.getPackageName())) {
+            return true;
+        }
+        return Modifier.isProtected(modifiers) && 
currentClass.isDerivedFrom(owner);
+    }
+
+    /**
+     * Whether {@code type} is public to a star import.
+     * <p>
+     * A class written without an access modifier is public, and
+     * {@code @PackageScope} clears that flag. The transform runs later in
+     * semantic analysis than this visitor, so a source class is still public
+     * here. The synthetic-public flag plus the annotation is the visibility
+     * the class will have. A class loaded from bytecode already has the flag
+     * removed; its modifier is the one in the class file.
+     */
+    private static boolean effectivelyPublic(final ClassNode type) {
+        ClassNode node = type.redirect();
+        if (!Modifier.isPublic(node.getModifiers())) {
+            return false;
+        }
+        return !node.isSyntheticPublic() || !packageScopeOnClass(node);
+    }
+
+    /**
+     * {@code @PackageScope} with no argument, or with an argument that
+     * includes {@code CLASS}, makes the class package-private.
+     * {@code FIELDS}, {@code METHODS} and {@code CONSTRUCTORS} do not.
+     * The simple name is the form seen before the annotation type is resolved.
+     */
+    private static boolean packageScopeOnClass(final ClassNode type) {
+        for (AnnotationNode annotation : type.getAnnotations()) {
+            String name = annotation.getClassNode().getName();
+            if (!"groovy.transform.PackageScope".equals(name) && 
!"PackageScope".equals(name)) {
+                continue;
+            }
+            Expression value = annotation.getMember("value");
+            if (value == null) {
+                return true;
+            }
+            return targetsClass(value);
+        }
+        return false;
+    }
+
+    private static boolean targetsClass(final Expression value) {
+        if (value instanceof PropertyExpression property) {
+            return "CLASS".equals(property.getPropertyAsString());
+        }
+        if (value instanceof ListExpression list) {
+            for (Expression element : list.getExpressions()) {
+                if (element instanceof PropertyExpression property && 
"CLASS".equals(property.getPropertyAsString())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Enclosing binary type of a member type whose {@link 
ClassNode#getOuterClass()}
+     * is unset. Source inner classes are {@link InnerClassNode} and carry that
+     * link. Classes read from bytecode are ordinary class nodes and do not, so
+     * the enclosing type is recovered from the {@code $} in the binary name
+     * rather than by reclassing every loaded member type as an
+     * {@link InnerClassNode}.
+     */
+    private ClassNode binaryEnclosing(final ClassNode type) {
+        String name = type.getName();
+        int dollar = name.lastIndexOf('$');
+        if (dollar <= 0 || classNodeResolver == null) {
+            return null;
+        }
+        ClassNodeResolver.LookupResult lr = 
classNodeResolver.resolveName(name.substring(0, dollar), compilationUnit);
+        if (lr != null && lr.isClassNode()) {
+            return lr.getClassNode();
+        }
+        return null;
+    }

Review Comment:
   I was pondering about what problem I have with this function and finally it 
clicked. While
   ```java
   class O {
     static class I {}
   }
   ```
   produces a class named O$I
   ```java
   class O$I {}
   ```
   Also produces class name O$I. And yes, that is legal in Java. which means 
there is no 1:1 relationship. 



##########
src/test/groovy/bugs/Groovy11916.groovy:
##########
@@ -0,0 +1,727 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package bugs
+
+import groovy.lang.GroovyClassLoader
+import org.codehaus.groovy.control.CompilationUnit
+import org.codehaus.groovy.control.CompilerConfiguration
+import org.codehaus.groovy.control.Phases
+import org.codehaus.groovy.control.customizers.ImportCustomizer
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+
+import java.lang.reflect.Modifier
+
+import static groovy.test.GroovyAssert.assertScript
+import static groovy.test.GroovyAssert.shouldFail
+
+/**
+ * Star imports, module imports, and default imports resolve only accessible
+ * types. A source import shadows those defaults, including {@code java.lang}.
+ * Two source star imports bind the first accessible type in source order.
+ * An explicit single-type import, a fully qualified name, and
+ * {@code Class.forName} still name a type that is not public.
+ */
+final class Groovy11916 {
+
+    private static GroovyClassLoader types
+
+    @BeforeAll
+    static void compilePackagePrivateTypes() {
+        types = compile(Groovy11916.classLoader, [
+            'p/Types': '''
+                package p
+
+                @groovy.transform.PackageScope
+                class Hidden {}
+
+                class Visible {}
+
+                @groovy.transform.PackageScope
+                class Outer {
+                    public static class Inner {}
+                }
+
+                class Protector {
+                    protected static class Secret {}
+                }
+
+                class Priv {
+                    private static class Secret {}
+                    public static class Shown {}
+                }
+
+                @groovy.transform.PackageScope
+                class Collision {}
+            '''
+        ])
+        assert !Modifier.isPublic(types.loadClass('p.Hidden').modifiers)
+        assert !Modifier.isPublic(types.loadClass('p.Collision').modifiers)
+        assert Modifier.isPublic(types.loadClass('p.Visible').modifiers)
+        assert !Modifier.isPublic(types.loadClass('p.Outer').modifiers)
+        assert Modifier.isPublic(types.loadClass('p.Outer$Inner').modifiers)
+        assert 
Modifier.isProtected(types.loadClass('p.Protector$Secret').modifiers)
+        assert Modifier.isPrivate(types.loadClass('p.Priv$Secret').modifiers)
+    }
+
+    private static GroovyClassLoader compile(ClassLoader parent, Map<String, 
String> sources, CompilerConfiguration config = null) {
+        def loader = new GroovyClassLoader(parent, config)
+        def unit = new CompilationUnit(config, null, loader)
+        sources.each { name, text -> unit.addSource(name + '.groovy', text) }
+        unit.compile(Phases.CLASS_GENERATION)
+        unit.classes.sort { it.name }.each { groovyClass ->
+            loader.defineClass(groovyClass.name, groovyClass.bytes)
+        }
+        loader
+    }
+
+    private static void putType(Map<String, String> sources, String pkg, 
String simpleName, String state) {
+        sources[pkg + '/Marker'] = "package ${pkg}\nclass Marker {}"
+        if (state == 'p') {
+            sources[pkg + '/' + simpleName] = "package ${pkg}\nclass 
${simpleName} {}"
+        } else if (state == 'k') {
+            sources[pkg + '/' + simpleName] = "package 
${pkg}\[email protected]\nclass ${simpleName} {}"
+        }
+    }
+
+    private static String useSource(String pkg, String imports, String 
simpleName) {
+        """\
+package ${pkg}
+${imports}
+class Use {
+    ${simpleName} field
+    static Class which() { ${simpleName} }
+}
+"""
+    }
+
+    /** First public type in source order. {@code p} public, {@code k} 
package-private, {@code m} missing. */
+    private static String firstStar(String a, String b, String c) {
+        if (a == 'p') return 'pa.X'
+        if (b == 'p') return 'pb.X'
+        if (c == 'p') return 'pc.X'
+        return 'unresolved'
+    }
+
+    private static String classifyUse(Map<String, String> sources, String 
className, CompilerConfiguration config = null) {
+        // Dependency types are compiled first so package-private modifiers are
+        // already on the bytecode when the importing compilation unit is 
resolved.
+        def deps = sources.findAll { name, text -> !name.endsWith('/Use') }
+        def use = sources.findAll { name, text -> name.endsWith('/Use') }
+        try {
+            def parent = deps ? compile(Groovy11916.classLoader, deps) : 
Groovy11916.classLoader
+            def loader = compile(parent, use, config)
+            return 
loader.loadClass(className).getDeclaredMethod('which').invoke(null).name
+        } catch (Exception e) {
+            String text = ''
+            for (Throwable t = e; t != null; t = t.cause) {
+                if (t.message != null) text += t.message + '\n'
+            }
+            if (text.contains('ambiguous')) return 'ambiguous'
+            if (text.contains('unable to resolve')) return 'unresolved'
+            if (text.contains('not public')) return 'not-public'
+            def snippet = text.readLines().collect { it.trim() }.findAll { it 
}.take(4).join(' | ')
+            return 'other:' + (snippet ?: e.getClass().simpleName)
+        }
+    }
+
+    @Test
+    void testStarImportDoesNotResolvePackagePrivateJdkType() {
+        assert !Modifier.isPublic(Class.forName('java.util.TimSort').modifiers)
+
+        def err = shouldFail '''
+            import java.util.*
+            def seen = null instanceof TimSort
+        '''
+        assert err.message.contains('unable to resolve class TimSort')
+
+        // A bare name in a script is a dynamic property when it is not a type.
+        // It must not bind the inaccessible class (that binding is what throws
+        // IllegalAccessError for a later instanceof / checkcast).
+        err = shouldFail '''
+            import java.util.*
+            assert TimSort.name == 'java.util.TimSort'
+        '''
+        assert err instanceof MissingPropertyException
+    }
+
+    @Test
+    void testDefaultImportDoesNotResolvePackagePrivateJdkType() {
+        def err = shouldFail '''
+            def seen = null instanceof TimSort
+        '''
+        assert err.message.contains('unable to resolve class TimSort')
+    }
+
+    @Test
+    void testModuleImportDoesNotResolvePackagePrivateJdkType() {
+        def err = shouldFail '''
+            import module java.base
+            def seen = null instanceof TimSort
+        '''
+        assert err.message.contains('unable to resolve class TimSort')
+    }
+
+    @Test
+    void testStarImportStillResolvesPublicTypes() {
+        assertScript '''
+            import java.util.*
+            assert ArrayList.name == 'java.util.ArrayList'
+            assert List.name == 'java.util.List'
+            assert new ArrayList() instanceof List
+        '''
+        assertScript '''
+            import java.util.Map.*
+            Entry e = [a:1].entrySet().first()
+            assert e.key == 'a'
+        '''
+        assertScript '''
+            import static java.util.Map.*
+            Entry e = [a:1].entrySet().first()
+            assert e instanceof Entry
+        '''
+        assertScript '''
+            import module java.base
+            assert ArrayList.name == 'java.util.ArrayList'
+            assert LocalDate.name == 'java.time.LocalDate'
+        '''
+    }
+
+    @Test
+    void testExplicitReferenceToPackagePrivateTypeStillResolves() {
+        assertScript '''
+            import java.util.TimSort
+            assert TimSort.name == 'java.util.TimSort'

Review Comment:
   but it still looks like
   ```Java
   import p.*
   import q.*
   X
   ```
   will resolve to p.X if p.X and q.X are available, while this was not 
compiling before. The problem is not so much that, but if p.X is not 
accessible, this selected q.X. If a change make p.X visible the selection will 
change. This is different from p.* being a default import, because then q.X 
would always win.
   
   





> Star imports should not resolve package-private types
> -----------------------------------------------------
>
>                 Key: GROOVY-11916
>                 URL: https://issues.apache.org/jira/browse/GROOVY-11916
>             Project: Groovy
>          Issue Type: Bug
>            Reporter: Paul King
>            Priority: Major
>
> Groovy's star import resolution (e.g., import java.util.*) currently includes 
> package-private classes in name resolution. On modern JDKs (9+) with the 
> module system, these classes cannot actually be used — attempts result in 
> IllegalAccessError at runtime. This can lead to confusing errors and 
> inconsistency with Java's behaviour where star imports only resolve public 
> types.
> For example, import java.util.* allows def cls = TimSort to compile 
> (resolving the package-private java.util.TimSort), but any actual usage 
> (instanceof, construction, method calls) fails at runtime with 
> IllegalAccessError.
> {code:groovy}
> import java.util.*
> assert String.modifiers == 17
> def cls = TimSort     // fine
> assert cls.modifiers == 0
> println cls           // => class java.util.TimSort
> println Class.forName('java.util.TimSort') // => class java.util.TimSort
> println new Object() instanceof TimSort // IllegalAccessError
> {code}
> Having said that, as a counter example, is it really any different than being 
> able to get the class via Class.forName?
> If the Java behavior is deemed correct, the fix would be to filter non-public 
> classes during star import resolution in ResolveVisitor, producing a clean 
> compile-time error instead of a runtime error. This is technically a breaking 
> change but only affects code that was already failing at runtime on modular 
> JDKs.
> This also benefits the import module feature (GROOVY-11896), which expands to 
> star imports — filtering at the resolution level means module imports 
> correctly include only public types, matching Java's import module semantics.



--
This message was sent by Atlassian Jira
(v10.3.26#10030026)

Reply via email to