/*

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

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

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

import com.sun.tools.javac.jvm.PoolConstant.LoadableConstant;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.sun.tools.javac.comp.Lower.BasicFreeVarCollector;

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

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

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

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

import com.sun.source.tree.MemberReferenceTree.ReferenceMode;

import java.util.EnumMap;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.function.Consumer;

import java.util.function.Supplier;

import static com.sun.tools.javac.comp.LambdaToMethod.LambdaSymbolKind.*;

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

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

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

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

import javax.lang.model.element.ElementKind;

import javax.lang.model.type.TypeKind;

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

/**

 * This pass desugars lambda expressions into static methods

 *

 *  <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 LambdaToMethod extends TreeTranslator {

    private Attr attr;

    private JCDiagnostic.Factory diags;

    private Log log;

    private Lower lower;

    private Names names;

    private Symtab syms;

    private Resolve rs;

    private Operators operators;

    private TreeMaker make;

    private Types types;

    private TransTypes transTypes;

    private Env<AttrContext> attrEnv;

    /** the analyzer scanner */

    private LambdaAnalyzerPreprocessor analyzer;

    /** map from lambda trees to translation contexts */

    private Map<JCTree, TranslationContext<?>> contextMap;

    /** current translation context (visitor argument) */

    private TranslationContext<?> context;

    /** info about the current class being processed */

    private KlassInfo kInfo;

    /** dump statistics about lambda code generation */

    private final boolean dumpLambdaToMethodStats;

    /** force serializable representation, for stress testing **/

    private final boolean forceSerializable;

    /** true if line or local variable debug info has been requested */

    private final boolean debugLinesOrVars;

    /** dump statistics about lambda method deduplication */

    private final boolean verboseDeduplication;

    /** deduplicate lambda implementation methods */

    private final boolean deduplicateLambdas;

    /** Flag for alternate metafactories indicating the lambda object is intended to be serializable */

    public static final int FLAG_SERIALIZABLE = 1 << 0;

    /** Flag for alternate metafactories indicating the lambda object has multiple targets */

    public static final int FLAG_MARKERS = 1 << 1;

    /** Flag for alternate metafactories indicating the lambda object requires multiple bridges */

    public static final int FLAG_BRIDGES = 1 << 2;

    // <editor-fold defaultstate="collapsed" desc="Instantiating">

    protected static final Context.Key<LambdaToMethod> unlambdaKey = new Context.Key<>();

    public static LambdaToMethod instance(Context context) {

        LambdaToMethod instance = context.get(unlambdaKey);

        if (instance == null) {

            instance = new LambdaToMethod(context);

        }

        return instance;

    }

    private LambdaToMethod(Context context) {

        context.put(unlambdaKey, this);

        diags = JCDiagnostic.Factory.instance(context);

        log = Log.instance(context);

        lower = Lower.instance(context);

        names = Names.instance(context);

        syms = Symtab.instance(context);

        rs = Resolve.instance(context);

        operators = Operators.instance(context);

        make = TreeMaker.instance(context);

        types = Types.instance(context);

        transTypes = TransTypes.instance(context);

        analyzer = new LambdaAnalyzerPreprocessor();

        Options options = Options.instance(context);

        dumpLambdaToMethodStats = options.isSet("debug.dumpLambdaToMethodStats");

        attr = Attr.instance(context);

        forceSerializable = options.isSet("forceSerializable");

        debugLinesOrVars = options.isSet(Option.G)

                || options.isSet(Option.G_CUSTOM, "lines")

                || options.isSet(Option.G_CUSTOM, "vars");

        verboseDeduplication = options.isSet("debug.dumpLambdaToMethodDeduplication");

        deduplicateLambdas = options.getBoolean("deduplicateLambdas", true);

    }

    // </editor-fold>

    class DedupedLambda {

        private final MethodSymbol symbol;

        private final JCTree tree;

        private int hashCode;

        DedupedLambda(MethodSymbol symbol, JCTree tree) {

            this.symbol = symbol;

            this.tree = tree;

        }

        @Override

        public int hashCode() {

            int hashCode = this.hashCode;

            if (hashCode == 0) {

                this.hashCode = hashCode = TreeHasher.hash(tree, symbol.params());

            }

            return hashCode;

        }

        @Override

        public boolean equals(Object o) {

            if (!(o instanceof DedupedLambda)) {

                return false;

            }

            DedupedLambda that = (DedupedLambda) o;

            return types.isSameType(symbol.asType(), that.symbol.asType())

                    && new TreeDiffer(symbol.params(), that.symbol.params()).scan(tree, that.tree);

        }

    }

    private class KlassInfo {

        /**

         * list of methods to append

         */

        private ListBuffer<JCTree> appendedMethodList;

        private Map<DedupedLambda, DedupedLambda> dedupedLambdas;

        private Map<Object, DynamicMethodSymbol> dynMethSyms = new HashMap<>();

        /**

         * list of deserialization cases

         */

        private final Map<String, ListBuffer<JCStatement>> deserializeCases;

       /**

         * deserialize method symbol

         */

        private final MethodSymbol deserMethodSym;

        /**

         * deserialize method parameter symbol

         */

        private final VarSymbol deserParamSym;

        private final JCClassDecl clazz;

        private KlassInfo(JCClassDecl clazz) {

            this.clazz = clazz;

            appendedMethodList = new ListBuffer<>();

            dedupedLambdas = new HashMap<>();

            deserializeCases = new HashMap<>();

            MethodType type = new MethodType(List.of(syms.serializedLambdaType), syms.objectType,

                    List.nil(), syms.methodClass);

            deserMethodSym = makePrivateSyntheticMethod(STATIC, names.deserializeLambda, type, clazz.sym);

            deserParamSym = new VarSymbol(FINAL, names.fromString("lambda"),

                    syms.serializedLambdaType, deserMethodSym);

        }

        private void addMethod(JCTree decl) {

            appendedMethodList = appendedMethodList.prepend(decl);

        }

    }

    // <editor-fold defaultstate="collapsed" desc="translate methods">

    @Override

    public <T extends JCTree> T translate(T tree) {

        TranslationContext<?> newContext = contextMap.get(tree);

        return translate(tree, newContext != null ? newContext : context);

    }

    <T extends JCTree> T translate(T tree, TranslationContext<?> newContext) {

        TranslationContext<?> prevContext = context;

        try {

            context = newContext;

            return super.translate(tree);

        }

        finally {

            context = prevContext;

        }

    }

    <T extends JCTree> List<T> translate(List<T> trees, TranslationContext<?> newContext) {

        ListBuffer<T> buf = new ListBuffer<>();

        for (T tree : trees) {

            buf.append(translate(tree, newContext));

        }

        return buf.toList();

    }

    public JCTree translateTopLevelClass(Env<AttrContext> env, JCTree cdef, TreeMaker make) {

        this.make = make;

        this.attrEnv = env;

        this.context = null;

        this.contextMap = new HashMap<>();

        return translate(cdef);

    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="visitor methods">

    /**

     * Visit a class.

     * Maintain the translatedMethodList across nested classes.

     * Append the translatedMethodList to the class after it is translated.

     * @param tree

     */

    @Override

    public void visitClassDef(JCClassDecl tree) {

        if (tree.sym.owner.kind == PCK) {

            //analyze class

            tree = analyzer.analyzeAndPreprocessClass(tree);

        }

        KlassInfo prevKlassInfo = kInfo;

        try {

            kInfo = new KlassInfo(tree);

            super.visitClassDef(tree);

            if (!kInfo.deserializeCases.isEmpty()) {

                int prevPos = make.pos;

                try {

                    make.at(tree);

                    kInfo.addMethod(makeDeserializeMethod(tree.sym));

                } finally {

                    make.at(prevPos);

                }

            }

            //add all translated instance methods here

            List<JCTree> newMethods = kInfo.appendedMethodList.toList();

            tree.defs = tree.defs.appendList(newMethods);

            for (JCTree lambda : newMethods) {

                tree.sym.members().enter(((JCMethodDecl)lambda).sym);

            }

            result = tree;

        } finally {

            kInfo = prevKlassInfo;

        }

    }

    /**

     * Translate a lambda into a method to be inserted into the class.

     * Then replace the lambda site with an invokedynamic call of to lambda

     * meta-factory, which will use the lambda method.

     * @param tree

     */

    @Override

    public void visitLambda(JCLambda tree) {

        LambdaTranslationContext localContext = (LambdaTranslationContext)context;

        MethodSymbol sym = localContext.translatedSym;

        MethodType lambdaType = (MethodType) sym.type;

        {   /* Type annotation management: Based on where the lambda features, type annotations that

               are interior to it, may at this point be attached to the enclosing method, or the first

               constructor in the class, or in the enclosing class symbol or in the field whose

               initializer is the lambda. In any event, gather up the annotations that belong to the

               lambda and attach it to the implementation method.

            */

            Symbol owner = localContext.owner;

            apportionTypeAnnotations(tree,

                    owner::getRawTypeAttributes,

                    owner::setTypeAttributes,

                    sym::setTypeAttributes);

            boolean init;

            if ((init = (owner.name == names.init)) || owner.name == names.clinit) {

                owner = owner.owner;

                apportionTypeAnnotations(tree,

                        init ? owner::getInitTypeAttributes : owner::getClassInitTypeAttributes,

                        init ? owner::setInitTypeAttributes : owner::setClassInitTypeAttributes,

                        sym::appendUniqueTypeAttributes);

            }

            if (localContext.self != null && localContext.self.getKind() == ElementKind.FIELD) {

                owner = localContext.self;

                apportionTypeAnnotations(tree,

                        owner::getRawTypeAttributes,

                        owner::setTypeAttributes,

                        sym::appendUniqueTypeAttributes);

            }

        }

        //create the method declaration hoisting the lambda body

        JCMethodDecl lambdaDecl = make.MethodDef(make.Modifiers(sym.flags_field),

                sym.name,

                make.QualIdent(lambdaType.getReturnType().tsym),

                List.nil(),

                localContext.syntheticParams,

                lambdaType.getThrownTypes() == null ?

                    List.nil() :

                    make.Types(lambdaType.getThrownTypes()),

                null,

                null);

        lambdaDecl.sym = sym;

        lambdaDecl.type = lambdaType;

        //translate lambda body

        //As the lambda body is translated, all references to lambda locals,

        //captured variables, enclosing members are adjusted accordingly

        //to refer to the static method parameters (rather than i.e. acessing to

        //captured members directly).

        lambdaDecl.body = translate(makeLambdaBody(tree, lambdaDecl));

        boolean dedupe = false;

        if (deduplicateLambdas && !debugLinesOrVars && !localContext.isSerializable()) {

            DedupedLambda dedupedLambda = new DedupedLambda(lambdaDecl.sym, lambdaDecl.body);

            DedupedLambda existing = kInfo.dedupedLambdas.putIfAbsent(dedupedLambda, dedupedLambda);

            if (existing != null) {

                sym = existing.symbol;

                dedupe = true;

                if (verboseDeduplication) log.note(tree, Notes.VerboseL2mDeduplicate(sym));

            }

        }

        if (!dedupe) {

            //Add the method to the list of methods to be added to this class.

            kInfo.addMethod(lambdaDecl);

        }

        //now that we have generated a method for the lambda expression,

        //we can translate the lambda into a method reference pointing to the newly

        //created method.

        //

        //Note that we need to adjust the method handle so that it will match the

        //signature of the SAM descriptor - this means that the method reference

        //should be added the following synthetic arguments:

        //

        // * the "this" argument if it is an instance method

        // * enclosing locals captured by the lambda expression

        ListBuffer<JCExpression> syntheticInits = new ListBuffer<>();

        if (localContext.methodReferenceReceiver != null) {

            syntheticInits.append(localContext.methodReferenceReceiver);

        } else if (!sym.isStatic()) {

            syntheticInits.append(makeThis(

                    sym.owner.enclClass().asType(),

                    localContext.owner.enclClass()));

        }

        //add captured locals

        for (Symbol fv : localContext.getSymbolMap(CAPTURED_VAR).keySet()) {

            if (fv != localContext.self) {

                JCTree captured_local = make.Ident(fv).setType(fv.type);

                syntheticInits.append((JCExpression) captured_local);

            }

        }

        // add captured outer this instances (used only when `this' capture itself is illegal)

        for (Symbol fv : localContext.getSymbolMap(CAPTURED_OUTER_THIS).keySet()) {

            JCTree captured_local = make.QualThis(fv.type);

            syntheticInits.append((JCExpression) captured_local);

        }

        //then, determine the arguments to the indy call

        List<JCExpression> indy_args = translate(syntheticInits.toList(), localContext.prev);

        //convert to an invokedynamic call

        result = makeMetafactoryIndyCall(context, sym.asHandle(), indy_args);

    }

    // where

        // Reassign type annotations from the source that should really belong to the lambda

        private void apportionTypeAnnotations(JCLambda tree,

                                              Supplier<List<Attribute.TypeCompound>> source,

                                              Consumer<List<Attribute.TypeCompound>> owner,

                                              Consumer<List<Attribute.TypeCompound>> lambda) {

            ListBuffer<Attribute.TypeCompound> ownerTypeAnnos = new ListBuffer<>();

            ListBuffer<Attribute.TypeCompound> lambdaTypeAnnos = new ListBuffer<>();

            for (Attribute.TypeCompound tc : source.get()) {

                if (tc.position.onLambda == tree) {

                    lambdaTypeAnnos.append(tc);

                } else {

                    ownerTypeAnnos.append(tc);

                }

            }

            if (lambdaTypeAnnos.nonEmpty()) {

                owner.accept(ownerTypeAnnos.toList());

                lambda.accept(lambdaTypeAnnos.toList());

            }

        }

    private JCIdent makeThis(Type type, Symbol owner) {

        VarSymbol _this = new VarSymbol(PARAMETER | FINAL | SYNTHETIC,

                names._this,

                type,

                owner);

        return make.Ident(_this);

    }

    /**

     * Translate a method reference into an invokedynamic call to the

     * meta-factory.

     * @param tree

     */

    @Override

    public void visitReference(JCMemberReference tree) {

        ReferenceTranslationContext localContext = (ReferenceTranslationContext)context;

        //first determine the method symbol to be used to generate the sam instance

        //this is either the method reference symbol, or the bridged reference symbol

        MethodSymbol refSym = (MethodSymbol)tree.sym;

        //the qualifying expression is treated as a special captured arg

        JCExpression init;

        switch(tree.kind) {

            case IMPLICIT_INNER:    /** Inner :: new */

            case SUPER:             /** super :: instMethod */

                init = makeThis(

                    localContext.owner.enclClass().asType(),

                    localContext.owner.enclClass());

                break;

            case BOUND:             /** Expr :: instMethod */

                init = transTypes.coerce(attrEnv, tree.getQualifierExpression(),

                    types.erasure(tree.sym.owner.type));