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

equal deleted inserted replaced

-:1cbbf23b22f9
+:f8929e3790b4
 completionFailureName =
 (options.get("failcomplete") != null)
 ? names.fromString(options.get("failcomplete"))
 : null;
+shouldStopPolicy =
+(options.get("shouldStopPolicy") != null)
+? CompileState.valueOf(options.get("shouldStopPolicy"))
+: null;
 }
 /* Switches:
 */
 /**
 * Report activity related to compilePolicy
 */
 public boolean verboseCompilePolicy;
+/**
+* Policy of how far to continue processing. null means until first
+* error.
+*/
+public CompileState shouldStopPolicy;
 /** A queue of all as yet unattributed classes.
 */
 public Todo todo;
+/** Ordered list of compiler phases for each compilation unit. */
 protected enum CompileState {
-TODO(0),
+PARSE(1),
-ATTR(1),
+ENTER(2),
-FLOW(2);
+PROCESS(3),
+ATTR(4),
+FLOW(5),
+TRANSTYPES(6),
+LOWER(7),
+GENERATE(8);
 CompileState(int value) {
 this.value = value;
 }
 boolean isDone(CompileState other) {
 return value >= other.value;
 }
 private int value;
 };
+/** Partial map to record which compiler phases have been executed
+* for each compilation unit. Used for ATTR and FLOW phases.
+*/
 protected class CompileStates extends HashMap<Env<AttrContext>,CompileState> {
 private static final long serialVersionUID = 1812267524140424433L;
 boolean isDone(Env<AttrContext> env, CompileState cs) {
 CompileState ecs = get(env);
 return ecs != null && ecs.isDone(cs);
 /** The set of currently compiled inputfiles, needed to ensure
 *  we don't accidentally overwrite an input file when -s is set.
 *  initialized by `compile'.
 */
 protected Set<JavaFileObject> inputFiles = new HashSet<JavaFileObject>();
+protected boolean shouldStop(CompileState cs) {
+if (shouldStopPolicy == null)
+return (errorCount() > 0);
+else
+return cs.ordinal() > shouldStopPolicy.ordinal();
+}
 /** The number of errors reported so far.
 */
 public int errorCount() {
 if (delegateCompiler != null && delegateCompiler != this)
 }
 }
 return log.nerrors;
 }
-protected final <T> Queue<T> stopIfError(Queue<T> queue) {
+protected final <T> Queue<T> stopIfError(CompileState cs, Queue<T> queue) {
-if (errorCount() == 0)
+return shouldStop(cs) ? ListBuffer.<T>lb() : queue;
-return queue;
+}
-else
-return ListBuffer.lb();
+protected final <T> List<T> stopIfError(CompileState cs, List<T> list) {
-}
+return shouldStop(cs) ? List.<T>nil() : list;
-protected final <T> List<T> stopIfError(List<T> list) {
-if (errorCount() == 0)
-return list;
-else
-return List.nil();
 }
 /** The number of warnings reported so far.
 */
 public int warningCount() {
 *                containing this class.
 *  @param cdef   The class definition from which code is generated.
 */
 JavaFileObject genCode(Env<AttrContext> env, JCClassDecl cdef) throws IOException {
 try {
-if (gen.genClass(env, cdef))
+if (gen.genClass(env, cdef) && (errorCount() == 0))
 return writer.writeClass(cdef.sym);
 } catch (ClassWriter.PoolOverflow ex) {
 log.error(cdef.pos(), "limit.pool");
 } catch (ClassWriter.StringOverflow ex) {
 log.error(cdef.pos(), "limit.string.overflow",
 start_msec = now();
 try {
 initProcessAnnotations(processors);
 // These method calls must be chained to avoid memory leaks
-delegateCompiler = processAnnotations(enterTrees(stopIfError(parseFiles(sourceFileObjects))),
+delegateCompiler =
-classnames);
+processAnnotations(
+enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
+classnames);
 delegateCompiler.compile2();
 delegateCompiler.close();
 elapsed_msec = delegateCompiler.elapsed_msec;
 } catch (Abort ex) {
 generate(desugar(flow(attribute(todo))));
 break;
 case BY_FILE: {
 Queue<Queue<Env<AttrContext>>> q = todo.groupByFile();
-while (!q.isEmpty() && errorCount() == 0) {
+while (!q.isEmpty() && !shouldStop(CompileState.ATTR)) {
 generate(desugar(flow(attribute(q.remove()))));
 }
 }
 break;
 /**
 * Parses a list of files.
 */
 public List<JCCompilationUnit> parseFiles(List<JavaFileObject> fileObjects) throws IOException {
-if (errorCount() > 0)
+if (shouldStop(CompileState.PARSE))
 return List.nil();
 //parse all files
 ListBuffer<JCCompilationUnit> trees = lb();
 for (JavaFileObject fileObject : fileObjects)
 * @return an instance of the compiler in which to complete the compilation
 */
 public JavaCompiler processAnnotations(List<JCCompilationUnit> roots,
 List<String> classnames)
 throws IOException  { // TODO: see TEMP note in JavacProcessingEnvironment
-if (errorCount() != 0) {
+if (shouldStop(CompileState.PROCESS)) {
 // Errors were encountered.  If todo is empty, then the
 // encountered errors were parse errors.  Otherwise, the
 // errors were found during the enter phase which should
 // be ignored when processing annotations.
 */
 public Queue<Env<AttrContext>> attribute(Queue<Env<AttrContext>> envs) {
 ListBuffer<Env<AttrContext>> results = lb();
 while (!envs.isEmpty())
 results.append(attribute(envs.remove()));
-return results;
+return stopIfError(CompileState.ATTR, results);
 }
 /**
 * Attribute a parse tree.
 * @returns the attributed parse tree
 public Queue<Env<AttrContext>> flow(Queue<Env<AttrContext>> envs) {
 ListBuffer<Env<AttrContext>> results = lb();
 for (Env<AttrContext> env: envs) {
 flow(env, results);
 }
-return stopIfError(results);
+return stopIfError(CompileState.FLOW, results);
 }
 /**
 * Perform dataflow checks on an attributed parse tree.
 */
 public Queue<Env<AttrContext>> flow(Env<AttrContext> env) {
 ListBuffer<Env<AttrContext>> results = lb();
 flow(env, results);
-return stopIfError(results);
+return stopIfError(CompileState.FLOW, results);
 }
 /**
 * Perform dataflow checks on an attributed parse tree.
 */
 protected void flow(Env<AttrContext> env, Queue<Env<AttrContext>> results) {
 try {
-if (errorCount() > 0)
+if (shouldStop(CompileState.FLOW))
 return;
 if (relax || compileStates.isDone(env, CompileState.FLOW)) {
 results.add(env);
 return;
 }
 if (verboseCompilePolicy)
-log.printLines(log.noticeWriter, "[flow " + env.enclClass.sym + "]");
+printNote("[flow " + env.enclClass.sym + "]");
 JavaFileObject prev = log.useSource(
 env.enclClass.sym.sourcefile != null ?
 env.enclClass.sym.sourcefile :
 env.toplevel.sourcefile);
 try {
 make.at(Position.FIRSTPOS);
 TreeMaker localMake = make.forToplevel(env.toplevel);
 flow.analyzeTree(env.tree, localMake);
 compileStates.put(env, CompileState.FLOW);
-if (errorCount() > 0)
+if (shouldStop(CompileState.FLOW))
 return;
 results.add(env);
 }
 finally {
 */
 public Queue<Pair<Env<AttrContext>, JCClassDecl>> desugar(Queue<Env<AttrContext>> envs) {
 ListBuffer<Pair<Env<AttrContext>, JCClassDecl>> results = lb();
 for (Env<AttrContext> env: envs)
 desugar(env, results);
-return stopIfError(results);
+return stopIfError(CompileState.FLOW, 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(final Env<AttrContext> env, Queue<Pair<Env<AttrContext>, JCClassDecl>> results) {
-if (errorCount() > 0)
+if (shouldStop(CompileState.TRANSTYPES))
 return;
 if (implicitSourcePolicy == ImplicitSourcePolicy.NONE
 && !inputFiles.contains(env.toplevel.sourcefile)) {
 return;
 * including information in supertypes, we need to ensure that supertypes
 * are processed through attribute and flow before subtypes are translated.
 */
 class ScanNested extends TreeScanner {
 Set<Env<AttrContext>> dependencies = new LinkedHashSet<Env<AttrContext>>();
+@Override
 public void visitClassDef(JCClassDecl node) {
 Type st = types.supertype(node.sym.type);
 if (st.tag == TypeTags.CLASS) {
 ClassSymbol c = st.tsym.outermostClass();
 Env<AttrContext> stEnv = enter.getEnv(c);
 flow(attribute(dep));
 }
 //We need to check for error another time as more classes might
 //have been attributed and analyzed at this stage
-if (errorCount() > 0)
+if (shouldStop(CompileState.TRANSTYPES))
 return;
 if (verboseCompilePolicy)
-log.printLines(log.noticeWriter, "[desugar " + env.enclClass.sym + "]");
+printNote("[desugar " + env.enclClass.sym + "]");
 JavaFileObject prev = log.useSource(env.enclClass.sym.sourcefile != null ?
 env.enclClass.sym.sourcefile :
 env.toplevel.sourcefile);
 try {
 make.at(Position.FIRSTPOS);
 TreeMaker localMake = make.forToplevel(env.toplevel);
 if (env.tree instanceof JCCompilationUnit) {
 if (!(stubOutput || sourceOutput || printFlat)) {
+if (shouldStop(CompileState.LOWER))
+return;
 List<JCTree> pdef = lower.translateTopLevelClass(env, env.tree, localMake);
 if (pdef.head != null) {
 assert pdef.tail.isEmpty();
 results.add(new Pair<Env<AttrContext>, JCClassDecl>(env, (JCClassDecl)pdef.head));
 }
 results.add(new Pair<Env<AttrContext>, JCClassDecl>(env, removeMethodBodies(cdef)));
 }
 return;
 }
+if (shouldStop(CompileState.TRANSTYPES))
+return;
 env.tree = transTypes.translateTopLevelClass(env.tree, localMake);
-if (errorCount() != 0)
+if (shouldStop(CompileState.LOWER))
 return;
 if (sourceOutput) {
 //emit standard Java source file, only for compilation
 //units enumerated explicitly on the command line
 }
 //translate out inner classes
 List<JCTree> cdefs = lower.translateTopLevelClass(env, env.tree, localMake);
-if (errorCount() != 0)
+if (shouldStop(CompileState.LOWER))
 return;
 //generate code for each class
 for (List<JCTree> l = cdefs; l.nonEmpty(); l = l.tail) {
 JCClassDecl cdef = (JCClassDecl)l.head;
 public void generate(Queue<Pair<Env<AttrContext>, JCClassDecl>> queue) {
 generate(queue, null);
 }
 public void generate(Queue<Pair<Env<AttrContext>, JCClassDecl>> queue, Queue<JavaFileObject> results) {
+if (shouldStop(CompileState.GENERATE))
+return;
 boolean usePrintSource = (stubOutput || sourceOutput || printFlat);
 for (Pair<Env<AttrContext>, JCClassDecl> x: queue) {
 Env<AttrContext> env = x.fst;
 JCClassDecl cdef = x.snd;
 if (verboseCompilePolicy) {
-log.printLines(log.noticeWriter, "[generate "
+printNote("[generate "
 + (usePrintSource ? " source" : "code")
 + " " + cdef.sym + "]");
 }
 if (taskListener != null) {
 }
 JCClassDecl removeMethodBodies(JCClassDecl cdef) {
 final boolean isInterface = (cdef.mods.flags & Flags.INTERFACE) != 0;
 class MethodBodyRemover extends TreeTranslator {
+@Override
 public void visitMethodDef(JCMethodDecl tree) {
 tree.mods.flags &= ~Flags.SYNCHRONIZED;
 for (JCVariableDecl vd : tree.params)
 vd.mods.flags &= ~Flags.FINAL;
 tree.body = null;
 super.visitMethodDef(tree);
 }
+@Override
 public void visitVarDef(JCVariableDecl tree) {
 if (tree.init != null && tree.init.type.constValue() == null)
 tree.init = null;
 super.visitVarDef(tree);
 }
+@Override
 public void visitClassDef(JCClassDecl tree) {
 ListBuffer<JCTree> newdefs = lb();
 for (List<JCTree> it = tree.defs; it.tail != null; it = it.tail) {
 JCTree t = it.head;
 switch (t.getTag()) {
 names.dispose();
 names = null;
 }
 }
+protected void printNote(String lines) {
+Log.printLines(log.noticeWriter, lines);
+}
 /** Output for "-verbose" option.
 *  @param key The key to look up the correct internationalized string.
 *  @param arg An argument for substitution into the output string.
 */
 protected void printVerbose(String key, Object arg) {
-Log.printLines(log.noticeWriter, log.getLocalizedString("verbose." + key, arg));
+Log.printLines(log.noticeWriter, Log.getLocalizedString("verbose." + key, arg));
 }
 /** Print numbers of errors and warnings.
 */
 protected void printCount(String kind, int count) {
 if (count != 0) {
 String text;
 if (count == 1)
-text = log.getLocalizedString("count." + kind, String.valueOf(count));
+text = Log.getLocalizedString("count." + kind, String.valueOf(count));
 else
-text = log.getLocalizedString("count." + kind + ".plural", String.valueOf(count));
+text = Log.getLocalizedString("count." + kind + ".plural", String.valueOf(count));
 Log.printLines(log.errWriter, text);
 log.errWriter.flush();
 }
 }

changeset 2514	f8929e3790b4
parent 2212	1d3dc0e0ba0c
child 2984	e15ff3a34054