/*

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

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

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

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

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

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.Dependencies.AttributionKind;

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

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

    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 TypeAnnotations typeAnnotations;

    final DeferredLintHandler deferredLintHandler;

    final TypeEnvs typeEnvs;

    final Dependencies dependencies;

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

        typeAnnotations = TypeAnnotations.instance(context);

        deferredLintHandler = DeferredLintHandler.instance(context);

        typeEnvs = TypeEnvs.instance(context);

        dependencies = Dependencies.instance(context);

        Options options = Options.instance(context);

        Source source = Source.instance(context);

        allowStringsInSwitch = source.allowStringsInSwitch();

        allowPoly = source.allowPoly();

        allowTypeAnnos = source.allowTypeAnnotations();

        allowLambda = source.allowLambda();

        allowDefaultMethods = source.allowDefaultMethods();

        allowStaticInterfaceMethods = source.allowStaticInterfaceMethods();

        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(KindSelector.NIL, Type.noType);

        varAssignmentInfo = new ResultInfo(KindSelector.ASG, Type.noType);

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

        unknownAnyPolyInfo = new ResultInfo(KindSelector.VAL, Infer.anyPoly);

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

        unknownTypeExprInfo = new ResultInfo(KindSelector.VAL_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 type annotations.

     */

    boolean allowTypeAnnos;

    /** Switch: support lambda expressions ?

     */

    boolean allowLambda;

    /** Switch: support default methods ?

     */

    boolean allowDefaultMethods;

    /** Switch: static interface methods enabled?

     */

    boolean allowStaticInterfaceMethods;

    /** 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 KindSelector ownkind,

               final ResultInfo resultInfo) {

        InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();

        Type owntype;

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

            if (!ownkind.subset(resultInfo.pkind)) {

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

                        resultInfo.pkind.kindNames(),

                        ownkind.kindNames());

                owntype = types.createErrorType(found);

            } else if (allowPoly && inferenceContext.free(found)) {

                //delay the check if there are inference variables in the found type

                //this means we are dealing with a partially inferred poly expression

                owntype = resultInfo.pt;

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

                    @Override

                    public void typesInferred(InferenceContext inferenceContext) {

                        ResultInfo pendingResult =

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

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

                    }

                });

            } else {

                owntype = resultInfo.check(tree, found);

            }

        } else {

            owntype = found;

        }

        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 = env.info.scope.owner;

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

    }

    /** 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 @DefinedBy(Api.COMPILER_TREE)

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

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

                if (site.kind == ERR || site.kind == ABSENT_TYP)

                    return site;

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

                if (site.kind == PCK) {

                    env.toplevel.packge = (PackageSymbol)site;

                    return rs.findIdentInPackage(env, (TypeSymbol)site, name,

                            KindSelector.TYP_PCK);

                } else {

                    env.enclClass.sym = (ClassSymbol)site;

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

                }

            }

            @Override @DefinedBy(Api.COMPILER_TREE)

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

                return rs.findIdent(env, (Name)node.getName(), KindSelector.TYP_PCK);

            }

        }

    public Type coerce(Type etype, Type ttype) {

        return cfolder.coerce(etype, ttype);

    }

    public Type attribType(JCTree node, TypeSymbol sym) {

        Env<AttrContext> env = 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 ?

                                         KindSelector.TYP : KindSelector.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 = env;

        }

    }

    class ResultInfo {

        final KindSelector pkind;

        final Type pt;

        final CheckContext checkContext;

        ResultInfo(KindSelector pkind, Type pt) {

            this(pkind, pt, chk.basicHandler);

        }

        protected ResultInfo(KindSelector pkind,

                             Type pt, CheckContext checkContext) {

            this.pkind = pkind;

            this.pt = pt;

            this.checkContext = checkContext;

        }

        protected Type check(final DiagnosticPosition pos, final Type found) {

            return chk.checkType(pos, found, pt, checkContext);

        }

        protected ResultInfo dup(Type newPt) {

            return new ResultInfo(pkind, newPt, checkContext);

        }

        protected ResultInfo dup(CheckContext newContext) {

            return new ResultInfo(pkind, pt, newContext);

        }

        protected ResultInfo dup(Type newPt, CheckContext newContext) {

            return new ResultInfo(pkind, newPt, newContext);

        }

        @Override

        public String toString() {

            if (pt != null) {

                return pt.toString();

            } else {

                return "";

            }

        }

    }

    class RecoveryInfo extends ResultInfo {

        public RecoveryInfo(final DeferredAttr.DeferredAttrContext deferredAttrContext) {

            super(KindSelector.VAL, Type.recoveryType,

                  new Check.NestedCheckContext(chk.basicHandler) {

                @Override

                public DeferredAttr.DeferredAttrContext deferredAttrContext() {

                    return deferredAttrContext;

                }

                @Override

                public boolean compatible(Type found, Type req, Warner warn) {

                    return true;

                }

                @Override

                public void report(DiagnosticPosition pos, JCDiagnostic details) {

                    chk.basicHandler.report(pos, details);

                }

            });

        }

    }