/*

 * Copyright 1999-2008 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.tools.javac.comp;

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

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

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

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

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

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

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

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

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

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 javax.lang.model.element.ElementVisitor;

import java.util.Map;

import java.util.HashMap;

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

 *

 *  <p><b>This is NOT part of any API supported by Sun Microsystems.  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();

    private final boolean debugResolve;

    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

            ResolveError(ABSENT_VAR, syms.errSymbol, "variable not found");

        wrongMethod = new

            ResolveError(WRONG_MTH, syms.errSymbol, "method not found");

        wrongMethods = new

            ResolveError(WRONG_MTHS, syms.errSymbol, "wrong methods");

        methodNotFound = new

            ResolveError(ABSENT_MTH, syms.errSymbol, "method not found");

        typeNotFound = new

            ResolveError(ABSENT_TYP, syms.errSymbol, "type not found");

        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.get("debugresolve") != null;

    }

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

     */

    final ResolveError varNotFound;

    final ResolveError wrongMethod;

    final ResolveError wrongMethods;

    final ResolveError methodNotFound;

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

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

        case PRIVATE:

            return

                env.enclClass.sym.outermostClass() ==

                c.owner.outermostClass();

        case 0:

            return

                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;

        default: // error recovery

        case PUBLIC:

            return true;

        case PROTECTED:

            return

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

                ||

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

                ||

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

        }

    }

    //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 (t.tag == ARRAY)

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

            : isAccessible(env, t.tsym);

    }

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

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

        ClassSymbol sub;

        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)

                &&

                sym.isInheritedIn(site.tsym, types);

        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)

                &&

                // `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'.)

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

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

        default: // this case includes erroneous combinations as well

            return isAccessible(env, site);

        }

    }

    //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.NoInstanceException {

        if (useVarargs && (m.flags() & VARARGS) == 0) return null;

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

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

        // need to inferred.

        List<Type> tvars = env.info.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 JLS3 15.12.2.1

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

            ForAll pmt = (ForAll) mt;

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

                return null;

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

                        return null;

                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(tvars,

                                    (MethodType)mt,

                                    argtypes,

                                    allowBoxing,

                                    useVarargs,

                                    warn);

        return

            argumentsAcceptable(argtypes, mt.getParameterTypes(),

                                allowBoxing, useVarargs, warn)

            ? mt

            : null;

    }

    /** 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 (Infer.NoInstanceException ex) {

            return null;

        }

    }

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

     */

    boolean argumentsAcceptable(List<Type> argtypes,

                                List<Type> formals,

                                boolean allowBoxing,

                                boolean useVarargs,

                                Warner warn) {

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

        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) return false;

            argtypes = argtypes.tail;

            formals = formals.tail;

        }

        if (formals.head != varargsFormal) return false; // not enough args

        if (!useVarargs)

            return argtypes.isEmpty();

        Type elt = types.elemtype(varargsFormal);

        while (argtypes.nonEmpty()) {

            if (!types.isConvertible(argtypes.head, elt, warn))

                return false;

            argtypes = argtypes.tail;

        }

        return true;

    }

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

 *  Symbol lookup

 *  the following naming conventions for arguments are used

 *

 *       env      is the environment where the symbol was mentioned

 *       site     is the type of which the symbol is a member

 *       name     is the symbol's name

 *                if no arguments are given

 *       argtypes are the value arguments, if we search for a method

 *

 *  If no symbol was found, a ResolveError detailing the problem is returned.

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

    /** Find field. Synthetic fields are always skipped.

     *  @param env     The current environment.

     *  @param site    The original type from where the selection takes place.

     *  @param name    The name of the field.

     *  @param c       The class to search for the field. This is always

     *                 a superclass or implemented interface of site's class.

     */

    Symbol findField(Env<AttrContext> env,

                     Type site,

                     Name name,

                     TypeSymbol c) {

        while (c.type.tag == TYPEVAR)

            c = c.type.getUpperBound().tsym;

        Symbol bestSoFar = varNotFound;

        Symbol sym;

        Scope.Entry e = c.members().lookup(name);

        while (e.scope != null) {

            if (e.sym.kind == VAR && (e.sym.flags_field & SYNTHETIC) == 0) {

                return isAccessible(env, site, e.sym)

                    ? e.sym : new AccessError(env, site, e.sym);

            }

            e = e.next();

        }

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

        if (st != null && (st.tag == CLASS || st.tag == TYPEVAR)) {

            sym = findField(env, site, name, st.tsym);

            if (sym.kind < bestSoFar.kind) bestSoFar = sym;

        }

        for (List<Type> l = types.interfaces(c.type);

             bestSoFar.kind != AMBIGUOUS && l.nonEmpty();

             l = l.tail) {

            sym = findField(env, site, name, l.head.tsym);

            if (bestSoFar.kind < AMBIGUOUS && sym.kind < AMBIGUOUS &&

                sym.owner != bestSoFar.owner)

                bestSoFar = new AmbiguityError(bestSoFar, sym);

            else if (sym.kind < bestSoFar.kind)

                bestSoFar = sym;

        }

        return bestSoFar;

    }

    /** Resolve a field identifier, throw a fatal error if not found.

     *  @param pos       The position to use for error reporting.

     *  @param env       The environment current at the method invocation.

     *  @param site      The type of the qualifying expression, in which

     *                   identifier is searched.

     *  @param name      The identifier's name.

     */

    public VarSymbol resolveInternalField(DiagnosticPosition pos, Env<AttrContext> env,

                                          Type site, Name name) {

        Symbol sym = findField(env, site, name, site.tsym);

        if (sym.kind == VAR) return (VarSymbol)sym;

        else throw new FatalError(

                 diags.fragment("fatal.err.cant.locate.field",

                                name));

    }

    /** Find unqualified variable or field with given name.

     *  Synthetic fields always skipped.

     *  @param env     The current environment.

     *  @param name    The name of the variable or field.

     */

    Symbol findVar(Env<AttrContext> env, Name name) {

        Symbol bestSoFar = varNotFound;

        Symbol sym;

        Env<AttrContext> env1 = env;

        boolean staticOnly = false;

        while (env1.outer != null) {

            if (isStatic(env1)) staticOnly = true;

            Scope.Entry e = env1.info.scope.lookup(name);

            while (e.scope != null &&

                   (e.sym.kind != VAR ||

                    (e.sym.flags_field & SYNTHETIC) != 0))

                e = e.next();

            sym = (e.scope != null)

                ? e.sym

                : findField(

                    env1, env1.enclClass.sym.type, name, env1.enclClass.sym);

            if (sym.exists()) {

                if (staticOnly &&

                    sym.kind == VAR &&

                    sym.owner.kind == TYP &&

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

                    return new StaticError(sym);

                else

                    return sym;

            } else if (sym.kind < bestSoFar.kind) {

                bestSoFar = sym;

            }

            if ((env1.enclClass.sym.flags() & STATIC) != 0) staticOnly = true;

            env1 = env1.outer;

        }

        sym = findField(env, syms.predefClass.type, name, syms.predefClass);

        if (sym.exists())

            return sym;

        if (bestSoFar.exists())

            return bestSoFar;

        Scope.Entry e = env.toplevel.namedImportScope.lookup(name);

        for (; e.scope != null; e = e.next()) {

            sym = e.sym;

            Type origin = e.getOrigin().owner.type;

            if (sym.kind == VAR) {

                if (e.sym.owner.type != origin)

                    sym = sym.clone(e.getOrigin().owner);

                return isAccessible(env, origin, sym)

                    ? sym : new AccessError(env, origin, sym);

            }

        }

        Symbol origin = null;

        e = env.toplevel.starImportScope.lookup(name);

        for (; e.scope != null; e = e.next()) {

            sym = e.sym;

            if (sym.kind != VAR)

                continue;

            // invariant: sym.kind == VAR

            if (bestSoFar.kind < AMBIGUOUS && sym.owner != bestSoFar.owner)

                return new AmbiguityError(bestSoFar, sym);