jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java

equal deleted inserted replaced

-:9405883da95f
+:b92eb80925f0
 import javax.annotation.processing.*;
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.*;
 import javax.lang.model.util.*;
-import javax.tools.DiagnosticListener;
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
 import static javax.tools.StandardLocation.*;
-import com.sun.source.util.JavacTask;
 import com.sun.source.util.TaskEvent;
-import com.sun.tools.javac.api.BasicJavacTask;
-import com.sun.tools.javac.api.JavacTrees;
 import com.sun.tools.javac.api.MultiTaskListener;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Symbol.*;
-import com.sun.tools.javac.file.FSInfo;
+import com.sun.tools.javac.code.Type.ClassType;
+import com.sun.tools.javac.code.Types;
+import com.sun.tools.javac.comp.AttrContext;
+import com.sun.tools.javac.comp.Check;
+import com.sun.tools.javac.comp.Enter;
+import com.sun.tools.javac.comp.Env;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.jvm.ClassReader.BadClassFile;
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.model.JavacElements;
 import com.sun.tools.javac.model.JavacTypes;
-import com.sun.tools.javac.parser.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.util.Abort;
 import com.sun.tools.javac.util.Assert;
 import com.sun.tools.javac.util.ClientCodeException;
 private final JavacFiler filer;
 private final JavacMessager messager;
 private final JavacElements elementUtils;
 private final JavacTypes typeUtils;
+private final Types types;
+private final JavaCompiler compiler;
 /**
 * Holds relevant state history of which processors have been
 * used.
 */
 */
 private Set<PackageSymbol> specifiedPackages = Collections.emptySet();
 /** The log to be used for error reporting.
 */
-Log log;
+final Log log;
 /** Diagnostic factory.
 */
 JCDiagnostic.Factory diags;
 * JavacMessages object used for localization
 */
 private JavacMessages messages;
 private MultiTaskListener taskListener;
+private final Symtab symtab;
-private Context context;
+private final Names names;
+private final Enter enter;
+private final Completer initialCompleter;
+private final Check chk;
+private final Context context;
 /** Get the JavacProcessingEnvironment instance for this context. */
 public static JavacProcessingEnvironment instance(Context context) {
 JavacProcessingEnvironment instance = context.get(JavacProcessingEnvironment.class);
 if (instance == null)
 options = Options.instance(context);
 printProcessorInfo = options.isSet(XPRINTPROCESSORINFO);
 printRounds = options.isSet(XPRINTROUNDS);
 verbose = options.isSet(VERBOSE);
 lint = Lint.instance(context).isEnabled(PROCESSING);
+compiler = JavaCompiler.instance(context);
 if (options.isSet(PROC, "only") || options.isSet(XPRINT)) {
-JavaCompiler compiler = JavaCompiler.instance(context);
 compiler.shouldStopPolicyIfNoError = CompileState.PROCESS;
 }
 fatalErrors = options.isSet("fatalEnterError");
 showResolveErrors = options.isSet("showResolveErrors");
 werror = options.isSet(WERROR);
 // in case processors use them.
 filer = new JavacFiler(context);
 messager = new JavacMessager(context, this);
 elementUtils = JavacElements.instance(context);
 typeUtils = JavacTypes.instance(context);
-processorOptions = initProcessorOptions(context);
+types = Types.instance(context);
+processorOptions = initProcessorOptions();
 unmatchedProcessorOptions = initUnmatchedProcessorOptions();
 messages = JavacMessages.instance(context);
 taskListener = MultiTaskListener.instance(context);
+symtab = Symtab.instance(context);
+names = Names.instance(context);
+enter = Enter.instance(context);
+initialCompleter = ClassReader.instance(context).getCompleter();
+chk = Check.instance(context);
 initProcessorClassLoader();
 }
 public void setProcessors(Iterable<? extends Processor> processors) {
 Assert.checkNull(discoveredProcs);
-initProcessorIterator(context, processors);
+initProcessorIterator(processors);
 }
 private Set<String> initPlatformAnnotations() {
 Set<String> platformAnnotations = new HashSet<>();
 platformAnnotations.add("java.lang.Deprecated");
 processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
 ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
 : fileManager.getClassLoader(CLASS_PATH);
 if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
-JavaCompiler compiler = JavaCompiler.instance(context);
 compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);
 }
 } catch (SecurityException e) {
 processorClassLoaderException = e;
 }
 }
-private void initProcessorIterator(Context context, Iterable<? extends Processor> processors) {
+private void initProcessorIterator(Iterable<? extends Processor> processors) {
-Log   log   = Log.instance(context);
 Iterator<? extends Processor> processorIterator;
 if (options.isSet(XPRINT)) {
 try {
 Processor processor = PrintingProcessor.class.newInstance();
 public boolean atLeastOneProcessor() {
 return discoveredProcs.iterator().hasNext();
 }
-private Map<String, String> initProcessorOptions(Context context) {
+private Map<String, String> initProcessorOptions() {
-Options options = Options.instance(context);
 Set<String> keySet = options.keySet();
 Map<String, String> tempOptions = new LinkedHashMap<>();
 for(String key : keySet) {
 if (key.startsWith("-A") && key.length() > 2) {
 ((ServiceIterator) processorIterator).close();
 }
 }
 }
-private void discoverAndRunProcs(Context context,
+private void discoverAndRunProcs(Set<TypeElement> annotationsPresent,
-Set<TypeElement> annotationsPresent,
 List<ClassSymbol> topLevelClasses,
 List<PackageSymbol> packageInfoFiles) {
 Map<String, TypeElement> unmatchedAnnotations = new HashMap<>(annotationsPresent.size());
 for(TypeElement a  : annotationsPresent) {
 if (lint && unmatchedAnnotations.size() > 0) {
 // Remove annotations processed by javac
 unmatchedAnnotations.keySet().removeAll(platformAnnotations);
 if (unmatchedAnnotations.size() > 0) {
-log = Log.instance(context);
 log.warning("proc.annotations.without.processors",
 unmatchedAnnotations.keySet());
 }
 }
 * Helper object for a single round of annotation processing.
 */
 class Round {
 /** The round number. */
 final int number;
-/** The context for the round. */
-final Context context;
-/** The compiler for the round. */
-final JavaCompiler compiler;
-/** The log for the round. */
-final Log log;
 /** The diagnostic handler for the round. */
 final Log.DeferredDiagnosticHandler deferredDiagnosticHandler;
 /** The ASTs to be compiled. */
 List<JCCompilationUnit> roots;
+/** The trees that need to be cleaned - includes roots and implicitly parsed trees. */
+Set<JCCompilationUnit> treesToClean;
 /** 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;
 List<ClassSymbol> topLevelClasses;
 /** The set of package-info files to be processed this round. */
 List<PackageSymbol> packageInfoFiles;
 /** Create a round (common code). */
-private Round(Context context, int number, int priorErrors, int priorWarnings,
+private Round(int number, Set<JCCompilationUnit> treesToClean,
 Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
-this.context = context;
 this.number = number;
-compiler = JavaCompiler.instance(context);
-log = Log.instance(context);
-log.nerrors = priorErrors;
-log.nwarnings = priorWarnings;
 if (number == 1) {
 Assert.checkNonNull(deferredDiagnosticHandler);
 this.deferredDiagnosticHandler = deferredDiagnosticHandler;
 } else {
 this.deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log);
-}
+compiler.setDeferredDiagnosticHandler(this.deferredDiagnosticHandler);
+}
-// the following is for the benefit of JavacProcessingEnvironment.getContext()
-JavacProcessingEnvironment.this.context = context;
 // the following will be populated as needed
 topLevelClasses  = List.nil();
 packageInfoFiles = List.nil();
+this.treesToClean = treesToClean;
 }
 /** Create the first round. */
-Round(Context context, List<JCCompilationUnit> roots, List<ClassSymbol> classSymbols,
+Round(List<JCCompilationUnit> roots,
-Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
+List<ClassSymbol> classSymbols,
-this(context, 1, 0, 0, deferredDiagnosticHandler);
+Set<JCCompilationUnit> treesToClean,
+Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
+this(1, treesToClean, deferredDiagnosticHandler);
 this.roots = roots;
 genClassFiles = new HashMap<>();
-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 =
 }
 /** Create a new round. */
 private Round(Round prev,
 Set<JavaFileObject> newSourceFiles, Map<String,JavaFileObject> newClassFiles) {
-this(prev.nextContext(),
+this(prev.number+1, prev.treesToClean, null);
-prev.number+1,
+prev.newRound();
-prev.compiler.log.nerrors,
-prev.compiler.log.nwarnings,
-null);
 this.genClassFiles = prev.genClassFiles;
 List<JCCompilationUnit> parsedFiles = compiler.parseFiles(newSourceFiles);
-roots = cleanTrees(prev.roots).appendList(parsedFiles);
+roots = prev.roots.appendList(parsedFiles);
 // Check for errors after parsing
 if (unrecoverableError())
 return;
 findAnnotationsPresent();
 }
 /** Create the next round to be used. */
 Round next(Set<JavaFileObject> newSourceFiles, Map<String, JavaFileObject> newClassFiles) {
-try {
+return new Round(this, newSourceFiles, newClassFiles);
-return new Round(this, newSourceFiles, newClassFiles);
+}
-} finally {
-compiler.close(false);
+/** Prepare the compiler for the final compilation. */
-}
+void finalCompiler() {
-}
+newRound();
-/** Create the compiler to be used for the final compilation. */
-JavaCompiler finalCompiler() {
-try {
-Context nextCtx = nextContext();
-JavacProcessingEnvironment.this.context = nextCtx;
-JavaCompiler c = JavaCompiler.instance(nextCtx);
-c.log.initRound(compiler.log);
-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. */
 annotationComputer.scan(pkgSym, annotationsPresent);
 }
 /** Enter a set of generated class files. */
 private List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) {
-Symtab symtab = Symtab.instance(context);
-Names names = Names.instance(context);
 List<ClassSymbol> list = List.nil();
 for (Map.Entry<String,JavaFileObject> entry : classFiles.entrySet()) {
 Name name = names.fromString(entry.getKey());
 JavaFileObject file = entry.getValue();
 Name packageName = Convert.packagePart(name);
 PackageSymbol p = symtab.enterPackage(packageName);
 if (p.package_info == null)
 p.package_info = symtab.enterClass(Convert.shortName(name), p);
 cs = p.package_info;
+cs.reset();
 if (cs.classfile == null)
 cs.classfile = file;
-} else
+cs.completer = initialCompleter;
-cs = symtab.enterClass(name, file);
+} else {
+cs = symtab.enterClass(name);
+cs.reset();
+cs.classfile = file;
+cs.completer = initialCompleter;
+}
 list = list.prepend(cs);
 }
 return list.reverse();
 }
 errorStatus,
 emptyRootElements,
 JavacProcessingEnvironment.this);
 discoveredProcs.iterator().runContributingProcs(renv);
 } else {
-discoverAndRunProcs(context, annotationsPresent, topLevelClasses, packageInfoFiles);
+discoverAndRunProcs(annotationsPresent, topLevelClasses, packageInfoFiles);
 }
 } catch (Throwable t) {
 // we're specifically expecting Abort here, but if any Throwable
 // comes by, we should flush all deferred diagnostics, rather than
 // drop them on the ground.
 deferredDiagnosticHandler.reportDeferredDiagnostics();
 log.popDiagnosticHandler(deferredDiagnosticHandler);
+compiler.setDeferredDiagnosticHandler(null);
 throw t;
 } finally {
 if (!taskListener.isEmpty())
 taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
 }
 // suppress errors, which are all presumed to be transient resolve errors
 kinds.remove(JCDiagnostic.Kind.ERROR);
 }
 deferredDiagnosticHandler.reportDeferredDiagnostics(kinds);
 log.popDiagnosticHandler(deferredDiagnosticHandler);
+compiler.setDeferredDiagnosticHandler(null);
 }
 /** Print info about this round. */
 private void printRoundInfo(boolean lastRound) {
 if (printRounds || verbose) {
 ap,
 lastRound);
 }
 }
-/** Get the context for the next round of processing.
+/** Prepare for new round of annotation processing. Cleans trees, resets symbols, and
-* Important values are propagated from round to round;
+* asks selected services to prepare to a new round of annotation processing.
-* other values are implicitly reset.
 */
-private Context nextContext() {
+private void newRound() {
-Context next = new Context(context);
+//ensure treesToClean contains all trees, including implicitly parsed ones
+for (Env<AttrContext> env : enter.getEnvs()) {
-Options options = Options.instance(context);
+treesToClean.add(env.toplevel);
-Assert.checkNonNull(options);
+}
-next.put(Options.optionsKey, options);
+for (JCCompilationUnit node : treesToClean) {
+treeCleaner.scan(node);
-Locale locale = context.get(Locale.class);
+}
-if (locale != null)
+chk.newRound();
-next.put(Locale.class, locale);
+enter.newRound();
+filer.newRound();
-Assert.checkNonNull(messages);
+messager.newRound();
-next.put(JavacMessages.messagesKey, messages);
+compiler.newRound();
+types.newRound();
-final boolean shareNames = true;
-if (shareNames) {
+boolean foundError = false;
-Names names = Names.instance(context);
-Assert.checkNonNull(names);
+for (ClassSymbol cs : symtab.classes.values()) {
-next.put(Names.namesKey, names);
+if (cs.kind == Kinds.ERR) {
-}
+foundError = true;
+break;
-DiagnosticListener<?> dl = context.get(DiagnosticListener.class);
+}
-if (dl != null)
+}
-next.put(DiagnosticListener.class, dl);
+if (foundError) {
-MultiTaskListener mtl = context.get(MultiTaskListener.taskListenerKey);
+for (ClassSymbol cs : symtab.classes.values()) {
-if (mtl != null)
+if (cs.classfile != null || cs.kind == Kinds.ERR) {
-next.put(MultiTaskListener.taskListenerKey, mtl);
+cs.reset();
+cs.type = new ClassType(cs.type.getEnclosingType(), null, cs);
-FSInfo fsInfo = context.get(FSInfo.class);
+if (cs.completer == null) {
-if (fsInfo != null)
+cs.completer = initialCompleter;
-next.put(FSInfo.class, fsInfo);
+}
+}
-JavaFileManager jfm = context.get(JavaFileManager.class);
+}
-Assert.checkNonNull(jfm);
+}
-next.put(JavaFileManager.class, jfm);
-if (jfm instanceof JavacFileManager) {
-((JavacFileManager)jfm).setContext(next);
-}
-Names names = Names.instance(context);
-Assert.checkNonNull(names);
-next.put(Names.namesKey, names);
-Tokens tokens = Tokens.instance(context);
-Assert.checkNonNull(tokens);
-next.put(Tokens.tokensKey, tokens);
-Log nextLog = Log.instance(next);
-nextLog.initRound(log);
-JavaCompiler oldCompiler = JavaCompiler.instance(context);
-JavaCompiler nextCompiler = JavaCompiler.instance(next);
-nextCompiler.initRound(oldCompiler);
-filer.newRound(next);
-messager.newRound(next);
-elementUtils.setContext(next);
-typeUtils.setContext(next);
-JavacTask task = context.get(JavacTask.class);
-if (task != null) {
-next.put(JavacTask.class, task);
-if (task instanceof BasicJavacTask)
-((BasicJavacTask) task).updateContext(next);
-}
-JavacTrees trees = context.get(JavacTrees.class);
-if (trees != null) {
-next.put(JavacTrees.class, trees);
-trees.updateContext(next);
-}
-context.clear();
-return next;
 }
 }
 // TODO: internal catch clauses?; catch and rethrow an annotation
 // processing error
-public JavaCompiler doProcessing(Context context,
+public boolean doProcessing(List<JCCompilationUnit> roots,
-List<JCCompilationUnit> roots,
+List<ClassSymbol> classSymbols,
-List<ClassSymbol> classSymbols,
+Iterable<? extends PackageSymbol> pckSymbols,
-Iterable<? extends PackageSymbol> pckSymbols,
+Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
-Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
+final Set<JCCompilationUnit> treesToClean =
-log = Log.instance(context);
+Collections.newSetFromMap(new IdentityHashMap<JCCompilationUnit, Boolean>());
+//fill already attributed implicit trees:
+for (Env<AttrContext> env : enter.getEnvs()) {
+treesToClean.add(env.toplevel);
+}
 Set<PackageSymbol> specifiedPackages = new LinkedHashSet<>();
 for (PackageSymbol psym : pckSymbols)
 specifiedPackages.add(psym);
 this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages);
-Round round = new Round(context, roots, classSymbols, deferredDiagnosticHandler);
+Round round = new Round(roots, classSymbols, treesToClean, deferredDiagnosticHandler);
 boolean errorStatus;
 boolean moreToDo;
 do {
 // Run processors for round n
 || werror && round.warningCount() > 0 && round.errorCount() > 0)
 errorStatus = true;
 Set<JavaFileObject> newSourceFiles =
 new LinkedHashSet<>(filer.getGeneratedSourceFileObjects());
-roots = cleanTrees(round.roots);
+roots = round.roots;
-JavaCompiler compiler = round.finalCompiler();
+errorStatus = errorStatus || (compiler.errorCount() > 0);
+if (!errorStatus)
+round.finalCompiler();
 if (newSourceFiles.size() > 0)
 roots = roots.appendList(compiler.parseFiles(newSourceFiles));
 errorStatus = errorStatus || (compiler.errorCount() > 0);
 taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
 if (errorStatus) {
 if (compiler.errorCount() == 0)
 compiler.log.nerrors++;
-return compiler;
+return true;
 }
 compiler.enterTreesIfNeeded(roots);
-return compiler;
+return true;
 }
 private void warnIfUnmatchedOptions() {
 if (!unmatchedProcessorOptions.isEmpty()) {
 log.warning("proc.unmatched.processor.options", unmatchedProcessorOptions.toString());
 }
 return false;
 }
-private static <T extends JCTree> List<T> cleanTrees(List<T> nodes) {
+class ImplicitCompleter implements Completer {
-for (T node : nodes)
-treeCleaner.scan(node);
+private final JCCompilationUnit topLevel;
-return nodes;
-}
+public ImplicitCompleter(JCCompilationUnit topLevel) {
+this.topLevel = topLevel;
-private static final TreeScanner treeCleaner = new TreeScanner() {
+}
+@Override public void complete(Symbol sym) throws CompletionFailure {
+compiler.complete(topLevel, (ClassSymbol) sym);
+}
+}
+private final TreeScanner treeCleaner = new TreeScanner() {
 public void scan(JCTree node) {
 super.scan(node);
 if (node != null)
 node.type = null;
 }
+JCCompilationUnit topLevel;
 public void visitTopLevel(JCCompilationUnit node) {
+if (node.packge != null) {
+if (node.packge.package_info != null) {
+node.packge.package_info.reset();
+}
+node.packge.reset();
+}
 node.packge = null;
-super.visitTopLevel(node);
+topLevel = node;
+try {
+super.visitTopLevel(node);
+} finally {
+topLevel = null;
+}
 }
 public void visitClassDef(JCClassDecl node) {
+if (node.sym != null) {
+node.sym.reset();
+node.sym.completer = new ImplicitCompleter(topLevel);
+}
 node.sym = null;
 super.visitClassDef(node);
 }
 public void visitMethodDef(JCMethodDecl node) {
 node.sym = null;

changeset 23810	b92eb80925f0
parent 23795	62509b72088e
child 24396	3c36c6afcbca