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

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

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


##########
src/main/java/org/codehaus/groovy/control/ResolveVisitor.java:
##########
@@ -1195,6 +1289,72 @@ 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.*} when
+     *                   {@code type} is a binary member type that does not 
expose
+     *                   {@link ClassNode#getOuterClass()}
+     * @return {@code true} if the star import may bind {@code type}
+     */
+    private boolean isStarImportAccessible(final ClassNode type, final 
ClassNode knownOuter) {
+        ClassNode outer = type.getOuterClass();
+        if (outer == null) {
+            outer = knownOuter;

Review Comment:
   true, I overlooked line 839. But why does ConstructedNestedClass not return 
the outer class node it was constructed with on getOuterClass? If it would then 
that parameter would not be needed. Not sure about the side effects, but it 
would make sense to me.





> 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