/*

 * Copyright (c) 1999, 2016, 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.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 javax.annotation.processing.Processor;

import javax.lang.model.SourceVersion;

import javax.tools.DiagnosticListener;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.StandardLocation;

import com.sun.source.util.TaskEvent;

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.Log.WriterKind;

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

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 static javax.tools.StandardLocation.CLASS_OUTPUT;

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

            new Symbol.Completer() {

                @Override

                public void complete(Symbol sym) throws CompletionFailure {

                    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;

    protected CompileStates compileStates;

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

            if (ex instanceof ClassFinder.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 = MultiTaskListener.instance(context);

        finder.sourceCompleter = sourceCompleter;

        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;

        devVerbose    = options.isSet("dev");

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

        werror        = options.isSet(WERROR);

        verboseCompilePolicy = options.isSet("verboseCompilePolicy");

        if (options.isSet("shouldStopPolicy") &&

            CompileState.valueOf(options.get("shouldStopPolicy")) == 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("shouldStopPolicy") // backwards compatible

            ? CompileState.valueOf(options.get("shouldStopPolicy"))

            : options.isSet("shouldStopPolicyIfError")

            ? CompileState.valueOf(options.get("shouldStopPolicyIfError"))

            : CompileState.INIT;

        shouldStopPolicyIfNoError =

            options.isSet("shouldStopPolicyIfNoError")

            ? CompileState.valueOf(options.get("shouldStopPolicyIfNoError"))

            : CompileState.GENERATE;

        if (options.isUnset("oldDiags"))

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

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

        if (platformProvider != null)

            closeables = closeables.prepend(platformProvider);

    }

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