daniellansun commented on PR #3109: URL: https://github.com/apache/groovy/pull/3109#issuecomment-6858559365
Thanks, Jochen. You are right on both points, and I think the approach was wrong in the way you describe. The absence of a class resource or a cache entry does not show that a loader cannot supply the class. I have reworked it in 09a594ad so that Groovy skips a lookup only when it knows the name, and the class loader stays authoritative for everything else. - `GroovyClassLoader.loadClass` no longer special-cases names containing `$`, and no longer looks at class resources or the parent's cache. Such names are delegated to the parent as before. - The `$` probes came from the compiler. For an unqualified type name, `ResolveVisitor` tries `Outer$Name` for the current class, its superclasses and interfaces, and its outer classes, and a miss went to `loadClass`. When `Outer` is a source class of the current compile unit, all of its member types are in that compile unit (JLS 8.5), so a miss there is final and the class loader is no longer asked. Precompiled and Java outer types take the existing path. - Groovy now records when it generated a script name itself (`GroovyShell`, `GroovyClassLoader.parseClass(String)`, the JSR 223 engine without `ScriptEngine.FILENAME`, the template engines when they mint the name, and `GroovySocketServer`). The flag is carried on `GroovyCodeSource` and kept on the `InnerLoader` of that compilation, so nothing is held in a global set. Only for a class with such a name, or a class nested in it, `MetaClassRegistry` does not look up `groovy.runtime.metaclass.<name>MetaClass`, `MetaClassImpl` ignores the immediate `BeanInfo` (superclass `BeanInfo` is still read), and the `<name>Customizer` probe is answered by the defining loader with a private unchecked exception rather than `ClassNotFoundException`, so that the JDK does not go on to ask the thread context loader. This is a deviation from the usual `loadClass` contract, limited to that one companion name of a generated class that the loader has not defined. A script or class with a name chosen by the user, including a class declared inside a script, goes through `Class.forName` exactly as before. - The resource checks are gone, together with the native-image special cases. I added the two regressions you suggested. In `Groovy8113ParentDefined`, a parent loader that defines `groovy8113.Holder$Inner` with no `.class` resource is used by `loadClass`, when a script refers to `Holder.Inner` or imports it, and when a source subclass of `Holder` refers to `Inner`. In `Groovy8113UserMeta`, a custom MetaClass for a user-named script, and for a class declared inside it, defined with no `.class` resource and reached through the script's parent chain, is used. Both fail on the previous head. The retention tests now expect no new lock-map entries for generated names from `GroovyShell`, JSR 223 and the template engines, and only MetaClass, BeanInfo and Customizer companions for names chosen by the user. For a name chosen by the caller, for example `evaluate(text, name)` with a fresh name each time or `GroovyScriptEngine`, these companion lookups are still made and still recorded, so this change does not address that case. One limit I should mention: `Class.forName` in `MetaClassRegistry` uses the loader that defined Groovy, so a custom MetaClass, which refers to Groovy types, has to be defined in a loader that can see Groovy. The test defines it there rather than in a loader above it. These names are chosen by Groovy and are not a documented or stable contract, so I do not think a custom MetaClass or BeanInfo should rely on them. Strictly speaking this is a behaviour change: for example, a `groovy.runtime.metaclass.Script1MetaClass` on the classpath would previously have been applied to the first script of a new `GroovyShell`, and now it is not. If you think that matters, I can keep the lookup and document `setDisableCustomMetaClassLookup` instead. On compatibility: the overloads without a file name still delegate to the overloads taking one, so a subclass that overrides those is still called. To record a generated name across packages, `GroovyShell` and `GroovyClassLoader` gain `noteGeneratedScriptName` and `clearGeneratedScriptName` for use by the template and JSR 223 modules, and `GroovyCodeSource` gains `setNameGenerated` and `isNameGenerated`, all `@since 7.0.0`; the four note and clear methods are also marked `@Incubating`. A source is marked as generated only when the name that reaches the overload is the one just generated on the same thread, so an override of `generateScriptName` that returns a different name, or a caller that passes its own name, keeps the custom MetaClass lookup. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
