/*

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

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.type.TypeKind;

/**

 * 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 boolean dumpLambdaToMethodStats;

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

    private final boolean forceSerializable;

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

        attr = Attr.instance(context);

        forceSerializable = options.isSet("forceSerializable");

    }

    // </editor-fold>

    private class KlassInfo {

        /**

         * list of methods to append

         */

        private ListBuffer<JCTree> appendedMethodList;

        /**

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

            deserializeCases = new HashMap<>();

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

                    List.<Type>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;

        {

            Symbol owner = localContext.owner;

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

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

            for (Attribute.TypeCompound tc : owner.getRawTypeAttributes()) {

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

                    lambdaTypeAnnos.append(tc);

                } else {

                    ownerTypeAnnos.append(tc);

                }

            }

            if (lambdaTypeAnnos.nonEmpty()) {

                owner.setTypeAttributes(ownerTypeAnnos.toList());

                sym.setTypeAttributes(lambdaTypeAnnos.toList());

            }

        }

        //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.<JCTypeParameter>nil(),

                localContext.syntheticParams,

                lambdaType.getThrownTypes() == null ?

                    List.<JCExpression>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));

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

            }

        }

        //then, determine the arguments to the indy call

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

        //build a sam instance using an indy call to the meta-factory

        int refKind = referenceKind(sym);

        //convert to an invokedynamic call

        result = makeMetafactoryIndyCall(context, refKind, sym, indy_args);

    }

    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

        Symbol refSym = localContext.isSignaturePolymorphic()

                ? localContext.sigPolySym

                : 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 = tree.getQualifierExpression();

                init = attr.makeNullCheck(init);

                break;

            case UNBOUND:           /** Type :: instMethod */

            case STATIC:            /** Type :: staticMethod */

            case TOPLEVEL:          /** Top level :: new */

            case ARRAY_CTOR:        /** ArrayType :: new */

                init = null;

                break;

            default:

                throw new InternalError("Should not have an invalid kind");

        }

        List<JCExpression> indy_args = init==null? List.<JCExpression>nil() : translate(List.of(init), localContext.prev);

        //build a sam instance using an indy call to the meta-factory

        result = makeMetafactoryIndyCall(localContext, localContext.referenceKind(), refSym, indy_args);

    }

    /**

     * Translate identifiers within a lambda to the mapped identifier

     * @param tree

     */

    @Override

    public void visitIdent(JCIdent tree) {

        if (context == null || !analyzer.lambdaIdentSymbolFilter(tree.sym)) {

            super.visitIdent(tree);

        } else {

            int prevPos = make.pos;

            try {

                make.at(tree);

                LambdaTranslationContext lambdaContext = (LambdaTranslationContext) context;

                JCTree ltree = lambdaContext.translate(tree);

                if (ltree != null) {

                    result = ltree;

                } else {

                    //access to untranslated symbols (i.e. compile-time constants,

                    //members defined inside the lambda body, etc.) )

                    super.visitIdent(tree);

                }

            } finally {

                make.at(prevPos);

            }

        }

    }

    @Override

    public void visitVarDef(JCVariableDecl tree) {

        LambdaTranslationContext lambdaContext = (LambdaTranslationContext)context;

        if (context != null && lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {

            tree.init = translate(tree.init);

            tree.sym = (VarSymbol) lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym);

            result = tree;

        } else if (context != null && lambdaContext.getSymbolMap(TYPE_VAR).containsKey(tree.sym)) {

            JCExpression init = translate(tree.init);

            VarSymbol xsym = (VarSymbol)lambdaContext.getSymbolMap(TYPE_VAR).get(tree.sym);

            int prevPos = make.pos;

            try {

                result = make.at(tree).VarDef(xsym, init);

            } finally {

                make.at(prevPos);

            }

            // Replace the entered symbol for this variable

            WriteableScope sc = tree.sym.owner.members();

            if (sc != null) {

                sc.remove(tree.sym);

                sc.enter(xsym);

            }

        } else {

            super.visitVarDef(tree);

        }

    }

    // </editor-fold>

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

    private JCBlock makeLambdaBody(JCLambda tree, JCMethodDecl lambdaMethodDecl) {

        return tree.getBodyKind() == JCLambda.BodyKind.EXPRESSION ?

                makeLambdaExpressionBody((JCExpression)tree.body, lambdaMethodDecl) :

                makeLambdaStatementBody((JCBlock)tree.body, lambdaMethodDecl, tree.canCompleteNormally);

    }

    private JCBlock makeLambdaExpressionBody(JCExpression expr, JCMethodDecl lambdaMethodDecl) {

        Type restype = lambdaMethodDecl.type.getReturnType();

        boolean isLambda_void = expr.type.hasTag(VOID);

        boolean isTarget_void = restype.hasTag(VOID);

        boolean isTarget_Void = types.isSameType(restype, types.boxedClass(syms.voidType).type);

        int prevPos = make.pos;

        try {

            if (isTarget_void) {

                //target is void:

                // BODY;

                JCStatement stat = make.at(expr).Exec(expr);

                return make.Block(0, List.<JCStatement>of(stat));

            } else if (isLambda_void && isTarget_Void) {

                //void to Void conversion:

                // BODY; return null;

                ListBuffer<JCStatement> stats = new ListBuffer<>();

                stats.append(make.at(expr).Exec(expr));

                stats.append(make.Return(make.Literal(BOT, null).setType(syms.botType)));

                return make.Block(0, stats.toList());

            } else {

                //non-void to non-void conversion:

                // return (TYPE)BODY;

                JCExpression retExpr = transTypes.coerce(attrEnv, expr, restype);

                return make.at(retExpr).Block(0, List.<JCStatement>of(make.Return(retExpr)));

            }

        } finally {

            make.at(prevPos);

        }

    }

    private JCBlock makeLambdaStatementBody(JCBlock block, final JCMethodDecl lambdaMethodDecl, boolean completeNormally) {

        final Type restype = lambdaMethodDecl.type.getReturnType();

        final boolean isTarget_void = restype.hasTag(VOID);