/*

 * Copyright (c) 1999, 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 java.util.*;

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

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

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

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

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

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

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

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

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

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

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

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

import static com.sun.tools.javac.comp.CompileStates.CompileState;

/** This pass translates Generic Java to conventional Java.

 *

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

    /** The context key for the TransTypes phase. */

    protected static final Context.Key<TransTypes> transTypesKey = new Context.Key<>();

    /** Get the instance for this context. */

    public static TransTypes instance(Context context) {

        TransTypes instance = context.get(transTypesKey);

        if (instance == null)

            instance = new TransTypes(context);

        return instance;

    }

    private Names names;

    private Log log;

    private Symtab syms;

    private TreeMaker make;

    private Enter enter;

    private boolean allowEnums;

    private boolean allowInterfaceBridges;

    private Types types;

    private final Resolve resolve;

    /**

     * Flag to indicate whether or not to generate bridge methods.

     * For pre-Tiger source there is no need for bridge methods, so it

     * can be skipped to get better performance for -source 1.4 etc.

     */

    private final boolean addBridges;

    private final CompileStates compileStates;

    protected TransTypes(Context context) {

        context.put(transTypesKey, this);

        compileStates = CompileStates.instance(context);

        names = Names.instance(context);

        log = Log.instance(context);

        syms = Symtab.instance(context);

        enter = Enter.instance(context);

        overridden = new HashMap<>();

        Source source = Source.instance(context);

        allowEnums = source.allowEnums();

        addBridges = source.addBridges();

        allowInterfaceBridges = source.allowDefaultMethods();

        types = Types.instance(context);

        make = TreeMaker.instance(context);

        resolve = Resolve.instance(context);

    }

    /** A hashtable mapping bridge methods to the methods they override after

     *  type erasure.

     */

    Map<MethodSymbol,MethodSymbol> overridden;

    /** Construct an attributed tree for a cast of expression to target type,

     *  unless it already has precisely that type.

     *  @param tree    The expression tree.

     *  @param target  The target type.

     */

    JCExpression cast(JCExpression tree, Type target) {

        int oldpos = make.pos;

        make.at(tree.pos);

        if (!types.isSameType(tree.type, target)) {

            if (!resolve.isAccessible(env, target.tsym))

                resolve.logAccessErrorInternal(env, tree, target);

            tree = make.TypeCast(make.Type(target), tree).setType(target);

        }

        make.pos = oldpos;

        return tree;

    }

    /** Construct an attributed tree to coerce an expression to some erased

     *  target type, unless the expression is already assignable to that type.

     *  If target type is a constant type, use its base type instead.

     *  @param tree    The expression tree.

     *  @param target  The target type.

     */

    public JCExpression coerce(Env<AttrContext> env, JCExpression tree, Type target) {

        Env<AttrContext> prevEnv = this.env;

        try {

            this.env = env;

            return coerce(tree, target);

        }

        finally {

            this.env = prevEnv;

        }

    }

    JCExpression coerce(JCExpression tree, Type target) {

        Type btarget = target.baseType();

        if (tree.type.isPrimitive() == target.isPrimitive()) {

            return types.isAssignable(tree.type, btarget, types.noWarnings)

                ? tree

                : cast(tree, btarget);

        }

        return tree;

    }

    /** Given an erased reference type, assume this type as the tree's type.

     *  Then, coerce to some given target type unless target type is null.

     *  This operation is used in situations like the following:

     *

     *  <pre>{@code

     *  class Cell<A> { A value; }

     *  ...

     *  Cell<Integer> cell;

     *  Integer x = cell.value;

     *  }</pre>

     *

     *  Since the erasure of Cell.value is Object, but the type

     *  of cell.value in the assignment is Integer, we need to

     *  adjust the original type of cell.value to Object, and insert

     *  a cast to Integer. That is, the last assignment becomes:

     *

     *  <pre>{@code

     *  Integer x = (Integer)cell.value;

     *  }</pre>

     *

     *  @param tree       The expression tree whose type might need adjustment.

     *  @param erasedType The expression's type after erasure.

     *  @param target     The target type, which is usually the erasure of the

     *                    expression's original type.

     */

    JCExpression retype(JCExpression tree, Type erasedType, Type target) {

//      System.err.println("retype " + tree + " to " + erasedType);//DEBUG

        if (!erasedType.isPrimitive()) {

            if (target != null && target.isPrimitive()) {

                target = erasure(tree.type);

            }

            tree.type = erasedType;

            if (target != null) {

                return coerce(tree, target);

            }

        }

        return tree;

    }

    /** Translate method argument list, casting each argument

     *  to its corresponding type in a list of target types.

     *  @param _args            The method argument list.

     *  @param parameters       The list of target types.

     *  @param varargsElement   The erasure of the varargs element type,

     *  or null if translating a non-varargs invocation

     */

    <T extends JCTree> List<T> translateArgs(List<T> _args,

                                           List<Type> parameters,

                                           Type varargsElement) {

        if (parameters.isEmpty()) return _args;

        List<T> args = _args;

        while (parameters.tail.nonEmpty()) {

            args.head = translate(args.head, parameters.head);

            args = args.tail;

            parameters = parameters.tail;

        }

        Type parameter = parameters.head;

        Assert.check(varargsElement != null || args.length() == 1);

        if (varargsElement != null) {

            while (args.nonEmpty()) {

                args.head = translate(args.head, varargsElement);

                args = args.tail;

            }

        } else {

            args.head = translate(args.head, parameter);

        }

        return _args;

    }

    public <T extends JCTree> List<T> translateArgs(List<T> _args,

                                           List<Type> parameters,

                                           Type varargsElement,

                                           Env<AttrContext> localEnv) {

        Env<AttrContext> prevEnv = env;

        try {

            env = localEnv;

            return translateArgs(_args, parameters, varargsElement);

        }

        finally {

            env = prevEnv;

        }

    }

    /** Add a bridge definition and enter corresponding method symbol in

     *  local scope of origin.

     *

     *  @param pos     The source code position to be used for the definition.

     *  @param meth    The method for which a bridge needs to be added

     *  @param impl    That method's implementation (possibly the method itself)

     *  @param origin  The class to which the bridge will be added

     *  @param hypothetical

     *                 True if the bridge method is not strictly necessary in the

     *                 binary, but is represented in the symbol table to detect

     *                 erasure clashes.

     *  @param bridges The list buffer to which the bridge will be added

     */

    void addBridge(DiagnosticPosition pos,

                   MethodSymbol meth,

                   MethodSymbol impl,

                   ClassSymbol origin,

                   boolean hypothetical,

                   ListBuffer<JCTree> bridges) {

        make.at(pos);

        Type origType = types.memberType(origin.type, meth);

        Type origErasure = erasure(origType);

        // Create a bridge method symbol and a bridge definition without a body.

        Type bridgeType = meth.erasure(types);

        long flags = impl.flags() & AccessFlags | SYNTHETIC | BRIDGE |

                (origin.isInterface() ? DEFAULT : 0);

        if (hypothetical) flags |= HYPOTHETICAL;

        MethodSymbol bridge = new MethodSymbol(flags,

                                               meth.name,

                                               bridgeType,

                                               origin);

        /* once JDK-6996415 is solved it should be checked if this approach can

         * be applied to method addOverrideBridgesIfNeeded

         */

        bridge.params = createBridgeParams(impl, bridge, bridgeType);

        bridge.setAttributes(impl);

        if (!hypothetical) {

            JCMethodDecl md = make.MethodDef(bridge, null);

            // The bridge calls this.impl(..), if we have an implementation

            // in the current class, super.impl(...) otherwise.

            JCExpression receiver = (impl.owner == origin)

                ? make.This(origin.erasure(types))

                : make.Super(types.supertype(origin.type).tsym.erasure(types), origin);

            // The type returned from the original method.

            Type calltype = erasure(impl.type.getReturnType());

            // Construct a call of  this.impl(params), or super.impl(params),

            // casting params and possibly results as needed.

            JCExpression call =

                make.Apply(

                           null,

                           make.Select(receiver, impl).setType(calltype),

                           translateArgs(make.Idents(md.params), origErasure.getParameterTypes(), null))

                .setType(calltype);

            JCStatement stat = (origErasure.getReturnType().hasTag(VOID))

                ? make.Exec(call)

                : make.Return(coerce(call, bridgeType.getReturnType()));

            md.body = make.Block(0, List.of(stat));

            // Add bridge to `bridges' buffer

            bridges.append(md);

        }

        // Add bridge to scope of enclosing class and `overridden' table.

        origin.members().enter(bridge);

        overridden.put(bridge, meth);

    }

    private List<VarSymbol> createBridgeParams(MethodSymbol impl, MethodSymbol bridge,

            Type bridgeType) {

        List<VarSymbol> bridgeParams = null;

        if (impl.params != null) {

            bridgeParams = List.nil();

            List<VarSymbol> implParams = impl.params;

            Type.MethodType mType = (Type.MethodType)bridgeType;

            List<Type> argTypes = mType.argtypes;

            while (implParams.nonEmpty() && argTypes.nonEmpty()) {

                VarSymbol param = new VarSymbol(implParams.head.flags() | SYNTHETIC | PARAMETER,

                        implParams.head.name, argTypes.head, bridge);

                param.setAttributes(implParams.head);

                bridgeParams = bridgeParams.append(param);

                implParams = implParams.tail;

                argTypes = argTypes.tail;

            }

        }

        return bridgeParams;

    }

    /** Add bridge if given symbol is a non-private, non-static member

     *  of the given class, which is either defined in the class or non-final

     *  inherited, and one of the two following conditions holds:

     *  1. The method's type changes in the given class, as compared to the

     *     class where the symbol was defined, (in this case

     *     we have extended a parameterized class with non-trivial parameters).

     *  2. The method has an implementation with a different erased return type.

     *     (in this case we have used co-variant returns).

     *  If a bridge already exists in some other class, no new bridge is added.

     *  Instead, it is checked that the bridge symbol overrides the method symbol.

     *  (Spec ???).

     *  todo: what about bridges for privates???

     *

     *  @param pos     The source code position to be used for the definition.

     *  @param sym     The symbol for which a bridge might have to be added.

     *  @param origin  The class in which the bridge would go.

     *  @param bridges The list buffer to which the bridge would be added.

     */

    void addBridgeIfNeeded(DiagnosticPosition pos,

                           Symbol sym,

                           ClassSymbol origin,

                           ListBuffer<JCTree> bridges) {

        if (sym.kind == MTH &&

            sym.name != names.init &&

            (sym.flags() & (PRIVATE | STATIC)) == 0 &&

            (sym.flags() & (SYNTHETIC | OVERRIDE_BRIDGE)) != SYNTHETIC &&

            sym.isMemberOf(origin, types))

        {

            MethodSymbol meth = (MethodSymbol)sym;

            MethodSymbol bridge = meth.binaryImplementation(origin, types);

            MethodSymbol impl = meth.implementation(origin, types, true, overrideBridgeFilter);

            if (bridge == null ||

                bridge == meth ||

                (impl != null && !bridge.owner.isSubClass(impl.owner, types))) {

                // No bridge was added yet.

                if (impl != null && isBridgeNeeded(meth, impl, origin.type)) {

                    addBridge(pos, meth, impl, origin, bridge==impl, bridges);

                } else if (impl == meth

                           && impl.owner != origin

                           && (impl.flags() & FINAL) == 0

                           && (meth.flags() & (ABSTRACT|PUBLIC)) == PUBLIC

                           && (origin.flags() & PUBLIC) > (impl.owner.flags() & PUBLIC)) {

                    // this is to work around a horrible but permanent

                    // reflection design error.

                    addBridge(pos, meth, impl, origin, false, bridges);

                }

            } else if ((bridge.flags() & (SYNTHETIC | OVERRIDE_BRIDGE)) == SYNTHETIC) {

                MethodSymbol other = overridden.get(bridge);

                if (other != null && other != meth) {

                    if (impl == null || !impl.overrides(other, origin, types, true)) {

                        // Bridge for other symbol pair was added

                        log.error(pos, "name.clash.same.erasure.no.override",

                                  other, other.location(origin.type, types),

                                  meth,  meth.location(origin.type, types));

                    }

                }

            } else if (!bridge.overrides(meth, origin, types, true)) {

                // Accidental binary override without source override.

                if (bridge.owner == origin ||

                    types.asSuper(bridge.owner.type, meth.owner) == null)

                    // Don't diagnose the problem if it would already

                    // have been reported in the superclass

                    log.error(pos, "name.clash.same.erasure.no.override",

                              bridge, bridge.location(origin.type, types),

                              meth,  meth.location(origin.type, types));

            }

        }

    }

    // where

        private Filter<Symbol> overrideBridgeFilter = new Filter<Symbol>() {

            public boolean accepts(Symbol s) {

                return (s.flags() & (SYNTHETIC | OVERRIDE_BRIDGE)) != SYNTHETIC;

            }

        };

        /**

         * @param method The symbol for which a bridge might have to be added

         * @param impl The implementation of method

         * @param dest The type in which the bridge would go

         */

        private boolean isBridgeNeeded(MethodSymbol method,

                                       MethodSymbol impl,

                                       Type dest) {

            if (impl != method) {

                // If either method or impl have different erasures as

                // members of dest, a bridge is needed.

                Type method_erasure = method.erasure(types);

                if (!isSameMemberWhenErased(dest, method, method_erasure))

                    return true;

                Type impl_erasure = impl.erasure(types);

                if (!isSameMemberWhenErased(dest, impl, impl_erasure))

                    return true;

                // If the erasure of the return type is different, a

                // bridge is needed.

                return !types.isSameType(impl_erasure.getReturnType(),

                                         method_erasure.getReturnType());

            } else {

               // method and impl are the same...

                if ((method.flags() & ABSTRACT) != 0) {

                    // ...and abstract so a bridge is not needed.

                    // Concrete subclasses will bridge as needed.

                    return false;

                }

                // The erasure of the return type is always the same

                // for the same symbol.  Reducing the three tests in

                // the other branch to just one:

                return !isSameMemberWhenErased(dest, method, method.erasure(types));

            }

        }

        /**

         * Lookup the method as a member of the type.  Compare the

         * erasures.

         * @param type the class where to look for the method

         * @param method the method to look for in class

         * @param erasure the erasure of method

         */

        private boolean isSameMemberWhenErased(Type type,

                                               MethodSymbol method,

                                               Type erasure) {

            return types.isSameType(erasure(types.memberType(type, method)),

                                    erasure);

        }

    void addBridges(DiagnosticPosition pos,

                    TypeSymbol i,

                    ClassSymbol origin,

                    ListBuffer<JCTree> bridges) {

        for (Scope.Entry e = i.members().elems; e != null; e = e.sibling)

            addBridgeIfNeeded(pos, e.sym, origin, bridges);

        for (List<Type> l = types.interfaces(i.type); l.nonEmpty(); l = l.tail)

            addBridges(pos, l.head.tsym, origin, bridges);

    }

    /** Add all necessary bridges to some class appending them to list buffer.

     *  @param pos     The source code position to be used for the bridges.

     *  @param origin  The class in which the bridges go.

     *  @param bridges The list buffer to which the bridges are added.

     */

    void addBridges(DiagnosticPosition pos, ClassSymbol origin, ListBuffer<JCTree> bridges) {

        Type st = types.supertype(origin.type);

        while (st.hasTag(CLASS)) {

//          if (isSpecialization(st))

            addBridges(pos, st.tsym, origin, bridges);

            st = types.supertype(st);

        }

        for (List<Type> l = types.interfaces(origin.type); l.nonEmpty(); l = l.tail)

//          if (isSpecialization(l.head))

            addBridges(pos, l.head.tsym, origin, bridges);

    }

/* ************************************************************************

 * Visitor methods

 *************************************************************************/

    /** Visitor argument: proto-type.

     */

    private Type pt;

    /** Visitor method: perform a type translation on tree.

     */

    public <T extends JCTree> T translate(T tree, Type pt) {

        Type prevPt = this.pt;

        try {

            this.pt = pt;

            return translate(tree);

        } finally {

            this.pt = prevPt;

        }

    }

    /** Visitor method: perform a type translation on list of trees.

     */

    public <T extends JCTree> List<T> translate(List<T> trees, Type pt) {

        Type prevPt = this.pt;

        List<T> res;

        try {

            this.pt = pt;

            res = translate(trees);

        } finally {

            this.pt = prevPt;

        }

        return res;

    }

    public void visitClassDef(JCClassDecl tree) {

        translateClass(tree.sym);

        result = tree;

    }

    JCTree currentMethod = null;

    public void visitMethodDef(JCMethodDecl tree) {

        JCTree previousMethod = currentMethod;