@Generated requires java.compiler / what should my annotation processor do

[Rob Bygrave]

*>  Since the type javax.annotation.processing.Generated has source *


* retention only, there are no @javax.annotation.processing.Generated
annotations in any class files compiled from source code emitted by your
processor*


The annotation processor generates *source code*. It does not generate byte
code. In this source generation case it does not seem to matter that the
annotation is retention source - it will not compile but result in
compilation errors [package javax.annotation.processing is not visible].

That is, with tooling of maven (and intellij) both do not compile the
generated source that includes javax.annotation.processing.Generated
without java.compiler being added to the *project module path*. It is not
sufficient that requires java.compiler; is in the module-info of the
annotation processor.

When the annotation processor generates java source code that includes
javax.annotation.processing.Generated and when this generated source is
compiled it fails to compile with compilation errors like:.


[ERROR] /<my generated source file>.java:[4,24] package
javax.annotation.processing is not visible
[ERROR]   (package javax.annotation.processing is declared in module
java.compiler, but module example does not read it)


I believe the generated source is compiled along with the rest of the
project source code using the *projects module path* which should not
include the java.compiler module.

To me this compile error is correct and reasonable.  I think it's telling
me that the generated source should only include things that are in the
project module path (and java.compiler is not in the project module path).


*> so your downstream users don't need `requires java.compiler;`.*

That is the plan. As I see it the generated source compilation uses the
project module path.  So generated source that includes
javax.annotation.processing.Generated would then require java.compiler in
the project module path regardless of the fact that the annotation is
defined with retention source.



*> P.S. Your annotation processor `requires java.annotation;` but there is *
* no such module.*

Note that this exists via Automatic-Module-Name of the JEE dependency
(which we want people to migrate to the jakarta equivalent over time).

 Automatic-Module-Name: java.annotation

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>




Thanks, Rob.



> ---------- Forwarded message ----------
> From: Alex Buckley <alex.buckley at oracle.com>
> To: jigsaw-dev at openjdk.java.net
> Cc:
> Bcc:
> Date: Fri, 30 Oct 2020 08:34:55 -0700
> Subject: Re: @Generated requires java.compiler / what should my annotation
> processor do
> The type javax.annotation.processing.Generated was the replacement
> introduced in Java SE 9 for the type javax.annotation.Generated.
>
> Why was a replacement needed for the type javax.annotation.Generated?
> Because the package javax.annotation belonged to Java EE, and was
> removed in Java SE 11.
>
> By contrast, the package javax.annotation.processing has always been
> part of Java SE and is the logical home for a "Generated" type
> associated with annotation processors.
>
> Since the type javax.annotation.processing.Generated has source
> retention only, there are no @javax.annotation.processing.Generated
> annotations in any class files compiled from source code emitted by your
> processor, so your downstream users don't need `requires java.compiler;`.
>
> Alex
>
> P.S. Your annotation processor `requires java.annotation;` but there is
> no such module.
>
> On 10/29/2020 10:49 PM, Rob Bygrave wrote:
> > Are Java 9+ annotation processors using module path supposed to generate
> > source code that has a javax.annotation.processing.Generated annotation?
> > (which is part of java.compile)
> >
> > I have an annotation processor that supports modules and is fine except
> > that when module applications use it the @Generated will not be included
> in
> > the generated source unless the application module-info adds a *requires
> > java.compiler;*  (which seems wrong).
> >
> > So this is a minor niggle that the @Generated no longer is included in
> the
> > generated source when apps go from class path to module path.
> >
> > Apologies is this has been asked before.  I was unable to find anything
> on
> > this issue.
> >
> > Any pointers or thoughts?
> >
> >
> > *Background*
> >
> > I have an annotation processor that generates source code (that now
> > supports java modules with a module-info via a Multi-Release jar).  The
> > module-info for the annotation processor is:
> >
> > module io.avaje.inject.generator {
> >
> >    requires java.compiler;
> >    requires io.avaje.inject;
> >    requires java.annotation;
> >
> >    provides javax.annotation.processing.Processor with
> > io.avaje.inject.generator.Processor;
> > }
> >
> >
> > The annotation processor adds a @Generated to the generated source to
> > document that the source code is generated. The annotation processor only
> > adds the @Generated if javax.annotation.processing.Generated is deemed
> > available by using:
> >
> >   *elements.getTypeElement("javax.annotation.processing.Generated") !=
> null*
> >
> >
> >
> > The annotation processor generates source that includes the @Generated in
> > the cases of:
> >
> > - There is no module-info.java  (app is using class path and not module
> > path)
> > - The app module-info.java includes:   *requires java.compiler;*
> >
> > I'm not expecting users of this annotation processor to put a *requires
> > java.compiler;* into their module-info.
> >
> > I think I must be doing something wrong or should not try to
> > use javax.annotation.processing.Generated which is part of java.compile.
> >
> >
> > Cheers, Rob.
> >
>
>