[
https://issues.apache.org/jira/browse/GROOVY-12568?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18140042#comment-18140042
]
ASF GitHub Bot commented on GROOVY-12568:
-----------------------------------------
codeconsole commented on PR #3097:
URL: https://github.com/apache/groovy/pull/3097#issuecomment-6700491444
@blackdrag This is now path 2, as proposed. The meta-class route is gone,
`invokeNew` included, and the writers emit what master emits.
- **Compile time and run time may see different classes.** Nothing is
selected at run time now. Each in-memory compilation is defined by a new
`InnerLoader` that defines only that compilation's classes, so a class of the
same package name outside the compilation is in another run-time package,
whatever class the name resolves to at run time. That access is reported when
the class is generated.
- **The meta-class can influence the call.** Statically compiled code no
longer goes through it for these members. The error suggests `@CompileDynamic`
for anyone who wants that.
- **Run time may still fail.** With the option on, it no longer gets to run
time. With it off, it fails with `IllegalAccessError` as on master.
The option is `CompilerConfiguration.RUNTIME_PACKAGE_CHECK`, off by default,
with the same bytecode as before, and no effect on class files. `GroovyShell`
turns it on for the class loader it creates, unless the configuration sets it.
It does that on the loader rather than in the configuration, so
`CompilerConfiguration.DEFAULT` stays read-only and a configuration changed
after the shell is created still applies.
Your comment on `isFieldDirectlyAccessible` no longer applies: that method
and `isMemberDirectlyAccessible` are back to what master has. The check is in a
new `RuntimePackageCheck`, and its only conditions are the package name,
`isInSameRuntimePackage`, and the protected subclass rule of JVMS 5.4.4 and
4.10.1.8.
#3098 is the same check for a package-private class, on the instructions
that name the class. The rest moved as proposed:
- protected members of another package: #3251
- `super$` for a package-private method of another run-time package: #3099
- dynamic `super.f`, `super.@f` and `this.@f` of such a field: #3252
- the invokedynamic `GroovyBugError` for a constructor the JVM refuses: #3253
Your objection also applies to something already on master: since #3022
(GROOVY-12488), a constructor reference to such a constructor is selected at
run time. I left that as it is, so `A::new` works and is not reported, because
reporting it would break code that works today. Say if you want it under this
option too.
> SC: protected and package-private members of a class defined by another
> GroovyClassLoader compilation fail with IllegalAccessError
> ----------------------------------------------------------------------------------------------------------------------------------
>
> Key: GROOVY-12568
> URL: https://issues.apache.org/jira/browse/GROOVY-12568
> Project: Groovy
> Issue Type: Bug
> Components: Static compilation
> Affects Versions: 6.0.0
> Reporter: Scott Murphy Heiberg
> Priority: Major
>
> The JVM allows access to a protected or package-private member only within
> the same run-time package, which is the package name and the class loader. A
> {{GroovyClassLoader}} defines each compilation in memory with a class loader
> of its own: a {{GroovyShell}} script, {{parseClass}}, a script run with
> {{groovy}}, JSR-223. So a class of an earlier parse, or a precompiled class
> used by such a script, is in another run-time package even with the same
> package name. Statically compiled code calls such members directly and fails;
> dynamic code goes through the meta-class and works.
> {code:groovy}
> def shell = new GroovyShell()
> shell.evaluate '''package p
> class A {
> @groovy.transform.PackageScope A(String s) { }
> @groovy.transform.PackageScope String name() { 'a' }
> @groovy.transform.PackageScope String tag = 't'
> }
> true
> '''
> shell.evaluate '''package p
> @groovy.transform.CompileStatic
> List make() { def a = new A('x'); [a.name(), a.tag] }
> make()
> ''' // IllegalAccessError; without @CompileStatic: ['a', 't']
> {code}
> The same happens for map-style construction, instance and static methods,
> getters and setters used as properties, method references such as
> {{a::name}}, and field reads and writes including {{.@}}, {{+=}} and {{++}}.
> Expected: with the option {{CompilerConfiguration.RUNTIME_PACKAGE_CHECK}},
> which {{GroovyShell}} turns on for the class loader it creates, such an
> access is reported when the class is generated. With it off, the bytecode and
> the {{IllegalAccessError}} stay as they are. Code compiled to class files is
> not affected. Statically compiled code does not go through the meta-class for
> these members: compile time and run time may see different classes, and the
> meta-class can influence the call.
> Split out: GROOVY-12717 (protected members of another package), GROOVY-12718
> (dynamic {{super.f}}, {{super.@f}} and {{this.@f}} of such a field),
> GROOVY-12719 (the invokedynamic {{GroovyBugError}} for a constructor the JVM
> refuses). {{super.m()}} of such a method is GROOVY-12570.
> PR: https://github.com/apache/groovy/pull/3097
--
This message was sent by Atlassian Jira
(v10.3.26#10030026)
