/*

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

import java.util.ArrayList;

import com.sun.source.tree.LambdaExpressionTree;

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

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

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

import com.sun.tools.javac.comp.ArgumentAttr.LocalCacheContext;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import java.util.EnumSet;

import java.util.HashMap;

import java.util.Map;

import java.util.function.Predicate;

import com.sun.source.tree.NewClassTree;

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

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

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

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

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

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

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

import static com.sun.tools.javac.code.Flags.GENERATEDCONSTR;

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

import static com.sun.tools.javac.tree.JCTree.Tag.APPLY;

import static com.sun.tools.javac.tree.JCTree.Tag.FOREACHLOOP;

import static com.sun.tools.javac.tree.JCTree.Tag.LABELLED;

import static com.sun.tools.javac.tree.JCTree.Tag.METHODDEF;

import static com.sun.tools.javac.tree.JCTree.Tag.NEWCLASS;

import static com.sun.tools.javac.tree.JCTree.Tag.NULLCHK;

import static com.sun.tools.javac.tree.JCTree.Tag.TYPEAPPLY;

import static com.sun.tools.javac.tree.JCTree.Tag.VARDEF;

/**

 * Helper class for defining custom code analysis, such as finding instance creation expression

 * that can benefit from diamond syntax.

 */

public class Analyzer {

    protected static final Context.Key<Analyzer> analyzerKey = new Context.Key<>();

    final Types types;

    final Log log;

    final Attr attr;

    final DeferredAttr deferredAttr;

    final ArgumentAttr argumentAttr;

    final TreeMaker make;

    final Names names;

    private final boolean allowDiamondWithAnonymousClassCreation;

    final EnumSet<AnalyzerMode> analyzerModes;

    public static Analyzer instance(Context context) {

        Analyzer instance = context.get(analyzerKey);

        if (instance == null)

            instance = new Analyzer(context);

        return instance;

    }

    protected Analyzer(Context context) {

        context.put(analyzerKey, this);

        types = Types.instance(context);

        log = Log.instance(context);

        attr = Attr.instance(context);

        deferredAttr = DeferredAttr.instance(context);

        argumentAttr = ArgumentAttr.instance(context);

        make = TreeMaker.instance(context);

        names = Names.instance(context);

        Options options = Options.instance(context);

        String findOpt = options.get("find");

        //parse modes

        Source source = Source.instance(context);

        allowDiamondWithAnonymousClassCreation = source.allowDiamondWithAnonymousClassCreation();

        analyzerModes = AnalyzerMode.getAnalyzerModes(findOpt, source);

    }

    /**

     * This enum defines supported analyzer modes, as well as defining the logic for decoding

     * the {@code -XDfind} option.

     */

    enum AnalyzerMode {

        DIAMOND("diamond", Source::allowDiamond),

        LAMBDA("lambda", Source::allowLambda),

        METHOD("method", Source::allowGraphInference),

        LOCAL("local", Source::allowLocalVariableTypeInference);

        final String opt;

        final Predicate<Source> sourceFilter;

        AnalyzerMode(String opt, Predicate<Source> sourceFilter) {

            this.opt = opt;

            this.sourceFilter = sourceFilter;

        }

        /**

         * This method is used to parse the {@code find} option.

         * Possible modes are separated by colon; a mode can be excluded by

         * prepending '-' to its name. Finally, the special mode 'all' can be used to

         * add all modes to the resulting enum.

         */

        static EnumSet<AnalyzerMode> getAnalyzerModes(String opt, Source source) {

            if (opt == null) {

                return EnumSet.noneOf(AnalyzerMode.class);

            }

            List<String> modes = List.from(opt.split(","));

            EnumSet<AnalyzerMode> res = EnumSet.noneOf(AnalyzerMode.class);

            if (modes.contains("all")) {

                res = EnumSet.allOf(AnalyzerMode.class);

            }

            for (AnalyzerMode mode : values()) {

                if (modes.contains(mode.opt)) {

                    res.add(mode);

                } else if (modes.contains("-" + mode.opt) || !mode.sourceFilter.test(source)) {

                    res.remove(mode);

                }

            }

            return res;

        }

    }

    /**

     * A statement analyzer is a work-unit that matches certain AST nodes (of given type {@code S}),

     * rewrites them to different AST nodes (of type {@code T}) and then generates some meaningful

     * messages in case the analysis has been successful.

     */

    abstract class StatementAnalyzer<S extends JCTree, T extends JCTree> {

        AnalyzerMode mode;

        JCTree.Tag tag;

        StatementAnalyzer(AnalyzerMode mode, Tag tag) {

            this.mode = mode;

            this.tag = tag;

        }

        /**

         * Is this analyzer allowed to run?

         */

        boolean isEnabled() {

            return analyzerModes.contains(mode);

        }

        /**

         * Should this analyzer be rewriting the given tree?

         */

        abstract boolean match(S tree);

        /**

         * Rewrite a given AST node into a new one

         */

        abstract T map(S oldTree, S newTree);

        /**

         * Entry-point for comparing results and generating diagnostics.

         */

        abstract void process(S oldTree, T newTree, boolean hasErrors);

    }

    /**

     * This analyzer checks if generic instance creation expression can use diamond syntax.

     */

    class DiamondInitializer extends StatementAnalyzer<JCNewClass, JCNewClass> {

        DiamondInitializer() {

            super(AnalyzerMode.DIAMOND, NEWCLASS);

        }

        @Override

        boolean match(JCNewClass tree) {

            return tree.clazz.hasTag(TYPEAPPLY) &&

                    !TreeInfo.isDiamond(tree) &&

                    (tree.def == null || allowDiamondWithAnonymousClassCreation);

        }

        @Override

        JCNewClass map(JCNewClass oldTree, JCNewClass newTree) {

            if (newTree.clazz.hasTag(TYPEAPPLY)) {

                ((JCTypeApply)newTree.clazz).arguments = List.nil();

            }

            return newTree;

        }

        @Override

        void process(JCNewClass oldTree, JCNewClass newTree, boolean hasErrors) {

            if (!hasErrors) {

                List<Type> inferredArgs, explicitArgs;

                if (oldTree.def != null) {

                    inferredArgs = newTree.def.implementing.nonEmpty()

                                      ? newTree.def.implementing.get(0).type.getTypeArguments()

                                      : newTree.def.extending.type.getTypeArguments();

                    explicitArgs = oldTree.def.implementing.nonEmpty()

                                      ? oldTree.def.implementing.get(0).type.getTypeArguments()

                                      : oldTree.def.extending.type.getTypeArguments();

                } else {

                    inferredArgs = newTree.type.getTypeArguments();

                    explicitArgs = oldTree.type.getTypeArguments();

                }

                for (Type t : inferredArgs) {

                    if (!types.isSameType(t, explicitArgs.head)) {

                        return;

                    }

                    explicitArgs = explicitArgs.tail;

                }

                //exact match

                log.warning(oldTree.clazz, Warnings.DiamondRedundantArgs);

            }

        }

    }

    /**

     * This analyzer checks if anonymous instance creation expression can replaced by lambda.

     */

    class LambdaAnalyzer extends StatementAnalyzer<JCNewClass, JCLambda> {

        LambdaAnalyzer() {

            super(AnalyzerMode.LAMBDA, NEWCLASS);

        }

        @Override

        boolean match (JCNewClass tree){

            Type clazztype = tree.clazz.type;

            return tree.def != null &&

                    clazztype.hasTag(CLASS) &&

                    types.isFunctionalInterface(clazztype.tsym) &&

                    decls(tree.def).length() == 1;

        }

        //where

            private List<JCTree> decls(JCClassDecl decl) {

                ListBuffer<JCTree> decls = new ListBuffer<>();

                for (JCTree t : decl.defs) {

                    if (t.hasTag(METHODDEF)) {

                        JCMethodDecl md = (JCMethodDecl)t;

                        if ((md.getModifiers().flags & GENERATEDCONSTR) == 0) {

                            decls.add(md);

                        }

                    } else {

                        decls.add(t);

                    }

                }

                return decls.toList();

            }

        @Override

        JCLambda map (JCNewClass oldTree, JCNewClass newTree){

            JCMethodDecl md = (JCMethodDecl)decls(newTree.def).head;

            List<JCVariableDecl> params = md.params;

            JCBlock body = md.body;

            return make.Lambda(params, body);

        }

        @Override

        void process (JCNewClass oldTree, JCLambda newTree, boolean hasErrors){

            if (!hasErrors) {

                log.warning(oldTree.def, Warnings.PotentialLambdaFound);

            }

        }

    }

    /**

     * This analyzer checks if generic method call has redundant type arguments.

     */

    class RedundantTypeArgAnalyzer extends StatementAnalyzer<JCMethodInvocation, JCMethodInvocation> {

        RedundantTypeArgAnalyzer() {

            super(AnalyzerMode.METHOD, APPLY);

        }

        @Override

        boolean match (JCMethodInvocation tree){

            return tree.typeargs != null &&

                    tree.typeargs.nonEmpty();

        }

        @Override

        JCMethodInvocation map (JCMethodInvocation oldTree, JCMethodInvocation newTree){

            newTree.typeargs = List.nil();

            return newTree;

        }

        @Override

        void process (JCMethodInvocation oldTree, JCMethodInvocation newTree, boolean hasErrors){

            if (!hasErrors) {

                //exact match

                log.warning(oldTree, Warnings.MethodRedundantTypeargs);

            }

        }

    }

    /**

     * Base class for local variable inference analyzers.

     */

    abstract class RedundantLocalVarTypeAnalyzerBase<X extends JCStatement> extends StatementAnalyzer<X, X> {

        RedundantLocalVarTypeAnalyzerBase(JCTree.Tag tag) {

            super(AnalyzerMode.LOCAL, tag);

        }

        /**

         * Map a variable tree into a new declaration using implicit type.

         */

        JCVariableDecl mapVar(JCVariableDecl oldTree, JCVariableDecl newTree){

            newTree.vartype = null;

            return newTree;

        }

        /**

         * Analyze results of local variable inference.

         */

        void processVar(JCVariableDecl oldTree, JCVariableDecl newTree, boolean hasErrors){

            if (!hasErrors) {

                if (types.isSameType(oldTree.type, newTree.type)) {

                    log.warning(oldTree, Warnings.LocalRedundantType);

                }

            }

        }

    }

    /**

     * This analyzer checks if a local variable declaration has redundant type.

     */

    class RedundantLocalVarTypeAnalyzer extends RedundantLocalVarTypeAnalyzerBase<JCVariableDecl> {

        RedundantLocalVarTypeAnalyzer() {

            super(VARDEF);

        }

        boolean match(JCVariableDecl tree){

            return tree.sym.owner.kind == Kind.MTH &&

                    tree.init != null && !tree.isImplicitlyTyped() &&

                    attr.canInferLocalVarType(tree) == null;

        }

        @Override

        JCVariableDecl map(JCVariableDecl oldTree, JCVariableDecl newTree){

            return mapVar(oldTree, newTree);

        }

        @Override

        void process(JCVariableDecl oldTree, JCVariableDecl newTree, boolean hasErrors){

            processVar(oldTree, newTree, hasErrors);

        }

    }

    /**

     * This analyzer checks if a for each variable declaration has redundant type.

     */

    class RedundantLocalVarTypeAnalyzerForEach extends RedundantLocalVarTypeAnalyzerBase<JCEnhancedForLoop> {

        RedundantLocalVarTypeAnalyzerForEach() {

            super(FOREACHLOOP);

        }

        @Override

        boolean match(JCEnhancedForLoop tree){

            return !tree.var.isImplicitlyTyped();

        }

        @Override

        JCEnhancedForLoop map(JCEnhancedForLoop oldTree, JCEnhancedForLoop newTree){

            newTree.var = mapVar(oldTree.var, newTree.var);

            newTree.body = make.Block(0, List.nil()); //ignore body for analysis purpose

            return newTree;

        }

        @Override

        void process(JCEnhancedForLoop oldTree, JCEnhancedForLoop newTree, boolean hasErrors){

            processVar(oldTree.var, newTree.var, hasErrors);

        }

    }

    @SuppressWarnings({"unchecked", "rawtypes"})

    StatementAnalyzer<JCTree, JCTree>[] analyzers = new StatementAnalyzer[] {

            new DiamondInitializer(),

            new LambdaAnalyzer(),

            new RedundantTypeArgAnalyzer(),

            new RedundantLocalVarTypeAnalyzer(),

            new RedundantLocalVarTypeAnalyzerForEach()

    };

    /**

     * Create a copy of Env if needed.

     */

    Env<AttrContext> copyEnvIfNeeded(JCTree tree, Env<AttrContext> env) {

        if (!analyzerModes.isEmpty() &&

                !env.info.isSpeculative &&

                TreeInfo.isStatement(tree) &&

                !tree.hasTag(LABELLED)) {

            Env<AttrContext> analyzeEnv =

                    env.dup(env.tree, env.info.dup(env.info.scope.dupUnshared(env.info.scope.owner)));

            analyzeEnv.info.returnResult = analyzeEnv.info.returnResult != null ?

                    attr.new ResultInfo(analyzeEnv.info.returnResult.pkind,

                                        analyzeEnv.info.returnResult.pt) : null;

            return analyzeEnv;

        } else {

            return null;

        }

    }

    /**

     * Analyze an AST node if needed.

     */

    void analyzeIfNeeded(JCTree tree, Env<AttrContext> env) {

        if (env != null) {

            JCStatement stmt = (JCStatement)tree;

            analyze(stmt, env);

        }

    }

    /**

     * Analyze an AST node; this involves collecting a list of all the nodes that needs rewriting,

     * and speculatively type-check the rewritten code to compare results against previously attributed code.

     */

    void analyze(JCStatement statement, Env<AttrContext> env) {

        AnalysisContext context = new AnalysisContext(statement, env);

        StatementScanner statementScanner = new StatementScanner(context);

        statementScanner.scan(statement);

        if (!context.treesToAnalyzer.isEmpty()) {

            deferredAnalysisHelper.queue(context);

        }

    }

    /**

     * Helper interface to handle deferral of analysis tasks.

     */

    interface DeferredAnalysisHelper {

        /**

         * Add a new analysis task to the queue.

         */

        void queue(AnalysisContext context);

        /**

         * Flush queue with given attribution env.

         */

        void flush(Env<AttrContext> flushEnv);

    }

    /**

     * Dummy deferral handler.

     */

    DeferredAnalysisHelper flushDeferredHelper = new DeferredAnalysisHelper() {

        @Override

        public void queue(AnalysisContext context) {

            //do nothing

        }

        @Override

        public void flush(Env<AttrContext> flushEnv) {

            //do nothing

        }

    };

    /**

     * Simple deferral handler. All tasks belonging to the same outermost class are added to

     * the same queue. The queue is flushed after flow analysis (only if no error occurred).

     */

    DeferredAnalysisHelper queueDeferredHelper = new DeferredAnalysisHelper() {

        Map<ClassSymbol, ArrayList<AnalysisContext>> Q = new HashMap<>();