TaskListener taskListener = context.get(TaskListener.class);
AnnotationCollector collector = new AnnotationCollector();
JavaCompiler compiler = JavaCompiler.instance(context);
compiler.todo.clear(); // free the compiler's resources
int round = 0;
// List<JCAnnotation> annotationsPresentInSource = collector.findAnnotations(roots);
List<ClassSymbol> topLevelClasses = getTopLevelClasses(roots);
for (ClassSymbol classSym : classSymbols)
topLevelClasses = topLevelClasses.prepend(classSym);
List<PackageSymbol> packageInfoFiles =
getPackageInfoFiles(roots);
DEBUG.P("topLevelClasses ="+topLevelClasses);
DEBUG.P("packageInfoFiles="+packageInfoFiles);
Set<PackageSymbol> specifiedPackages = new LinkedHashSet<PackageSymbol>();
for (PackageSymbol psym : pckSymbols)
specifiedPackages.add(psym);
this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages);
DEBUG.P("this.specifiedPackages="+this.specifiedPackages);
// Use annotation processing to compute the set of annotations present
Set<TypeElement> annotationsPresent = new LinkedHashSet<TypeElement>();
ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils);
for (ClassSymbol classSym : topLevelClasses)
annotationComputer.scan(classSym, annotationsPresent);
for (PackageSymbol pkgSym : packageInfoFiles)
annotationComputer.scan(pkgSym, annotationsPresent);
DEBUG.P("annotationsPresent="+annotationsPresent);
Context currentContext = context;
int roundNumber = 0;
boolean errorStatus = false;
runAround:
while(true) {
DEBUG.P("roundNumber="+roundNumber);
DEBUG.P("fatalErrors="+fatalErrors);
DEBUG.P("compiler.errorCount()="+compiler.errorCount());
if (fatalErrors && compiler.errorCount() != 0) {
errorStatus = true;
break runAround;
}
this.context = currentContext;
roundNumber++;
printRoundInfo(xout, roundNumber, topLevelClasses, annotationsPresent, false);
if (taskListener != null)
taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
try {
discoverAndRunProcs(currentContext, annotationsPresent, topLevelClasses, packageInfoFiles);
} finally {
if (taskListener != null)
taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
}
/*
* Processors for round n have run to completion. Prepare
* for round (n+1) by checked for errors raised by
* annotation processors and then checking for syntax
* errors on any generated source files.
*/
DEBUG.P("messager.errorRaised()="+messager.errorRaised());
DEBUG.P("moreToDo()="+moreToDo());
if (messager.errorRaised()) {
errorStatus = true;
break runAround;
} else {
if (moreToDo()) {
// <editor-fold defaultstate="collapsed">
// annotationsPresentInSource = List.nil();
annotationsPresent = new LinkedHashSet<TypeElement>();
topLevelClasses = List.nil();
packageInfoFiles = List.nil();
compiler.close();
currentContext = contextForNextRound(currentContext, true);
JavaFileManager fileManager = currentContext.get(JavaFileManager.class);
List<JavaFileObject> fileObjects = List.nil();
for (JavaFileObject jfo : filer.getGeneratedSourceFileObjects() ) {
fileObjects = fileObjects.prepend(jfo);
}
compiler = JavaCompiler.instance(currentContext);
List<JCCompilationUnit> parsedFiles = compiler.parseFiles(fileObjects);
roots = cleanTrees(roots).reverse();
for (JCCompilationUnit unit : parsedFiles)
roots = roots.prepend(unit);
roots = roots.reverse();
// Check for errors after parsing
if (compiler.parseErrors()) {
errorStatus = true;
break runAround;
} else {
ListBuffer<ClassSymbol> classes = enterNewClassFiles(currentContext);
compiler.enterTrees(roots);
// annotationsPresentInSource =
// collector.findAnnotations(parsedFiles);
classes.appendList(getTopLevelClasses(parsedFiles));
topLevelClasses = classes.toList();
packageInfoFiles = getPackageInfoFiles(parsedFiles);
annotationsPresent = new LinkedHashSet<TypeElement>();
for (ClassSymbol classSym : topLevelClasses)
annotationComputer.scan(classSym, annotationsPresent);
for (PackageSymbol pkgSym : packageInfoFiles)
annotationComputer.scan(pkgSym, annotationsPresent);
updateProcessingState(currentContext, false);
}
// </editor-fold>
} else
break runAround; // No new files
}
}
runLastRound(xout, roundNumber, errorStatus, taskListener);
compiler.close();
currentContext = contextForNextRound(currentContext, true);
compiler = JavaCompiler.instance(currentContext);
filer.newRound(currentContext, true);
filer.warnIfUnclosedFiles();
warnIfUnmatchedOptions();
/*
* If an annotation processor raises an error in a round,
* that round runs to completion and one last round occurs.
* The last round may also occur because no more source or
* class files have been generated. Therefore, if an error
* was raised on either of the last *two* rounds, the compile
* should exit with a nonzero exit code. The current value of
* errorStatus holds whether or not an error was raised on the
* second to last round; errorRaised() gives the error status
* of the last round.
*/
errorStatus = errorStatus || messager.errorRaised();
// Free resources
this.close();
if (taskListener != null)
taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
if (errorStatus) {
compiler.log.nerrors += messager.errorCount();
if (compiler.errorCount() == 0)
compiler.log.nerrors++;
} else if (procOnly) {
compiler.todo.clear();
} else { // Final compilation
compiler.close();
currentContext = contextForNextRound(currentContext, true);
compiler = JavaCompiler.instance(currentContext);
if (true) {
compiler.enterTrees(cleanTrees(roots));
} else {
List<JavaFileObject> fileObjects = List.nil();
for (JCCompilationUnit unit : roots)
fileObjects = fileObjects.prepend(unit.getSourceFile());
roots = null;
compiler.enterTrees(compiler.parseFiles(fileObjects.reverse()));
}
}
DEBUG.P(0,this,"doProcessing(4)");
return compiler;