/*

 * Copyright (c) 2005, 2019, 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.processing;

import java.io.Closeable;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.lang.reflect.Method;

import java.net.MalformedURLException;

import java.net.URL;

import java.nio.file.Path;

import java.util.*;

import java.util.Map.Entry;

import java.util.function.Predicate;

import java.util.regex.*;

import java.util.stream.Collectors;

import javax.annotation.processing.*;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.*;

import javax.lang.model.util.*;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.JavaFileObject.Kind;

import javax.tools.StandardJavaFileManager;

import static 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.DeferredCompletionFailureHandler.Handler;

import com.sun.tools.javac.code.Scope.WriteableScope;

import com.sun.tools.javac.code.Source.Feature;

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

import com.sun.tools.javac.code.Type.ClassType;

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

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

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

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

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

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

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

import com.sun.tools.javac.main.JavaCompiler;

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

import com.sun.tools.javac.model.JavacElements;

import com.sun.tools.javac.model.JavacTypes;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**

 * Objects of this class hold and manage the state needed to support

 * annotation processing.

 *

 * <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 JavacProcessingEnvironment implements ProcessingEnvironment, Closeable {

    private final Options options;

    private final boolean printProcessorInfo;

    private final boolean printRounds;

    private final boolean verbose;

    private final boolean lint;

    private final boolean fatalErrors;

    private final boolean werror;

    private final boolean showResolveErrors;

    private final JavacFiler filer;

    private final JavacMessager messager;

    private final JavacElements elementUtils;

    private final JavacTypes typeUtils;

    private final JavaCompiler compiler;

    private final Modules modules;

    private final Types types;

    private final Annotate annotate;

    /**

     * Holds relevant state history of which processors have been

     * used.

     */

    private DiscoveredProcessors discoveredProcs;

    /**

     * Map of processor-specific options.

     */

    private final Map<String, String> processorOptions;

    /**

     */

    private final Set<String> unmatchedProcessorOptions;

    /**

     * Annotations implicitly processed and claimed by javac.

     */

    private final Set<String> platformAnnotations;

    /**

     * Set of packages given on command line.

     */

    private Set<PackageSymbol> specifiedPackages = Collections.emptySet();

    /** The log to be used for error reporting.

     */

    final Log log;

    /** Diagnostic factory.

     */

    JCDiagnostic.Factory diags;

    /**

     * Source level of the compile.

     */

    Source source;

    private ClassLoader processorClassLoader;

    private ServiceLoader<Processor> serviceLoader;

    private SecurityException processorLoaderException;

    private final JavaFileManager fileManager;

    /**

     * JavacMessages object used for localization

     */

    private JavacMessages messages;

    private MultiTaskListener taskListener;

    private final Symtab symtab;

    private final DeferredCompletionFailureHandler dcfh;

    private final Names names;

    private final Enter enter;

    private final Completer initialCompleter;

    private final Check chk;

    private final Context context;

    /**

     * Support for preview language features.

     */

    private final Preview preview;

    /** Get the JavacProcessingEnvironment instance for this context. */

    public static JavacProcessingEnvironment instance(Context context) {

        JavacProcessingEnvironment instance = context.get(JavacProcessingEnvironment.class);

        if (instance == null)

            instance = new JavacProcessingEnvironment(context);

        return instance;

    }

    protected JavacProcessingEnvironment(Context context) {

        this.context = context;

        context.put(JavacProcessingEnvironment.class, this);

        log = Log.instance(context);

        source = Source.instance(context);

        diags = JCDiagnostic.Factory.instance(context);

        options = Options.instance(context);

        printProcessorInfo = options.isSet(Option.XPRINTPROCESSORINFO);

        printRounds = options.isSet(Option.XPRINTROUNDS);

        verbose = options.isSet(Option.VERBOSE);

        lint = Lint.instance(context).isEnabled(PROCESSING);

        compiler = JavaCompiler.instance(context);

        if (options.isSet(Option.PROC, "only") || options.isSet(Option.XPRINT)) {

            compiler.shouldStopPolicyIfNoError = CompileState.PROCESS;

        }

        fatalErrors = options.isSet("fatalEnterError");

        showResolveErrors = options.isSet("showResolveErrors");

        werror = options.isSet(Option.WERROR);

        fileManager = context.get(JavaFileManager.class);

        platformAnnotations = initPlatformAnnotations();

        // Initialize services before any processors are initialized

        // in case processors use them.

        filer = new JavacFiler(context);

        messager = new JavacMessager(context, this);

        elementUtils = JavacElements.instance(context);

        typeUtils = JavacTypes.instance(context);

        modules = Modules.instance(context);

        types = Types.instance(context);

        annotate = Annotate.instance(context);

        processorOptions = initProcessorOptions();

        unmatchedProcessorOptions = initUnmatchedProcessorOptions();

        messages = JavacMessages.instance(context);

        taskListener = MultiTaskListener.instance(context);

        symtab = Symtab.instance(context);

        dcfh = DeferredCompletionFailureHandler.instance(context);

        names = Names.instance(context);

        enter = Enter.instance(context);

        initialCompleter = ClassFinder.instance(context).getCompleter();

        chk = Check.instance(context);

        preview = Preview.instance(context);

        initProcessorLoader();

    }

    public void setProcessors(Iterable<? extends Processor> processors) {

        Assert.checkNull(discoveredProcs);

        initProcessorIterator(processors);

    }

    private Set<String> initPlatformAnnotations() {

        final String module_prefix =

            Feature.MODULES.allowedInSource(source) ? "java.base/" : "";

        return Set.of(module_prefix + "java.lang.Deprecated",

                      module_prefix + "java.lang.FunctionalInterface",

                      module_prefix + "java.lang.Override",

                      module_prefix + "java.lang.SafeVarargs",

                      module_prefix + "java.lang.SuppressWarnings",

                      module_prefix + "java.lang.annotation.Documented",

                      module_prefix + "java.lang.annotation.Inherited",

                      module_prefix + "java.lang.annotation.Native",

                      module_prefix + "java.lang.annotation.Repeatable",

                      module_prefix + "java.lang.annotation.Retention",

    }

    private void initProcessorLoader() {

        try {

            if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {

                try {

                    serviceLoader = fileManager.getServiceLoader(ANNOTATION_PROCESSOR_MODULE_PATH, Processor.class);

                } catch (IOException e) {

                    throw new Abort(e);

                }

            } else {

                // If processorpath is not explicitly set, use the classpath.

                processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)

                    ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)

                    : fileManager.getClassLoader(CLASS_PATH);

                if (options.isSet("accessInternalAPI"))

                    ModuleHelper.addExports(getClass().getModule(), processorClassLoader.getUnnamedModule());

                if (processorClassLoader != null && processorClassLoader instanceof Closeable) {

                    compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);

                }

            }

        } catch (SecurityException e) {

            processorLoaderException = e;

        }

    }

    private void initProcessorIterator(Iterable<? extends Processor> processors) {

        Iterator<? extends Processor> processorIterator;

        if (options.isSet(Option.XPRINT)) {

            try {

                processorIterator = List.of(new PrintingProcessor()).iterator();

            } catch (Throwable t) {

                AssertionError assertError =

                    new AssertionError("Problem instantiating PrintingProcessor.");

                assertError.initCause(t);

                throw assertError;

            }

        } else if (processors != null) {

            processorIterator = processors.iterator();

        } else {

            if (processorLoaderException == null) {

                /*

                 * If the "-processor" option is used, search the appropriate

                 * path for the named class.  Otherwise, use a service

                 * provider mechanism to create the processor iterator.

                 */

                String processorNames = options.get(Option.PROCESSOR);

                if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {

                    processorIterator = (processorNames == null) ?

                            new ServiceIterator(serviceLoader, log) :

                            new NameServiceIterator(serviceLoader, log, processorNames);

                } else if (processorNames != null) {

                    processorIterator = new NameProcessIterator(processorNames, processorClassLoader, log);

                } else {

                    processorIterator = new ServiceIterator(processorClassLoader, log);

                }

            } else {

                /*

                 * A security exception will occur if we can't create a classloader.

                 * Ignore the exception if, with hindsight, we didn't need it anyway

                 * (i.e. no processor was specified either explicitly, or implicitly,

                 * in service configuration file.) Otherwise, we cannot continue.

                 */

                processorIterator = handleServiceLoaderUnavailability("proc.cant.create.loader",

                        processorLoaderException);

            }

        }

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

        java.util.List<Processor> platformProcessors = Collections.emptyList();

        if (platformProvider != null) {

            platformProcessors = platformProvider.getAnnotationProcessors()

                                                 .stream()

                                                 .map(PluginInfo::getPlugin)

                                                 .collect(Collectors.toList());

        }

        List<Iterator<? extends Processor>> iterators = List.of(processorIterator,

                                                                platformProcessors.iterator());

        Iterator<? extends Processor> compoundIterator =

                Iterators.createCompoundIterator(iterators, i -> i);

        discoveredProcs = new DiscoveredProcessors(compoundIterator);

    }

    public <S> ServiceLoader<S> getServiceLoader(Class<S> service) {

        if (fileManager.hasLocation(ANNOTATION_PROCESSOR_MODULE_PATH)) {

            try {

                return fileManager.getServiceLoader(ANNOTATION_PROCESSOR_MODULE_PATH, service);

            } catch (IOException e) {

                throw new Abort(e);

            }

        } else {

            return ServiceLoader.load(service, getProcessorClassLoader());

        }

    }

    /**

     * Returns an empty processor iterator if no processors are on the

     * relevant path, otherwise if processors are present, logs an

     * error.  Called when a service loader is unavailable for some

     * reason, either because a service loader class cannot be found

     * or because a security policy prevents class loaders from being

     * created.

     *

     * @param key The resource key to use to log an error message

     * @param e   If non-null, pass this exception to Abort

     */

    private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {

        if (fileManager instanceof JavacFileManager) {

            StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;

            Iterable<? extends Path> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)

                ? standardFileManager.getLocationAsPaths(ANNOTATION_PROCESSOR_PATH)

                : standardFileManager.getLocationAsPaths(CLASS_PATH);

            if (needClassLoader(options.get(Option.PROCESSOR), workingPath) )

                handleException(key, e);

        } else {

            handleException(key, e);

        }

        java.util.List<Processor> pl = Collections.emptyList();

        return pl.iterator();

    }

    /**

     * Handle a security exception thrown during initializing the

     * Processor iterator.

     */

    private void handleException(String key, Exception e) {

        if (e != null) {

            log.error(key, e.getLocalizedMessage());

            throw new Abort(e);

        } else {

            log.error(key);

            throw new Abort();

        }

    }

    /**

     * Use a service loader appropriate for the platform to provide an

     * iterator over annotations processors; fails if a loader is

     * needed but unavailable.

     */

    private class ServiceIterator implements Iterator<Processor> {

        Iterator<Processor> iterator;

        Log log;

        ServiceLoader<Processor> loader;

        ServiceIterator(ClassLoader classLoader, Log log) {

            this.log = log;

            try {

                try {

                    loader = ServiceLoader.load(Processor.class, classLoader);

                    this.iterator = loader.iterator();

                } catch (Exception e) {

                    // Fail softly if a loader is not actually needed.

                    this.iterator = handleServiceLoaderUnavailability("proc.no.service", null);

                }

            } catch (Throwable t) {

                log.error(Errors.ProcServiceProblem);

                throw new Abort(t);

            }

        }

        ServiceIterator(ServiceLoader<Processor> loader, Log log) {

            this.log = log;

            this.loader = loader;

            this.iterator = loader.iterator();

        }

        @Override

        public boolean hasNext() {

            try {

                return internalHasNext();

            } catch(ServiceConfigurationError sce) {

                log.error(Errors.ProcBadConfigFile(sce.getLocalizedMessage()));

                throw new Abort(sce);

            } catch (UnsupportedClassVersionError ucve) {

                log.error(Errors.ProcCantLoadClass(ucve.getLocalizedMessage()));

                throw new Abort(ucve);

            } catch (ClassFormatError cfe) {

                log.error(Errors.ProcCantLoadClass(cfe.getLocalizedMessage()));

                throw new Abort(cfe);

            } catch (Throwable t) {

                log.error(Errors.ProcBadConfigFile(t.getLocalizedMessage()));

                throw new Abort(t);

            }

        }

        boolean internalHasNext() {

            return iterator.hasNext();

        }

        @Override

        public Processor next() {

            try {

                return internalNext();

            } catch (ServiceConfigurationError sce) {

                log.error(Errors.ProcBadConfigFile(sce.getLocalizedMessage()));

                throw new Abort(sce);

            } catch (Throwable t) {

                log.error(Errors.ProcBadConfigFile(t.getLocalizedMessage()));

                throw new Abort(t);

            }

        }

        Processor internalNext() {

            return iterator.next();

        }

        @Override

        public void remove() {

            throw new UnsupportedOperationException();

        }

        public void close() {

            if (loader != null) {

                try {

                    loader.reload();

                } catch(Exception e) {

                    // Ignore problems during a call to reload.

                }

            }

        }