jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java

equal deleted inserted replaced

-:4caf88912b7f
+:3b41f1c69604
 /*
-* Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicBoolean;
 import javax.annotation.processing.Processor;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.ElementFilter;
 import javax.tools.*;
+import javax.tools.JavaFileObject.Kind;
 import com.sun.source.tree.*;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.ModuleSymbol;
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
 import com.sun.tools.javac.comp.*;
 import com.sun.tools.javac.file.BaseFileManager;
 import com.sun.tools.javac.main.*;
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.parser.Parser;
 import com.sun.tools.javac.parser.ParserFactory;
 import com.sun.tools.javac.processing.AnnotationProcessingError;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.tree.JCTree.JCModuleDecl;
+import com.sun.tools.javac.tree.JCTree.Tag;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.DefinedBy.Api;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.Log.PrefixKind;
 import com.sun.tools.javac.util.Log.WriterKind;
 * Translate all the abstract syntax trees to elements.
 *
 * @return a list of elements corresponding to the top level
 * classes in the abstract syntax trees
 */
-public Iterable<? extends TypeElement> enter() {
+public Iterable<? extends Element> enter() {
 return enter(null);
 }
 /**
 * Translate the given abstract syntax trees to elements.
 *
 * @param trees a list of abstract syntax trees.
 * @return a list of elements corresponding to the top level
 * classes in the abstract syntax trees
 */
-public Iterable<? extends TypeElement> enter(Iterable<? extends CompilationUnitTree> trees)
+public Iterable<? extends Element> enter(Iterable<? extends CompilationUnitTree> trees)
 {
 if (trees == null && notYetEntered != null && notYetEntered.isEmpty())
 return List.nil();
+boolean wasInitialized = compiler != null;
 prepareCompiler(true);
 ListBuffer<JCCompilationUnit> roots = null;
 else
 throw new IllegalArgumentException(cu.toString());
 }
 }
-if (roots == null)
+if (roots == null) {
+if (trees == null && !wasInitialized) {
+compiler.initModules(List.nil());
+}
 return List.nil();
+}
-try {
-List<JCCompilationUnit> units = compiler.enterTrees(roots.toList());
+List<JCCompilationUnit> units = compiler.initModules(roots.toList());
+try {
+units = compiler.enterTrees(units);
 if (notYetEntered.isEmpty())
 compiler.processAnnotations(units);
-ListBuffer<TypeElement> elements = new ListBuffer<>();
+ListBuffer<Element> elements = new ListBuffer<>();
 for (JCCompilationUnit unit : units) {
-for (JCTree node : unit.defs) {
+boolean isPkgInfo = unit.sourcefile.isNameCompatible("package-info",
-if (node.hasTag(JCTree.Tag.CLASSDEF)) {
+JavaFileObject.Kind.SOURCE);
-JCClassDecl cdef = (JCClassDecl) node;
+if (isPkgInfo) {
-if (cdef.sym != null) // maybe null if errors in anno processing
+elements.append(unit.packge);
-elements.append(cdef.sym);
+} else {
+for (JCTree node : unit.defs) {
+if (node.hasTag(JCTree.Tag.CLASSDEF)) {
+JCClassDecl cdef = (JCClassDecl) node;
+if (cdef.sym != null) // maybe null if errors in anno processing
+elements.append(cdef.sym);
+} else if (node.hasTag(JCTree.Tag.MODULEDEF)) {
+JCModuleDecl mdef = (JCModuleDecl) node;
+if (mdef.sym != null)
+elements.append(mdef.sym);
+}
 }
 }
 }
 return elements.toList();
 }
 * @return the elements that were analyzed
 */
 // This implementation requires that we open up privileges on JavaCompiler.
 // An alternative implementation would be to move this code to JavaCompiler and
 // wrap it here
-public Iterable<? extends Element> analyze(Iterable<? extends TypeElement> classes) {
+public Iterable<? extends Element> analyze(Iterable<? extends Element> classes) {
 enter(null);  // ensure all classes have been entered
 final ListBuffer<Element> results = new ListBuffer<>();
 try {
 if (classes == null) {
 case CLASSDEF:
 JCClassDecl cdef = (JCClassDecl) env.tree;
 if (cdef.sym != null)
 elems.append(cdef.sym);
 break;
-case TOPLEVEL:
+case MODULEDEF:
-JCCompilationUnit unit = (JCCompilationUnit) env.tree;
+JCModuleDecl mod = (JCModuleDecl) env.tree;
+if (mod.sym != null)
+elems.append(mod.sym);
+break;
+case PACKAGEDEF:
+JCCompilationUnit unit = env.toplevel;
 if (unit.packge != null)
 elems.append(unit.packge);
 break;
 }
 }
 * If null is specified, code will be generated for all outstanding classes.
 *
 * @param classes a list of class elements
 * @return the files that were generated
 */
-public Iterable<? extends JavaFileObject> generate(Iterable<? extends TypeElement> classes) {
+public Iterable<? extends JavaFileObject> generate(Iterable<? extends Element> classes) {
 final ListBuffer<JavaFileObject> results = new ListBuffer<>();
 try {
 analyze(null);  // ensure all classes have been parsed, entered, and analyzed
 if (classes == null) {
 public Iterable<? extends Tree> pathFor(CompilationUnitTree unit, Tree node) {
 return TreeInfo.pathFor((JCTree) node, (JCTree.JCCompilationUnit) unit).reverse();
 }
+public void ensureEntered() {
+args.allowEmpty();
+enter(null);
+}
 abstract class Filter {
-void run(Queue<Env<AttrContext>> list, Iterable<? extends TypeElement> classes) {
+void run(Queue<Env<AttrContext>> list, Iterable<? extends Element> elements) {
-Set<TypeElement> set = new HashSet<>();
+Set<Element> set = new HashSet<>();
-for (TypeElement item: classes)
+for (Element item: elements) {
 set.add(item);
+}
 ListBuffer<Env<AttrContext>> defer = new ListBuffer<>();
 while (list.peek() != null) {
 Env<AttrContext> env = list.remove();
-ClassSymbol csym = env.enclClass.sym;
+Symbol test = null;
-if (csym != null && set.contains(csym.outermostClass()))
+if (env.tree.hasTag(Tag.MODULEDEF)) {
+test = ((JCModuleDecl) env.tree).sym;
+} else if (env.tree.hasTag(Tag.PACKAGEDEF)) {
+test = env.toplevel.packge;
+} else {
+ClassSymbol csym = env.enclClass.sym;
+if (csym != null)
+test = csym.outermostClass();
+}
+if (test != null && set.contains(test))
 process(env);
 else
 defer = defer.append(env);
 }

changeset 36526	3b41f1c69604
parent 32454	b0ac04e0fefe
child 41938	8e66bf10fcec