/*

 * 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 java.util.*;

import java.util.Set;

import javax.lang.model.element.ElementKind;

import javax.tools.JavaFileObject;

import com.sun.source.tree.IdentifierTree;

import com.sun.source.tree.MemberReferenceTree.ReferenceMode;

import com.sun.source.tree.MemberSelectTree;

import com.sun.source.tree.TreeVisitor;

import com.sun.source.util.SimpleTreeVisitor;

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

import com.sun.tools.javac.code.Lint.LintCategory;

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

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

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

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

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

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

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

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

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

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.TypeTag.*;

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

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

/** This is the main context-dependent analysis phase in GJC. It

 *  encompasses name resolution, type checking and constant folding as

 *  subtasks. Some subtasks involve auxiliary classes.

 *  @see Check

 *  @see Resolve

 *  @see ConstFold

 *  @see Infer

 *

 *  <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 Attr extends JCTree.Visitor {

    protected static final Context.Key<Attr> attrKey =

        new Context.Key<Attr>();

    final Names names;

    final Log log;

    final Symtab syms;

    final Resolve rs;

    final Infer infer;

    final DeferredAttr deferredAttr;

    final Check chk;

    final Flow flow;

    final MemberEnter memberEnter;

    final TreeMaker make;

    final ConstFold cfolder;

    final Enter enter;

    final Target target;

    final Types types;

    final JCDiagnostic.Factory diags;

    final Annotate annotate;

    final DeferredLintHandler deferredLintHandler;

    public static Attr instance(Context context) {

        Attr instance = context.get(attrKey);

        if (instance == null)

            instance = new Attr(context);

        return instance;

    }

    protected Attr(Context context) {

        context.put(attrKey, this);

        names = Names.instance(context);

        log = Log.instance(context);

        syms = Symtab.instance(context);

        rs = Resolve.instance(context);

        chk = Check.instance(context);

        flow = Flow.instance(context);

        memberEnter = MemberEnter.instance(context);

        make = TreeMaker.instance(context);

        enter = Enter.instance(context);

        infer = Infer.instance(context);

        deferredAttr = DeferredAttr.instance(context);

        cfolder = ConstFold.instance(context);

        target = Target.instance(context);

        types = Types.instance(context);

        diags = JCDiagnostic.Factory.instance(context);

        annotate = Annotate.instance(context);

        deferredLintHandler = DeferredLintHandler.instance(context);

        Options options = Options.instance(context);

        Source source = Source.instance(context);

        allowGenerics = source.allowGenerics();

        allowVarargs = source.allowVarargs();

        allowEnums = source.allowEnums();

        allowBoxing = source.allowBoxing();

        allowCovariantReturns = source.allowCovariantReturns();

        allowAnonOuterThis = source.allowAnonOuterThis();

        allowStringsInSwitch = source.allowStringsInSwitch();

        allowPoly = source.allowPoly() && options.isSet("allowPoly");

        allowLambda = source.allowLambda();

        allowDefaultMethods = source.allowDefaultMethods();

        sourceName = source.name;

        relax = (options.isSet("-retrofit") ||

                 options.isSet("-relax"));

        findDiamonds = options.get("findDiamond") != null &&

                 source.allowDiamond();

        useBeforeDeclarationWarning = options.isSet("useBeforeDeclarationWarning");

        identifyLambdaCandidate = options.getBoolean("identifyLambdaCandidate", false);

        statInfo = new ResultInfo(NIL, Type.noType);

        varInfo = new ResultInfo(VAR, Type.noType);

        unknownExprInfo = new ResultInfo(VAL, Type.noType);

        unknownTypeInfo = new ResultInfo(TYP, Type.noType);

        recoveryInfo = new RecoveryInfo(deferredAttr.emptyDeferredAttrContext);

    }

    /** Switch: relax some constraints for retrofit mode.

     */

    boolean relax;

    /** Switch: support target-typing inference

     */

    boolean allowPoly;

    /** Switch: support generics?

     */

    boolean allowGenerics;

    /** Switch: allow variable-arity methods.

     */

    boolean allowVarargs;

    /** Switch: support enums?

     */

    boolean allowEnums;

    /** Switch: support boxing and unboxing?

     */

    boolean allowBoxing;

    /** Switch: support covariant result types?

     */

    boolean allowCovariantReturns;

    /** Switch: support default methods ?

     */

    boolean allowDefaultMethods;

    /** Switch: support lambda expressions ?

     */

    boolean allowLambda;

    /** Switch: allow references to surrounding object from anonymous

     * objects during constructor call?

     */

    boolean allowAnonOuterThis;

    /** Switch: generates a warning if diamond can be safely applied

     *  to a given new expression

     */

    boolean findDiamonds;

    /**

     * Internally enables/disables diamond finder feature

     */

    static final boolean allowDiamondFinder = true;

    /**

     * Switch: warn about use of variable before declaration?

     * RFE: 6425594

     */

    boolean useBeforeDeclarationWarning;

    /**

     * Switch: generate warnings whenever an anonymous inner class that is convertible

     * to a lambda expression is found

     */

    boolean identifyLambdaCandidate;

    /**

     * Switch: allow strings in switch?

     */

    boolean allowStringsInSwitch;

    /**

     * Switch: name of source level; used for error reporting.

     */

    String sourceName;

    /** Check kind and type of given tree against protokind and prototype.

     *  If check succeeds, store type in tree and return it.

     *  If check fails, store errType in tree and return it.

     *  No checks are performed if the prototype is a method type.

     *  It is not necessary in this case since we know that kind and type

     *  are correct.

     *

     *  @param tree     The tree whose kind and type is checked

     *  @param ownkind  The computed kind of the tree

     *  @param resultInfo  The expected result of the tree

     */

    Type check(final JCTree tree, final Type found, final int ownkind, final ResultInfo resultInfo) {

        InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();

        Type owntype = found;

        if (!owntype.hasTag(ERROR) && !resultInfo.pt.hasTag(METHOD) && !resultInfo.pt.hasTag(FORALL)) {

            if (inferenceContext.free(found)) {

                inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() {

                    @Override

                    public void typesInferred(InferenceContext inferenceContext) {

                        ResultInfo pendingResult =

                                    resultInfo.dup(inferenceContext.asInstType(resultInfo.pt, types));

                        check(tree, inferenceContext.asInstType(found, types), ownkind, pendingResult);

                    }

                });

                return tree.type = resultInfo.pt;

            } else {

                if ((ownkind & ~resultInfo.pkind) == 0) {

                    owntype = resultInfo.check(tree, owntype);

                } else {

                    log.error(tree.pos(), "unexpected.type",

                            kindNames(resultInfo.pkind),

                            kindName(ownkind));

                    owntype = types.createErrorType(owntype);

                }

            }

        }

        tree.type = owntype;

        return owntype;

    }

    /** Is given blank final variable assignable, i.e. in a scope where it

     *  may be assigned to even though it is final?

     *  @param v      The blank final variable.

     *  @param env    The current environment.

     */

    boolean isAssignableAsBlankFinal(VarSymbol v, Env<AttrContext> env) {

        Symbol owner = owner(env);

           // owner refers to the innermost variable, method or

           // initializer block declaration at this point.

        return

            v.owner == owner

            ||

            ((owner.name == names.init ||    // i.e. we are in a constructor

              owner.kind == VAR ||           // i.e. we are in a variable initializer

              (owner.flags() & BLOCK) != 0)  // i.e. we are in an initializer block

             &&

             v.owner == owner.owner

             &&

             ((v.flags() & STATIC) != 0) == Resolve.isStatic(env));

    }

    /**

     * Return the innermost enclosing owner symbol in a given attribution context

     */

    Symbol owner(Env<AttrContext> env) {

        while (true) {

            switch (env.tree.getTag()) {

                case VARDEF:

                    //a field can be owner

                    VarSymbol vsym = ((JCVariableDecl)env.tree).sym;

                    if (vsym.owner.kind == TYP) {

                        return vsym;

                    }

                    break;

                case METHODDEF:

                    //method def is always an owner

                    return ((JCMethodDecl)env.tree).sym;

                case CLASSDEF:

                    //class def is always an owner

                    return ((JCClassDecl)env.tree).sym;

                case LAMBDA:

                    //a lambda is an owner - return a fresh synthetic method symbol

                    return new MethodSymbol(0, names.empty, null, syms.methodClass);

                case BLOCK:

                    //static/instance init blocks are owner

                    Symbol blockSym = env.info.scope.owner;

                    if ((blockSym.flags() & BLOCK) != 0) {

                        return blockSym;

                    }

                    break;

                case TOPLEVEL:

                    //toplevel is always an owner (for pkge decls)

                    return env.info.scope.owner;

            }

            Assert.checkNonNull(env.next);

            env = env.next;

        }

    }

    /** Check that variable can be assigned to.

     *  @param pos    The current source code position.

     *  @param v      The assigned varaible

     *  @param base   If the variable is referred to in a Select, the part

     *                to the left of the `.', null otherwise.

     *  @param env    The current environment.

     */

    void checkAssignable(DiagnosticPosition pos, VarSymbol v, JCTree base, Env<AttrContext> env) {

        if ((v.flags() & FINAL) != 0 &&

            ((v.flags() & HASINIT) != 0

             ||

             !((base == null ||

               (base.hasTag(IDENT) && TreeInfo.name(base) == names._this)) &&

               isAssignableAsBlankFinal(v, env)))) {

            if (v.isResourceVariable()) { //TWR resource

                log.error(pos, "try.resource.may.not.be.assigned", v);

            } else {

                log.error(pos, "cant.assign.val.to.final.var", v);

            }

        }

    }

    /** Does tree represent a static reference to an identifier?

     *  It is assumed that tree is either a SELECT or an IDENT.

     *  We have to weed out selects from non-type names here.

     *  @param tree    The candidate tree.

     */

    boolean isStaticReference(JCTree tree) {

        if (tree.hasTag(SELECT)) {

            Symbol lsym = TreeInfo.symbol(((JCFieldAccess) tree).selected);

            if (lsym == null || lsym.kind != TYP) {

                return false;

            }

        }

        return true;

    }

    /** Is this symbol a type?

     */

    static boolean isType(Symbol sym) {

        return sym != null && sym.kind == TYP;

    }

    /** The current `this' symbol.

     *  @param env    The current environment.

     */

    Symbol thisSym(DiagnosticPosition pos, Env<AttrContext> env) {

        return rs.resolveSelf(pos, env, env.enclClass.sym, names._this);

    }

    /** Attribute a parsed identifier.

     * @param tree Parsed identifier name

     * @param topLevel The toplevel to use

     */

    public Symbol attribIdent(JCTree tree, JCCompilationUnit topLevel) {

        Env<AttrContext> localEnv = enter.topLevelEnv(topLevel);

        localEnv.enclClass = make.ClassDef(make.Modifiers(0),

                                           syms.errSymbol.name,

                                           null, null, null, null);

        localEnv.enclClass.sym = syms.errSymbol;

        return tree.accept(identAttributer, localEnv);

    }

    // where

        private TreeVisitor<Symbol,Env<AttrContext>> identAttributer = new IdentAttributer();

        private class IdentAttributer extends SimpleTreeVisitor<Symbol,Env<AttrContext>> {

            @Override

            public Symbol visitMemberSelect(MemberSelectTree node, Env<AttrContext> env) {

                Symbol site = visit(node.getExpression(), env);

                if (site.kind == ERR)

                    return site;

                Name name = (Name)node.getIdentifier();

                if (site.kind == PCK) {

                    env.toplevel.packge = (PackageSymbol)site;

                    return rs.findIdentInPackage(env, (TypeSymbol)site, name, TYP | PCK);

                } else {

                    env.enclClass.sym = (ClassSymbol)site;

                    return rs.findMemberType(env, site.asType(), name, (TypeSymbol)site);

                }

            }

            @Override

            public Symbol visitIdentifier(IdentifierTree node, Env<AttrContext> env) {

                return rs.findIdent(env, (Name)node.getName(), TYP | PCK);

            }

        }

    public Type coerce(Type etype, Type ttype) {

        return cfolder.coerce(etype, ttype);

    }

    public Type attribType(JCTree node, TypeSymbol sym) {

        Env<AttrContext> env = enter.typeEnvs.get(sym);

        Env<AttrContext> localEnv = env.dup(node, env.info.dup());

        return attribTree(node, localEnv, unknownTypeInfo);

    }

    public Type attribImportQualifier(JCImport tree, Env<AttrContext> env) {

        // Attribute qualifying package or class.

        JCFieldAccess s = (JCFieldAccess)tree.qualid;

        return attribTree(s.selected,

                       env,

                       new ResultInfo(tree.staticImport ? TYP : (TYP | PCK),

                       Type.noType));

    }

    public Env<AttrContext> attribExprToTree(JCTree expr, Env<AttrContext> env, JCTree tree) {

        breakTree = tree;

        JavaFileObject prev = log.useSource(env.toplevel.sourcefile);

        try {

            attribExpr(expr, env);

        } catch (BreakAttr b) {

            return b.env;

        } catch (AssertionError ae) {

            if (ae.getCause() instanceof BreakAttr) {

                return ((BreakAttr)(ae.getCause())).env;

            } else {

                throw ae;

            }

        } finally {

            breakTree = null;

            log.useSource(prev);

        }

        return env;

    }

    public Env<AttrContext> attribStatToTree(JCTree stmt, Env<AttrContext> env, JCTree tree) {

        breakTree = tree;

        JavaFileObject prev = log.useSource(env.toplevel.sourcefile);

        try {

            attribStat(stmt, env);

        } catch (BreakAttr b) {

            return b.env;

        } catch (AssertionError ae) {

            if (ae.getCause() instanceof BreakAttr) {

                return ((BreakAttr)(ae.getCause())).env;

            } else {

                throw ae;

            }

        } finally {

            breakTree = null;

            log.useSource(prev);

        }

        return env;

    }

    private JCTree breakTree = null;

    private static class BreakAttr extends RuntimeException {

        static final long serialVersionUID = -6924771130405446405L;

        private Env<AttrContext> env;

        private BreakAttr(Env<AttrContext> env) {

            this.env = copyEnv(env);

        }

        private Env<AttrContext> copyEnv(Env<AttrContext> env) {

            Env<AttrContext> newEnv =

                    env.dup(env.tree, env.info.dup(copyScope(env.info.scope)));

            if (newEnv.outer != null) {

                newEnv.outer = copyEnv(newEnv.outer);

            }

            return newEnv;

        }

        private Scope copyScope(Scope sc) {

            Scope newScope = new Scope(sc.owner);

            List<Symbol> elemsList = List.nil();

            while (sc != null) {

                for (Scope.Entry e = sc.elems ; e != null ; e = e.sibling) {

                    elemsList = elemsList.prepend(e.sym);

                }

                sc = sc.next;

            }

            for (Symbol s : elemsList) {

                newScope.enter(s);

            }

            return newScope;

        }

    }

    class ResultInfo {

        final int pkind;

        final Type pt;