/*

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

import java.lang.reflect.*;

import java.util.*;

import java.util.regex.*;

import java.net.URL;

import java.io.Closeable;

import java.io.File;

import java.io.PrintWriter;

import java.io.IOException;

import java.net.MalformedURLException;

import javax.annotation.processing.*;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.AnnotationMirror;

import javax.lang.model.element.Element;

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.PackageElement;

import javax.lang.model.util.*;

import javax.tools.JavaFileManager;

import javax.tools.StandardJavaFileManager;

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.api.JavacTaskImpl;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import static javax.tools.StandardLocation.*;

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

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

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

/**

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

    Options options;

    private final boolean printProcessorInfo;

    private final boolean printRounds;

    private final boolean verbose;

    private final boolean lint;

    private final boolean procOnly;

    private final boolean fatalErrors;

    private final boolean werror;

    private final boolean showResolveErrors;

    private boolean foundTypeProcessors;

    private final JavacFiler filer;

    private final JavacMessager messager;

    private final JavacElements elementUtils;

    private final JavacTypes typeUtils;

    /**

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

     */

    Log log;

    /** Diagnostic factory.

     */

    JCDiagnostic.Factory diags;

    /**

     * Source level of the compile.

     */

    Source source;

    private ClassLoader processorClassLoader;

    /**

     * JavacMessages object used for localization

     */

    private JavacMessages messages;

    private Context context;

    public JavacProcessingEnvironment(Context context, Iterable<? extends Processor> processors) {

        this.context = context;

        log = Log.instance(context);

        source = Source.instance(context);

        diags = JCDiagnostic.Factory.instance(context);

        options = Options.instance(context);

        printProcessorInfo = options.isSet(XPRINTPROCESSORINFO);

        printRounds = options.isSet(XPRINTROUNDS);

        verbose = options.isSet(VERBOSE);

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

        procOnly = options.isSet(PROC, "only") || options.isSet(XPRINT);

        fatalErrors = options.isSet("fatalEnterError");

        showResolveErrors = options.isSet("showResolveErrors");

        werror = options.isSet(WERROR);

        platformAnnotations = initPlatformAnnotations();

        foundTypeProcessors = false;

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

        processorOptions = initProcessorOptions(context);

        unmatchedProcessorOptions = initUnmatchedProcessorOptions();

        messages = JavacMessages.instance(context);

        initProcessorIterator(context, processors);

    }

    private Set<String> initPlatformAnnotations() {

        Set<String> platformAnnotations = new HashSet<String>();

        platformAnnotations.add("java.lang.Deprecated");

        platformAnnotations.add("java.lang.Override");

        platformAnnotations.add("java.lang.SuppressWarnings");

        platformAnnotations.add("java.lang.annotation.Documented");

        platformAnnotations.add("java.lang.annotation.Inherited");

        platformAnnotations.add("java.lang.annotation.Retention");

        platformAnnotations.add("java.lang.annotation.Target");

        return Collections.unmodifiableSet(platformAnnotations);

    }

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

        Log   log   = Log.instance(context);

        Iterator<? extends Processor> processorIterator;

        if (options.isSet(XPRINT)) {

            try {

                Processor processor = PrintingProcessor.class.newInstance();

                processorIterator = List.of(processor).iterator();

            } catch (Throwable t) {

                AssertionError assertError =

                    new AssertionError("Problem instantiating PrintingProcessor.");

                assertError.initCause(t);

                throw assertError;

            }

        } else if (processors != null) {

            processorIterator = processors.iterator();

        } else {

            String processorNames = options.get(PROCESSOR);

            JavaFileManager fileManager = context.get(JavaFileManager.class);

            try {

                // 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 the "-processor" option is used, search the appropriate

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

                 * provider mechanism to create the processor iterator.

                 */

                if (processorNames != null) {

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

                } else {

                    processorIterator = new ServiceIterator(processorClassLoader, log);

                }

            } catch (SecurityException e) {

                /*

                 * 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", e);

            }

        }

        discoveredProcs = new DiscoveredProcessors(processorIterator);

    }

    /**

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

        JavaFileManager fileManager = context.get(JavaFileManager.class);

        if (fileManager instanceof JavacFileManager) {

            StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;

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

                ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH)

                : standardFileManager.getLocation(CLASS_PATH);

            if (needClassLoader(options.get(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.  If

     * java.util.ServiceLoader is present use it, otherwise, use

     * sun.misc.Service, otherwise fail if a loader is needed.

     */

    private class ServiceIterator implements Iterator<Processor> {

        // The to-be-wrapped iterator.

        private Iterator<?> iterator;

        private Log log;

        private Class<?> loaderClass;

        private boolean jusl;

        private Object loader;

        ServiceIterator(ClassLoader classLoader, Log log) {

            String loadMethodName;

            this.log = log;

            try {

                try {

                    loaderClass = Class.forName("java.util.ServiceLoader");

                    loadMethodName = "load";

                    jusl = true;

                } catch (ClassNotFoundException cnfe) {

                    try {

                        loaderClass = Class.forName("sun.misc.Service");

                        loadMethodName = "providers";

                        jusl = false;

                    } catch (ClassNotFoundException cnfe2) {

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

                        this.iterator = handleServiceLoaderUnavailability("proc.no.service",

                                                                          null);

                        return;

                    }

                }

                // java.util.ServiceLoader.load or sun.misc.Service.providers

                Method loadMethod = loaderClass.getMethod(loadMethodName,

                                                          Class.class,

                                                          ClassLoader.class);

                Object result = loadMethod.invoke(null,

                                                  Processor.class,

                                                  classLoader);

                // For java.util.ServiceLoader, we have to call another

                // method to get the iterator.

                if (jusl) {

                    loader = result; // Store ServiceLoader to call reload later

                    Method m = loaderClass.getMethod("iterator");

                    result = m.invoke(result); // serviceLoader.iterator();

                }

                // The result should now be an iterator.

                this.iterator = (Iterator<?>) result;

            } catch (Throwable t) {

                log.error("proc.service.problem");

                throw new Abort(t);

            }

        }

        public boolean hasNext() {

            try {

                return iterator.hasNext();

            } catch (Throwable t) {

                if ("ServiceConfigurationError".

                    equals(t.getClass().getSimpleName())) {

                    log.error("proc.bad.config.file", t.getLocalizedMessage());

                }

                throw new Abort(t);

            }

        }

        public Processor next() {

            try {

                return (Processor)(iterator.next());

            } catch (Throwable t) {

                if ("ServiceConfigurationError".

                    equals(t.getClass().getSimpleName())) {

                    log.error("proc.bad.config.file", t.getLocalizedMessage());

                } else {

                    log.error("proc.processor.constructor.error", t.getLocalizedMessage());

                }

                throw new Abort(t);

            }

        }

        public void remove() {

            throw new UnsupportedOperationException();

        }

        public void close() {

            if (jusl) {

                try {

                    // Call java.util.ServiceLoader.reload

                    Method reloadMethod = loaderClass.getMethod("reload");

                    reloadMethod.invoke(loader);

                } catch(Exception e) {

                    ; // Ignore problems during a call to reload.

                }

            }

        }

    }

    private static class NameProcessIterator implements Iterator<Processor> {

        Processor nextProc = null;

        Iterator<String> names;

        ClassLoader processorCL;

        Log log;

        NameProcessIterator(String names, ClassLoader processorCL, Log log) {

            this.names = Arrays.asList(names.split(",")).iterator();

            this.processorCL = processorCL;

            this.log = log;

        }

        public boolean hasNext() {

            if (nextProc != null)

                return true;

            else {

                if (!names.hasNext())

                    return false;

                else {

                    String processorName = names.next();

                    Processor processor;

                    try {

                        try {

                            processor =

                                (Processor) (processorCL.loadClass(processorName).newInstance());

                        } catch (ClassNotFoundException cnfe) {

                            log.error("proc.processor.not.found", processorName);

                            return false;

                        } catch (ClassCastException cce) {

                            log.error("proc.processor.wrong.type", processorName);

                            return false;

                        } catch (Exception e ) {

                            log.error("proc.processor.cant.instantiate", processorName);

                            return false;

                        }

                    } catch(Throwable t) {

                        throw new AnnotationProcessingError(t);

                    }

                    nextProc = processor;

                    return true;

                }

            }

        }

        public Processor next() {

            if (hasNext()) {

                Processor p = nextProc;

                nextProc = null;

                return p;

            } else

                throw new NoSuchElementException();

        }

        public void remove () {

            throw new UnsupportedOperationException();

        }

    }

    public boolean atLeastOneProcessor() {

        return discoveredProcs.iterator().hasNext();

    }

    private Map<String, String> initProcessorOptions(Context context) {

        Options options = Options.instance(context);

        Set<String> keySet = options.keySet();

        Map<String, String> tempOptions = new LinkedHashMap<String, String>();

        for(String key : keySet) {

            if (key.startsWith("-A") && key.length() > 2) {

                int sepIndex = key.indexOf('=');

                String candidateKey = null;

                String candidateValue = null;

                if (sepIndex == -1)

                    candidateKey = key.substring(2);

                else if (sepIndex >= 3) {

                    candidateKey = key.substring(2, sepIndex);

                    candidateValue = (sepIndex < key.length()-1)?

                        key.substring(sepIndex+1) : null;

                }

                tempOptions.put(candidateKey, candidateValue);

            }

        }

        return Collections.unmodifiableMap(tempOptions);

    }

    private Set<String> initUnmatchedProcessorOptions() {

        Set<String> unmatchedProcessorOptions = new HashSet<String>();

        unmatchedProcessorOptions.addAll(processorOptions.keySet());

        return unmatchedProcessorOptions;

    }

    /**

     * State about how a processor has been used by the tool.  If a

     * processor has been used on a prior round, its process method is

     * called on all subsequent rounds, perhaps with an empty set of

     * annotations to process.  The {@code annotatedSupported} method

     * caches the supported annotation information from the first (and

     * only) getSupportedAnnotationTypes call to the processor.

     */

    static class ProcessorState {

        public Processor processor;

        public boolean   contributed;

        private ArrayList<Pattern> supportedAnnotationPatterns;

        private ArrayList<String>  supportedOptionNames;

        ProcessorState(Processor p, Log log, Source source, ProcessingEnvironment env) {

            processor = p;

            contributed = false;

            try {

                processor.init(env);

                checkSourceVersionCompatibility(source, log);

                supportedAnnotationPatterns = new ArrayList<Pattern>();