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

-:eb7c263aab73
+:4124840b35fe
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import com.sun.tools.javac.util.Options;
 import static javax.tools.StandardLocation.*;
+import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;
 /**
 * Objects of this class hold and manage the state needed to support
 * annotation processing.
 *
 private final boolean verbose;
 private final boolean lint;
 private final boolean procOnly;
 private final boolean fatalErrors;
 private final boolean werror;
+private final boolean showResolveErrors;
 private boolean foundTypeProcessors;
 private final JavacFiler filer;
 private final JavacMessager messager;
 private final JavacElements elementUtils;
 verbose = options.get("-verbose") != null;
 lint = options.lint("processing");
 procOnly = options.get("-proc:only") != null ||
 options.get("-Xprint") != null;
 fatalErrors = options.get("fatalEnterError") != null;
+showResolveErrors = options.get("showResolveErrors") != null;
 werror = options.get("-Werror") != null;
 platformAnnotations = initPlatformAnnotations();
 foundTypeProcessors = false;
 // Initialize services before any processors are initialzied
 this.number = number;
 this.priorWarnings = priorWarnings;
 compiler = JavaCompiler.instance(context);
 log = Log.instance(context);
+log.deferDiagnostics = true;
 // the following is for the benefit of JavacProcessingEnvironment.getContext()
 JavacProcessingEnvironment.this.context = context;
 // the following will be populated as needed
 return compiler.warningCount();
 }
 /** Return whether or not an unrecoverable error has occurred. */
 boolean unrecoverableError() {
-return log.unrecoverableError
+if (messager.errorRaised())
-|| messager.errorRaised()
+return true;
-|| (werror && log.nwarnings > 0)
-|| (fatalErrors && log.nerrors > 0);
+for (JCDiagnostic d: log.deferredDiagnostics) {
+switch (d.getKind()) {
+case WARNING:
+if (werror)
+return true;
+break;
+case ERROR:
+if (fatalErrors || !d.isFlagSet(RESOLVE_ERROR))
+return true;
+break;
+}
+}
+return false;
 }
 /** Find the set of annotations present in the set of top level
 *  classes and package info files to be processed this round. */
 void findAnnotationsPresent() {
 for (PackageSymbol pkgSym : packageInfoFiles)
 annotationComputer.scan(pkgSym, annotationsPresent);
 }
 /** Enter a set of generated class files. */
-List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) {
+private List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) {
 ClassReader reader = ClassReader.instance(context);
 Names names = Names.instance(context);
 List<ClassSymbol> list = List.nil();
 for (Map.Entry<String,JavaFileObject> entry : classFiles.entrySet()) {
 }
 return list.reverse();
 }
 /** Enter a set of syntax trees. */
-void enterTrees(List<JCCompilationUnit> roots) {
+private void enterTrees(List<JCCompilationUnit> roots) {
 compiler.enterTrees(roots);
 }
 /** Run a processing round. */
 void run(boolean lastRound, boolean errorStatus) {
 if (taskListener != null)
 taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
 }
 }
+void showDiagnostics(boolean showAll) {
+Set<JCDiagnostic.Kind> kinds = EnumSet.allOf(JCDiagnostic.Kind.class);
+if (!showAll) {
+// suppress errors, which are all presumed to be transient resolve errors
+kinds.remove(JCDiagnostic.Kind.ERROR);
+}
+log.reportDeferredDiagnostics(kinds);
+}
 /** Update the processing state for the current context. */
 private void updateProcessingState() {
 filer.newRound(context);
 messager.newRound(context);
 // Processors for round n have run to completion.
 // Check for errors and whether there is more work to do.
 errorStatus = round.unrecoverableError();
 moreToDo = moreToDo();
+round.showDiagnostics(errorStatus || showResolveErrors);
 // Set up next round.
 // Copy mutable collections returned from filer.
 round = round.next(
 new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects()),
 new LinkedHashMap<String,JavaFileObject>(filer.getGeneratedClasses()));
 } while (moreToDo && !errorStatus);
 // run last round
 round.run(true, errorStatus);
+round.showDiagnostics(true);
 filer.warnIfUnclosedFiles();
 warnIfUnmatchedOptions();
 /*

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