/*

 * Copyright (c) 1999, 2017, 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.code.TypeMetadata.Annotations;

import com.sun.tools.javac.code.Types.FunctionDescriptorLookupError;

import com.sun.tools.javac.comp.ArgumentAttr.LocalCacheContext;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    final Infer infer;

    final Analyzer analyzer;

    final DeferredAttr deferredAttr;

    final Check chk;

    final Flow flow;

    final MemberEnter memberEnter;

    final TypeEnter typeEnter;

    final TreeMaker make;

    final ConstFold cfolder;

    final Enter enter;

    final Target target;

    final Types types;

    final JCDiagnostic.Factory diags;

    final TypeAnnotations typeAnnotations;

    final DeferredLintHandler deferredLintHandler;

    final TypeEnvs typeEnvs;

    final Dependencies dependencies;

    final Annotate annotate;

    final ArgumentAttr argumentAttr;

    private final boolean isBackgroundCompilation;

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

        operators = Operators.instance(context);

        chk = Check.instance(context);

        flow = Flow.instance(context);

        memberEnter = MemberEnter.instance(context);

        typeEnter = TypeEnter.instance(context);

        make = TreeMaker.instance(context);

        enter = Enter.instance(context);

        infer = Infer.instance(context);

        analyzer = Analyzer.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);

        argumentAttr = ArgumentAttr.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;

        useBeforeDeclarationWarning = options.isSet("useBeforeDeclarationWarning");

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

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

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

        methodAttrInfo = new MethodAttrInfo();

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

        unknownTypeExprInfo = new ResultInfo(KindSelector.VAL_TYP, Type.noType);

        recoveryInfo = new RecoveryInfo(deferredAttr.emptyDeferredAttrContext);

        isBackgroundCompilation = options.get("backgroundCompilation") != null;     //NOI18N

    }

    /** 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: warn about use of variable before declaration?

     * RFE: 6425594

     */

    boolean useBeforeDeclarationWarning;

    /**

     * 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 found    The computed type of the tree

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

        boolean shouldCheck = !found.hasTag(ERROR) &&

                !resultInfo.pt.hasTag(METHOD) &&

                !resultInfo.pt.hasTag(FORALL);

        if (shouldCheck && !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 = shouldCheck ? resultInfo.pt : found;

            if (resultInfo.checkMode.installPostInferenceHook()) {

                inferenceContext.addFreeTypeListener(List.of(found),

                        instantiatedContext -> {

                            ResultInfo pendingResult =

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

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

                        });

            }

        } else {

            owntype = shouldCheck ?

            resultInfo.check(tree, found) :

            found;

        }

        if (resultInfo.checkMode.updateTreeType()) {

            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 variable

     *  @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.name == names._this) {

            log.error(pos, Errors.CantAssignValToThis);

        } else 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 attribIdent(tree, localEnv);

    }

    /** Attribute a parsed identifier.

     * @param tree Parsed identifier name

     * @param env The env to use

     */

    public Symbol attribIdent(JCTree tree, Env<AttrContext> env) {

        return tree.accept(identAttributer, env);

    }

    // 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.isValid())

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

        Env<AttrContext> localEnv = env.dup(env.tree, env.info.dup(env.info.scope.dupUnshared()));

        breakTree = tree;

        try {

            attribExpr(expr, localEnv);

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

        }

        return localEnv;

    }

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

        Env<AttrContext> localEnv = env.dup(env.tree, env.info.dup(env.info.scope.dupUnshared()));

        breakTree = tree;

        try {

            attribStat(stmt, localEnv);

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

        }

        return localEnv;

    }

    private JCTree breakTree = null;

    public static class BreakAttr extends RuntimeException {

        static final long serialVersionUID = -6924771130405446405L;

        private final Env<AttrContext> env;

        private final Type result;

        private BreakAttr(Env<AttrContext> env, Type result) {

            this.env = env;

            this.result = result;

        }

    }

    /**

     * Mode controlling behavior of Attr.Check

     */

    enum CheckMode {

        NORMAL,

        /**

         * Mode signalling 'fake check' - skip tree update. A side-effect of this mode is

         * that the captured var cache in {@code InferenceContext} will be used in read-only

         * mode when performing inference checks.

         */

        NO_TREE_UPDATE {

            @Override

            public boolean updateTreeType() {

                return false;

            }

        },

        /**

         * Mode signalling that caller will manage free types in tree decorations.

         */

        NO_INFERENCE_HOOK {

            @Override

            public boolean installPostInferenceHook() {

                return false;

            }

        };

        public boolean updateTreeType() {

            return true;

        }

        public boolean installPostInferenceHook() {

            return true;

        }

    }

    class ResultInfo {

        final KindSelector pkind;

        final Type pt;

        final CheckContext checkContext;

        final CheckMode checkMode;

        ResultInfo(KindSelector pkind, Type pt) {

            this(pkind, pt, chk.basicHandler, CheckMode.NORMAL);

        }

        ResultInfo(KindSelector pkind, Type pt, CheckMode checkMode) {

            this(pkind, pt, chk.basicHandler, checkMode);

        }

        protected ResultInfo(KindSelector pkind,

                             Type pt, CheckContext checkContext) {

            this(pkind, pt, checkContext, CheckMode.NORMAL);

        }

        protected ResultInfo(KindSelector pkind,

                             Type pt, CheckContext checkContext, CheckMode checkMode) {

            this.pkind = pkind;

            this.pt = pt;

            this.checkContext = checkContext;

            this.checkMode = checkMode;

        }

        /**

         * Should {@link Attr#attribTree} use the {@ArgumentAttr} visitor instead of this one?

         * @param tree The tree to be type-checked.

         * @return true if {@ArgumentAttr} should be used.

         */

        protected boolean needsArgumentAttr(JCTree tree) { return false; }

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

        }

        protected ResultInfo dup(CheckContext newContext) {

            return new ResultInfo(pkind, pt, newContext, checkMode);

        }

        protected ResultInfo dup(Type newPt, CheckContext newContext) {

            return new ResultInfo(pkind, newPt, newContext, checkMode);

        }

        protected ResultInfo dup(Type newPt, CheckContext newContext, CheckMode newMode) {

            return new ResultInfo(pkind, newPt, newContext, newMode);

        }

        protected ResultInfo dup(CheckMode newMode) {

            return new ResultInfo(pkind, pt, checkContext, newMode);

        }

        @Override

        public String toString() {

            if (pt != null) {

                return pt.toString();

            } else {

                return "";

            }

        }

    }

    class MethodAttrInfo extends ResultInfo {

        public MethodAttrInfo() {

            this(chk.basicHandler);

        }

        public MethodAttrInfo(CheckContext checkContext) {

            super(KindSelector.VAL, Infer.anyPoly, checkContext);

        }

        @Override

        protected boolean needsArgumentAttr(JCTree tree) {

            return true;

        }

        protected ResultInfo dup(Type newPt) {

            throw new IllegalStateException();

        }

        protected ResultInfo dup(CheckContext newContext) {

            return new MethodAttrInfo(newContext);

        }

        protected ResultInfo dup(Type newPt, CheckContext newContext) {

            throw new IllegalStateException();

        }

        protected ResultInfo dup(Type newPt, CheckContext newContext, CheckMode newMode) {

            throw new IllegalStateException();

        }

        protected ResultInfo dup(CheckMode newMode) {

            throw new IllegalStateException();

        }

    }

    class RecoveryInfo extends ResultInfo {

        public RecoveryInfo(final DeferredAttr.DeferredAttrContext deferredAttrContext) {

            this(deferredAttrContext, Type.recoveryType);

        }

        public RecoveryInfo(final DeferredAttr.DeferredAttrContext deferredAttrContext, final Type pt) {

            super(KindSelector.VAL, pt, 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);

                }

            });

        }

    }

    final ResultInfo statInfo;

    final ResultInfo varAssignmentInfo;

    final ResultInfo methodAttrInfo;

    final ResultInfo unknownExprInfo;

    final ResultInfo unknownTypeInfo;

    final ResultInfo unknownTypeExprInfo;

    final ResultInfo recoveryInfo;

    Type pt() {

        return resultInfo.pt;

    }

    KindSelector pkind() {

        return resultInfo.pkind;

    }

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

 * Visitor methods

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

    /** Visitor argument: the current environment.

     */

    Env<AttrContext> env;

    /** Visitor argument: the currently expected attribution result.

     */

    ResultInfo resultInfo;

    /** Visitor result: the computed type.

     */

    Type result;

    /** Visitor method: attribute a tree, catching any completion failure

     *  exceptions. Return the tree's type.

     *

     *  @param tree    The tree to be visited.

     *  @param env     The environment visitor argument.

     *  @param resultInfo   The result info visitor argument.

     */

    Type attribTree(JCTree tree, Env<AttrContext> env, ResultInfo resultInfo) {

        Env<AttrContext> prevEnv = this.env;

        ResultInfo prevResult = this.resultInfo;

        try {

            this.env = env;

            this.resultInfo = resultInfo;

            try {

                if (resultInfo.needsArgumentAttr(tree)) {

                    result = argumentAttr.attribArg(tree, env);

                } else {

                    tree.accept(this);

                }

            } catch (Resolve.InapplicableMethodException ime) {

                if (tree != breakTree ||

                        resultInfo.checkContext.deferredAttrContext().mode != AttrMode.CHECK) {

                    throw ime;

                }

            }

            if (tree == breakTree &&

                    resultInfo.checkContext.deferredAttrContext().mode == AttrMode.CHECK) {

                throw new BreakAttr(copyEnv(env), result);

            }

            return result;

        } catch (CompletionFailure ex) {

            tree.type = syms.errType;

            return chk.completionError(tree.pos(), ex);

        } finally {

            this.env = prevEnv;

            this.resultInfo = prevResult;

        }

    }

    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;

    }

    WriteableScope copyScope(WriteableScope sc) {

        WriteableScope newScope = WriteableScope.create(sc.owner);

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

        for (Symbol sym : sc.getSymbols()) {

            elemsList = elemsList.prepend(sym);

        }

        for (Symbol s : elemsList) {

            newScope.enter(s);

        }

        return newScope;

    }

    /** Derived visitor method: attribute an expression tree.

     */

    public Type attribExpr(JCTree tree, Env<AttrContext> env, Type pt) {

        return attribTree(tree, env, new ResultInfo(KindSelector.VAL, pt != null && !pt.hasTag(ERROR) ? pt : Type.noType));

    }

    /** Derived visitor method: attribute an expression tree with

     *  no constraints on the computed type.

     */

    public Type attribExpr(JCTree tree, Env<AttrContext> env) {

        return attribTree(tree, env, unknownExprInfo);

    }

    /** Derived visitor method: attribute a type tree.

     */

    public Type attribType(JCTree tree, Env<AttrContext> env) {

        Type result = attribType(tree, env, Type.noType);

        return result;

    }

    /** Derived visitor method: attribute a type tree.

     */

    Type attribType(JCTree tree, Env<AttrContext> env, Type pt) {

        Type result = attribTree(tree, env, new ResultInfo(KindSelector.TYP, pt));

        return result;

    }

    /** Derived visitor method: attribute a statement or definition tree.

     */

    public Type attribStat(JCTree tree, Env<AttrContext> env) {

        Env<AttrContext> analyzeEnv = analyzer.copyEnvIfNeeded(tree, env);

        boolean baCatched = false;

        try {

            return attribTree(tree, env, statInfo);

        } catch (BreakAttr ba) {

            baCatched = true;

            throw ba;

        } finally {

            if (!baCatched) {

                analyzer.analyzeIfNeeded(tree, analyzeEnv);

            }

        }

    }

    /** Attribute a list of expressions, returning a list of types.

     */

    List<Type> attribExprs(List<JCExpression> trees, Env<AttrContext> env, Type pt) {

        ListBuffer<Type> ts = new ListBuffer<>();

        for (List<JCExpression> l = trees; l.nonEmpty(); l = l.tail)

            ts.append(attribExpr(l.head, env, pt));

        return ts.toList();

    }

    /** Attribute a list of statements, returning nothing.

     */

    <T extends JCTree> void attribStats(List<T> trees, Env<AttrContext> env) {

        for (List<T> l = trees; l.nonEmpty(); l = l.tail)

            attribStat(l.head, env);

    }

    /** Attribute the arguments in a method call, returning the method kind.

     */

    KindSelector attribArgs(KindSelector initialKind, List<JCExpression> trees, Env<AttrContext> env, ListBuffer<Type> argtypes) {

        KindSelector kind = initialKind;

        for (JCExpression arg : trees) {

            try {

                Type argtype = chk.checkNonVoid(arg, attribTree(arg, env, allowPoly ? methodAttrInfo : unknownExprInfo));

                if (argtype.hasTag(DEFERRED)) {

                    kind = KindSelector.of(KindSelector.POLY, kind);

                }

                argtypes.append(argtype);

            } catch (BreakAttr ba) {

                if (ba.result != null && !ba.result.hasTag(PACKAGE) && !ba.result.hasTag(METHOD) && env.tree == ba.env.tree) {

                    argtypes.append(chk.checkNonVoid(arg, ba.result));

                }

                throw ba;

            }

        }

        return kind;

    }

    /** Attribute a type argument list, returning a list of types.

     *  Caller is responsible for calling checkRefTypes.

     */

    List<Type> attribAnyTypes(List<JCExpression> trees, Env<AttrContext> env) {

        ListBuffer<Type> argtypes = new ListBuffer<>();

        for (List<JCExpression> l = trees; l.nonEmpty(); l = l.tail)

            argtypes.append(attribType(l.head, env));

        return argtypes.toList();

    }

    /** Attribute a type argument list, returning a list of types.

     *  Check that all the types are references.

     */

    List<Type> attribTypes(List<JCExpression> trees, Env<AttrContext> env) {

        List<Type> types = attribAnyTypes(trees, env);

        return chk.checkRefTypes(trees, types);

    }

    /**

     * Attribute type variables (of generic classes or methods).

     * Compound types are attributed later in attribBounds.

     * @param typarams the type variables to enter

     * @param env      the current environment

     */

    void attribTypeVariables(List<JCTypeParameter> typarams, Env<AttrContext> env) {

        for (JCTypeParameter tvar : typarams) {

            TypeVar a = (TypeVar)tvar.type;

            a.tsym.flags_field |= UNATTRIBUTED;

            a.bound = Type.noType;

            if (!tvar.bounds.isEmpty()) {

                List<Type> bounds = List.of(attribType(tvar.bounds.head, env));

                for (JCExpression bound : tvar.bounds.tail)

                    bounds = bounds.prepend(attribType(bound, env));

                types.setBounds(a, bounds.reverse());

            } else {

                // if no bounds are given, assume a single bound of

                // java.lang.Object.

                types.setBounds(a, List.of(syms.objectType));

            }

            a.tsym.flags_field &= ~UNATTRIBUTED;

        }

        for (JCTypeParameter tvar : typarams) {

            chk.checkNonCyclic(tvar.pos(), (TypeVar)tvar.type);

        }

    }

    /**

     * Attribute the type references in a list of annotations.

     */

    void attribAnnotationTypes(List<JCAnnotation> annotations,

                               Env<AttrContext> env) {

        for (List<JCAnnotation> al = annotations; al.nonEmpty(); al = al.tail) {

            JCAnnotation a = al.head;

            attribType(a.annotationType, env);

        }

    }

    /**

     * Attribute a "lazy constant value".

     *  @param env         The env for the const value

     *  @param variable    The initializer for the const value

     *  @param type        The expected type, or null

     *  @see VarSymbol#setLazyConstValue

     */

    public Object attribLazyConstantValue(Env<AttrContext> env,

                                      JCVariableDecl variable,

                                      Type type) {

        DiagnosticPosition prevLintPos

                = deferredLintHandler.setPos(variable.pos());

        final JavaFileObject prevSource = log.useSource(env.toplevel.sourcefile);

        try {

            if (variable.init == null) {

                return null;

            }

            Type itype = attribExpr(variable.init, env, type);

            if (itype.constValue() != null) {

                return coerce(itype, type).constValue();

            } else {

                return null;

            }

        } finally {

            log.useSource(prevSource);

            deferredLintHandler.setPos(prevLintPos);

        }

    }

    /** Attribute type reference in an `extends' or `implements' clause.

     *  Supertypes of anonymous inner classes are usually already attributed.

     *

     *  @param tree              The tree making up the type reference.

     *  @param env               The environment current at the reference.

     *  @param classExpected     true if only a class is expected here.

     *  @param interfaceExpected true if only an interface is expected here.

     */

    Type attribBase(JCTree tree,

                    Env<AttrContext> env,

                    boolean classExpected,

                    boolean interfaceExpected,

                    boolean checkExtensible) {

        Type t = tree.type != null ?

            tree.type :

            attribType(tree, env);

        return checkBase(t, tree, env, classExpected, interfaceExpected, checkExtensible);

    }

    Type checkBase(Type t,

                   JCTree tree,

                   Env<AttrContext> env,

                   boolean classExpected,

                   boolean interfaceExpected,

                   boolean checkExtensible) {

        final DiagnosticPosition pos = tree.hasTag(TYPEAPPLY) ?

                (((JCTypeApply) tree).clazz).pos() : tree.pos();

        if (t.tsym.isAnonymous()) {

            log.error(pos, "cant.inherit.from.anon");

            return types.createErrorType(t);

        }

        if (t.isErroneous())

            return t;

        if (t.hasTag(TYPEVAR) && !classExpected && !interfaceExpected) {

            // check that type variable is already visible

            if (t.getUpperBound() == null) {

                log.error(pos, "illegal.forward.ref");

                return types.createErrorType(t);

            }

        } else {

            t = chk.checkClassType(pos, t, checkExtensible);

        }

        if (interfaceExpected && (t.tsym.flags() & INTERFACE) == 0) {

            log.error(pos, "intf.expected.here");

            // return errType is necessary since otherwise there might

            // be undetected cycles which cause attribution to loop

            return types.createErrorType(t);

        } else if (checkExtensible &&

                   classExpected &&

                   (t.tsym.flags() & INTERFACE) != 0) {

            log.error(pos, "no.intf.expected.here");

            return types.createErrorType(t);

        }

        if (checkExtensible &&

            ((t.tsym.flags() & FINAL) != 0)) {

            log.error(pos,

                      "cant.inherit.from.final", t.tsym);

        }

        chk.checkNonCyclic(pos, t);

        return t;

    }

    Type attribIdentAsEnumType(Env<AttrContext> env, JCIdent id) {

        Assert.check((env.enclClass.sym.flags() & ENUM) != 0 || env.enclClass.sym.kind == ERR);

        id.type = env.info.scope.owner.enclClass().type;

        id.sym = env.info.scope.owner.enclClass();

        return id.type;

    }

    public void visitClassDef(JCClassDecl tree) {

        Optional<ArgumentAttr.LocalCacheContext> localCacheContext =

                Optional.ofNullable(env.info.isSpeculative ?

                        argumentAttr.withLocalCacheContext() : null);

        try {

            // Local and anonymous classes have not been entered yet, so we need to

            // do it now.

            if (env.info.scope.owner.kind.matches(KindSelector.VAL_MTH)

                    && (env.info.scope.owner.kind != ERR || tree.sym == null)) {

                enter.classEnter(tree, env);

            } else {

                // If this class declaration is part of a class level annotation,

                // as in @MyAnno(new Object() {}) class MyClass {}, enter it in

                // order to simplify later steps and allow for sensible error

                // messages.

                if (env.tree.hasTag(NEWCLASS) && TreeInfo.isInAnnotation(env, tree))

                    enter.classEnter(tree, env);

            }

            ClassSymbol c = tree.sym;

            if (c == null) {

                // exit in case something drastic went wrong during enter.

                result = null;

            } else {

                // make sure class has been completed:

                c.complete();

                // If this class appears as an anonymous class

                // in a superclass constructor call

                // disable implicit outer instance from being passed.

                // (This would be an illegal access to "this before super").

                if (env.info.isSelfCall &&

                        env.tree.hasTag(NEWCLASS)) {

                    c.flags_field |= NOOUTERTHIS;

                }

                attribClass(tree.pos(), c);

                result = tree.type = c.type;

            }

        } finally {

            localCacheContext.ifPresent(LocalCacheContext::leave);

        }

    }

    public void visitMethodDef(JCMethodDecl tree) {

        MethodSymbol m = tree.sym;

        if (m == null) {

            // exit in case something drastic went wrong during enter.

            result = null;

            return;

        }

        boolean isDefaultMethod = (m.flags() & DEFAULT) != 0;

        Lint lint = env.info.lint.augment(m);

        Lint prevLint = chk.setLint(lint);

        MethodSymbol prevMethod = chk.setMethod(m);

        try {

            deferredLintHandler.flush(tree.pos());