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

equal deleted inserted replaced

-:3113c955a388
+:b1cf6afb8244
 import static com.sun.tools.javac.util.ListBuffer.lb;
 // TEMP, until we have a more efficient way to save doc comment info
 import com.sun.tools.javac.parser.DocCommentScanner;
+import java.util.Queue;
 import javax.lang.model.SourceVersion;
 /** This class could be the main entry point for GJC when GJC is used as a
 *  component in a larger software system. It provides operations to
 *  construct a new compiler, and to run a new compiler on a set of source
 return delegateCompiler.errorCount();
 else
 return log.nerrors;
 }
-protected final <T> List<T> stopIfError(ListBuffer<T> listBuffer) {
+protected final <T> Queue<T> stopIfError(Queue<T> queue) {
 if (errorCount() == 0)
-return listBuffer.toList();
+return queue;
 else
-return List.nil();
+return ListBuffer.lb();
 }
 protected final <T> List<T> stopIfError(List<T> list) {
 if (errorCount() == 0)
 return list;
 case SIMPLE:
 generate(desugar(flow(attribute(todo))));
 break;
 case BY_FILE:
-for (List<Env<AttrContext>> list : groupByFile(flow(attribute(todo))).values())
+for (Queue<Env<AttrContext>> queue : groupByFile(flow(attribute(todo))).values())
-generate(desugar(list));
+generate(desugar(queue));
 break;
 case BY_TODO:
 while (todo.nonEmpty())
 generate(desugar(flow(attribute(todo.next()))));
 if (devVerbose)
 ex.printStackTrace();
 }
 if (verbose) {
-elapsed_msec = elapsed(start_msec);;
+elapsed_msec = elapsed(start_msec);
 printVerbose("total", Long.toString(elapsed_msec));
 }
 reportDeferredDiagnostics();
 * Note that attributing classes may cause additional files to be
 * parsed and entered via the SourceCompleter.
 * Attribution of the entries in the list does not stop if any errors occur.
 * @returns a list of environments for attributd classes.
 */
-public List<Env<AttrContext>> attribute(ListBuffer<Env<AttrContext>> envs) {
+public Queue<Env<AttrContext>> attribute(Queue<Env<AttrContext>> envs) {
 ListBuffer<Env<AttrContext>> results = lb();
-while (envs.nonEmpty())
+while (!envs.isEmpty())
-results.append(attribute(envs.next()));
+results.append(attribute(envs.remove()));
-return results.toList();
+return results;
 }
 /**
 * Attribute a parse tree.
 * @returns the attributed parse tree
 * Perform dataflow checks on attributed parse trees.
 * These include checks for definite assignment and unreachable statements.
 * If any errors occur, an empty list will be returned.
 * @returns the list of attributed parse trees
 */
-public List<Env<AttrContext>> flow(List<Env<AttrContext>> envs) {
+public Queue<Env<AttrContext>> flow(Queue<Env<AttrContext>> envs) {
 ListBuffer<Env<AttrContext>> results = lb();
-for (List<Env<AttrContext>> l = envs; l.nonEmpty(); l = l.tail) {
+for (Env<AttrContext> env: envs) {
-flow(l.head, results);
+flow(env, results);
 }
 return stopIfError(results);
 }
 /**
 * Perform dataflow checks on an attributed parse tree.
 */
-public List<Env<AttrContext>> flow(Env<AttrContext> env) {
+public Queue<Env<AttrContext>> flow(Env<AttrContext> env) {
 ListBuffer<Env<AttrContext>> results = lb();
 flow(env, results);
 return stopIfError(results);
 }
 * Prepare attributed parse trees, in conjunction with their attribution contexts,
 * for source or code generation.
 * If any errors occur, an empty list will be returned.
 * @returns a list containing the classes to be generated
 */
-public List<Pair<Env<AttrContext>, JCClassDecl>> desugar(List<Env<AttrContext>> envs) {
+public Queue<Pair<Env<AttrContext>, JCClassDecl>> desugar(Queue<Env<AttrContext>> envs) {
 ListBuffer<Pair<Env<AttrContext>, JCClassDecl>> results = lb();
-for (List<Env<AttrContext>> l = envs; l.nonEmpty(); l = l.tail)
+for (Env<AttrContext> env: envs)
-desugar(l.head, results);
+desugar(env, results);
 return stopIfError(results);
 }
 /**
 * Prepare attributed parse trees, in conjunction with their attribution contexts,
 * for source or code generation. If the file was not listed on the command line,
 * the current implicitSourcePolicy is taken into account.
 * The preparation stops as soon as an error is found.
 */
-protected void desugar(Env<AttrContext> env, ListBuffer<Pair<Env<AttrContext>, JCClassDecl>> results) {
+protected void desugar(Env<AttrContext> env, Queue<Pair<Env<AttrContext>, JCClassDecl>> results) {
 if (errorCount() > 0)
 return;
 if (implicitSourcePolicy == ImplicitSourcePolicy.NONE
 && !inputFiles.contains(env.toplevel.sourcefile)) {
 if (env.tree instanceof JCCompilationUnit) {
 if (!(stubOutput || sourceOutput || printFlat)) {
 List<JCTree> pdef = lower.translateTopLevelClass(env, env.tree, localMake);
 if (pdef.head != null) {
 assert pdef.tail.isEmpty();
-results.append(new Pair<Env<AttrContext>, JCClassDecl>(env, (JCClassDecl)pdef.head));
+results.add(new Pair<Env<AttrContext>, JCClassDecl>(env, (JCClassDecl)pdef.head));
 }
 }
 return;
 }
 JCClassDecl cdef = (JCClassDecl)env.tree;
 if (untranslated instanceof JCClassDecl &&
 rootClasses.contains((JCClassDecl)untranslated) &&
 ((cdef.mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 ||
 cdef.sym.packge().getQualifiedName() == names.java_lang)) {
-results.append(new Pair<Env<AttrContext>, JCClassDecl>(env, removeMethodBodies(cdef)));
+results.add(new Pair<Env<AttrContext>, JCClassDecl>(env, removeMethodBodies(cdef)));
 }
 return;
 }
 env.tree = transTypes.translateTopLevelClass(env.tree, localMake);
 //emit standard Java source file, only for compilation
 //units enumerated explicitly on the command line
 JCClassDecl cdef = (JCClassDecl)env.tree;
 if (untranslated instanceof JCClassDecl &&
 rootClasses.contains((JCClassDecl)untranslated)) {
-results.append(new Pair<Env<AttrContext>, JCClassDecl>(env, cdef));
+results.add(new Pair<Env<AttrContext>, JCClassDecl>(env, cdef));
 }
 return;
 }
 //translate out inner classes
 return;
 //generate code for each class
 for (List<JCTree> l = cdefs; l.nonEmpty(); l = l.tail) {
 JCClassDecl cdef = (JCClassDecl)l.head;
-results.append(new Pair<Env<AttrContext>, JCClassDecl>(env, cdef));
+results.add(new Pair<Env<AttrContext>, JCClassDecl>(env, cdef));
 }
 }
 finally {
 log.useSource(prev);
 }
 /** Generates the source or class file for a list of classes.
 * The decision to generate a source file or a class file is
 * based upon the compiler's options.
 * Generation stops if an error occurs while writing files.
 */
-public void generate(List<Pair<Env<AttrContext>, JCClassDecl>> list) {
+public void generate(Queue<Pair<Env<AttrContext>, JCClassDecl>> queue) {
-generate(list, null);
+generate(queue, null);
 }
-public void generate(List<Pair<Env<AttrContext>, JCClassDecl>> list, ListBuffer<JavaFileObject> results) {
+public void generate(Queue<Pair<Env<AttrContext>, JCClassDecl>> queue, ListBuffer<JavaFileObject> results) {
 boolean usePrintSource = (stubOutput || sourceOutput || printFlat);
-for (List<Pair<Env<AttrContext>, JCClassDecl>> l = list; l.nonEmpty(); l = l.tail) {
+for (Pair<Env<AttrContext>, JCClassDecl> x: queue) {
-Pair<Env<AttrContext>, JCClassDecl> x = l.head;
 Env<AttrContext> env = x.fst;
 JCClassDecl cdef = x.snd;
 if (verboseCompilePolicy) {
 log.printLines(log.noticeWriter, "[generate "
 }
 }
 }
 // where
-Map<JCCompilationUnit, List<Env<AttrContext>>> groupByFile(List<Env<AttrContext>> list) {
+Map<JCCompilationUnit, Queue<Env<AttrContext>>> groupByFile(Queue<Env<AttrContext>> envs) {
 // use a LinkedHashMap to preserve the order of the original list as much as possible
-Map<JCCompilationUnit, List<Env<AttrContext>>> map = new LinkedHashMap<JCCompilationUnit, List<Env<AttrContext>>>();
+Map<JCCompilationUnit, Queue<Env<AttrContext>>> map = new LinkedHashMap<JCCompilationUnit, Queue<Env<AttrContext>>>();
-Set<JCCompilationUnit> fixupSet = new HashSet<JCTree.JCCompilationUnit>();
+for (Env<AttrContext> env: envs) {
-for (List<Env<AttrContext>> l = list; l.nonEmpty(); l = l.tail) {
+Queue<Env<AttrContext>> sublist = map.get(env.toplevel);
-Env<AttrContext> env = l.head;
+if (sublist == null) {
-List<Env<AttrContext>> sublist = map.get(env.toplevel);
+sublist = new ListBuffer<Env<AttrContext>>();
-if (sublist == null)
+map.put(env.toplevel, sublist);
-sublist = List.of(env);
-else {
-// this builds the list for the file in reverse order, so make a note
-// to reverse the list before returning.
-sublist = sublist.prepend(env);
-fixupSet.add(env.toplevel);
 }
-map.put(env.toplevel, sublist);
+sublist.add(env);
 }
-// fixup any lists that need reversing back to the correct order
-for (JCTree.JCCompilationUnit tree: fixupSet)
-map.put(tree, map.get(tree).reverse());
 return map;
 }
 JCClassDecl removeMethodBodies(JCClassDecl cdef) {
 final boolean isInterface = (cdef.mods.flags & Flags.INTERFACE) != 0;

changeset 864	b1cf6afb8244
parent 735	372aa565a221
child 936	1d395a623f16