/*

 * Copyright (c) 1999, 2018, 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.Scope.WriteableScope;

import com.sun.tools.javac.code.Source.Feature;

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.Resolve.MethodResolutionContext.Candidate;

import com.sun.tools.javac.comp.Resolve.MethodResolutionDiagHelper.Template;

import com.sun.tools.javac.comp.Resolve.ReferenceLookupResult.StaticKind;

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

import com.sun.tools.javac.main.Option;

import com.sun.tools.javac.resources.CompilerProperties.Errors;

import com.sun.tools.javac.resources.CompilerProperties.Fragments;

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

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

import com.sun.tools.javac.util.DefinedBy.Api;

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

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Set;

import java.util.function.BiFunction;

import java.util.function.BiPredicate;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.stream.Stream;

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.Flags.STATIC;

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

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

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

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

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

import static com.sun.tools.javac.util.Iterators.createCompoundIterator;

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

    Names names;

    Log log;

    Symtab syms;

    Attr attr;

    DeferredAttr deferredAttr;

    Check chk;

    Infer infer;

    ClassFinder finder;

    ModuleFinder moduleFinder;

    Types types;

    JCDiagnostic.Factory diags;

    public final boolean allowFunctionalInterfaceMostSpecific;

    public final boolean allowModules;

    public final boolean checkVarargsAccessAfterResolution;

    private final boolean compactMethodDiags;

    private final boolean allowLocalVariableTypeInference;

    final EnumSet<VerboseResolutionMode> verboseResolutionMode;

    WriteableScope polymorphicSignatureScope;

    protected Resolve(Context context) {

        context.put(resolveKey, this);

        syms = Symtab.instance(context);

        varNotFound = new SymbolNotFoundError(ABSENT_VAR);

        methodNotFound = new SymbolNotFoundError(ABSENT_MTH);

        typeNotFound = new SymbolNotFoundError(ABSENT_TYP);

        referenceNotFound = ReferenceLookupResult.error(methodNotFound);

        names = Names.instance(context);

        log = Log.instance(context);

        attr = Attr.instance(context);

        deferredAttr = DeferredAttr.instance(context);

        chk = Check.instance(context);

        infer = Infer.instance(context);

        finder = ClassFinder.instance(context);

        moduleFinder = ModuleFinder.instance(context);

        types = Types.instance(context);

        diags = JCDiagnostic.Factory.instance(context);

        Source source = Source.instance(context);

        Options options = Options.instance(context);

        compactMethodDiags = options.isSet(Option.XDIAGS, "compact") ||

                options.isUnset(Option.XDIAGS) && options.isUnset("rawDiagnostics");

        verboseResolutionMode = VerboseResolutionMode.getVerboseResolutionMode(options);

        Target target = Target.instance(context);

        allowFunctionalInterfaceMostSpecific = Feature.FUNCTIONAL_INTERFACE_MOST_SPECIFIC.allowedInSource(source);

        allowLocalVariableTypeInference = Feature.LOCAL_VARIABLE_TYPE_INFERENCE.allowedInSource(source);

        checkVarargsAccessAfterResolution =

                Feature.POST_APPLICABILITY_VARARGS_ACCESS_CHECK.allowedInSource(source);

        polymorphicSignatureScope = WriteableScope.create(syms.noSymbol);

        allowModules = Feature.MODULES.allowedInSource(source);

    }

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

     */

    private final SymbolNotFoundError varNotFound;

    private final SymbolNotFoundError methodNotFound;

    private final SymbolNotFoundError typeNotFound;

    /** empty reference lookup result */

    private final ReferenceLookupResult referenceNotFound;

    public static Resolve instance(Context context) {

        Resolve instance = context.get(resolveKey);

        if (instance == null)

            instance = new Resolve(context);

        return instance;

    }

    private static Symbol bestOf(Symbol s1,

                                 Symbol s2) {

        return s1.kind.betterThan(s2.kind) ? s1 : s2;

    }

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

        final String opt;

        private VerboseResolutionMode(String opt) {

            this.opt = opt;

        }

        static EnumSet<VerboseResolutionMode> getVerboseResolutionMode(Options opts) {

            String s = opts.get("debug.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.isResolutionError();

        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 = new ListBuffer<>();

        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 = argtypes.map(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.hasTag(FORALL)) {

            subDiag = diags.fragment(Fragments.PartialInstSig(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(Fragments.NotApplicableMethodFound(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.outer != null && 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) {

        /* 15.9.5.1: Note that it is possible for the signature of the anonymous constructor

           to refer to an inaccessible type

        */

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

            return true;

        if (env.info.visitingServiceImplementation &&

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

            return true;

        }

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

                break;

            default: // error recovery

                isAccessible = true;

                break;

            case PUBLIC:

                if (allowModules) {

                    ModuleSymbol currModule = env.toplevel.modle;

                    currModule.complete();

                    PackageSymbol p = c.packge();

                    isAccessible =

                        currModule == p.modle ||

                        currModule.visiblePackages.get(p.fullname) == p ||

                        p == syms.rootPackage ||

                        (p.modle == syms.unnamedModule && currModule.readModules.contains(p.modle));

                } else {

                    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.hasTag(ARRAY))

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

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

    }

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

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

        /* 15.9.5.1: Note that it is possible for the signature of the anonymous constructor

           to refer to an inaccessible type

        */

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

            return true;

        if (env.info.visitingServiceImplementation &&

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

            return true;

        }

        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) {

            Type newSite = site.hasTag(TYPEVAR) ? site.getUpperBound() : 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 || newSite.tsym.isSubClass(c, types))))

                c = c.owner.enclClass();

            return c != null;

        }

    /**

     * Performs a recursive scan of a type looking for accessibility problems

     * from current attribution environment

     */

    void checkAccessibleType(Env<AttrContext> env, Type t) {

        accessibilityChecker.visit(t, env);

    }

    /**

     * Accessibility type-visitor

     */

    Types.SimpleVisitor<Void, Env<AttrContext>> accessibilityChecker =

            new Types.SimpleVisitor<Void, Env<AttrContext>>() {

        void visit(List<Type> ts, Env<AttrContext> env) {