Attenzione: il documento per il tipo '[Inserire classe qui]' creato nell'ultimo turno non saranno oggetto di trattamento annotazione

Question

ho acceso una base di codice esistente per Java 7 e continuo a ricevere questo avvertimento:

warning: File for type '[Insert class here]' created in the last round 
    will not be subject to annotation processing. 

Una rapida ricerca rivela che nessuno ha ricevuto questo avvertimento.

Non è documentata nella sorgente del compilatore javac sia:

Da OpenJDK \ langtools \ src \ share \ Classes \ com \ sole \ tools \ javac \ elaborazione \ JavacFiler.java

private JavaFileObject createSourceOrClassFile(boolean isSourceFile, String name) throws IOException { 
    checkNameAndExistence(name, isSourceFile); 
    Location loc = (isSourceFile ? SOURCE_OUTPUT : CLASS_OUTPUT); 
    JavaFileObject.Kind kind = (isSourceFile ? 
           JavaFileObject.Kind.SOURCE : 
           JavaFileObject.Kind.CLASS); 

    JavaFileObject fileObject = 
     fileManager.getJavaFileForOutput(loc, name, kind, null); 
    checkFileReopening(fileObject, true); 

    if (lastRound) // <-------------------------------TRIGGERS WARNING 
     log.warning("proc.file.create.last.round", name); 

    if (isSourceFile) 
     aggregateGeneratedSourceNames.add(name); 
    else 
     aggregateGeneratedClassNames.add(name); 
    openTypeNames.add(name); 

    return new FilerOutputJavaFileObject(name, fileObject); 
} 

Cosa questo significa e quali passi posso prendere per cancellare questo avviso?

Grazie.

Answer 1

In OpenJDK test case questo avviso generato poiché il processore utilizza "processingOver()" per scrivere esattamente il nuovo file all'ultimo round.

public boolean process(Set<? extends TypeElement> elems, RoundEnvironment renv) { 
     if (renv.processingOver()) { // Write only at last round 
      Filer filer = processingEnv.getFiler(); 
      Messager messager = processingEnv.getMessager(); 
      try { 
       JavaFileObject fo = filer.createSourceFile("Gen"); 
       Writer out = fo.openWriter(); 
       out.write("class Gen { }"); 
       out.close(); 
       messager.printMessage(Diagnostic.Kind.NOTE, "File 'Gen' created"); 
      } catch (IOException e) { 
       messager.printMessage(Diagnostic.Kind.ERROR, e.toString()); 
      } 
     } 
     return false; 
    } 

Ho modificato un esempio di codice originale. Aggiunta nota diagnostica "File 'Gen' creato", sostituita "*" maschera con "org.junit.runner.RunWith" e imposta il valore di ritorno su "true". log compilatore prodotta era:

Round 1: 
input files: {ProcFileCreateLastRound} 
annotations: [org.junit.runner.RunWith] 
last round: false 
Processor AnnoProc matches [org.junit.runner.RunWith] and returns true. 
Round 2: 
input files: {} 
annotations: [] 
last round: true 
Note: File 'Gen' created 
Compilation completed successfully with 1 warning 
0 errors 
1 warning 
Warning: File for type 'Gen' created in the last round will not be subject to annotation processing. 

Se togliamo la mia nota personalizzato dal registro, è difficile dire che il file 'Gen' stato effettivamente creato il 'Round 2' - ultimo round. Quindi, si applica la consulenza di base: in caso di dubbio, aggiungere più registri.

---

dove si trova anche un po 'di informazioni utili su questa pagina: http://docs.oracle.com/javase/7/docs/technotes/tools/solaris/javac.html

Leggere il capitolo su "ANNOTAZIONE TRATTAMENTO" e cercare di ottenere maggiori informazioni con le opzioni di compilazione:
-XprintProcessorInfo Stampa informazioni su quali annotazioni un processore è richiesto per elaborare.
-XprintRounds Stampa informazioni sui cicli di elaborazione delle annotazioni iniziali e successivi.

Answer 2

ho curiosato le opzioni del compilatore Java 7 e ho trovato questo:

-implicit: {class, nessuno} controlla la generazione di file di classe per i file di origine in modo implicito caricati. Per generare automaticamente i file di classe, utilizzare -implicit: class. Per sopprimere la generazione di file di classe, utilizzare -implicit: none. Se questa opzione non è specificata, l'impostazione predefinita è generare automaticamente i file di classe. In questo caso, il compilatore emetterà un avviso se vengono generati tali file di classe quando si esegue anche l'elaborazione delle annotazioni. L'avviso non verrà emesso se questa opzione è impostata in modo esplicito. Vedi Ricerca di tipi.

Source

Puoi provare e implicitamente dichiarare il file di classe.

Answer 3

L'avvertimento

Attenzione: il documento per il tipo '[Inserire classe qui]' creato nell'ultimo turno non saranno oggetto di trattamento annotazione

significa che il vostro correvano un'annotazione processore che crea una nuova classe o un file sorgente utilizzando un'implementazione javax.annotation.processing.Filer (fornita attraverso javax.annotation.processing.ProcessingEnvironment) sebbene lo strumento di elaborazione abbia già deciso "nell'ultimo round".

Questo potrebbe essere un problema (e quindi l'avviso) perché il file generato stesso può contenere annotazioni ignorate dal processore di annotazione (perché non sta per fare un ulteriore giro).

È possibile che questo deve rispondere alla prima parte della tua domanda

Cosa significa e quali passi posso prendere per cancellare questo avvertimento?

(si capito questo già da solo, non è vero :-))

Quale possibile passi da fare? Controlla i processori di annotazione:

1) Devi davvero usare filer.createClassFile/filer.createSourceFile nell'ultimo round del processore annotaion? Di solito si utilizza l'oggetto filer all'interno di un blocco di codice come

for (TypeElement annotation : annotations) { 
... 
} 

(nel processo del metodo). Ciò garantisce che il processore di annotazione non si trovi nel suo ultimo round (l'ultimo round è sempre quello con una serie vuota di annotazioni).

2) Se davvero non si può evitare di scrivere i file generati nell'ultimo ciclo e questi file sono file sorgente, ingannare il processore di annotazione e utilizzare il metodo "createResource" dell'oggetto filer (prendere "SOURCE_OUTPUT" come posizione).