/*

 * Copyright (c) 1999, 2011, 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.api.Formattable.LocalizedString;

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

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

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

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

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

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

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

import java.util.Arrays;

import java.util.Collection;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Set;

import javax.lang.model.element.ElementVisitor;

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

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

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

import static com.sun.tools.javac.comp.Resolve.MethodResolutionPhase.*;

/** Helper class for name resolution, used mostly by the attribution phase.

 *

 *  <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 Resolve {

    protected static final Context.Key<Resolve> resolveKey =

        new Context.Key<Resolve>();

    Names names;

    Log log;

    Symtab syms;

    Check chk;

    Infer infer;

    ClassReader reader;

    TreeInfo treeinfo;

    Types types;

    JCDiagnostic.Factory diags;

    public final boolean boxingEnabled; // = source.allowBoxing();

    public final boolean varargsEnabled; // = source.allowVarargs();

    public final boolean allowMethodHandles;

    private final boolean debugResolve;

    final EnumSet<VerboseResolutionMode> verboseResolutionMode;

    Scope polymorphicSignatureScope;

    enum VerboseResolutionMode {

        SUCCESS("success"),

        FAILURE("failure"),

        APPLICABLE("applicable"),

        INAPPLICABLE("inapplicable"),

        DEFERRED_INST("deferred-inference"),

        PREDEF("predef"),

        OBJECT_INIT("object-init"),

        INTERNAL("internal");

        String opt;

        private VerboseResolutionMode(String opt) {

            this.opt = opt;

        }

        static EnumSet<VerboseResolutionMode> getVerboseResolutionMode(Options opts) {

            String s = opts.get("verboseResolution");

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

            if (s == null) return res;

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

                res = EnumSet.allOf(VerboseResolutionMode.class);

            }

            Collection<String> args = Arrays.asList(s.split(","));

            for (VerboseResolutionMode mode : values()) {

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

                    res.add(mode);

                } else if (args.contains("-" + mode.opt)) {

                    res.remove(mode);

                }

            }

            return res;

        }

    }

    public static Resolve instance(Context context) {

        Resolve instance = context.get(resolveKey);

        if (instance == null)

            instance = new Resolve(context);

        return instance;

    }

    protected Resolve(Context context) {

        context.put(resolveKey, this);

        syms = Symtab.instance(context);

        varNotFound = new

            SymbolNotFoundError(ABSENT_VAR);

        wrongMethod = new

            InapplicableSymbolError(syms.errSymbol);

        wrongMethods = new

            InapplicableSymbolsError(syms.errSymbol);

        methodNotFound = new

            SymbolNotFoundError(ABSENT_MTH);

        typeNotFound = new

            SymbolNotFoundError(ABSENT_TYP);

        names = Names.instance(context);

        log = Log.instance(context);

        chk = Check.instance(context);

        infer = Infer.instance(context);

        reader = ClassReader.instance(context);

        treeinfo = TreeInfo.instance(context);

        types = Types.instance(context);

        diags = JCDiagnostic.Factory.instance(context);

        Source source = Source.instance(context);

        boxingEnabled = source.allowBoxing();

        varargsEnabled = source.allowVarargs();

        Options options = Options.instance(context);

        debugResolve = options.isSet("debugresolve");

        verboseResolutionMode = VerboseResolutionMode.getVerboseResolutionMode(options);

        Target target = Target.instance(context);

        allowMethodHandles = target.hasMethodHandles();

        polymorphicSignatureScope = new Scope(syms.noSymbol);

        inapplicableMethodException = new InapplicableMethodException(diags);

    }

    /** error symbols, which are returned when resolution fails

     */

    final SymbolNotFoundError varNotFound;

    final InapplicableSymbolError wrongMethod;

    final InapplicableSymbolsError wrongMethods;

    final SymbolNotFoundError methodNotFound;

    final SymbolNotFoundError typeNotFound;

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

 * Identifier resolution

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

    /** An environment is "static" if its static level is greater than

     *  the one of its outer environment

     */

    static boolean isStatic(Env<AttrContext> env) {

        return env.info.staticLevel > env.outer.info.staticLevel;

    }

    /** An environment is an "initializer" if it is a constructor or

     *  an instance initializer.

     */

    static boolean isInitializer(Env<AttrContext> env) {

        Symbol owner = env.info.scope.owner;

        return owner.isConstructor() ||

            owner.owner.kind == TYP &&

            (owner.kind == VAR ||

             owner.kind == MTH && (owner.flags() & BLOCK) != 0) &&

            (owner.flags() & STATIC) == 0;

    }

    /** Is class accessible in given evironment?

     *  @param env    The current environment.

     *  @param c      The class whose accessibility is checked.

     */

    public boolean isAccessible(Env<AttrContext> env, TypeSymbol c) {

        return isAccessible(env, c, false);

    }

    public boolean isAccessible(Env<AttrContext> env, TypeSymbol c, boolean checkInner) {

        boolean isAccessible = false;

        switch ((short)(c.flags() & AccessFlags)) {

            case PRIVATE:

                isAccessible =

                    env.enclClass.sym.outermostClass() ==

                    c.owner.outermostClass();

                break;

            case 0:

                isAccessible =

                    env.toplevel.packge == c.owner // fast special case

                    ||

                    env.toplevel.packge == c.packge()

                    ||

                    // Hack: this case is added since synthesized default constructors

                    // of anonymous classes should be allowed to access

                    // classes which would be inaccessible otherwise.

                    env.enclMethod != null &&

                    (env.enclMethod.mods.flags & ANONCONSTR) != 0;

                break;

            default: // error recovery

            case PUBLIC:

                isAccessible = true;

                break;

            case PROTECTED:

                isAccessible =

                    env.toplevel.packge == c.owner // fast special case

                    ||

                    env.toplevel.packge == c.packge()

                    ||

                    isInnerSubClass(env.enclClass.sym, c.owner);

                break;

        }

        return (checkInner == false || c.type.getEnclosingType() == Type.noType) ?

            isAccessible :

            isAccessible && isAccessible(env, c.type.getEnclosingType(), checkInner);

    }

    //where

        /** Is given class a subclass of given base class, or an inner class

         *  of a subclass?

         *  Return null if no such class exists.

         *  @param c     The class which is the subclass or is contained in it.

         *  @param base  The base class

         */

        private boolean isInnerSubClass(ClassSymbol c, Symbol base) {

            while (c != null && !c.isSubClass(base, types)) {

                c = c.owner.enclClass();

            }

            return c != null;

        }

    boolean isAccessible(Env<AttrContext> env, Type t) {

        return isAccessible(env, t, false);

    }

    boolean isAccessible(Env<AttrContext> env, Type t, boolean checkInner) {

        return (t.tag == ARRAY)

            ? isAccessible(env, types.elemtype(t))

            : isAccessible(env, t.tsym, checkInner);

    }

    /** Is symbol accessible as a member of given type in given evironment?

     *  @param env    The current environment.

     *  @param site   The type of which the tested symbol is regarded

     *                as a member.

     *  @param sym    The symbol.

     */

    public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym) {

        return isAccessible(env, site, sym, false);

    }

    public boolean isAccessible(Env<AttrContext> env, Type site, Symbol sym, boolean checkInner) {

        if (sym.name == names.init && sym.owner != site.tsym) return false;

        switch ((short)(sym.flags() & AccessFlags)) {

        case PRIVATE:

            return

                (env.enclClass.sym == sym.owner // fast special case

                 ||

                 env.enclClass.sym.outermostClass() ==

                 sym.owner.outermostClass())

                &&

                sym.isInheritedIn(site.tsym, types);

        case 0:

            return

                (env.toplevel.packge == sym.owner.owner // fast special case

                 ||

                 env.toplevel.packge == sym.packge())

                &&

                isAccessible(env, site, checkInner)

                &&

                sym.isInheritedIn(site.tsym, types)

                &&

                notOverriddenIn(site, sym);

        case PROTECTED:

            return

                (env.toplevel.packge == sym.owner.owner // fast special case

                 ||

                 env.toplevel.packge == sym.packge()

                 ||

                 isProtectedAccessible(sym, env.enclClass.sym, site)

                 ||

                 // OK to select instance method or field from 'super' or type name

                 // (but type names should be disallowed elsewhere!)

                 env.info.selectSuper && (sym.flags() & STATIC) == 0 && sym.kind != TYP)

                &&

                isAccessible(env, site, checkInner)

                &&

                notOverriddenIn(site, sym);

        default: // this case includes erroneous combinations as well

            return isAccessible(env, site, checkInner) && notOverriddenIn(site, sym);

        }

    }

    //where

    /* `sym' is accessible only if not overridden by

     * another symbol which is a member of `site'

     * (because, if it is overridden, `sym' is not strictly

     * speaking a member of `site'). A polymorphic signature method

     * cannot be overridden (e.g. MH.invokeExact(Object[])).

     */

    private boolean notOverriddenIn(Type site, Symbol sym) {

        if (sym.kind != MTH || sym.isConstructor() || sym.isStatic())

            return true;

        else {

            Symbol s2 = ((MethodSymbol)sym).implementation(site.tsym, types, true);

            return (s2 == null || s2 == sym || sym.owner == s2.owner ||

                    s2.isPolymorphicSignatureGeneric() ||

                    !types.isSubSignature(types.memberType(site, s2), types.memberType(site, sym)));

        }

    }

    //where

        /** Is given protected symbol accessible if it is selected from given site

         *  and the selection takes place in given class?

         *  @param sym     The symbol with protected access

         *  @param c       The class where the access takes place

         *  @site          The type of the qualifier

         */

        private

        boolean isProtectedAccessible(Symbol sym, ClassSymbol c, Type site) {

            while (c != null &&

                   !(c.isSubClass(sym.owner, types) &&

                     (c.flags() & INTERFACE) == 0 &&

                     // In JLS 2e 6.6.2.1, the subclass restriction applies

                     // only to instance fields and methods -- types are excluded

                     // regardless of whether they are declared 'static' or not.

                     ((sym.flags() & STATIC) != 0 || sym.kind == TYP || site.tsym.isSubClass(c, types))))

                c = c.owner.enclClass();

            return c != null;

        }

    /** Try to instantiate the type of a method so that it fits

     *  given type arguments and argument types. If succesful, return

     *  the method's instantiated type, else return null.

     *  The instantiation will take into account an additional leading

     *  formal parameter if the method is an instance method seen as a member

     *  of un underdetermined site In this case, we treat site as an additional

     *  parameter and the parameters of the class containing the method as

     *  additional type variables that get instantiated.

     *

     *  @param env         The current environment

     *  @param site        The type of which the method is a member.

     *  @param m           The method symbol.

     *  @param argtypes    The invocation's given value arguments.

     *  @param typeargtypes    The invocation's given type arguments.

     *  @param allowBoxing Allow boxing conversions of arguments.

     *  @param useVarargs Box trailing arguments into an array for varargs.

     */

    Type rawInstantiate(Env<AttrContext> env,

                        Type site,

                        Symbol m,

                        List<Type> argtypes,

                        List<Type> typeargtypes,

                        boolean allowBoxing,

                        boolean useVarargs,

                        Warner warn)

        throws Infer.InferenceException {

        boolean polymorphicSignature = m.isPolymorphicSignatureGeneric() && allowMethodHandles;

        if (useVarargs && (m.flags() & VARARGS) == 0)

            throw inapplicableMethodException.setMessage();

        Type mt = types.memberType(site, m);

        // tvars is the list of formal type variables for which type arguments

        // need to inferred.

        List<Type> tvars = null;

        if (env.info.tvars != null) {

            tvars = types.newInstances(env.info.tvars);

            mt = types.subst(mt, env.info.tvars, tvars);

        }

        if (typeargtypes == null) typeargtypes = List.nil();

        if (mt.tag != FORALL && typeargtypes.nonEmpty()) {

            // This is not a polymorphic method, but typeargs are supplied

            // which is fine, see JLS 15.12.2.1

        } else if (mt.tag == FORALL && typeargtypes.nonEmpty()) {

            ForAll pmt = (ForAll) mt;

            if (typeargtypes.length() != pmt.tvars.length())

                throw inapplicableMethodException.setMessage("arg.length.mismatch"); // not enough args

            // Check type arguments are within bounds

            List<Type> formals = pmt.tvars;

            List<Type> actuals = typeargtypes;

            while (formals.nonEmpty() && actuals.nonEmpty()) {

                List<Type> bounds = types.subst(types.getBounds((TypeVar)formals.head),

                                                pmt.tvars, typeargtypes);

                for (; bounds.nonEmpty(); bounds = bounds.tail)

                    if (!types.isSubtypeUnchecked(actuals.head, bounds.head, warn))

                        throw inapplicableMethodException.setMessage("explicit.param.do.not.conform.to.bounds",actuals.head, bounds);

                formals = formals.tail;

                actuals = actuals.tail;

            }

            mt = types.subst(pmt.qtype, pmt.tvars, typeargtypes);

        } else if (mt.tag == FORALL) {

            ForAll pmt = (ForAll) mt;

            List<Type> tvars1 = types.newInstances(pmt.tvars);

            tvars = tvars.appendList(tvars1);

            mt = types.subst(pmt.qtype, pmt.tvars, tvars1);

        }

        // find out whether we need to go the slow route via infer

        boolean instNeeded = tvars.tail != null || /*inlined: tvars.nonEmpty()*/

                polymorphicSignature;

        for (List<Type> l = argtypes;

             l.tail != null/*inlined: l.nonEmpty()*/ && !instNeeded;

             l = l.tail) {

            if (l.head.tag == FORALL) instNeeded = true;

        }

        if (instNeeded)

            return polymorphicSignature ?

                infer.instantiatePolymorphicSignatureInstance(env, site, m.name, (MethodSymbol)m, argtypes) :

                infer.instantiateMethod(env,

                                    tvars,

                                    (MethodType)mt,

                                    m,

                                    argtypes,

                                    allowBoxing,

                                    useVarargs,

                                    warn);

        checkRawArgumentsAcceptable(env, argtypes, mt.getParameterTypes(),

                                allowBoxing, useVarargs, warn);

        return mt;

    }

    /** Same but returns null instead throwing a NoInstanceException

     */

    Type instantiate(Env<AttrContext> env,

                     Type site,

                     Symbol m,

                     List<Type> argtypes,

                     List<Type> typeargtypes,

                     boolean allowBoxing,

                     boolean useVarargs,

                     Warner warn) {

        try {

            return rawInstantiate(env, site, m, argtypes, typeargtypes,

                                  allowBoxing, useVarargs, warn);

        } catch (InapplicableMethodException ex) {

            return null;

        }

    }

    /** Check if a parameter list accepts a list of args.

     */

    boolean argumentsAcceptable(Env<AttrContext> env,

                                List<Type> argtypes,

                                List<Type> formals,

                                boolean allowBoxing,

                                boolean useVarargs,

                                Warner warn) {

        try {

            checkRawArgumentsAcceptable(env, argtypes, formals, allowBoxing, useVarargs, warn);

            return true;

        } catch (InapplicableMethodException ex) {

            return false;

        }

    }

    void checkRawArgumentsAcceptable(Env<AttrContext> env,

                                List<Type> argtypes,

                                List<Type> formals,

                                boolean allowBoxing,

                                boolean useVarargs,

                                Warner warn) {

        Type varargsFormal = useVarargs ? formals.last() : null;

        if (varargsFormal == null &&

                argtypes.size() != formals.size()) {

            throw inapplicableMethodException.setMessage("arg.length.mismatch"); // not enough args

        }

        while (argtypes.nonEmpty() && formals.head != varargsFormal) {

            boolean works = allowBoxing

                ? types.isConvertible(argtypes.head, formals.head, warn)

                : types.isSubtypeUnchecked(argtypes.head, formals.head, warn);

            if (!works)

                throw inapplicableMethodException.setMessage("no.conforming.assignment.exists",

                        argtypes.head,

                        formals.head);

            argtypes = argtypes.tail;

            formals = formals.tail;

        }

        if (formals.head != varargsFormal)

            throw inapplicableMethodException.setMessage("arg.length.mismatch"); // not enough args

        if (useVarargs) {

            Type elt = types.elemtype(varargsFormal);