[
https://issues.apache.org/jira/browse/GROOVY-11916?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18147615#comment-18147615
]
ASF GitHub Bot commented on GROOVY-11916:
-----------------------------------------
daniellansun commented on code in PR #3227:
URL: https://github.com/apache/groovy/pull/3227#discussion_r4629194287
##########
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:
Jochen,
Both of these are fair, and the behaviour is updated as follows.
On the two source stars: historical resolution binds the first source star
that actually supplies the type. The program-structure chapter does not treat
two accessible user stars as an ambiguity. `import java.util.*; import
java.sql.*; Date` is `java.util.Date`, and the reverse order is
`java.sql.Date`. Making every pair of accessible source stars an ambiguity
would reject those programs, which is why that is not what this does. Two
accessible source stars still bind the earlier one. They do not tie.
The unstable case is the one you described. If `p.X` exists but is not
accessible, a later `import q.*` no longer binds `q.X`. That statement has
already claimed the name, so a later source star cannot supply a different type
that would be displaced when `p.X` becomes visible. The name is then
unresolved, unless a lower tier still applies (a compilation-customizer star,
or a language default such as `java.lang.String`). A non-static member is not
claimed, because `import Type.*` does not import it.
That is different from a default import, as you said. `import module
java.base` does not repeat `java.util`, because that package is already a
language default. A later `import pb.*` therefore keeps `pb.TimSort` even
though `java.util.TimSort` exists and is not public. Making the JDK type public
would not take the name away from `pb`.
##########
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:
Jochen,
On `binaryEnclosing`: you are right that there is no 1:1 relationship. `O.I`
and a top-level class literally named `O$I` have the same binary name, and the
second is legal. The enclosing type is no longer inferred by splitting on `$`.
For a class read from bytecode it is the outer named by the InnerClasses
attribute, and only when that attribute records this class as a member. A
top-level class whose name contains `$` has no such entry, so a package-private
`p.O` does not hide a public top-level `p.O$I`. A real member still follows its
declaring class: a public member of an inaccessible outer is not imported by a
star. When the class was loaded rather than decompiled,
`Class.getDeclaringClass()` is the same test. `getOuterClass()` is unchanged,
so this does not turn loaded member types into `InnerClassNode`s.
> 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)