/*

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

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

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

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

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

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

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

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

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

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

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

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

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

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

/**

 * 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 Lower lower;

    private Names names;

    private Symtab syms;

    private Resolve rs;

    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;

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

    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 KlassInfo(Symbol kSym) {

            appendedMethodList = ListBuffer.lb();

            deserializeCases = new HashMap<String, ListBuffer<JCStatement>>();

            long flags = PRIVATE | STATIC | SYNTHETIC;

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

                    List.<Type>nil(), syms.methodClass);

            deserMethodSym = makeSyntheticMethod(flags, names.deserializeLambda, type, kSym);

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

                    syms.serializedLambdaType, deserMethodSym);

        }

        private void addMethod(JCTree decl) {

            appendedMethodList = appendedMethodList.prepend(decl);

        }

    }

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

    private static final Context.Key<LambdaToMethod> unlambdaKey =

            new Context.Key<LambdaToMethod>();

    public static LambdaToMethod instance(Context context) {

        LambdaToMethod instance = context.get(unlambdaKey);

        if (instance == null) {

            instance = new LambdaToMethod(context);

        }

        return instance;

    }

    private LambdaToMethod(Context context) {

        lower = Lower.instance(context);

        names = Names.instance(context);

        syms = Symtab.instance(context);

        rs = Resolve.instance(context);

        make = TreeMaker.instance(context);

        types = Types.instance(context);

        transTypes = TransTypes.instance(context);

        analyzer = new LambdaAnalyzerPreprocessor();

    }

    // </editor-fold>

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

    }

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

        TranslationContext<?> prevContext = context;

        try {

            context = newContext;

            return super.translate(tree);

        }

        finally {

            context = prevContext;

        }

    }

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

        ListBuffer<T> buf = ListBuffer.lb();

        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<JCTree, TranslationContext<?>>();

        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.sym);

            super.visitClassDef(tree);

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

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

            }

            //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 = (MethodSymbol)localContext.translatedSym;

        MethodType lambdaType = (MethodType) sym.type;

        //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 = ListBuffer.lb();

        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(tree, context.needsAltMetafactory(), context.isSerializable(), 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.needsBridge() ?

            localContext.bridgeSym :

            tree.sym;

        //build the bridge method, if needed

        if (localContext.needsBridge()) {

            bridgeMemberReference(tree, localContext);

        }

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

                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(tree, localContext.needsAltMetafactory(), localContext.isSerializable(), 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 {

            LambdaTranslationContext lambdaContext = (LambdaTranslationContext) context;

            if (lambdaContext.getSymbolMap(PARAM).containsKey(tree.sym)) {

                Symbol translatedSym = lambdaContext.getSymbolMap(PARAM).get(tree.sym);

                result = make.Ident(translatedSym).setType(tree.type);

            } else if (lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {

                Symbol translatedSym = lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym);

                result = make.Ident(translatedSym).setType(tree.type);

            } else if (lambdaContext.getSymbolMap(TYPE_VAR).containsKey(tree.sym)) {

                Symbol translatedSym = lambdaContext.getSymbolMap(TYPE_VAR).get(tree.sym);

                result = make.Ident(translatedSym).setType(translatedSym.type);

            } else if (lambdaContext.getSymbolMap(CAPTURED_VAR).containsKey(tree.sym)) {

                Symbol translatedSym = lambdaContext.getSymbolMap(CAPTURED_VAR).get(tree.sym);

                result = make.Ident(translatedSym).setType(tree.type);

            } else {

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

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

                super.visitIdent(tree);

            }

        }

    }

    @Override

    public void visitVarDef(JCVariableDecl tree) {

        LambdaTranslationContext lambdaContext = (LambdaTranslationContext)context;

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

            JCExpression init = translate(tree.init);

            result = make.VarDef((VarSymbol)lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym), init);

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

            result = make.VarDef(xsym, init);

            // Replace the entered symbol for this variable

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

        if (isTarget_void) {

            //target is void:

            // BODY;

            JCStatement stat = make.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 = ListBuffer.lb();

            stats.append(make.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.Block(0, List.<JCStatement>of(make.Return(retExpr)));

        }

    }

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

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

        final boolean isTarget_void = restype.hasTag(VOID);

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

        class LambdaBodyTranslator extends TreeTranslator {

            @Override

            public void visitClassDef(JCClassDecl tree) {

                //do NOT recurse on any inner classes

                result = tree;

            }

            @Override

            public void visitLambda(JCLambda tree) {

                //do NOT recurse on any nested lambdas

                result = tree;

            }

            @Override

            public void visitReturn(JCReturn tree) {

                boolean isLambda_void = tree.expr == null;

                if (isTarget_void && !isLambda_void) {

                    //Void to void conversion:

                    // { TYPE $loc = RET-EXPR; return; }

                    VarSymbol loc = makeSyntheticVar(0, names.fromString("$loc"), tree.expr.type, lambdaMethodDecl.sym);

                    JCVariableDecl varDef = make.VarDef(loc, tree.expr);

                    result = make.Block(0, List.<JCStatement>of(varDef, make.Return(null)));

                } else if (!isTarget_void || !isLambda_void) {

                    //non-void to non-void conversion:

                    // return (TYPE)RET-EXPR;

                    tree.expr = transTypes.coerce(attrEnv, tree.expr, restype);

                    result = tree;

                } else {

                    result = tree;

                }

            }

        }

        JCBlock trans_block = new LambdaBodyTranslator().translate(block);

        if (completeNormally && isTarget_Void) {

            //there's no return statement and the lambda (possibly inferred)

            //return type is java.lang.Void; emit a synthetic return statement

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

        }

        return trans_block;

    }

    private JCMethodDecl makeDeserializeMethod(Symbol kSym) {

        ListBuffer<JCCase> cases = ListBuffer.lb();

        ListBuffer<JCBreak> breaks = ListBuffer.lb();

        for (Map.Entry<String, ListBuffer<JCStatement>> entry : kInfo.deserializeCases.entrySet()) {

            JCBreak br = make.Break(null);

            breaks.add(br);

            List<JCStatement> stmts = entry.getValue().append(br).toList();

            cases.add(make.Case(make.Literal(entry.getKey()), stmts));

        }

        JCSwitch sw = make.Switch(deserGetter("getImplMethodName", syms.stringType), cases.toList());

        for (JCBreak br : breaks) {

            br.target = sw;

        }

        JCBlock body = make.Block(0L, List.<JCStatement>of(

                sw,

                make.Throw(makeNewClass(

                    syms.illegalArgumentExceptionType,

                    List.<JCExpression>of(make.Literal("Invalid lambda deserialization"))))));

        JCMethodDecl deser = make.MethodDef(make.Modifiers(kInfo.deserMethodSym.flags()),

                        names.deserializeLambda,