jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java

-:594b3c2ef585
+:6b95dd682538
 final Context context;
 /** The compiler for the round. */
 final JavaCompiler compiler;
 /** The log for the round. */
 final Log log;
+/** The number of warnings in the previous round. */
+final int priorWarnings;
+/** The ASTs to be compiled. */
+List<JCCompilationUnit> roots;
+/** The classes to be compiler that have were generated. */
+Map<String, JavaFileObject> genClassFiles;
 /** The set of annotations to be processed this round. */
 Set<TypeElement> annotationsPresent;
 /** The set of top level classes to be processed this round. */
 List<ClassSymbol> topLevelClasses;
 /** The set of package-info files to be processed this round. */
 List<PackageSymbol> packageInfoFiles;
-/** Create a round. */
+/** Create a round (common code). */
-Round(Context context, int number) {
+private Round(Context context, int number, int priorWarnings) {
 this.context = context;
 this.number = number;
+this.priorWarnings = priorWarnings;
 compiler = JavaCompiler.instance(context);
 log = Log.instance(context);
 // the following is for the benefit of JavacProcessingEnvironment.getContext()
 JavacProcessingEnvironment.this.context = context;
 // the following will be populated as needed
-annotationsPresent = new LinkedHashSet<TypeElement>();
 topLevelClasses  = List.nil();
 packageInfoFiles = List.nil();
 }
+/** Create the first round. */
+Round(Context context, List<JCCompilationUnit> roots, List<ClassSymbol> classSymbols) {
+this(context, 1, 0);
+this.roots = roots;
+genClassFiles = new HashMap<String,JavaFileObject>();
+compiler.todo.clear(); // free the compiler's resources
+// The reverse() in the following line is to maintain behavioural
+// compatibility with the previous revision of the code. Strictly speaking,
+// it should not be necessary, but a javah golden file test fails without it.
+topLevelClasses =
+getTopLevelClasses(roots).prependList(classSymbols.reverse());
+packageInfoFiles = getPackageInfoFiles(roots);
+findAnnotationsPresent();
+}
+/** Create a new round. */
+private Round(Round prev,
+Set<JavaFileObject> newSourceFiles, Map<String,JavaFileObject> newClassFiles)
+throws IOException {
+this(prev.nextContext(), prev.number+1, prev.compiler.log.nwarnings);
+this.genClassFiles = prev.genClassFiles;
+updateProcessingState();
+List<JCCompilationUnit> parsedFiles = compiler.parseFiles(newSourceFiles);
+roots = cleanTrees(prev.roots).appendList(parsedFiles);
+// Check for errors after parsing
+if (unrecoverableError())
+return;
+enterClassFiles(genClassFiles);
+List<ClassSymbol> newClasses = enterClassFiles(newClassFiles);
+genClassFiles.putAll(newClassFiles);
+enterTrees(roots);
+if (unrecoverableError())
+return;
+topLevelClasses = join(
+getTopLevelClasses(parsedFiles),
+getTopLevelClassesFromClasses(newClasses));
+packageInfoFiles = join(
+getPackageInfoFiles(parsedFiles),
+getPackageInfoFilesFromClasses(newClasses));
+findAnnotationsPresent();
+}
 /** Create the next round to be used. */
-Round next() {
+Round next(Set<JavaFileObject> newSourceFiles, Map<String, JavaFileObject> newClassFiles)
-compiler.close(false);
+throws IOException {
-return new Round(contextForNextRound(), number + 1);
+try {
+return new Round(this, newSourceFiles, newClassFiles);
+} finally {
+compiler.close(false);
+}
+}
+/** Create the compiler to be used for the final compilation. */
+JavaCompiler finalCompiler(boolean errorStatus) {
+try {
+JavaCompiler c = JavaCompiler.instance(nextContext());
+if (errorStatus) {
+c.log.nwarnings += priorWarnings + compiler.log.nwarnings;
+c.log.nerrors += compiler.log.nerrors;
+}
+return c;
+} finally {
+compiler.close(false);
+}
 }
 /** Return the number of errors found so far in this round.
 * This may include uncoverable errors, such as parse errors,
 * and transient errors, such as missing symbols. */
 return compiler.warningCount();
 }
 /** Return whether or not an unrecoverable error has occurred. */
 boolean unrecoverableError() {
-return log.unrecoverableError;
+return log.unrecoverableError
+|| messager.errorRaised()
+|| (werror && log.nwarnings > 0)
+|| (fatalErrors && log.nerrors > 0);
 }
 /** Find the set of annotations present in the set of top level
-* classes and package info files to be processed this round. */
+*  classes and package info files to be processed this round. */
-void findAnnotationsPresent(ComputeAnnotationSet annotationComputer) {
+void findAnnotationsPresent() {
+ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils);
 // Use annotation processing to compute the set of annotations present
 annotationsPresent = new LinkedHashSet<TypeElement>();
 for (ClassSymbol classSym : topLevelClasses)
 annotationComputer.scan(classSym, annotationsPresent);
 for (PackageSymbol pkgSym : packageInfoFiles)
 annotationComputer.scan(pkgSym, annotationsPresent);
 }
-/**
+/** Enter a set of generated class files. */
-* Parse the latest set of generated source files created by the filer.
+List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) {
-*/
-List<JCCompilationUnit> parseNewSourceFiles()
-throws IOException {
-List<JavaFileObject> fileObjects = List.nil();
-for (JavaFileObject jfo : filer.getGeneratedSourceFileObjects() ) {
-fileObjects = fileObjects.prepend(jfo);
-}
-return compiler.parseFiles(fileObjects);
-}
-/** Enter the latest set of generated class files created by the filer. */
-List<ClassSymbol> enterNewClassFiles() {
 ClassReader reader = ClassReader.instance(context);
 Names names = Names.instance(context);
 List<ClassSymbol> list = List.nil();
-for (Map.Entry<String,JavaFileObject> entry : filer.getGeneratedClasses().entrySet()) {
+for (Map.Entry<String,JavaFileObject> entry : classFiles.entrySet()) {
 Name name = names.fromString(entry.getKey());
 JavaFileObject file = entry.getValue();
 if (file.getKind() != JavaFileObject.Kind.CLASS)
 throw new AssertionError(file);
 ClassSymbol cs;
 compiler.enterTrees(roots);
 }
 /** Run a processing round. */
 void run(boolean lastRound, boolean errorStatus) {
-//            assert lastRound
+printRoundInfo(lastRound);
-//                ? (topLevelClasses.size() == 0 && annotationsPresent.size() == 0)
-//                : (errorStatus == false);
-//
-//            printRoundInfo(topLevelClasses, annotationsPresent, lastRound);
 TaskListener taskListener = context.get(TaskListener.class);
 if (taskListener != null)
 taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
 try {
 if (lastRound) {
-printRoundInfo(List.<ClassSymbol>nil(), Collections.<TypeElement>emptySet(), lastRound);
 filer.setLastRound(true);
 Set<Element> emptyRootElements = Collections.emptySet(); // immutable
 RoundEnvironment renv = new JavacRoundEnvironment(true,
 errorStatus,
 emptyRootElements,
 JavacProcessingEnvironment.this);
 discoveredProcs.iterator().runContributingProcs(renv);
 } else {
-printRoundInfo(topLevelClasses, annotationsPresent, lastRound);
 discoverAndRunProcs(context, annotationsPresent, topLevelClasses, packageInfoFiles);
 }
 } finally {
 if (taskListener != null)
 taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
 }
 }
 /** Update the processing state for the current context. */
-// Question: should this not be part of next()?
+private void updateProcessingState() {
-// Note: Calling it from next() breaks some tests. There is an issue
-// whether the annotationComputer is using elementUtils with the
-// correct context.
-void updateProcessingState() {
 filer.newRound(context);
 messager.newRound(context);
 elementUtils.setContext(context);
 typeUtils.setContext(context);
 }
 /** Print info about this round. */
-private void printRoundInfo(List<ClassSymbol> topLevelClasses,
+private void printRoundInfo(boolean lastRound) {
-Set<TypeElement> annotationsPresent,
-boolean lastRound) {
 if (printRounds || verbose) {
+List<ClassSymbol> tlc = lastRound ? List.<ClassSymbol>nil() : topLevelClasses;
+Set<TypeElement> ap = lastRound ? Collections.<TypeElement>emptySet() : annotationsPresent;
 log.printNoteLines("x.print.rounds",
-(!lastRound ? number : number + 1),
+number,
-"{" + topLevelClasses.toString(", ") + "}",
+"{" + tlc.toString(", ") + "}",
-annotationsPresent,
+ap,
 lastRound);
 }
 }
 /** Get the context for the next round of processing.
 * Important values are propogated from round to round;
 * other values are implicitly reset.
 */
-private Context contextForNextRound() {
+private Context nextContext() {
 Context next = new Context();
 Options options = Options.instance(context);
 assert options != null;
 next.put(Options.optionsKey, options);
 List<JCCompilationUnit> roots,
 List<ClassSymbol> classSymbols,
 Iterable<? extends PackageSymbol> pckSymbols)
 throws IOException {
+TaskListener taskListener = context.get(TaskListener.class);
 log = Log.instance(context);
-Round round = new Round(context, 1);
-round.compiler.todo.clear(); // free the compiler's resources
-// The reverse() in the following line is to maintain behavioural
-// compatibility with the previous revision of the code. Strictly speaking,
-// it should not be necessary, but a javah golden file test fails without it.
-round.topLevelClasses =
-getTopLevelClasses(roots).prependList(classSymbols.reverse());
-round.packageInfoFiles = getPackageInfoFiles(roots);
 Set<PackageSymbol> specifiedPackages = new LinkedHashSet<PackageSymbol>();
 for (PackageSymbol psym : pckSymbols)
 specifiedPackages.add(psym);
 this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages);
-ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils);
+Round round = new Round(context, roots, classSymbols);
-round.findAnnotationsPresent(annotationComputer);
+boolean errorStatus;
-boolean errorStatus = false;
+boolean moreToDo;
+do {
-runAround:
+// Run processors for round n
-while (true) {
+round.run(false, false);
-if ((fatalErrors && round.errorCount() != 0)
-|| (werror && round.warningCount() != 0)) {
+// Processors for round n have run to completion.
+// Check for errors and whether there is more work to do.
+errorStatus = round.unrecoverableError();
+moreToDo = moreToDo();
+// Set up next round.
+// Copy mutable collections returned from filer.
+round = round.next(
+new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects()),
+new LinkedHashMap<String,JavaFileObject>(filer.getGeneratedClasses()));
+// Check for errors during setup.
+if (round.unrecoverableError())
 errorStatus = true;
-break runAround;
-}
+} while (moreToDo && !errorStatus);
-round.run(false, false);
-/*
-* 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.
-*/
-if (messager.errorRaised()) {
-errorStatus = true;
-break runAround;
-}
-if (!moreToDo())
-break runAround; // No new files
-round = round.next();
-List<JCCompilationUnit> parsedFiles = round.parseNewSourceFiles();
-roots = cleanTrees(roots).appendList(parsedFiles);
-// Check for errors after parsing
-if (round.unrecoverableError()) {
-errorStatus = true;
-break runAround;
-}
-List<ClassSymbol> newClasses = round.enterNewClassFiles();
-round.enterTrees(roots);
-round.topLevelClasses = join(
-getTopLevelClasses(parsedFiles),
-getTopLevelClassesFromClasses(newClasses));
-round.packageInfoFiles = join(
-getPackageInfoFiles(parsedFiles),
-getPackageInfoFilesFromClasses(newClasses));
-round.findAnnotationsPresent(annotationComputer);
-round.updateProcessingState();
-}
 // run last round
 round.run(true, errorStatus);
-// Add any sources generated during the last round to the set
-// of files to be compiled.
-if (moreToDo()) {
-List<JCCompilationUnit> parsedFiles = round.parseNewSourceFiles();
-roots = cleanTrees(roots).appendList(parsedFiles);
-}
-// Set error status for any files compiled and generated in
-// the last round
-if (round.unrecoverableError() || (werror && round.warningCount() != 0))
-errorStatus = true;
-round = round.next();
 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();
+if (messager.errorRaised()
+|| werror && round.warningCount() > 0 && round.errorCount() > 0)
+errorStatus = true;
+Set<JavaFileObject> newSourceFiles =
+new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects());
+roots = cleanTrees(round.roots);
+JavaCompiler compiler = round.finalCompiler(errorStatus);
+if (newSourceFiles.size() > 0)
+roots = roots.appendList(compiler.parseFiles(newSourceFiles));
+errorStatus = errorStatus || (compiler.errorCount() > 0);
 // Free resources
 this.close();
-TaskListener taskListener = this.context.get(TaskListener.class);
 if (taskListener != null)
 taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
-JavaCompiler compiler;
 if (errorStatus) {
-compiler = round.compiler;
-compiler.log.nwarnings += messager.warningCount();
-compiler.log.nerrors += messager.errorCount();
 if (compiler.errorCount() == 0)
 compiler.log.nerrors++;
-} else if (procOnly && !foundTypeProcessors) {
+return compiler;
-compiler = round.compiler;
+}
+if (procOnly && !foundTypeProcessors) {
 compiler.todo.clear();
-} else { // Final compilation
+} else {
-round = round.next();
-round.updateProcessingState();
-compiler = round.compiler;
 if (procOnly && foundTypeProcessors)
 compiler.shouldStopPolicy = CompileState.FLOW;
-compiler.enterTrees(cleanTrees(roots));
+compiler.enterTrees(roots);
 }
 return compiler;
 }
 private List<ClassSymbol> getTopLevelClasses(List<? extends JCCompilationUnit> units) {
 List<ClassSymbol> classes = List.nil();
 for (JCCompilationUnit unit : units) {
 for (JCTree node : unit.defs) {
 if (node.getTag() == JCTree.CLASSDEF) {
-classes = classes.prepend(((JCClassDecl) node).sym);
+ClassSymbol sym = ((JCClassDecl) node).sym;
+assert sym != null;
+classes = classes.prepend(sym);
 }
 }
 }
 return classes.reverse();
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java

src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java