/* * Copyright (c) 1999, 2011, 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 * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package com.sun.tools.javac.main; import java.io.*; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.LinkedHashMap; import java.util.Map; import java.util.MissingResourceException; import java.util.Queue; import java.util.ResourceBundle; import java.util.Set; import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.Logger; import javax.annotation.processing.Processor; import javax.lang.model.SourceVersion; import javax.tools.JavaFileManager; import javax.tools.JavaFileObject; import javax.tools.DiagnosticListener; import com.sun.source.util.TaskEvent; import com.sun.source.util.TaskListener; import com.sun.tools.javac.file.JavacFileManager; import com.sun.tools.javac.util.*; import com.sun.tools.javac.code.*; import com.sun.tools.javac.code.Lint.LintCategory; import com.sun.tools.javac.code.Symbol.*; import com.sun.tools.javac.tree.*; import com.sun.tools.javac.tree.JCTree.*; import com.sun.tools.javac.parser.*; import com.sun.tools.javac.comp.*; import com.sun.tools.javac.jvm.*; import com.sun.tools.javac.processing.*; import static javax.tools.StandardLocation.CLASS_OUTPUT; import static com.sun.tools.javac.main.OptionName.*; import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*; import static com.sun.tools.javac.util.ListBuffer.lb; /** 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 * files. * *

This is NOT part of any supported API. * If you write code that depends on this, you do so at your own risk. * This code and its internal interfaces are subject to change or * deletion without notice. */ public class JavaCompiler implements ClassReader.SourceCompleter { /** The context key for the compiler. */ protected static final Context.Key compilerKey = new Context.Key(); /** Get the JavaCompiler instance for this context. */ public static JavaCompiler instance(Context context) { JavaCompiler instance = context.get(compilerKey); if (instance == null) instance = new JavaCompiler(context); return instance; } /** The current version number as a string. */ public static String version() { return version("release"); // mm.nn.oo[-milestone] } /** The current full version number as a string. */ public static String fullVersion() { return version("full"); // mm.mm.oo[-milestone]-build } private static final String versionRBName = "com.sun.tools.javac.resources.version"; private static ResourceBundle versionRB; private static String version(String key) { if (versionRB == null) { try { versionRB = ResourceBundle.getBundle(versionRBName); } catch (MissingResourceException e) { return Log.getLocalizedString("version.not.available"); } } try { return versionRB.getString(key); } catch (MissingResourceException e) { return Log.getLocalizedString("version.not.available"); } } /** * Control how the compiler's latter phases (attr, flow, desugar, generate) * are connected. Each individual file is processed by each phase in turn, * but with different compile policies, you can control the order in which * each class is processed through its next phase. * *

Generally speaking, the compiler will "fail fast" in the face of * errors, although not aggressively so. flow, desugar, etc become no-ops * once any errors have occurred. No attempt is currently made to determine * if it might be safe to process a class through its next phase because * it does not depend on any unrelated errors that might have occurred. */ protected static enum CompilePolicy { /** * Just attribute the parse trees. */ ATTR_ONLY, /** * Just attribute and do flow analysis on the parse trees. * This should catch most user errors. */ CHECK_ONLY, /** * Attribute everything, then do flow analysis for everything, * then desugar everything, and only then generate output. * This means no output will be generated if there are any * errors in any classes. */ SIMPLE, /** * Groups the classes for each source file together, then process * each group in a manner equivalent to the {@code SIMPLE} policy. * This means no output will be generated if there are any * errors in any of the classes in a source file. */ BY_FILE, /** * Completely process each entry on the todo list in turn. * -- this is the same for 1.5. * Means output might be generated for some classes in a compilation unit * and not others. */ BY_TODO; static CompilePolicy decode(String option) { if (option == null) return DEFAULT_COMPILE_POLICY; else if (option.equals("attr")) return ATTR_ONLY; else if (option.equals("check")) return CHECK_ONLY; else if (option.equals("simple")) return SIMPLE; else if (option.equals("byfile")) return BY_FILE; else if (option.equals("bytodo")) return BY_TODO; else return DEFAULT_COMPILE_POLICY; } } private static CompilePolicy DEFAULT_COMPILE_POLICY = CompilePolicy.BY_TODO; protected static enum ImplicitSourcePolicy { /** Don't generate or process implicitly read source files. */ NONE, /** Generate classes for implicitly read source files. */ CLASS, /** Like CLASS, but generate warnings if annotation processing occurs */ UNSET; static ImplicitSourcePolicy decode(String option) { if (option == null) return UNSET; else if (option.equals("none")) return NONE; else if (option.equals("class")) return CLASS; else return UNSET; } } /** The log to be used for error reporting. */ public Log log; /** Factory for creating diagnostic objects */ JCDiagnostic.Factory diagFactory; /** The tree factory module. */ protected TreeMaker make; /** The class reader. */ protected ClassReader reader; /** The class writer. */ protected ClassWriter writer; /** The module for the symbol table entry phases. */ protected Enter enter; /** The symbol table. */ protected Symtab syms; /** The language version. */ protected Source source; /** The module for code generation. */ protected Gen gen; /** The name table. */ protected Names names; /** The attributor. */ protected Attr attr; /** The attributor. */ protected Check chk; /** The flow analyzer. */ protected Flow flow; /** The type eraser. */ protected TransTypes transTypes; /** The syntactic sugar desweetener. */ protected Lower lower; /** The annotation annotator. */ protected Annotate annotate; /** Force a completion failure on this name */ protected final Name completionFailureName; /** Type utilities. */ protected Types types; /** Access to file objects. */ protected JavaFileManager fileManager; /** Factory for parsers. */ protected ParserFactory parserFactory; /** Optional listener for progress events */ protected TaskListener taskListener; /** * Annotation processing may require and provide a new instance * of the compiler to be used for the analyze and generate phases. */ protected JavaCompiler delegateCompiler; /** * Command line options. */ protected Options options; protected Context context; /** * Flag set if any annotation processing occurred. **/ protected boolean annotationProcessingOccurred; /** * Flag set if any implicit source files read. **/ protected boolean implicitSourceFilesRead; /** Construct a new compiler using a shared context. */ public JavaCompiler(Context context) { this.context = context; context.put(compilerKey, this); // if fileManager not already set, register the JavacFileManager to be used if (context.get(JavaFileManager.class) == null) JavacFileManager.preRegister(context); names = Names.instance(context); log = Log.instance(context); diagFactory = JCDiagnostic.Factory.instance(context); reader = ClassReader.instance(context); make = TreeMaker.instance(context); writer = ClassWriter.instance(context); enter = Enter.instance(context); todo = Todo.instance(context); fileManager = context.get(JavaFileManager.class); parserFactory = ParserFactory.instance(context); try { // catch completion problems with predefineds syms = Symtab.instance(context); } catch (CompletionFailure ex) { // inlined Check.completionError as it is not initialized yet log.error("cant.access", ex.sym, ex.getDetailValue()); if (ex instanceof ClassReader.BadClassFile) throw new Abort(); } source = Source.instance(context); attr = Attr.instance(context); chk = Check.instance(context); gen = Gen.instance(context); flow = Flow.instance(context); transTypes = TransTypes.instance(context); lower = Lower.instance(context); annotate = Annotate.instance(context); types = Types.instance(context); taskListener = context.get(TaskListener.class); reader.sourceCompleter = this; options = Options.instance(context); verbose = options.isSet(VERBOSE); sourceOutput = options.isSet(PRINTSOURCE); // used to be -s stubOutput = options.isSet("-stubs"); relax = options.isSet("-relax"); printFlat = options.isSet("-printflat"); attrParseOnly = options.isSet("-attrparseonly"); encoding = options.get(ENCODING); lineDebugInfo = options.isUnset(G_CUSTOM) || options.isSet(G_CUSTOM, "lines"); genEndPos = options.isSet(XJCOV) || context.get(DiagnosticListener.class) != null; devVerbose = options.isSet("dev"); processPcks = options.isSet("process.packages"); werror = options.isSet(WERROR); if (source.compareTo(Source.DEFAULT) < 0) { if (options.isUnset(XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option)) { if (fileManager instanceof BaseFileManager) { if (((BaseFileManager) fileManager).isDefaultBootClassPath()) log.warning(LintCategory.OPTIONS, "source.no.bootclasspath", source.name); } } } verboseCompilePolicy = options.isSet("verboseCompilePolicy"); if (attrParseOnly) compilePolicy = CompilePolicy.ATTR_ONLY; else compilePolicy = CompilePolicy.decode(options.get("compilePolicy")); implicitSourcePolicy = ImplicitSourcePolicy.decode(options.get("-implicit")); completionFailureName = options.isSet("failcomplete") ? names.fromString(options.get("failcomplete")) : null; shouldStopPolicy = options.isSet("shouldStopPolicy") ? CompileState.valueOf(options.get("shouldStopPolicy")) : null; if (options.isUnset("oldDiags")) log.setDiagnosticFormatter(RichDiagnosticFormatter.instance(context)); } /* Switches: */ /** Verbose output. */ public boolean verbose; /** Emit plain Java source files rather than class files. */ public boolean sourceOutput; /** Emit stub source files rather than class files. */ public boolean stubOutput; /** Generate attributed parse tree only. */ public boolean attrParseOnly; /** Switch: relax some constraints for producing the jsr14 prototype. */ boolean relax; /** Debug switch: Emit Java sources after inner class flattening. */ public boolean printFlat; /** The encoding to be used for source input. */ public String encoding; /** Generate code with the LineNumberTable attribute for debugging */ public boolean lineDebugInfo; /** Switch: should we store the ending positions? */ public boolean genEndPos; /** Switch: should we debug ignored exceptions */ protected boolean devVerbose; /** Switch: should we (annotation) process packages as well */ protected boolean processPcks; /** Switch: treat warnings as errors */ protected boolean werror; /** Switch: is annotation processing requested explitly via * CompilationTask.setProcessors? */ protected boolean explicitAnnotationProcessingRequested = false; /** * The policy for the order in which to perform the compilation */ protected CompilePolicy compilePolicy; /** * The policy for what to do with implicitly read source files */ protected ImplicitSourcePolicy implicitSourcePolicy; /** * 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. */ public enum CompileState { PARSE(1), ENTER(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,CompileState> { private static final long serialVersionUID = 1812267524140424433L; boolean isDone(Env env, CompileState cs) { CompileState ecs = get(env); return ecs != null && ecs.isDone(cs); } } private CompileStates compileStates = new CompileStates(); /** 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 inputFiles = new HashSet(); protected boolean shouldStop(CompileState cs) { if (shouldStopPolicy == null) return (errorCount() > 0 || unrecoverableError()); else return cs.ordinal() > shouldStopPolicy.ordinal(); } /** The number of errors reported so far. */ public int errorCount() { if (delegateCompiler != null && delegateCompiler != this) return delegateCompiler.errorCount(); else { if (werror && log.nerrors == 0 && log.nwarnings > 0) { log.error("warnings.and.werror"); } } return log.nerrors; } protected final Queue stopIfError(CompileState cs, Queue queue) { return shouldStop(cs) ? ListBuffer.lb() : queue; } protected final List stopIfError(CompileState cs, List list) { return shouldStop(cs) ? List.nil() : list; } /** The number of warnings reported so far. */ public int warningCount() { if (delegateCompiler != null && delegateCompiler != this) return delegateCompiler.warningCount(); else return log.nwarnings; } /** Try to open input stream with given name. * Report an error if this fails. * @param filename The file name of the input stream to be opened. */ public CharSequence readSource(JavaFileObject filename) { try { inputFiles.add(filename); return filename.getCharContent(false); } catch (IOException e) { log.error("error.reading.file", filename, JavacFileManager.getMessage(e)); return null; } } /** Parse contents of input stream. * @param filename The name of the file from which input stream comes. * @param input The input stream to be parsed. */ protected JCCompilationUnit parse(JavaFileObject filename, CharSequence content) { long msec = now(); JCCompilationUnit tree = make.TopLevel(List.nil(), null, List.nil()); if (content != null) { if (verbose) { log.printVerbose("parsing.started", filename); } if (taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.PARSE, filename); taskListener.started(e); } Parser parser = parserFactory.newParser(content, keepComments(), genEndPos, lineDebugInfo); tree = parser.parseCompilationUnit(); if (verbose) { log.printVerbose("parsing.done", Long.toString(elapsed(msec))); } } tree.sourcefile = filename; if (content != null && taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.PARSE, tree); taskListener.finished(e); } return tree; } // where public boolean keepComments = false; protected boolean keepComments() { return keepComments || sourceOutput || stubOutput; } /** Parse contents of file. * @param filename The name of the file to be parsed. */ @Deprecated public JCTree.JCCompilationUnit parse(String filename) { JavacFileManager fm = (JavacFileManager)fileManager; return parse(fm.getJavaFileObjectsFromStrings(List.of(filename)).iterator().next()); } /** Parse contents of file. * @param filename The name of the file to be parsed. */ public JCTree.JCCompilationUnit parse(JavaFileObject filename) { JavaFileObject prev = log.useSource(filename); try { JCTree.JCCompilationUnit t = parse(filename, readSource(filename)); if (t.endPositions != null) log.setEndPosTable(filename, t.endPositions); return t; } finally { log.useSource(prev); } } /** Resolve an identifier which may be the binary name of a class or * the Java name of a class or package. * @param name The name to resolve */ public Symbol resolveBinaryNameOrIdent(String name) { try { Name flatname = names.fromString(name.replace("/", ".")); return reader.loadClass(flatname); } catch (CompletionFailure ignore) { return resolveIdent(name); } } /** Resolve an identifier. * @param name The identifier to resolve */ public Symbol resolveIdent(String name) { if (name.equals("")) return syms.errSymbol; JavaFileObject prev = log.useSource(null); try { JCExpression tree = null; for (String s : name.split("\\.", -1)) { if (!SourceVersion.isIdentifier(s)) // TODO: check for keywords return syms.errSymbol; tree = (tree == null) ? make.Ident(names.fromString(s)) : make.Select(tree, names.fromString(s)); } JCCompilationUnit toplevel = make.TopLevel(List.nil(), null, List.nil()); toplevel.packge = syms.unnamedPackage; return attr.attribIdent(tree, toplevel); } finally { log.useSource(prev); } } /** Emit plain Java source for a class. * @param env The attribution environment of the outermost class * containing this class. * @param cdef The class definition to be printed. */ JavaFileObject printSource(Env env, JCClassDecl cdef) throws IOException { JavaFileObject outFile = fileManager.getJavaFileForOutput(CLASS_OUTPUT, cdef.sym.flatname.toString(), JavaFileObject.Kind.SOURCE, null); if (inputFiles.contains(outFile)) { log.error(cdef.pos(), "source.cant.overwrite.input.file", outFile); return null; } else { BufferedWriter out = new BufferedWriter(outFile.openWriter()); try { new Pretty(out, true).printUnit(env.toplevel, cdef); if (verbose) log.printVerbose("wrote.file", outFile); } finally { out.close(); } return outFile; } } /** Generate code and emit a class file for a given class * @param env The attribution environment of the outermost class * containing this class. * @param cdef The class definition from which code is generated. */ JavaFileObject genCode(Env env, JCClassDecl cdef) throws IOException { try { 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", ex.value.substring(0, 20)); } catch (CompletionFailure ex) { chk.completionError(cdef.pos(), ex); } return null; } /** Complete compiling a source file that has been accessed * by the class file reader. * @param c The class the source file of which needs to be compiled. * @param filename The name of the source file. * @param f An input stream that reads the source file. */ public void complete(ClassSymbol c) throws CompletionFailure { // System.err.println("completing " + c);//DEBUG if (completionFailureName == c.fullname) { throw new CompletionFailure(c, "user-selected completion failure by class name"); } JCCompilationUnit tree; JavaFileObject filename = c.classfile; JavaFileObject prev = log.useSource(filename); try { tree = parse(filename, filename.getCharContent(false)); } catch (IOException e) { log.error("error.reading.file", filename, JavacFileManager.getMessage(e)); tree = make.TopLevel(List.nil(), null, List.nil()); } finally { log.useSource(prev); } if (taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, tree); taskListener.started(e); } enter.complete(List.of(tree), c); if (taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, tree); taskListener.finished(e); } if (enter.getEnv(c) == null) { boolean isPkgInfo = tree.sourcefile.isNameCompatible("package-info", JavaFileObject.Kind.SOURCE); if (isPkgInfo) { if (enter.getEnv(tree.packge) == null) { JCDiagnostic diag = diagFactory.fragment("file.does.not.contain.package", c.location()); throw reader.new BadClassFile(c, filename, diag); } } else { JCDiagnostic diag = diagFactory.fragment("file.doesnt.contain.class", c.getQualifiedName()); throw reader.new BadClassFile(c, filename, diag); } } implicitSourceFilesRead = true; } /** Track when the JavaCompiler has been used to compile something. */ private boolean hasBeenUsed = false; private long start_msec = 0; public long elapsed_msec = 0; public void compile(List sourceFileObject) throws Throwable { compile(sourceFileObject, List.nil(), null); } /** * Main method: compile a list of files, return all compiled classes * * @param sourceFileObjects file objects to be compiled * @param classnames class names to process for annotations * @param processors user provided annotation processors to bypass * discovery, {@code null} means that no processors were provided */ public void compile(List sourceFileObjects, List classnames, Iterable processors) { if (processors != null && processors.iterator().hasNext()) explicitAnnotationProcessingRequested = true; // as a JavaCompiler can only be used once, throw an exception if // it has been used before. if (hasBeenUsed) throw new AssertionError("attempt to reuse JavaCompiler"); hasBeenUsed = true; // forcibly set the equivalent of -Xlint:-options, so that no further // warnings about command line options are generated from this point on options.put(XLINT_CUSTOM + "-" + LintCategory.OPTIONS.option, "true"); options.remove(XLINT_CUSTOM + LintCategory.OPTIONS.option); start_msec = now(); try { initProcessAnnotations(processors); // These method calls must be chained to avoid memory leaks delegateCompiler = processAnnotations( enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))), classnames); delegateCompiler.compile2(); delegateCompiler.close(); elapsed_msec = delegateCompiler.elapsed_msec; } catch (Abort ex) { if (devVerbose) ex.printStackTrace(System.err); } finally { if (procEnvImpl != null) procEnvImpl.close(); } } /** * The phases following annotation processing: attribution, * desugar, and finally code generation. */ private void compile2() { try { switch (compilePolicy) { case ATTR_ONLY: attribute(todo); break; case CHECK_ONLY: flow(attribute(todo)); break; case SIMPLE: generate(desugar(flow(attribute(todo)))); break; case BY_FILE: { Queue>> q = todo.groupByFile(); while (!q.isEmpty() && !shouldStop(CompileState.ATTR)) { generate(desugar(flow(attribute(q.remove())))); } } break; case BY_TODO: while (!todo.isEmpty()) generate(desugar(flow(attribute(todo.remove())))); break; default: Assert.error("unknown compile policy"); } } catch (Abort ex) { if (devVerbose) ex.printStackTrace(System.err); } if (verbose) { elapsed_msec = elapsed(start_msec); log.printVerbose("total", Long.toString(elapsed_msec)); } reportDeferredDiagnostics(); if (!log.hasDiagnosticListener()) { printCount("error", errorCount()); printCount("warn", warningCount()); } } private List rootClasses; /** * Parses a list of files. */ public List parseFiles(Iterable fileObjects) { if (shouldStop(CompileState.PARSE)) return List.nil(); //parse all files ListBuffer trees = lb(); Set filesSoFar = new HashSet(); for (JavaFileObject fileObject : fileObjects) { if (!filesSoFar.contains(fileObject)) { filesSoFar.add(fileObject); trees.append(parse(fileObject)); } } return trees.toList(); } /** * Enter the symbols found in a list of parse trees. * As a side-effect, this puts elements on the "todo" list. * Also stores a list of all top level classes in rootClasses. */ public List enterTrees(List roots) { //enter symbols for all files if (taskListener != null) { for (JCCompilationUnit unit: roots) { TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, unit); taskListener.started(e); } } enter.main(roots); if (taskListener != null) { for (JCCompilationUnit unit: roots) { TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, unit); taskListener.finished(e); } } //If generating source, remember the classes declared in //the original compilation units listed on the command line. if (sourceOutput || stubOutput) { ListBuffer cdefs = lb(); for (JCCompilationUnit unit : roots) { for (List defs = unit.defs; defs.nonEmpty(); defs = defs.tail) { if (defs.head instanceof JCClassDecl) cdefs.append((JCClassDecl)defs.head); } } rootClasses = cdefs.toList(); } // Ensure the input files have been recorded. Although this is normally // done by readSource, it may not have been done if the trees were read // in a prior round of annotation processing, and the trees have been // cleaned and are being reused. for (JCCompilationUnit unit : roots) { inputFiles.add(unit.sourcefile); } return roots; } /** * Set to true to enable skeleton annotation processing code. * Currently, we assume this variable will be replaced more * advanced logic to figure out if annotation processing is * needed. */ boolean processAnnotations = false; /** * Object to handle annotation processing. */ private JavacProcessingEnvironment procEnvImpl = null; /** * Check if we should process annotations. * If so, and if no scanner is yet registered, then set up the DocCommentScanner * to catch doc comments, and set keepComments so the parser records them in * the compilation unit. * * @param processors user provided annotation processors to bypass * discovery, {@code null} means that no processors were provided */ public void initProcessAnnotations(Iterable processors) { // Process annotations if processing is not disabled and there // is at least one Processor available. if (options.isSet(PROC, "none")) { processAnnotations = false; } else if (procEnvImpl == null) { procEnvImpl = new JavacProcessingEnvironment(context, processors); processAnnotations = procEnvImpl.atLeastOneProcessor(); if (processAnnotations) { options.put("save-parameter-names", "save-parameter-names"); reader.saveParameterNames = true; keepComments = true; genEndPos = true; if (taskListener != null) taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING)); log.deferDiagnostics = true; } else { // free resources procEnvImpl.close(); } } } // TODO: called by JavacTaskImpl public JavaCompiler processAnnotations(List roots) { return processAnnotations(roots, List.nil()); } /** * Process any anotations found in the specifed compilation units. * @param roots a list of compilation units * @return an instance of the compiler in which to complete the compilation */ // Implementation note: when this method is called, log.deferredDiagnostics // will have been set true by initProcessAnnotations, meaning that any diagnostics // that are reported will go into the log.deferredDiagnostics queue. // By the time this method exits, log.deferDiagnostics must be set back to false, // and all deferredDiagnostics must have been handled: i.e. either reported // or determined to be transient, and therefore suppressed. public JavaCompiler processAnnotations(List roots, List classnames) { if (shouldStop(CompileState.PROCESS)) { // Errors were encountered. // Unless all the errors are resolve errors, the errors were parse errors // or other errors during enter which cannot be fixed by running // any annotation processors. if (unrecoverableError()) { log.reportDeferredDiagnostics(); return this; } } // ASSERT: processAnnotations and procEnvImpl should have been set up by // by initProcessAnnotations // NOTE: The !classnames.isEmpty() checks should be refactored to Main. if (!processAnnotations) { // If there are no annotation processors present, and // annotation processing is to occur with compilation, // emit a warning. if (options.isSet(PROC, "only")) { log.warning("proc.proc-only.requested.no.procs"); todo.clear(); } // If not processing annotations, classnames must be empty if (!classnames.isEmpty()) { log.error("proc.no.explicit.annotation.processing.requested", classnames); } log.reportDeferredDiagnostics(); return this; // continue regular compilation } try { List classSymbols = List.nil(); List pckSymbols = List.nil(); if (!classnames.isEmpty()) { // Check for explicit request for annotation // processing if (!explicitAnnotationProcessingRequested()) { log.error("proc.no.explicit.annotation.processing.requested", classnames); log.reportDeferredDiagnostics(); return this; // TODO: Will this halt compilation? } else { boolean errors = false; for (String nameStr : classnames) { Symbol sym = resolveBinaryNameOrIdent(nameStr); if (sym == null || (sym.kind == Kinds.PCK && !processPcks) || sym.kind == Kinds.ABSENT_TYP) { log.error("proc.cant.find.class", nameStr); errors = true; continue; } try { if (sym.kind == Kinds.PCK) sym.complete(); if (sym.exists()) { if (sym.kind == Kinds.PCK) pckSymbols = pckSymbols.prepend((PackageSymbol)sym); else classSymbols = classSymbols.prepend((ClassSymbol)sym); continue; } Assert.check(sym.kind == Kinds.PCK); log.warning("proc.package.does.not.exist", nameStr); pckSymbols = pckSymbols.prepend((PackageSymbol)sym); } catch (CompletionFailure e) { log.error("proc.cant.find.class", nameStr); errors = true; continue; } } if (errors) { log.reportDeferredDiagnostics(); return this; } } } try { JavaCompiler c = procEnvImpl.doProcessing(context, roots, classSymbols, pckSymbols); if (c != this) annotationProcessingOccurred = c.annotationProcessingOccurred = true; // doProcessing will have handled deferred diagnostics Assert.check(c.log.deferDiagnostics == false && c.log.deferredDiagnostics.size() == 0); return c; } finally { procEnvImpl.close(); } } catch (CompletionFailure ex) { log.error("cant.access", ex.sym, ex.getDetailValue()); log.reportDeferredDiagnostics(); return this; } } private boolean unrecoverableError() { for (JCDiagnostic d: log.deferredDiagnostics) { if (d.getKind() == JCDiagnostic.Kind.ERROR && !d.isFlagSet(RECOVERABLE)) return true; } return false; } boolean explicitAnnotationProcessingRequested() { return explicitAnnotationProcessingRequested || explicitAnnotationProcessingRequested(options); } static boolean explicitAnnotationProcessingRequested(Options options) { return options.isSet(PROCESSOR) || options.isSet(PROCESSORPATH) || options.isSet(PROC, "only") || options.isSet(XPRINT); } /** * Attribute a list of parse trees, such as found on the "todo" list. * 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 Queue> attribute(Queue> envs) { ListBuffer> results = lb(); while (!envs.isEmpty()) results.append(attribute(envs.remove())); return stopIfError(CompileState.ATTR, results); } /** * Attribute a parse tree. * @returns the attributed parse tree */ public Env attribute(Env env) { if (compileStates.isDone(env, CompileState.ATTR)) return env; if (verboseCompilePolicy) printNote("[attribute " + env.enclClass.sym + "]"); if (verbose) log.printVerbose("checking.attribution", env.enclClass.sym); if (taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.ANALYZE, env.toplevel, env.enclClass.sym); taskListener.started(e); } JavaFileObject prev = log.useSource( env.enclClass.sym.sourcefile != null ? env.enclClass.sym.sourcefile : env.toplevel.sourcefile); try { attr.attrib(env); if (errorCount() > 0 && !shouldStop(CompileState.ATTR)) { //if in fail-over mode, ensure that AST expression nodes //are correctly initialized (e.g. they have a type/symbol) attr.postAttr(env); } compileStates.put(env, CompileState.ATTR); } finally { log.useSource(prev); } return env; } /** * 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 Queue> flow(Queue> envs) { ListBuffer> results = lb(); for (Env env: envs) { flow(env, results); } return stopIfError(CompileState.FLOW, results); } /** * Perform dataflow checks on an attributed parse tree. */ public Queue> flow(Env env) { ListBuffer> results = lb(); flow(env, results); return stopIfError(CompileState.FLOW, results); } /** * Perform dataflow checks on an attributed parse tree. */ protected void flow(Env env, Queue> results) { try { if (shouldStop(CompileState.FLOW)) return; if (relax || compileStates.isDone(env, CompileState.FLOW)) { results.add(env); return; } if (verboseCompilePolicy) 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, localMake); compileStates.put(env, CompileState.FLOW); if (shouldStop(CompileState.FLOW)) return; results.add(env); } finally { log.useSource(prev); } } finally { if (taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.ANALYZE, env.toplevel, env.enclClass.sym); taskListener.finished(e); } } } /** * 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 Queue, JCClassDecl>> desugar(Queue> envs) { ListBuffer, JCClassDecl>> results = lb(); for (Env env: envs) desugar(env, results); return stopIfError(CompileState.FLOW, results); } HashMap, Queue, JCClassDecl>>> desugaredEnvs = new HashMap, Queue, JCClassDecl>>>(); /** * 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 env, Queue, JCClassDecl>> results) { if (shouldStop(CompileState.TRANSTYPES)) return; if (implicitSourcePolicy == ImplicitSourcePolicy.NONE && !inputFiles.contains(env.toplevel.sourcefile)) { return; } if (compileStates.isDone(env, CompileState.LOWER)) { results.addAll(desugaredEnvs.get(env)); return; } /** * Ensure that superclasses of C are desugared before C itself. This is * required for two reasons: (i) as erasure (TransTypes) destroys * information needed in flow analysis and (ii) as some checks carried * out during lowering require that all synthetic fields/methods have * already been added to C and its superclasses. */ class ScanNested extends TreeScanner { Set> dependencies = new LinkedHashSet>(); @Override public void visitClassDef(JCClassDecl node) { Type st = types.supertype(node.sym.type); if (st.tag == TypeTags.CLASS) { ClassSymbol c = st.tsym.outermostClass(); Env stEnv = enter.getEnv(c); if (stEnv != null && env != stEnv) { if (dependencies.add(stEnv)) scan(stEnv.tree); } } super.visitClassDef(node); } } ScanNested scanner = new ScanNested(); scanner.scan(env.tree); for (Env dep: scanner.dependencies) { if (!compileStates.isDone(dep, CompileState.FLOW)) desugaredEnvs.put(dep, desugar(flow(attribute(dep)))); } //We need to check for error another time as more classes might //have been attributed and analyzed at this stage if (shouldStop(CompileState.TRANSTYPES)) return; if (verboseCompilePolicy) printNote("[desugar " + env.enclClass.sym + "]"); JavaFileObject prev = log.useSource(env.enclClass.sym.sourcefile != null ? env.enclClass.sym.sourcefile : env.toplevel.sourcefile); try { //save tree prior to rewriting JCTree untranslated = env.tree; 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 pdef = lower.translateTopLevelClass(env, env.tree, localMake); if (pdef.head != null) { Assert.check(pdef.tail.isEmpty()); results.add(new Pair, JCClassDecl>(env, (JCClassDecl)pdef.head)); } } return; } if (stubOutput) { //emit stub 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) && ((cdef.mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 || cdef.sym.packge().getQualifiedName() == names.java_lang)) { results.add(new Pair, JCClassDecl>(env, removeMethodBodies(cdef))); } return; } if (shouldStop(CompileState.TRANSTYPES)) return; env.tree = transTypes.translateTopLevelClass(env.tree, localMake); compileStates.put(env, CompileState.TRANSTYPES); if (shouldStop(CompileState.LOWER)) return; if (sourceOutput) { //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.add(new Pair, JCClassDecl>(env, cdef)); } return; } //translate out inner classes List cdefs = lower.translateTopLevelClass(env, env.tree, localMake); compileStates.put(env, CompileState.LOWER); if (shouldStop(CompileState.LOWER)) return; //generate code for each class for (List l = cdefs; l.nonEmpty(); l = l.tail) { JCClassDecl cdef = (JCClassDecl)l.head; results.add(new Pair, 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(Queue, JCClassDecl>> queue) { generate(queue, null); } public void generate(Queue, JCClassDecl>> queue, Queue results) { if (shouldStop(CompileState.GENERATE)) return; boolean usePrintSource = (stubOutput || sourceOutput || printFlat); for (Pair, JCClassDecl> x: queue) { Env env = x.fst; JCClassDecl cdef = x.snd; if (verboseCompilePolicy) { printNote("[generate " + (usePrintSource ? " source" : "code") + " " + cdef.sym + "]"); } if (taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.GENERATE, env.toplevel, cdef.sym); taskListener.started(e); } JavaFileObject prev = log.useSource(env.enclClass.sym.sourcefile != null ? env.enclClass.sym.sourcefile : env.toplevel.sourcefile); try { JavaFileObject file; if (usePrintSource) file = printSource(env, cdef); else file = genCode(env, cdef); if (results != null && file != null) results.add(file); } catch (IOException ex) { log.error(cdef.pos(), "class.cant.write", cdef.sym, ex.getMessage()); return; } finally { log.useSource(prev); } if (taskListener != null) { TaskEvent e = new TaskEvent(TaskEvent.Kind.GENERATE, env.toplevel, cdef.sym); taskListener.finished(e); } } } // where Map>> groupByFile(Queue> envs) { // use a LinkedHashMap to preserve the order of the original list as much as possible Map>> map = new LinkedHashMap>>(); for (Env env: envs) { Queue> sublist = map.get(env.toplevel); if (sublist == null) { sublist = new ListBuffer>(); map.put(env.toplevel, sublist); } sublist.add(env); } return map; } 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 newdefs = lb(); for (List it = tree.defs; it.tail != null; it = it.tail) { JCTree t = it.head; switch (t.getTag()) { case JCTree.CLASSDEF: if (isInterface || (((JCClassDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 || (((JCClassDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCClassDecl) t).sym.packge().getQualifiedName() == names.java_lang) newdefs.append(t); break; case JCTree.METHODDEF: if (isInterface || (((JCMethodDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 || ((JCMethodDecl) t).sym.name == names.init || (((JCMethodDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCMethodDecl) t).sym.packge().getQualifiedName() == names.java_lang) newdefs.append(t); break; case JCTree.VARDEF: if (isInterface || (((JCVariableDecl) t).mods.flags & (Flags.PROTECTED|Flags.PUBLIC)) != 0 || (((JCVariableDecl) t).mods.flags & (Flags.PRIVATE)) == 0 && ((JCVariableDecl) t).sym.packge().getQualifiedName() == names.java_lang) newdefs.append(t); break; default: break; } } tree.defs = newdefs.toList(); super.visitClassDef(tree); } } MethodBodyRemover r = new MethodBodyRemover(); return r.translate(cdef); } public void reportDeferredDiagnostics() { if (errorCount() == 0 && annotationProcessingOccurred && implicitSourceFilesRead && implicitSourcePolicy == ImplicitSourcePolicy.UNSET) { if (explicitAnnotationProcessingRequested()) log.warning("proc.use.implicit"); else log.warning("proc.use.proc.or.implicit"); } chk.reportDeferredDiagnostics(); } /** Close the compiler, flushing the logs */ public void close() { close(true); } public void close(boolean disposeNames) { rootClasses = null; reader = null; make = null; writer = null; enter = null; if (todo != null) todo.clear(); todo = null; parserFactory = null; syms = null; source = null; attr = null; chk = null; gen = null; flow = null; transTypes = null; lower = null; annotate = null; types = null; log.flush(); try { fileManager.flush(); } catch (IOException e) { throw new Abort(e); } finally { if (names != null && disposeNames) names.dispose(); names = null; } } protected void printNote(String lines) { Log.printLines(log.noticeWriter, lines); } /** Print numbers of errors and warnings. */ protected void printCount(String kind, int count) { if (count != 0) { String key; if (count == 1) key = "count." + kind; else key = "count." + kind + ".plural"; log.printErrLines(key, String.valueOf(count)); log.errWriter.flush(); } } private static long now() { return System.currentTimeMillis(); } private static long elapsed(long then) { return now() - then; } public void initRound(JavaCompiler prev) { genEndPos = prev.genEndPos; keepComments = prev.keepComments; start_msec = prev.start_msec; hasBeenUsed = true; } public static void enableLogging() { Logger logger = Logger.getLogger(com.sun.tools.javac.Main.class.getPackage().getName()); logger.setLevel(Level.ALL); for (Handler h : logger.getParent().getHandlers()) { h.setLevel(Level.ALL); } } }