/*

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

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

import com.sun.tools.javac.comp.Attr.ResultInfo;

import com.sun.tools.javac.comp.Check.CheckContext;

import com.sun.tools.javac.comp.DeferredAttr.AttrMode;

import com.sun.tools.javac.comp.DeferredAttr.DeferredAttrContext;

import com.sun.tools.javac.comp.DeferredAttr.DeferredType;

import com.sun.tools.javac.comp.Infer.InferenceContext;

import com.sun.tools.javac.comp.Infer.InferenceContext.FreeTypeListener;

import com.sun.tools.javac.comp.Resolve.MethodResolutionContext.Candidate;

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

import java.util.EnumSet;

import java.util.Iterator;

import java.util.Map;

import javax.lang.model.element.ElementVisitor;

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

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

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

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

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

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

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

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

    Attr attr;

    DeferredAttr deferredAttr;

    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;

    protected Resolve(Context context) {

        context.put(resolveKey, this);

        syms = Symtab.instance(context);

        varNotFound = new

            SymbolNotFoundError(ABSENT_VAR);

        wrongMethod = new

            InapplicableSymbolError();

        wrongMethods = new

            InapplicableSymbolsError();

        methodNotFound = new

            SymbolNotFoundError(ABSENT_MTH);

        typeNotFound = new

            SymbolNotFoundError(ABSENT_TYP);

        names = Names.instance(context);

        log = Log.instance(context);

        attr = Attr.instance(context);

        deferredAttr = DeferredAttr.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

     */

    private final SymbolNotFoundError varNotFound;

    private final InapplicableSymbolError wrongMethod;

    private final InapplicableSymbolsError wrongMethods;

    private final SymbolNotFoundError methodNotFound;

    private final SymbolNotFoundError typeNotFound;

    public static Resolve instance(Context context) {

        Resolve instance = context.get(resolveKey);

        if (instance == null)

            instance = new Resolve(context);

        return instance;

    }

    // <editor-fold defaultstate="collapsed" desc="Verbose resolution diagnostics support">

    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;

        }

    }

    void reportVerboseResolutionDiagnostic(DiagnosticPosition dpos, Name name, Type site,

            List<Type> argtypes, List<Type> typeargtypes, Symbol bestSoFar) {

        boolean success = bestSoFar.kind < ERRONEOUS;

        if (success && !verboseResolutionMode.contains(VerboseResolutionMode.SUCCESS)) {

            return;

        } else if (!success && !verboseResolutionMode.contains(VerboseResolutionMode.FAILURE)) {

            return;

        }

        if (bestSoFar.name == names.init &&

                bestSoFar.owner == syms.objectType.tsym &&

                !verboseResolutionMode.contains(VerboseResolutionMode.OBJECT_INIT)) {

            return; //skip diags for Object constructor resolution

        } else if (site == syms.predefClass.type &&

                !verboseResolutionMode.contains(VerboseResolutionMode.PREDEF)) {

            return; //skip spurious diags for predef symbols (i.e. operators)

        } else if (currentResolutionContext.internalResolution &&

                !verboseResolutionMode.contains(VerboseResolutionMode.INTERNAL)) {

            return;

        }

        int pos = 0;

        int mostSpecificPos = -1;

        ListBuffer<JCDiagnostic> subDiags = ListBuffer.lb();

        for (Candidate c : currentResolutionContext.candidates) {

            if (currentResolutionContext.step != c.step ||

                    (c.isApplicable() && !verboseResolutionMode.contains(VerboseResolutionMode.APPLICABLE)) ||

                    (!c.isApplicable() && !verboseResolutionMode.contains(VerboseResolutionMode.INAPPLICABLE))) {

                continue;

            } else {

                subDiags.append(c.isApplicable() ?

                        getVerboseApplicableCandidateDiag(pos, c.sym, c.mtype) :

                        getVerboseInapplicableCandidateDiag(pos, c.sym, c.details));

                if (c.sym == bestSoFar)

                    mostSpecificPos = pos;

                pos++;

            }

        }

        String key = success ? "verbose.resolve.multi" : "verbose.resolve.multi.1";

        List<Type> argtypes2 = Type.map(argtypes,

                    deferredAttr.new RecoveryDeferredTypeMap(AttrMode.SPECULATIVE, bestSoFar, currentResolutionContext.step));

        JCDiagnostic main = diags.note(log.currentSource(), dpos, key, name,

                site.tsym, mostSpecificPos, currentResolutionContext.step,

                methodArguments(argtypes2),

                methodArguments(typeargtypes));

        JCDiagnostic d = new JCDiagnostic.MultilineDiagnostic(main, subDiags.toList());

        log.report(d);

    }

    JCDiagnostic getVerboseApplicableCandidateDiag(int pos, Symbol sym, Type inst) {

        JCDiagnostic subDiag = null;

        if (sym.type.tag == FORALL) {

            subDiag = diags.fragment("partial.inst.sig", inst);

        }

        String key = subDiag == null ?

                "applicable.method.found" :

                "applicable.method.found.1";

        return diags.fragment(key, pos, sym, subDiag);

    }

    JCDiagnostic getVerboseInapplicableCandidateDiag(int pos, Symbol sym, JCDiagnostic subDiag) {

        return diags.fragment("not.applicable.method.found", pos, sym, subDiag);

    }

    // </editor-fold>

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

 * Identifier resolution

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

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

     *  the one of its outer environment

     */

    protected 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 ||

                    !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,

                        ResultInfo resultInfo,

                        List<Type> argtypes,

                        List<Type> typeargtypes,

                        boolean allowBoxing,

                        boolean useVarargs,

                        Warner warn)

        throws Infer.InferenceException {

        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 = List.nil();

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

        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 infer.instantiateMethod(env,

                                    tvars,