/*

 * Copyright (c) 1999, 2017, 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.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.Queue;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.function.Function;

import javax.annotation.processing.Processor;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.ElementVisitor;

import javax.tools.DiagnosticListener;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.JavaFileObject.Kind;

import javax.tools.StandardLocation;

import com.sun.source.util.TaskEvent;

import com.sun.tools.javac.api.DuplicateClassChecker;

import com.sun.tools.javac.api.MultiTaskListener;

import com.sun.tools.javac.code.*;

import com.sun.tools.javac.code.Lint.LintCategory;

import com.sun.tools.javac.code.Symbol.ClassSymbol;

import com.sun.tools.javac.code.Symbol.CompletionFailure;

import com.sun.tools.javac.code.Symbol.PackageSymbol;

import com.sun.tools.javac.comp.*;

import com.sun.tools.javac.comp.CompileStates.CompileState;

import com.sun.tools.javac.file.JavacFileManager;

import com.sun.tools.javac.jvm.*;

import com.sun.tools.javac.parser.*;

import com.sun.tools.javac.platform.PlatformDescription;

import com.sun.tools.javac.processing.*;

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.JCExpression;

import com.sun.tools.javac.tree.JCTree.JCLambda;

import com.sun.tools.javac.tree.JCTree.JCMemberReference;

import com.sun.tools.javac.tree.JCTree.JCMethodDecl;

import com.sun.tools.javac.tree.JCTree.JCVariableDecl;

import com.sun.tools.javac.util.*;

import com.sun.tools.javac.util.DefinedBy.Api;

import com.sun.tools.javac.util.JCDiagnostic.Factory;

import com.sun.tools.javac.util.Log.DiagnosticHandler;

import com.sun.tools.javac.util.Log.DiscardDiagnosticHandler;

import com.sun.tools.javac.util.Log.WriterKind;

import static com.sun.tools.javac.code.Kinds.Kind.*;

import com.sun.tools.javac.code.Symbol.ModuleSymbol;

import com.sun.tools.javac.resources.CompilerProperties.Errors;

import com.sun.tools.javac.resources.CompilerProperties.Warnings;

import static com.sun.tools.javac.code.TypeTag.CLASS;

import static com.sun.tools.javac.main.Option.*;

import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;

import java.util.Iterator;

import static javax.tools.StandardLocation.CLASS_OUTPUT;

import com.sun.tools.javac.tree.JCTree.JCModuleDecl;

/** 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.

 *

 *  <p><b>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.</b>

 */

public class JavaCompiler {

    /** The context key for the compiler. */

    public static final Context.Key<JavaCompiler> 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.

     *

     * <p>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 final 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 finder.

     */

    protected ClassFinder finder;

    /** The class reader.

     */

    protected ClassReader reader;

    /** The class writer.

     */

    protected ClassWriter writer;

    /** The native header writer.

     */

    protected JNIWriter jniWriter;

    /** 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 modules visitor

     */

    protected Modules modules;

    /** The module finder

     */

    protected ModuleFinder moduleFinder;

    /** The diagnostics factory

     */

    protected JCDiagnostic.Factory diags;

    /** The error repairer.

     */

    public Repair repair;

    /** 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;

    /** Broadcasting listener for progress events

     */

    protected MultiTaskListener taskListener;

    /**

     * SourceCompleter that delegates to the readSourceFile method of this class.

     */

    protected final Symbol.Completer sourceCompleter =

            sym -> readSourceFile((ClassSymbol) sym);

    /**

     * 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;

    private boolean enterDone;

    protected CompileStates compileStates;

    protected Map<JavaFileObject, JCCompilationUnit> notYetEntered;

    public boolean skipAnnotationProcessing = false;

    private final DuplicateClassChecker duplicateClassChecker;

    public List<JCCompilationUnit> toProcessAnnotations = List.nil();

    /** 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);

        finder = ClassFinder.instance(context);

        reader = ClassReader.instance(context);

        make = TreeMaker.instance(context);

        writer = ClassWriter.instance(context);

        jniWriter = JNIWriter.instance(context);

        enter = Enter.instance(context);

        todo = Todo.instance(context);

        fileManager = context.get(JavaFileManager.class);

        parserFactory = ParserFactory.instance(context);

        compileStates = CompileStates.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());

        }

        source = Source.instance(context);

        attr = Attr.instance(context);

        chk = Check.instance(context);

        gen = Gen.instance(context);

        flow = Flow.instance(context);

        repair = Repair.instance(context);

        transTypes = TransTypes.instance(context);

        lower = Lower.instance(context);

        annotate = Annotate.instance(context);

        types = Types.instance(context);

        taskListener = MultiTaskListener.instance(context);

        modules = Modules.instance(context);

        moduleFinder = ModuleFinder.instance(context);

        diags = Factory.instance(context);

        duplicateClassChecker = context.get(DuplicateClassChecker.class);

        finder.sourceCompleter = sourceCompleter;

        modules.findPackageInFile = this::findPackageInFile;

        moduleFinder.moduleNameFromSourceReader = this::readModuleName;

        options = Options.instance(context);

        verbose       = options.isSet(VERBOSE);

        sourceOutput  = options.isSet(PRINTSOURCE); // used to be -s

        lineDebugInfo = options.isUnset(G_CUSTOM) ||

                        options.isSet(G_CUSTOM, "lines");

        genEndPos     = options.isSet(XJCOV) ||

                        (context.get(DiagnosticListener.class) != null && options.get("backgroundCompilation") == null);

        devVerbose    = options.isSet("dev");

        processPcks   = options.isSet("process.packages");

        werror        = options.isSet(WERROR);

        keepComments  = options.getBoolean("keepComments");

        verboseCompilePolicy = options.isSet("verboseCompilePolicy");

        if (options.isSet("should-stop.at") &&

            CompileState.valueOf(options.get("should-stop.at")) == CompileState.ATTR)

            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;

        shouldStopPolicyIfError =

            options.isSet("should-stop.at") // backwards compatible

            ? CompileState.valueOf(options.get("should-stop.at"))

            : options.isSet("should-stop.ifError")

            ? CompileState.valueOf(options.get("should-stop.ifError"))

            : CompileState.INIT;

        shouldStopPolicyIfNoError =

            options.isSet("should-stop.ifNoError")

            ? CompileState.valueOf(options.get("should-stop.ifNoError"))

            : CompileState.GENERATE;

        if (options.isUnset("diags.legacy"))

            log.setDiagnosticFormatter(RichDiagnosticFormatter.instance(context));

        PlatformDescription platformProvider = context.get(PlatformDescription.class);

        if (platformProvider != null)

            closeables = closeables.prepend(platformProvider);

        silentFail = new Symbol(ABSENT_TYP, 0, names.empty, Type.noType, syms.rootPackage) {

            @DefinedBy(Api.LANGUAGE_MODEL)

            public <R, P> R accept(ElementVisitor<R, P> v, P p) {

                return v.visitUnknown(this, p);

            }

            @Override

            public boolean exists() {

                return false;

            }

        };

    }

    /* Switches:

     */

    /** Verbose output.

     */

    public boolean verbose;

    /** Emit plain Java source files rather than class files.

     */

    public boolean sourceOutput;

    /** 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 explicitly 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 compilation after errors have occurred.

     * Set this to minimum CompileState (INIT) to stop as soon as possible

     * after errors.

     */

    public CompileState shouldStopPolicyIfError;

    /**

     * Policy of how far to continue compilation when no errors have occurred.

     * Set this to maximum CompileState (GENERATE) to perform full compilation.

     * Set this lower to perform partial compilation, such as -proc:only.

     */

    public CompileState shouldStopPolicyIfNoError;

    /** A queue of all as yet unattributed classes.

     */

    public Todo todo;

    /** A list of items to be closed when the compilation is complete.

     */

    public List<Closeable> closeables = List.nil();

    /** 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<>();

    /** Used by the resolveBinaryNameOrIdent to say that the given type cannot be found, and that

     *  an error has already been produced about that.

     */

    private final Symbol silentFail;

    protected boolean shouldStop(CompileState cs) {

        CompileState shouldStopPolicy = (errorCount() > 0 || unrecoverableError())

            ? shouldStopPolicyIfError

            : shouldStopPolicyIfNoError;

        return cs.isAfter(shouldStopPolicy);

    }

    /** The number of errors reported so far.

     */

    public int errorCount() {

        if (werror && log.nerrors == 0 && log.nwarnings > 0) {

            log.error("warnings.and.werror");

        }

        return log.nerrors;

    }

    protected final <T> Queue<T> stopIfError(CompileState cs, Queue<T> queue) {

        return shouldStop(cs) ? new ListBuffer<T>() : queue;

    }

    protected final <T> List<T> stopIfError(CompileState cs, List<T> list) {

        return shouldStop(cs) ? List.nil() : list;

    }

    /** The number of warnings reported so far.

     */

    public int warningCount() {

        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 content      The characters to be parsed.

     */

    protected JCCompilationUnit parse(JavaFileObject filename, CharSequence content) {

        long msec = now();

        JCCompilationUnit tree = make.TopLevel(List.nil());

        if (content != null) {

            if (verbose) {

                log.printVerbose("parsing.started", filename);

            }

            if (!taskListener.isEmpty()) {

                TaskEvent e = new TaskEvent(TaskEvent.Kind.PARSE, filename);

                taskListener.started(e);

                keepComments = true;

                genEndPos = true;

            }

            Parser parser = parserFactory.newParser(content, keepComments(), genEndPos,

                                lineDebugInfo, filename != null && filename.isNameCompatible("module-info", Kind.SOURCE));

            tree = parser.parseCompilationUnit();

            if (verbose) {

                log.printVerbose("parsing.done", Long.toString(elapsed(msec)));

            }

        }

        tree.sourcefile = filename;

        if (content != null && !taskListener.isEmpty()) {

            TaskEvent e = new TaskEvent(TaskEvent.Kind.PARSE, tree);

            taskListener.finished(e);

        }

        return tree;

    }

    // where

        public boolean keepComments = false;

        protected boolean keepComments() {

            return keepComments || sourceOutput;

        }

    /** 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) {

        ModuleSymbol msym;

        String typeName;

        int sep = name.indexOf('/');

        if (sep == -1) {

            msym = modules.getDefaultModule();

            typeName = name;

        } else if (source.allowModules()) {

            Name modName = names.fromString(name.substring(0, sep));

            msym = moduleFinder.findModule(modName);

            typeName = name.substring(sep + 1);

        } else {

            log.error(Errors.InvalidModuleSpecifier(name));

            return silentFail;

        }

        return resolveBinaryNameOrIdent(msym, typeName);

    }

    /** Resolve an identifier which may be the binary name of a class or

     * the Java name of a class or package.

     * @param msym      The module in which the search should be performed

     * @param name      The name to resolve

     */

    public Symbol resolveBinaryNameOrIdent(ModuleSymbol msym, String name) {

        try {

            Name flatname = names.fromString(name.replace("/", "."));

            return finder.loadClass(msym, flatname);

        } catch (CompletionFailure ignore) {

            return resolveIdent(msym, name);

        }

    }

    /** Resolve an identifier.

     * @param msym      The module in which the search should be performed

     * @param name      The identifier to resolve

     */

    public Symbol resolveIdent(ModuleSymbol msym, String name) {

        if (name.equals(""))

            return syms.errSymbol;

        JavaFileObject prev = log.useSource(null);

        Log.DiagnosticHandler discardHandler = new Log.DiscardDiagnosticHandler(log);

        Log.DeferredDiagnosticHandler deferredHandler = deferredDiagnosticHandler;

        deferredDiagnosticHandler = 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());

            toplevel.modle = msym;

            toplevel.packge = msym.unnamedPackage;

            Symbol ret = attr.attribIdent(tree, toplevel);

            if (!skipAnnotationProcessing && deferredDiagnosticHandler != null && toProcessAnnotations.nonEmpty())

                processAnnotations(List.<JCCompilationUnit>nil());

            return ret;

        } finally {

            deferredDiagnosticHandler = deferredHandler;

            log.popDiagnosticHandler(discardHandler);

            log.useSource(prev);

        }

    }

    /** 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<AttrContext> env, JCClassDecl cdef) throws IOException {

        try {

            if (gen.genClass(env, cdef))

                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;

    }

    /** 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<AttrContext> 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 {

            try (BufferedWriter out = new BufferedWriter(outFile.openWriter())) {

                new Pretty(out, true).printUnit(env.toplevel, cdef);

                if (verbose)

                    log.printVerbose("wrote.file", outFile);

            }

            return outFile;

        }

    }

    /** Compile a source file that has been accessed by the class finder.

     *  @param c          The class the source file of which needs to be compiled.

     */

    private void readSourceFile(ClassSymbol c) throws CompletionFailure {

        readSourceFile(null, c);

    }

    /** Compile a ClassSymbol from source, optionally using the given compilation unit as

     *  the source tree.

     *  @param tree the compilation unit in which the given ClassSymbol resides,

     *              or null if should be parsed from source

     *  @param c    the ClassSymbol to complete

     */

    public void readSourceFile(JCCompilationUnit tree, ClassSymbol c) throws CompletionFailure {

        if (completionFailureName == c.fullname) {

            throw new CompletionFailure(c, "user-selected completion failure by class name");

        }

        JavaFileObject filename = c.classfile;

        if (tree == null && notYetEntered != null) {

            tree = notYetEntered.remove(filename);

        }

        if (tree == null) {

            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.<JCTree>nil());

            } finally {

                log.useSource(prev);

            }

        }

        if (!taskListener.isEmpty()) {

            TaskEvent e = new TaskEvent(TaskEvent.Kind.ENTER, tree);

            taskListener.started(e);

        }

        Log.DeferredDiagnosticHandler h = null;

        if (!skipAnnotationProcessing && processAnnotations && deferredDiagnosticHandler == null)

            deferredDiagnosticHandler = h = new Log.DeferredDiagnosticHandler(log);

        // Process module declarations.

        // If module resolution fails, ignore trees, and if trying to

        // complete a specific symbol, throw CompletionFailure.

        // Note that if module resolution failed, we may not even

        // have enough modules available to access java.lang, and

        // so risk getting FatalError("no.java.lang") from MemberEnter.

        if (!modules.enter(List.of(tree), c)) {

            throw new CompletionFailure(c, diags.fragment("cant.resolve.modules"));

        }

        enter.complete(List.of(tree), c);

        if (!taskListener.isEmpty()) {

            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);

            boolean isModuleInfo =

                tree.sourcefile.isNameCompatible("module-info",

                                                 JavaFileObject.Kind.SOURCE);

            if (isModuleInfo) {

                if (enter.getEnv(tree.modle) == null) {

                    if (h != null) {

                        log.popDiagnosticHandler(h);

                        deferredDiagnosticHandler = null;

                    }

                    JCDiagnostic diag =

                        diagFactory.fragment("file.does.not.contain.module");

                    throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory);

                }

            } else if (isPkgInfo) {

                if (enter.getEnv(tree.packge) == null) {

                    if (h != null) {

                        log.popDiagnosticHandler(h);

                        deferredDiagnosticHandler = null;

                    }

                    JCDiagnostic diag =

                        diagFactory.fragment("file.does.not.contain.package",

                                                 c.location());

                    throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory);

                }

            } else {

                if (h != null) {

                    log.popDiagnosticHandler(h);

                    deferredDiagnosticHandler = null;

                }

                JCDiagnostic diag =

                        diagFactory.fragment("file.doesnt.contain.class",

                                            c.getQualifiedName());

                throw new ClassFinder.BadClassFile(c, filename, diag, diagFactory);

            }

        }

        if (!skipAnnotationProcessing && processAnnotations && checkEntered(tree)) {

            JCCompilationUnit t = tree;

            finder.ap = () -> {

                if (annotate.annotationsBlocked() || annotate.isFlushing()) {

                    toProcessAnnotations = toProcessAnnotations.prepend(t);

                } else {

                    skipAnnotationProcessing = true;

                    try {

                        processAnnotations(List.of(t));

                    } finally {

                        skipAnnotationProcessing = false;

                    }

                }

            };

        }

        implicitSourceFilesRead = true;

    }

    private boolean checkEntered(JCCompilationUnit unit) {

        for (JCTree node : unit.defs) {

            if (node.hasTag(JCTree.Tag.CLASSDEF)) {

                if (((JCClassDecl) node).sym == null) {

                    return false;

                }

            }

        }

        return 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<JavaFileObject> sourceFileObject)

        throws Throwable {

        compile(sourceFileObject, List.nil(), null, List.nil());

    }

    /**

     * 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

     * @param addModules additional root modules to be used during

     * module resolution.

     */

    public void compile(Collection<JavaFileObject> sourceFileObjects,

                        Collection<String> classnames,

                        Iterable<? extends Processor> processors,

                        Collection<String> addModules)

    {

        if (!taskListener.isEmpty()) {

            taskListener.started(new TaskEvent(TaskEvent.Kind.COMPILATION));

        }

        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)

            checkReusable();

        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.primaryName + "-" + LintCategory.OPTIONS.option, "true");

        options.remove(XLINT_CUSTOM.primaryName + LintCategory.OPTIONS.option);

        start_msec = now();

        try {

            initProcessAnnotations(processors, sourceFileObjects, classnames);

            for (String className : classnames) {

                int sep = className.indexOf('/');

                if (sep != -1) {

                    modules.addExtraAddModules(className.substring(0, sep));

                }

            }

            for (String moduleName : addModules) {

                modules.addExtraAddModules(moduleName);

            }

            // These method calls must be chained to avoid memory leaks

            processAnnotations(

                enterTrees(