/*

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

             chk.checkDeprecatedAnnotation(tree.pos(), m);

             // Create a new environment with local scope

             // for attributing the method.

             Env<AttrContext> localEnv = memberEnter.methodEnv(tree, env);

             localEnv.info.lint = lint;

             attribStats(tree.typarams, localEnv);

             // If we override any other methods, check that we do so properly.

             // JLS ???

             if (m.isStatic()) {

                 chk.checkHideClashes(tree.pos(), env.enclClass.type, m);

             } else {

                 chk.checkOverrideClashes(tree.pos(), env.enclClass.type, m);

             }

             chk.checkOverride(env, tree, m);

             if (isDefaultMethod && types.overridesObjectMethod(m.enclClass(), m)) {

                 log.error(tree, "default.overrides.object.member", m.name, Kinds.kindName(m.location()), m.location());

             }

             // Enter all type parameters into the local method scope.

             for (List<JCTypeParameter> l = tree.typarams; l.nonEmpty(); l = l.tail)

                 localEnv.info.scope.enterIfAbsent(l.head.type.tsym);

             ClassSymbol owner = env.enclClass.sym;

             if ((owner.flags() & ANNOTATION) != 0 &&

                     (tree.params.nonEmpty() ||

                     tree.recvparam != null))

                 log.error(tree.params.nonEmpty() ?

                         tree.params.head.pos() :

                         tree.recvparam.pos(),

                         "intf.annotation.members.cant.have.params");

             // Attribute all value parameters.

             for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {

                 attribStat(l.head, localEnv);

             }

             chk.checkVarargsMethodDecl(localEnv, tree);

             // Check that type parameters are well-formed.

             chk.validate(tree.typarams, localEnv);

             // Check that result type is well-formed.

             if (tree.restype != null && !tree.restype.type.hasTag(VOID))

                 chk.validate(tree.restype, localEnv);

             // Check that receiver type is well-formed.

             if (tree.recvparam != null) {

                 // Use a new environment to check the receiver parameter.

                 // Otherwise I get "might not have been initialized" errors.

                 // Is there a better way?

                 Env<AttrContext> newEnv = memberEnter.methodEnv(tree, env);

                 attribType(tree.recvparam, newEnv);

                 chk.validate(tree.recvparam, newEnv);

             }

             // annotation method checks

             if ((owner.flags() & ANNOTATION) != 0) {

                 // annotation method cannot have throws clause

                 if (tree.thrown.nonEmpty()) {

                     log.error(tree.thrown.head.pos(),

                             "throws.not.allowed.in.intf.annotation");

                 }

                 // annotation method cannot declare type-parameters

                 if (tree.typarams.nonEmpty()) {

                     log.error(tree.typarams.head.pos(),

                             "intf.annotation.members.cant.have.type.params");

                 }

                 // validate annotation method's return type (could be an annotation type)

                 chk.validateAnnotationType(tree.restype);

                 // ensure that annotation method does not clash with members of Object/Annotation

                 chk.validateAnnotationMethod(tree.pos(), m);

             }

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

                 chk.checkType(l.head.pos(), l.head.type, syms.throwableType);

             if (tree.body == null) {

                 // Empty bodies are only allowed for

                 // abstract, native, or interface methods, or for methods

                 // in a retrofit signature class.

                 if (tree.defaultValue != null) {

                     if ((owner.flags() & ANNOTATION) == 0)

                         log.error(tree.pos(),

                                   "default.allowed.in.intf.annotation.member");

                 }

                 if (isDefaultMethod || (tree.sym.flags() & (ABSTRACT | NATIVE)) == 0)

                     log.error(tree.pos(), "missing.meth.body.or.decl.abstract");

             } else {

                 if ((tree.sym.flags() & (ABSTRACT|DEFAULT|PRIVATE)) == ABSTRACT) {

                     if ((owner.flags() & INTERFACE) != 0) {

                         log.error(tree.body.pos(), "intf.meth.cant.have.body");

                     } else {

                         log.error(tree.pos(), "abstract.meth.cant.have.body");

                     }

                 } else if ((tree.mods.flags & NATIVE) != 0) {

                     log.error(tree.pos(), "native.meth.cant.have.body");

                 }

                 // Add an implicit super() call unless an explicit call to

                 // super(...) or this(...) is given

                 // or we are compiling class java.lang.Object.

                 if (tree.name == names.init && !owner.type.isErroneous() && owner.type != syms.objectType) {

                     JCBlock body = tree.body;

                     if (body.stats.isEmpty() ||

                             !TreeInfo.isSelfCall(body.stats.head)) {

                         body.stats = body.stats.

                                 prepend(typeEnter.SuperCall(make.at(body.pos),

                                         List.nil(),

                                         List.nil(),

                                         false));

                     } else if ((env.enclClass.sym.flags() & ENUM) != 0 &&

                             (tree.mods.flags & GENERATEDCONSTR) == 0 &&

                             TreeInfo.isSuperCall(body.stats.head)) {

                         // enum constructors are not allowed to call super

                         // directly, so make sure there aren't any super calls

                         // in enum constructors, except in the compiler

                         // generated one.

                         log.error(tree.body.stats.head.pos(),

                                 "call.to.super.not.allowed.in.enum.ctor",

                                 env.enclClass.sym);

                     }

                 }

                 if (!isBackgroundCompilation) {

                     tree.localEnv = dupLocalEnv(localEnv);

                 }

                 // Attribute all type annotations in the body

                 annotate.queueScanTreeAndTypeAnnotate(tree.body, localEnv, m, null);

                 annotate.flush();

                 // Attribute method body.

                 attribStat(tree.body, localEnv);

             }

             localEnv.info.scope.leave();

             result = tree.type = m.type;

         } finally {

             chk.setLint(prevLint);

             chk.setMethod(prevMethod);

         }

     }

     public void visitVarDef(JCVariableDecl tree) {

         // Local variables have not been entered yet, so we need to do it now:

         if (env.info.scope.owner.kind == MTH) {

             if (tree.sym != null) {

                 // parameters have already been entered

                 env.info.scope.enter(tree.sym);

             } else {

                 try {

                     annotate.blockAnnotations();

                     memberEnter.memberEnter(tree, env);

                 } finally {

                     annotate.unblockAnnotations();

                 }

             }

         } else {

             if (tree.init != null) {

                 // Field initializer expression need to be entered.

                 annotate.queueScanTreeAndTypeAnnotate(tree.init, env, tree.sym, tree.pos());

                 annotate.flush();

             }

         }

         VarSymbol v = tree.sym;

         if (v == null) {

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

             result = null;

             return;

         }

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

         Lint prevLint = chk.setLint(lint);

         // Check that the variable's declared type is well-formed.

         boolean isImplicitLambdaParameter = env.tree.hasTag(LAMBDA) &&

                 ((JCLambda)env.tree).paramKind == JCLambda.ParameterKind.IMPLICIT &&

                 (tree.sym.flags() & PARAMETER) != 0;

         chk.validate(tree.vartype, env, !isImplicitLambdaParameter);

         try {

             v.getConstValue(); // ensure compile-time constant initializer is evaluated

             deferredLintHandler.flush(tree.pos());

             chk.checkDeprecatedAnnotation(tree.pos(), v);

             if (tree.init != null) {

                 if ((v.flags_field & FINAL) == 0 ||

                     !memberEnter.needsLazyConstValue(tree.init)) {

                     // Not a compile-time constant

                     // Attribute initializer in a new environment

                     // with the declared variable as owner.

                     // Check that initializer conforms to variable's declared type.

                     Env<AttrContext> initEnv = memberEnter.initEnv(tree, env);

                     initEnv.info.lint = lint;

                     // In order to catch self-references, we set the variable's

                     // declaration position to maximal possible value, effectively

                     // marking the variable as undefined.

                     initEnv.info.enclVar = v;

                     attribExpr(tree.init, initEnv, v.type);

                 }

             }

             result = tree.type = v.type;

         }

         finally {

             chk.setLint(prevLint);

         }

     }

     public void visitSkip(JCSkip tree) {

         result = null;

     }

     public void visitBlock(JCBlock tree) {

         if (env.info.scope != null && env.info.scope.owner != null && (env.info.scope.owner.kind == TYP || env.info.scope.owner.kind == ERR)) {

             // Block is a static or instance initializer;

             // let the owner of the environment be a freshly

             // created BLOCK-method.

             Symbol fakeOwner =

                 new MethodSymbol(tree.flags | BLOCK |

                     env.info.scope.owner.flags() & STRICTFP, names.empty, null,

                     env.info.scope.owner);

             final Env<AttrContext> localEnv =

                 env.dup(tree, env.info.dup(env.info.scope.dupUnshared(fakeOwner)));

             if ((tree.flags & STATIC) != 0) localEnv.info.staticLevel++;

             // Attribute all type annotations in the block

             annotate.queueScanTreeAndTypeAnnotate(tree, localEnv, localEnv.info.scope.owner, null);

             annotate.flush();

             attribStats(tree.stats, localEnv);

             {

                 // Store init and clinit type annotations with the ClassSymbol

                 // to allow output in Gen.normalizeDefs.

                 ClassSymbol cs = (ClassSymbol)env.info.scope.owner;

                 List<Attribute.TypeCompound> tas = localEnv.info.scope.owner.getRawTypeAttributes();

                 if ((tree.flags & STATIC) != 0) {

                     cs.appendClassInitTypeAttributes(tas);

                 } else {

                     cs.appendInitTypeAttributes(tas);

                 }

             }

         } else {

             // Create a new local environment with a local scope.

             Env<AttrContext> localEnv =

                 env.dup(tree, env.info.dup((env.info.scope != null ? env.info.scope : WriteableScope.create(syms.noSymbol)).dup()));

             try {

                 attribStats(tree.stats, localEnv);

             } finally {

                 localEnv.info.scope.leave();

             }

         }

         result = null;

     }

     public void visitDoLoop(JCDoWhileLoop tree) {

         attribStat(tree.body, env.dup(tree));

         attribExpr(tree.cond, env, syms.booleanType);

         result = null;

     }

     public void visitWhileLoop(JCWhileLoop tree) {

         attribExpr(tree.cond, env, syms.booleanType);

         attribStat(tree.body, env.dup(tree));

         result = null;

     }

     public void visitForLoop(JCForLoop tree) {

         Env<AttrContext> loopEnv =

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

         try {

             attribStats(tree.init, loopEnv);

             if (tree.cond != null) attribExpr(tree.cond, loopEnv, syms.booleanType);

             loopEnv.tree = tree; // before, we were not in loop!

             attribStats(tree.step, loopEnv);

             attribStat(tree.body, loopEnv);

             result = null;

         }

         finally {

             loopEnv.info.scope.leave();

         }

     }

     public void visitForeachLoop(JCEnhancedForLoop tree) {

         Env<AttrContext> loopEnv =

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

         try {

             //the Formal Parameter of a for-each loop is not in the scope when

             //attributing the for-each expression; we mimick this by attributing

             //the for-each expression first (against original scope).

             Type exprType = types.cvarUpperBound(attribExpr(tree.expr, loopEnv));

             attribStat(tree.var, loopEnv);

             chk.checkNonVoid(tree.pos(), exprType);

             Type elemtype = types.elemtype(exprType); // perhaps expr is an array?

             if (elemtype == null) {

                 // or perhaps expr implements Iterable<T>?

                 Type base = types.asSuper(exprType, syms.iterableType.tsym);

                 if (base == null) {

                     log.error(tree.expr.pos(),

                             "foreach.not.applicable.to.type",

                             exprType,

                             diags.fragment("type.req.array.or.iterable"));

                     elemtype = types.createErrorType(exprType);

                 } else {

                     List<Type> iterableParams = base.allparams();

                     elemtype = iterableParams.isEmpty()

                         ? syms.objectType

                         : types.wildUpperBound(iterableParams.head);

                 }

             }

             if (tree.var.sym != null)

                 chk.checkType(tree.expr.pos(), elemtype, tree.var.sym.type);

             loopEnv.tree = tree; // before, we were not in loop!

             attribStat(tree.body, loopEnv);

             result = null;

         }

         finally {

             loopEnv.info.scope.leave();

         }

     }

     public void visitLabelled(JCLabeledStatement tree) {

         // Check that label is not used in an enclosing statement

         Env<AttrContext> env1 = env;

         while (env1 != null && !env1.tree.hasTag(CLASSDEF)) {

             if (env1.tree.hasTag(LABELLED) &&

                 ((JCLabeledStatement) env1.tree).label == tree.label) {

                 log.error(tree.pos(), "label.already.in.use",

                           tree.label);

                 break;

             }

             env1 = env1.next;

         }

         attribStat(tree.body, env.dup(tree));

         result = null;

     }

     public void visitSwitch(JCSwitch tree) {

         Type seltype = attribExpr(tree.selector, env);

         Env<AttrContext> switchEnv =

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

         try {

             boolean enumSwitch = seltype.tsym != null && (seltype.tsym.flags() & Flags.ENUM) != 0;

             boolean stringSwitch = types.isSameType(seltype, syms.stringType);

             if (stringSwitch && !allowStringsInSwitch) {

                 log.error(DiagnosticFlag.SOURCE_LEVEL, tree.selector.pos(), "string.switch.not.supported.in.source", sourceName);

             }

             if (!enumSwitch && !stringSwitch)

                 seltype = chk.checkType(tree.selector.pos(), seltype, syms.intType);

             // Attribute all cases and

             // check that there are no duplicate case labels or default clauses.

             Set<Object> labels = new HashSet<>(); // The set of case labels.

             boolean hasDefault = false;      // Is there a default label?

             for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {

                 JCCase c = l.head;

                 if (c.pat != null) {

                     if (enumSwitch) {

                         Symbol sym = enumConstant(c.pat, seltype);

                         if (sym == null) {

                             log.error(c.pat.pos(), "enum.label.must.be.unqualified.enum");

                         } else if (!labels.add(sym)) {

                             log.error(c.pos(), "duplicate.case.label");

                         }

                     } else {

                         Type pattype = attribExpr(c.pat, switchEnv, seltype);

                         if (!pattype.hasTag(ERROR)) {

                             if (pattype.constValue() == null) {

                                 log.error(c.pat.pos(),

                                           (stringSwitch ? "string.const.req" : "const.expr.req"));

                             } else if (!labels.add(pattype.constValue())) {

                                 log.error(c.pos(), "duplicate.case.label");

                             }

                         }

                     }

                 } else if (hasDefault) {

                     log.error(c.pos(), "duplicate.default.label");

                 } else {

                     hasDefault = true;

                 }

                 if (c == breakTree &&

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

                     throw new BreakAttr(env, null);

                 Env<AttrContext> caseEnv =

                     switchEnv.dup(c, env.info.dup(switchEnv.info.scope.dup()));

                 boolean baCatched = false;

                 try {

                     attribStats(c.stats, caseEnv);

                 } catch (BreakAttr ba) {

                     baCatched = true;

                     throw ba;

                 } finally {

                     caseEnv.info.scope.leave();

                     if (!baCatched) {

                         addVars(c.stats, switchEnv.info.scope);

                     }

                 }

             }

             result = null;

         }

         finally {

             switchEnv.info.scope.leave();

         }

     }

     // where

         /** Add any variables defined in stats to the switch scope. */

         private static void addVars(List<JCStatement> stats, WriteableScope switchScope) {

             for (;stats.nonEmpty(); stats = stats.tail) {

                 JCTree stat = stats.head;

                 if (stat.hasTag(VARDEF) && ((JCVariableDecl) stat).sym != null)

                     switchScope.enter(((JCVariableDecl) stat).sym);

             }

         }

     // where

     /** Return the selected enumeration constant symbol, or null. */

     private Symbol enumConstant(JCTree tree, Type enumType) {

         if (tree.hasTag(IDENT)) {

             JCIdent ident = (JCIdent)tree;

             Name name = ident.name;

             for (Symbol sym : enumType.tsym.members().getSymbolsByName(name)) {

                 if (sym.kind == VAR) {

                     Symbol s = ident.sym = sym;

                     ((VarSymbol)s).getConstValue(); // ensure initializer is evaluated

                     ident.type = s.type;

                     return ((s.flags_field & Flags.ENUM) == 0)

                         ? null : s;

                 }

             }

         }

         return null;

     }

     public void visitSynchronized(JCSynchronized tree) {

         chk.checkRefType(tree.pos(), attribExpr(tree.lock, env));

         attribStat(tree.body, env);

         result = null;

     }

     public void visitTry(JCTry tree) {

         // Create a new local environment with a local

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

         try {

             boolean isTryWithResource = tree.resources.nonEmpty();

             // Create a nested environment for attributing the try block if needed

             Env<AttrContext> tryEnv = isTryWithResource ?

                 env.dup(tree, localEnv.info.dup(localEnv.info.scope.dup())) :

                 localEnv;

             try {

                 // Attribute resource declarations

                 for (JCTree resource : tree.resources) {

                     CheckContext twrContext = new Check.NestedCheckContext(resultInfo.checkContext) {

                         @Override

                         public void report(DiagnosticPosition pos, JCDiagnostic details) {

                             chk.basicHandler.report(pos, diags.fragment("try.not.applicable.to.type", details));

                         }

                     };

                     ResultInfo twrResult =

                         new ResultInfo(KindSelector.VAR,

                                        syms.autoCloseableType,

                                        twrContext);

                     if (resource.hasTag(VARDEF)) {

                         attribStat(resource, tryEnv);

                         twrResult.check(resource, resource.type);

                         //check that resource type cannot throw InterruptedException

                         checkAutoCloseable(resource.pos(), localEnv, resource.type);

                         VarSymbol var = ((JCVariableDecl) resource).sym;

                         var.setData(ElementKind.RESOURCE_VARIABLE);

                     } else {

                         attribTree(resource, tryEnv, twrResult);

                     }

                 }

                 // Attribute body

                 attribStat(tree.body, tryEnv);

             } finally {

                 if (isTryWithResource)

                     tryEnv.info.scope.leave();

             }

             // Attribute catch clauses

             for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {

                 JCCatch c = l.head;

                 Env<AttrContext> catchEnv =

                     localEnv.dup(c, localEnv.info.dup(localEnv.info.scope.dup()));

                 try {

                     Type ctype = attribStat(c.param, catchEnv);

                     if (TreeInfo.isMultiCatch(c)) {

                         //multi-catch parameter is implicitly marked as final

                         c.param.sym.flags_field |= FINAL | UNION;

                     }

                     if (c.param.sym.kind == VAR) {

                         c.param.sym.setData(ElementKind.EXCEPTION_PARAMETER);

                     }

                     chk.checkType(c.param.vartype.pos(),

                                   chk.checkClassType(c.param.vartype.pos(), ctype),

                                   syms.throwableType);

                     attribStat(c.body, catchEnv);

                 } finally {

                     catchEnv.info.scope.leave();

                 }

             }

             // Attribute finalizer

             if (tree.finalizer != null) attribStat(tree.finalizer, localEnv);

             result = null;

         }

         finally {

             localEnv.info.scope.leave();

         }

     }

     void checkAutoCloseable(DiagnosticPosition pos, Env<AttrContext> env, Type resource) {

         if (!resource.isErroneous() &&

             types.asSuper(resource, syms.autoCloseableType.tsym) != null &&

             !types.isSameType(resource, syms.autoCloseableType)) { // Don't emit warning for AutoCloseable itself

             Symbol close = syms.noSymbol;

             Log.DiagnosticHandler discardHandler = new Log.DiscardDiagnosticHandler(log);

             try {

                 close = rs.resolveQualifiedMethod(pos,

                         env,

                         types.skipTypeVars(resource, false),

                         names.close,

                         List.nil(),

                         List.nil());

             }

             finally {

                 log.popDiagnosticHandler(discardHandler);

             }

             if (close.kind == MTH &&

                     close.overrides(syms.autoCloseableClose, resource.tsym, types, true) &&

                     chk.isHandled(syms.interruptedExceptionType, types.memberType(resource, close).getThrownTypes()) &&

                     env.info.lint.isEnabled(LintCategory.TRY)) {

                 log.warning(LintCategory.TRY, pos, "try.resource.throws.interrupted.exc", resource);

             }

         }

     }

     public void visitConditional(JCConditional tree) {

         Type condtype = attribExpr(tree.cond, env, syms.booleanType);

         tree.polyKind = (!allowPoly ||

                 pt().hasTag(NONE) && pt() != Type.recoveryType && pt() != Infer.anyPoly ||

                 isBooleanOrNumeric(env, tree)) ?

                 PolyKind.STANDALONE : PolyKind.POLY;

         if (tree.polyKind == PolyKind.POLY && resultInfo.pt.hasTag(VOID)) {

             //this means we are returning a poly conditional from void-compatible lambda expression

             resultInfo.checkContext.report(tree, diags.fragment("conditional.target.cant.be.void"));

             tree.polyKind = PolyKind.STANDALONE;

         }

         ResultInfo condInfo = tree.polyKind == PolyKind.STANDALONE ?

                 unknownExprInfo :

                 resultInfo.dup(conditionalContext(resultInfo.checkContext));

         Type truetype = attribTree(tree.truepart, env, condInfo);

         Type falsetype = attribTree(tree.falsepart, env, condInfo);

         Type owntype = (tree.polyKind == PolyKind.STANDALONE) ? condType(tree, truetype, falsetype) : pt();

         if (condtype.constValue() != null &&

                 truetype.constValue() != null &&

                 falsetype.constValue() != null &&

                 !owntype.hasTag(NONE)) {

             //constant folding

             owntype = cfolder.coerce(condtype.isTrue() ? truetype : falsetype, owntype);

         }

         result = check(tree, owntype, KindSelector.VAL, resultInfo);

     }

     //where

         private boolean isBooleanOrNumeric(Env<AttrContext> env, JCExpression tree) {

             switch (tree.getTag()) {

                 case LITERAL: return ((JCLiteral)tree).typetag.isSubRangeOf(DOUBLE) ||

                               ((JCLiteral)tree).typetag == BOOLEAN ||

                               ((JCLiteral)tree).typetag == BOT;

                 case LAMBDA: case REFERENCE: return false;

                 case PARENS: return isBooleanOrNumeric(env, ((JCParens)tree).expr);

                 case CONDEXPR:

                     JCConditional condTree = (JCConditional)tree;

                     return isBooleanOrNumeric(env, condTree.truepart) &&

                             isBooleanOrNumeric(env, condTree.falsepart);

                 case APPLY:

                     JCMethodInvocation speculativeMethodTree =

                             (JCMethodInvocation)deferredAttr.attribSpeculative(

                                     tree, env, unknownExprInfo,

                                     argumentAttr.withLocalCacheContext());

                     Symbol msym = TreeInfo.symbol(speculativeMethodTree.meth);

                     Type receiverType = speculativeMethodTree.meth.hasTag(IDENT) ?

                             env.enclClass.type :

                             ((JCFieldAccess)speculativeMethodTree.meth).selected.type;

                     Type owntype = types.memberType(receiverType, msym).getReturnType();

                     return primitiveOrBoxed(owntype);

                 case NEWCLASS:

                     JCExpression className =

                             removeClassParams.translate(((JCNewClass)tree).clazz);

                     JCExpression speculativeNewClassTree =

                             (JCExpression)deferredAttr.attribSpeculative(

                                     className, env, unknownTypeInfo,

                                     argumentAttr.withLocalCacheContext());

                     return primitiveOrBoxed(speculativeNewClassTree.type);

                 default:

                     Type speculativeType = deferredAttr.attribSpeculative(tree, env, unknownExprInfo,

                             argumentAttr.withLocalCacheContext()).type;

                     return primitiveOrBoxed(speculativeType);

             }

         }

         //where

             boolean primitiveOrBoxed(Type t) {

                 return (!t.hasTag(TYPEVAR) && types.unboxedTypeOrType(t).isPrimitive());

             }

             TreeTranslator removeClassParams = new TreeTranslator() {

                 @Override

                 public void visitTypeApply(JCTypeApply tree) {

                     result = translate(tree.clazz);

                 }

             };

         CheckContext conditionalContext(CheckContext checkContext) {

             return new Check.NestedCheckContext(checkContext) {

                 //this will use enclosing check context to check compatibility of

                 //subexpression against target type; if we are in a method check context,

                 //depending on whether boxing is allowed, we could have incompatibilities

                 @Override

                 public void report(DiagnosticPosition pos, JCDiagnostic details) {

                     enclosingContext.report(pos, diags.fragment("incompatible.type.in.conditional", details));

                 }

             };

         }

         /** Compute the type of a conditional expression, after

          *  checking that it exists.  See JLS 15.25. Does not take into

          *  account the special case where condition and both arms

          *  are constants.

          *

          *  @param pos      The source position to be used for error

          *                  diagnostics.

          *  @param thentype The type of the expression's then-part.

          *  @param elsetype The type of the expression's else-part.

          */

         Type condType(DiagnosticPosition pos,

                                Type thentype, Type elsetype) {

             // If same type, that is the result

             if (types.isSameType(thentype, elsetype))

                 return thentype.baseType();

             Type thenUnboxed = (thentype.isPrimitive())

                 ? thentype : types.unboxedType(thentype);

             Type elseUnboxed = (elsetype.isPrimitive())

                 ? elsetype : types.unboxedType(elsetype);

             // Otherwise, if both arms can be converted to a numeric

             // type, return the least numeric type that fits both arms

             // (i.e. return larger of the two, or return int if one

             // arm is short, the other is char).

             if (thenUnboxed.isPrimitive() && elseUnboxed.isPrimitive()) {

                 // If one arm has an integer subrange type (i.e., byte,

                 // short, or char), and the other is an integer constant

                 // that fits into the subrange, return the subrange type.

                 if (thenUnboxed.getTag().isStrictSubRangeOf(INT) &&

                     elseUnboxed.hasTag(INT) &&

                     types.isAssignable(elseUnboxed, thenUnboxed)) {

                     return thenUnboxed.baseType();

                 }

                 if (elseUnboxed.getTag().isStrictSubRangeOf(INT) &&

                     thenUnboxed.hasTag(INT) &&

                     types.isAssignable(thenUnboxed, elseUnboxed)) {

                     return elseUnboxed.baseType();

                 }

                 for (TypeTag tag : primitiveTags) {

                     Type candidate = syms.typeOfTag[tag.ordinal()];

                     if (types.isSubtype(thenUnboxed, candidate) &&

                         types.isSubtype(elseUnboxed, candidate)) {

                         return candidate;

                     }

                 }

             }

             // Those were all the cases that could result in a primitive

             if (thentype.isPrimitive())

                 thentype = types.boxedClass(thentype).type;

             if (elsetype.isPrimitive())

                 elsetype = types.boxedClass(elsetype).type;

             if (types.isSubtype(thentype, elsetype))

                 return elsetype.baseType();

             if (types.isSubtype(elsetype, thentype))

                 return thentype.baseType();

             if (thentype.hasTag(VOID) || elsetype.hasTag(VOID)) {

                 log.error(pos, "neither.conditional.subtype",

                           thentype, elsetype);

                 return thentype.baseType();

             }

             // both are known to be reference types.  The result is

             // lub(thentype,elsetype). This cannot fail, as it will

             // always be possible to infer "Object" if nothing better.

             return types.lub(thentype.baseType(), elsetype.baseType());

         }

     final static TypeTag[] primitiveTags = new TypeTag[]{

         BYTE,

         CHAR,

         SHORT,

         INT,

         LONG,

         FLOAT,

         DOUBLE,

         BOOLEAN,

     };

     public void visitIf(JCIf tree) {

         attribExpr(tree.cond, env, syms.booleanType);

         attribStat(tree.thenpart, env);

         if (tree.elsepart != null)

             attribStat(tree.elsepart, env);

         chk.checkEmptyIf(tree);

         result = null;

     }

     public void visitExec(JCExpressionStatement tree) {

         //a fresh environment is required for 292 inference to work properly ---

         //see Infer.instantiatePolymorphicSignatureInstance()

         Env<AttrContext> localEnv = env.dup(tree);

         attribExpr(tree.expr, localEnv);

         result = null;

     }

     public void visitBreak(JCBreak tree) {

         tree.target = findJumpTarget(tree.pos(), tree.getTag(), tree.label, env);

         result = null;

     }

     public void visitContinue(JCContinue tree) {

         tree.target = findJumpTarget(tree.pos(), tree.getTag(), tree.label, env);

         result = null;

     }

     //where

         /** Return the target of a break or continue statement, if it exists,

          *  report an error if not.

          *  Note: The target of a labelled break or continue is the

          *  (non-labelled) statement tree referred to by the label,

          *  not the tree representing the labelled statement itself.

          *

          *  @param pos     The position to be used for error diagnostics

          *  @param tag     The tag of the jump statement. This is either

          *                 Tree.BREAK or Tree.CONTINUE.

          *  @param label   The label of the jump statement, or null if no

          *                 label is given.

          *  @param env     The environment current at the jump statement.

          */

         private JCTree findJumpTarget(DiagnosticPosition pos,

                                     JCTree.Tag tag,

                                     Name label,

                                     Env<AttrContext> env) {

             // Search environments outwards from the point of jump.

             Env<AttrContext> env1 = env;

             LOOP:

             while (env1 != null) {

                 switch (env1.tree.getTag()) {

                     case LABELLED:

                         JCLabeledStatement labelled = (JCLabeledStatement)env1.tree;

                         if (label == labelled.label) {

                             // If jump is a continue, check that target is a loop.

                             if (tag == CONTINUE) {

                                 if (!labelled.body.hasTag(DOLOOP) &&

                                         !labelled.body.hasTag(WHILELOOP) &&

                                         !labelled.body.hasTag(FORLOOP) &&

                                         !labelled.body.hasTag(FOREACHLOOP))

                                     log.error(pos, "not.loop.label", label);

                                 // Found labelled statement target, now go inwards

                                 // to next non-labelled tree.

                                 return TreeInfo.referencedStatement(labelled);

                             } else {

                                 return labelled;

                             }

                         }

                         break;

                     case DOLOOP:

                     case WHILELOOP:

                     case FORLOOP:

                     case FOREACHLOOP:

                         if (label == null) return env1.tree;

                         break;

                     case SWITCH:

                         if (label == null && tag == BREAK) return env1.tree;

                         break;

                     case LAMBDA:

                     case METHODDEF:

                     case CLASSDEF:

                         break LOOP;

                     default:

                 }

                 env1 = env1.next;

             }

             if (label != null)

                 log.error(pos, "undef.label", label);

             else if (tag == CONTINUE)

                 log.error(pos, "cont.outside.loop");

             else

                 log.error(pos, "break.outside.switch.loop");

             return null;

         }

     public void visitReturn(JCReturn tree) {

         // Check that there is an enclosing method which is

         // nested within than the enclosing class.

         if (env.info.returnResult == null) {

             log.error(tree.pos(), "ret.outside.meth");

         } else {

             // Attribute return expression, if it exists, and check that

             // it conforms to result type of enclosing method.

             if (tree.expr != null) {

                 if (env.info.returnResult.pt.hasTag(VOID)) {

                     env.info.returnResult.checkContext.report(tree.expr.pos(),

                               diags.fragment("unexpected.ret.val"));

                 }

                 attribTree(tree.expr, env, env.info.returnResult);

             } else if (!env.info.returnResult.pt.hasTag(VOID) &&

                     !env.info.returnResult.pt.hasTag(NONE)) {

                 env.info.returnResult.checkContext.report(tree.pos(),

                               diags.fragment("missing.ret.val"));

             }

         }

         result = null;

     }

     public void visitThrow(JCThrow tree) {

         Type owntype = attribExpr(tree.expr, env, allowPoly ? Type.noType : syms.throwableType);

         if (allowPoly) {

             chk.checkType(tree, owntype, syms.throwableType);

         }

         result = null;

     }

     public void visitAssert(JCAssert tree) {

         attribExpr(tree.cond, env, syms.booleanType);

         if (tree.detail != null) {

             chk.checkNonVoid(tree.detail.pos(), attribExpr(tree.detail, env));

         }

         result = null;

     }

      /** Visitor method for method invocations.

      *  NOTE: The method part of an application will have in its type field

      *        the return type of the method, not the method's type itself!

      */

     public void visitApply(JCMethodInvocation tree) {

         // The local environment of a method application is

         // a new environment nested in the current one.

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

         // The types of the actual method arguments.

         List<Type> argtypes = null;

         // The types of the actual method type arguments.

         List<Type> typeargtypes = null;

         Name methName = TreeInfo.name(tree.meth);

         boolean isConstructorCall =

             methName == names._this || methName == names._super;

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

         if (isConstructorCall) {

             // We are seeing a ...this(...) or ...super(...) call.

             // Check that this is the first statement in a constructor.

             checkFirstConstructorStat(tree, env);

             // Record the fact

             // that this is a constructor call (using isSelfCall).

             localEnv.info.isSelfCall = true;

             // Attribute arguments, yielding list of argument types.

             KindSelector kind = attribArgs(KindSelector.MTH, tree.args, localEnv, argtypesBuf);

             argtypes = argtypesBuf.toList();

             typeargtypes = attribTypes(tree.typeargs, localEnv);

             // Variable `site' points to the class in which the called

             // constructor is defined.

             Type site = env.enclClass.sym.type;

             if (methName == names._super) {

                 if (site == syms.objectType) {

                     log.error(tree.meth.pos(), "no.superclass", site);

                     site = types.createErrorType(syms.objectType);

                 } else {

                     site = types.supertype(site);

                 }

             }

             if (site.hasTag(CLASS) || site.hasTag(ERROR)) {

                 Type encl = site.getEnclosingType();

                 while (encl != null && encl.hasTag(TYPEVAR))

                     encl = encl.getUpperBound();

                 if (encl.hasTag(CLASS)) {

                     // we are calling a nested class

                     if (tree.meth.hasTag(SELECT)) {

                         JCTree qualifier = ((JCFieldAccess) tree.meth).selected;

                         // We are seeing a prefixed call, of the form

                         //     <expr>.super(...).

                         // Check that the prefix expression conforms

                         // to the outer instance type of the class.

                         chk.checkRefType(qualifier.pos(),

                                          attribExpr(qualifier, localEnv,

                                                     encl));

                     } else if (methName == names._super) {

                         // qualifier omitted; check for existence

                         // of an appropriate implicit qualifier.

                         rs.resolveImplicitThis(tree.meth.pos(),

                                                localEnv, site, true);

                     }

                 } else if (tree.meth.hasTag(SELECT)) {

                     log.error(tree.meth.pos(), "illegal.qual.not.icls",

                               site.tsym);

                 }

                 // if we're calling a java.lang.Enum constructor,

                 // prefix the implicit String and int parameters

                 if (site.tsym == syms.enumSym)

                     argtypes = argtypes.prepend(syms.intType).prepend(syms.stringType);

                 // Resolve the called constructor under the assumption

                 // that we are referring to a superclass instance of the

                 // current instance (JLS ???).

                 boolean selectSuperPrev = localEnv.info.selectSuper;

                 localEnv.info.selectSuper = true;

                 localEnv.info.pendingResolutionPhase = null;

                 Symbol sym = rs.resolveConstructor(

                     tree.meth.pos(), localEnv, site, argtypes, typeargtypes);

                 localEnv.info.selectSuper = selectSuperPrev;

                 // Set method symbol to resolved constructor...

                 TreeInfo.setSymbol(tree.meth, sym);

                 // ...and check that it is legal in the current context.

                 // (this will also set the tree's type)

                 Type mpt = newMethodTemplate(resultInfo.pt, argtypes, typeargtypes);

                 checkId(tree.meth, site, sym, localEnv,

                         new ResultInfo(kind, mpt));

             }

             result = tree.type = syms.voidType;

         } else {

             // Otherwise, we are seeing a regular method call.

             // Attribute the arguments, yielding list of argument types, ...

             KindSelector kind;

             try {

                 kind = attribArgs(KindSelector.VAL, tree.args, localEnv, argtypesBuf);

             } catch (BreakAttr bae) {

                 argtypes = argtypesBuf.toList();

                 typeargtypes = attribAnyTypes(tree.typeargs, localEnv);

                 Type mpt = newMethodTemplate(resultInfo.pt, argtypes, typeargtypes);

                 localEnv.info.pendingResolutionPhase = null;

                 attribTree(tree.meth, localEnv, new ResultInfo(KindSelector.VAL_POLY, mpt, resultInfo.checkContext));

                 throw bae;

             }

             argtypes = argtypesBuf.toList();

             typeargtypes = attribAnyTypes(tree.typeargs, localEnv);

             // ... and attribute the method using as a prototype a methodtype

             // whose formal argument types is exactly the list of actual

             // arguments (this will also set the method symbol).

             Type mpt = newMethodTemplate(resultInfo.pt, argtypes, typeargtypes);

             localEnv.info.pendingResolutionPhase = null;

             Type mtype = attribTree(tree.meth, localEnv, new ResultInfo(kind, mpt, resultInfo.checkContext));

             // Compute the result type.

             Type restype = mtype.getReturnType();

             if (restype.hasTag(WILDCARD))

                 throw new AssertionError(mtype);

             Type qualifier = (tree.meth.hasTag(SELECT))

                     ? ((JCFieldAccess) tree.meth).selected.type

                     : env.enclClass.sym.type;

             Symbol msym = TreeInfo.symbol(tree.meth);

             restype = adjustMethodReturnType(msym, qualifier, methName, argtypes, restype);

             chk.checkRefTypes(tree.typeargs, typeargtypes);

             // Check that value of resulting type is admissible in the

             // current context.  Also, capture the return type

             Type capturedRes = resultInfo.checkContext.inferenceContext().cachedCapture(tree, restype, true);

             result = check(tree, capturedRes, KindSelector.VAL, resultInfo);

         }

         chk.validate(tree.typeargs, localEnv);

     }

     //where

         Type adjustMethodReturnType(Symbol msym, Type qualifierType, Name methodName, List<Type> argtypes, Type restype) {

             if (msym != null &&

                     msym.owner == syms.objectType.tsym &&

                     methodName == names.getClass &&

                     argtypes.isEmpty()) {

                 // as a special case, x.getClass() has type Class<? extends |X|>

                 return new ClassType(restype.getEnclosingType(),

                         List.of(new WildcardType(types.erasure(qualifierType),

                                 BoundKind.EXTENDS,

                                 syms.boundClass)),

                         restype.tsym,

                         restype.getMetadata());

             } else if (msym != null &&

                     msym.owner == syms.arrayClass &&

                     methodName == names.clone &&

                     types.isArray(qualifierType)) {

                 // as a special case, array.clone() has a result that is

                 // the same as static type of the array being cloned

                 return qualifierType;

             } else {

                 return restype;

             }

         }

         /** Check that given application node appears as first statement

          *  in a constructor call.

          *  @param tree   The application node

          *  @param env    The environment current at the application.

          */

         boolean checkFirstConstructorStat(JCMethodInvocation tree, Env<AttrContext> env) {

             JCMethodDecl enclMethod = env.enclMethod;

             if (enclMethod != null && enclMethod.name == names.init) {

                 JCBlock body = enclMethod.body;

                 if (body.stats.head.hasTag(EXEC) &&

                     ((JCExpressionStatement) body.stats.head).expr == tree)

                     return true;

             }

             log.error(tree.pos(),"call.must.be.first.stmt.in.ctor",

                       TreeInfo.name(tree.meth));

             return false;

         }

         /** Obtain a method type with given argument types.

          */

         Type newMethodTemplate(Type restype, List<Type> argtypes, List<Type> typeargtypes) {

             MethodType mt = new MethodType(argtypes, restype, List.nil(), syms.methodClass);

             return (typeargtypes == null) ? mt : (Type)new ForAll(typeargtypes, mt);

         }

     public void visitNewClass(final JCNewClass tree) {

         Type owntype = types.createErrorType(tree.type);

         // The local environment of a class creation is

         // a new environment nested in the current one.

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

         // The anonymous inner class definition of the new expression,

         // if one is defined by it.

         JCClassDecl cdef = tree.def;

         // If enclosing class is given, attribute it, and

         // complete class name to be fully qualified

         JCExpression clazz = tree.clazz; // Class field following new

         JCExpression clazzid;            // Identifier in class field

         JCAnnotatedType annoclazzid;     // Annotated type enclosing clazzid

         annoclazzid = null;

         if (clazz.hasTag(TYPEAPPLY)) {

             clazzid = ((JCTypeApply) clazz).clazz;

             if (clazzid.hasTag(ANNOTATED_TYPE)) {

                 annoclazzid = (JCAnnotatedType) clazzid;

                 clazzid = annoclazzid.underlyingType;

             }

         } else {

             if (clazz.hasTag(ANNOTATED_TYPE)) {

                 annoclazzid = (JCAnnotatedType) clazz;

                 clazzid = annoclazzid.underlyingType;

             } else {

                 clazzid = clazz;

             }

         }

         JCExpression clazzid1 = clazzid; // The same in fully qualified form

         if (tree.encl != null) {

             // We are seeing a qualified new, of the form

             //    <expr>.new C <...> (...) ...

             // In this case, we let clazz stand for the name of the

             // allocated class C prefixed with the type of the qualifier

             // expression, so that we can

             // resolve it with standard techniques later. I.e., if

             // <expr> has type T, then <expr>.new C <...> (...)

             // yields a clazz T.C.

             Type encltype = chk.checkRefType(tree.encl.pos(),

                                              attribExpr(tree.encl, env));

             // TODO 308: in <expr>.new C, do we also want to add the type annotations

             // from expr to the combined type, or not? Yes, do this.

             clazzid1 = make.at(clazz.pos).Select(make.Type(encltype),

                                                  ((JCIdent) clazzid).name);

             EndPosTable endPosTable = this.env.toplevel.endPositions;

             endPosTable.storeEnd(clazzid1, tree.getEndPosition(endPosTable));

             if (clazz.hasTag(ANNOTATED_TYPE)) {

                 JCAnnotatedType annoType = (JCAnnotatedType) clazz;

                 List<JCAnnotation> annos = annoType.annotations;

                 if (annoType.underlyingType.hasTag(TYPEAPPLY)) {

                     clazzid1 = make.at(tree.pos).

                         TypeApply(clazzid1,

                                   ((JCTypeApply) clazz).arguments);

                 }

                 clazzid1 = make.at(tree.pos).

                     AnnotatedType(annos, clazzid1);

             } else if (clazz.hasTag(TYPEAPPLY)) {

                 clazzid1 = make.at(tree.pos).

                     TypeApply(clazzid1,

                               ((JCTypeApply) clazz).arguments);

             }

             clazz = clazzid1;

         }

         // Attribute clazz expression and store

         // symbol + type back into the attributed tree.

         Type clazztype;

         try {

             env.info.isNewClass = true;

             clazztype = TreeInfo.isEnumInit(env.tree) ?

                 attribIdentAsEnumType(env, (JCIdent)clazz) :

                 attribType(clazz, env);

         } finally {

             env.info.isNewClass = false;

         }

         clazztype = chk.checkDiamond(tree, clazztype);

         chk.validate(clazz, localEnv);

         if (tree.encl != null) {

             // We have to work in this case to store

             // symbol + type back into the attributed tree.

             tree.clazz.type = clazztype;

             TreeInfo.setSymbol(clazzid, TreeInfo.symbol(clazzid1));

             clazzid.type = ((JCIdent) clazzid).sym.type;

             if (annoclazzid != null) {

                 annoclazzid.type = clazzid.type;

             }

             if (!clazztype.isErroneous()) {

                 if (cdef != null && clazztype.tsym.isInterface()) {

                     log.error(tree.encl.pos(), "anon.class.impl.intf.no.qual.for.new");

                 } else if (clazztype.tsym.isStatic()) {

                     log.error(tree.encl.pos(), "qualified.new.of.static.class", clazztype.tsym);

                 }

             }

         } else if (!clazztype.tsym.isInterface() &&

                    clazztype.getEnclosingType().hasTag(CLASS)) {

             // Check for the existence of an apropos outer instance

             rs.resolveImplicitThis(tree.pos(), env, clazztype);

         }

         // Attribute constructor arguments.

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

         final KindSelector pkind =

             attribArgs(KindSelector.VAL, tree.args, localEnv, argtypesBuf);

         List<Type> argtypes = argtypesBuf.toList();

         List<Type> typeargtypes = attribTypes(tree.typeargs, localEnv);

         // If we have made no mistakes in the class type...

         boolean wasError = clazztype.hasTag(ERROR);

         if (clazztype.hasTag(CLASS) || wasError) {

             // Enums may not be instantiated except implicitly

             if ((clazztype.tsym.flags_field & Flags.ENUM) != 0 &&

                 (!env.tree.hasTag(VARDEF) ||

                  (((JCVariableDecl) env.tree).mods.flags & Flags.ENUM) == 0 ||

                  ((JCVariableDecl) env.tree).init != tree))

                 log.error(tree.pos(), "enum.cant.be.instantiated");

             boolean isSpeculativeDiamondInferenceRound = TreeInfo.isDiamond(tree) &&

                     resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;

             boolean skipNonDiamondPath = false;

             // Check that class is not abstract

             if (cdef == null && !isSpeculativeDiamondInferenceRound && // class body may be nulled out in speculative tree copy

                 (clazztype.tsym.flags() & (ABSTRACT | INTERFACE)) != 0) {

                 log.error(tree.pos(), "abstract.cant.be.instantiated",

                           clazztype.tsym);

                 skipNonDiamondPath = true;

             } else if (cdef != null && clazztype.tsym.isInterface()) {

                 // Check that no constructor arguments are given to

                 // anonymous classes implementing an interface

                 if (!argtypes.isEmpty())

                     log.error(tree.args.head.pos(), "anon.class.impl.intf.no.args");

                 if (!typeargtypes.isEmpty())

                     log.error(tree.typeargs.head.pos(), "anon.class.impl.intf.no.typeargs");

                 // Error recovery: pretend no arguments were supplied.

                 argtypes = List.nil();

                 typeargtypes = List.nil();

                 skipNonDiamondPath = true;

             }

             if (TreeInfo.isDiamond(tree) && !wasError) {

                 ClassType site = new ClassType(clazztype.getEnclosingType(),

                             clazztype.tsym.type.getTypeArguments(),

                                                clazztype.tsym,

                                                clazztype.getMetadata());

                 Env<AttrContext> diamondEnv = localEnv.dup(tree);

                 diamondEnv.info.selectSuper = cdef != null;

                 diamondEnv.info.pendingResolutionPhase = null;

                 //if the type of the instance creation expression is a class type

                 //apply method resolution inference (JLS 15.12.2.7). The return type

                 //of the resolved constructor will be a partially instantiated type

                 Symbol constructor = rs.resolveDiamond(tree.pos(),

                             diamondEnv,

                             site,

                             argtypes,

                             typeargtypes);

                 tree.constructor = constructor.baseSymbol();

                 final TypeSymbol csym = clazztype.tsym;

                 ResultInfo diamondResult = new ResultInfo(pkind, newMethodTemplate(resultInfo.pt, argtypes, typeargtypes),

                         diamondContext(tree, csym, resultInfo.checkContext), CheckMode.NO_TREE_UPDATE);

                 Type constructorType = tree.constructorType = types.createErrorType(clazztype);

                 constructorType = checkId(tree, site,

                         constructor,

                         diamondEnv,

                         diamondResult);

                 tree.clazz.type = types.createErrorType(clazztype);

                 if (!constructorType.isErroneous()) {

                     tree.clazz.type = clazz.type = constructorType.getReturnType();

                     tree.constructorType = types.createMethodTypeWithReturn(constructorType, syms.voidType);

                 } else if (errArgs(tree.args)) {

                     Symbol s = null;

                     for (Symbol sym : site.tsym.members().getSymbolsByName(names.init)) {

                         if (s == null || sym.asType().getParameterTypes().isEmpty())

                             s = sym;

                     }

                     if (s != null) {

                         List<Type> atypes = s.asType().getParameterTypes();

                         constructor = rs.resolveDiamond(tree.pos(),

                             diamondEnv,

                             site,

                             atypes,

                             typeargtypes);

                         diamondResult = new ResultInfo(KindSelector.MTH, newMethodTemplate(resultInfo.pt, atypes, typeargtypes), new Check.NestedCheckContext(resultInfo.checkContext) {

                             @Override

                             public void report(DiagnosticPosition _unused, JCDiagnostic details) {

                             }

                         });

                         constructorType = checkId(tree, site,

                                 constructor,

                                 diamondEnv,

                                 diamondResult);

                         if (!constructorType.isErroneous())

                             tree.clazz.type = constructorType.getReturnType();

                     }

                 }

                 clazztype = chk.checkClassType(tree.clazz, tree.clazz.type, true);

             }

             // Resolve the called constructor under the assumption

             // that we are referring to a superclass instance of the

             // current instance (JLS ???).

             else if (!skipNonDiamondPath) {

                 //the following code alters some of the fields in the current

                 //AttrContext - hence, the current context must be dup'ed in

                 //order to avoid downstream failures

                 Env<AttrContext> rsEnv = localEnv.dup(tree);

                 rsEnv.info.selectSuper = cdef != null;

                 rsEnv.info.pendingResolutionPhase = null;

                 tree.constructor = rs.resolveConstructor(

                     tree.pos(), rsEnv, clazztype, argtypes, typeargtypes);

                 if (cdef == null) { //do not check twice!

                     tree.constructorType = checkId(tree,

                             clazztype,

                             tree.constructor,

                             rsEnv,

                             new ResultInfo(pkind, newMethodTemplate(syms.voidType, argtypes, typeargtypes), CheckMode.NO_TREE_UPDATE));

                     if (rsEnv.info.lastResolveVarargs())

                         Assert.check(tree.constructorType.isErroneous() || tree.varargsElement != null);                    

                     Env<AttrContext> enclosing;

                     if (tree.constructor.kind == MTH && tree.constructor.type.isErroneous() && ((enclosing = enter.getEnv(tree.constructor.enclClass())) == null || enclosing.toplevel != env.toplevel)) {

                         log.error(tree, "type.error", tree.constructor);

                     }

                 }

             }

             if (cdef != null) {

                 visitAnonymousClassDefinition(tree, clazz, clazztype, cdef, localEnv, argtypes, typeargtypes, pkind);

                 return;

             }

             if (tree.constructor != null && tree.constructor.kind == MTH)

                 owntype = wasError ? types.createErrorType(clazztype) : clazztype;

         }

         result = check(tree, owntype, KindSelector.VAL, resultInfo);

         InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();

         if (tree.constructorType != null && inferenceContext.free(tree.constructorType)) {

             //we need to wait for inference to finish and then replace inference vars in the constructor type

             inferenceContext.addFreeTypeListener(List.of(tree.constructorType),

                     instantiatedContext -> {

                         tree.constructorType = instantiatedContext.asInstType(tree.constructorType);

                     });

         }

         chk.validate(tree.typeargs, localEnv);

     }

     //where

     private boolean errArgs(List<JCExpression> args) {

         for (JCExpression arg : args) {

             if (arg.hasTag(Tag.ERRONEOUS))

                 return true;

         }

         return false;

     }

         // where

         private void visitAnonymousClassDefinition(JCNewClass tree, JCExpression clazz, Type clazztype,

                                                    JCClassDecl cdef, Env<AttrContext> localEnv,

                                                    List<Type> argtypes, List<Type> typeargtypes,

                                                    KindSelector pkind) {

             // We are seeing an anonymous class instance creation.

             // In this case, the class instance creation

             // expression

             //

             //    E.new <typeargs1>C<typargs2>(args) { ... }

             //

             // is represented internally as

             //

             //    E . new <typeargs1>C<typargs2>(args) ( class <empty-name> { ... } )  .

             //

             // This expression is then *transformed* as follows:

             //

             // (1) add an extends or implements clause

             // (2) add a constructor.

             //

             // For instance, if C is a class, and ET is the type of E,

             // the expression

             //

             //    E.new <typeargs1>C<typargs2>(args) { ... }

             //

             // is translated to (where X is a fresh name and typarams is the

             // parameter list of the super constructor):

             //

             //   new <typeargs1>X(<*nullchk*>E, args) where

             //     X extends C<typargs2> {

             //       <typarams> X(ET e, args) {

             //         e.<typeargs1>super(args)

             //       }

             //       ...

             //     }

             InferenceContext inferenceContext = resultInfo.checkContext.inferenceContext();

             final boolean isDiamond = TreeInfo.isDiamond(tree);

             if (isDiamond

                     && ((tree.constructorType != null && inferenceContext.free(tree.constructorType))

                     || (tree.clazz.type != null && inferenceContext.free(tree.clazz.type)))) {

                 final ResultInfo resultInfoForClassDefinition = this.resultInfo;

                 inferenceContext.addFreeTypeListener(List.of(tree.constructorType, tree.clazz.type),

                         instantiatedContext -> {

                             tree.constructorType = instantiatedContext.asInstType(tree.constructorType);

                             tree.clazz.type = clazz.type = instantiatedContext.asInstType(clazz.type);

                             ResultInfo prevResult = this.resultInfo;

                             try {

                                 this.resultInfo = resultInfoForClassDefinition;

                                 visitAnonymousClassDefinition(tree, clazz, clazz.type, cdef,

                                                             localEnv, argtypes, typeargtypes, pkind);

                             } finally {

                                 this.resultInfo = prevResult;

                             }

                         });

             } else {

                 if (isDiamond && clazztype.hasTag(CLASS)) {

                     List<Type> invalidDiamondArgs = chk.checkDiamondDenotable((ClassType)clazztype);

                     if (!clazztype.isErroneous() && invalidDiamondArgs.nonEmpty()) {

                         // One or more types inferred in the previous steps is non-denotable.

                         Fragment fragment = Diamond(clazztype.tsym);

                         log.error(tree.clazz.pos(),

                                 Errors.CantApplyDiamond1(

                                         fragment,

                                         invalidDiamondArgs.size() > 1 ?

                                                 DiamondInvalidArgs(invalidDiamondArgs, fragment) :

                                                 DiamondInvalidArg(invalidDiamondArgs, fragment)));

                     }

                     // For <>(){}, inferred types must also be accessible.

                     for (Type t : clazztype.getTypeArguments()) {

                         rs.checkAccessibleType(env, t);

                     }

                 }

                 // If we already errored, be careful to avoid a further avalanche. ErrorType answers

                 // false for isInterface call even when the original type is an interface.

                 boolean implementing = clazztype.tsym.isInterface() ||

                         clazztype.isErroneous() && !clazztype.getOriginalType().hasTag(NONE) && clazztype.getOriginalType().tsym.isInterface();

                 if (implementing) {

                     cdef.implementing = List.of(clazz);

                 } else {

                     cdef.extending = clazz;

                 }

                 if (resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK &&

                     isSerializable(clazztype)) {

                     localEnv.info.isSerializable = true;

                 }

                 attribStat(cdef, localEnv);

                 JCExpression clazzCopy = new TreeCopier<JCTree>(make) {

                     @Override

                     public <T extends JCTree> T copy(T tree, JCTree p) {

                         T t = super.copy(tree, p);

                         if (t != null) {

                             t.pos = Position.NOPOS;

                             t.type = tree.type;

                         }

                         return t;

                     }

                     @Override public JCTree visitIdentifier(IdentifierTree node, JCTree p) {

                         JCIdent result = (JCIdent) super.visitIdentifier(node, p);

                         result.sym = ((JCIdent) node).sym;

                         return result;

                     }

                     @Override public JCTree visitMemberSelect(MemberSelectTree node, JCTree p) {

                         JCFieldAccess result = (JCFieldAccess) super.visitMemberSelect(node, p);

                         result.sym = ((JCFieldAccess) node).sym;

                         return result;

                     }

                 }.copy(clazz);

                 if (clazztype.tsym.isInterface()) {

                     cdef.implementing = List.of(clazzCopy);

                 } else {

                     cdef.extending = clazzCopy;

                 }

                 List<Type> finalargtypes;

                 // If an outer instance is given,

                 // prefix it to the constructor arguments

                 // "encl" will be cleared in TransTypes

                 if (tree.encl != null && !clazztype.tsym.isInterface()) {

                     tree.args = tree.args.prepend(makeNullCheck(tree.encl));

                     finalargtypes = argtypes.prepend(tree.encl.type);

                 } else {

                     finalargtypes = argtypes;

                 }

                 // Reassign clazztype and recompute constructor. As this necessarily involves

                 // another attribution pass for deferred types in the case of <>, replicate

                 // them. Original arguments have right decorations already.

                 if (isDiamond && pkind.contains(KindSelector.POLY)) {

                     finalargtypes = finalargtypes.map(deferredAttr.deferredCopier);

                 }

                 clazztype = cdef.sym.type;

                 Symbol sym = tree.constructor = rs.resolveConstructor(

                         tree.pos(), localEnv, clazztype, finalargtypes, typeargtypes);

                 Assert.check(!sym.kind.isResolutionError());

                 tree.constructor = sym;

                 tree.constructorType = checkId(tree,

                         clazztype,

                         tree.constructor,

                         localEnv,

                         new ResultInfo(pkind, newMethodTemplate(syms.voidType, finalargtypes, typeargtypes), CheckMode.NO_TREE_UPDATE));

             }

             Type owntype = (tree.constructor != null && tree.constructor.kind == MTH) ?

                                 clazztype : types.createErrorType(tree.type);

             result = check(tree, owntype, KindSelector.VAL, resultInfo.dup(CheckMode.NO_INFERENCE_HOOK));

             chk.validate(tree.typeargs, localEnv);

         }

         CheckContext diamondContext(JCNewClass clazz, TypeSymbol tsym, CheckContext checkContext) {

             return new Check.NestedCheckContext(checkContext) {

                 @Override

                 public void report(DiagnosticPosition _unused, JCDiagnostic details) {

                     enclosingContext.report(clazz.clazz,

                             diags.fragment("cant.apply.diamond.1", diags.fragment("diamond", tsym), details));

                 }

             };

         }

     /** Make an attributed null check tree.

      */

     public JCExpression makeNullCheck(JCExpression arg) {

         // optimization: new Outer() can never be null; skip null check

         if (arg.getTag() == NEWCLASS)

             return arg;

         // optimization: X.this is never null; skip null check

         Name name = TreeInfo.name(arg);

         if (name == names._this || name == names._super) return arg;

         JCTree.Tag optag = NULLCHK;

         JCUnary tree = make.at(Position.NOPOS).Unary(optag, arg);

         tree.operator = operators.resolveUnary(arg, optag, arg.type);

         tree.type = arg.type;

         return tree;

     }

     public void visitNewArray(JCNewArray tree) {

         Type owntype = types.createErrorType(tree.type);

         Env<AttrContext> localEnv = env.dup(tree);

         Type elemtype;

         if (tree.elemtype != null) {

             elemtype = attribType(tree.elemtype, localEnv);

             chk.validate(tree.elemtype, localEnv);

             owntype = elemtype;

             for (List<JCExpression> l = tree.dims; l.nonEmpty(); l = l.tail) {

                 attribExpr(l.head, localEnv, syms.intType);

                 owntype = new ArrayType(owntype, syms.arrayClass);

             }

         } else {

             // we are seeing an untyped aggregate { ... }

             // this is allowed only if the prototype is an array

             if (pt().hasTag(ARRAY)) {

                 elemtype = types.elemtype(pt());

             } else {

                 if (!pt().hasTag(ERROR)) {

                     log.error(tree.pos(), "illegal.initializer.for.type",

                               pt());

                 }

                 elemtype = types.createErrorType(pt());

             }

         }

         if (tree.elems != null) {

             attribExprs(tree.elems, localEnv, elemtype);

             owntype = new ArrayType(elemtype, syms.arrayClass);

         }

         if (!types.isReifiable(elemtype))

             log.error(tree.pos(), "generic.array.creation");

         result = check(tree, owntype, KindSelector.VAL, resultInfo);

     }

     /*

      * A lambda expression can only be attributed when a target-type is available.

      * In addition, if the target-type is that of a functional interface whose

      * descriptor contains inference variables in argument position the lambda expression

      * is 'stuck' (see DeferredAttr).

      */

     @Override

     public void visitLambda(final JCLambda that) {

         if (pt().isErroneous() || (pt().hasTag(NONE) && pt() != Type.recoveryType)) {

             if (pt().hasTag(NONE)) {

                 //lambda only allowed in assignment or method invocation/cast context

                 log.error(that.pos(), "unexpected.lambda");

             }

         }

         //create an environment for attribution of the lambda expression

         final Env<AttrContext> localEnv = lambdaEnv(that, env);

         boolean needsRecovery = resultInfo != recoveryInfo &&

                 resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.CHECK;

         Type currentTarget = null;

         try {

             if (needsRecovery && isSerializable(pt())) {

                 localEnv.info.isSerializable = true;

                 localEnv.info.isLambda = true;

             }

             List<Type> explicitParamTypes = null;

             if (that.paramKind == JCLambda.ParameterKind.EXPLICIT) {

                 //attribute lambda parameters

                 attribStats(that.params, localEnv);

                 explicitParamTypes = TreeInfo.types(that.params);

             }

             if (pt().hasTag(NONE) && pt() != Type.recoveryType) {

                 resultInfo = recoveryInfo;

             }

             TargetInfo targetInfo = getTargetInfo(that, resultInfo, explicitParamTypes);

             currentTarget = targetInfo.target;

             Type lambdaType = targetInfo.descriptor;

             if (currentTarget.isErroneous()) {

                 result = that.type = currentTarget;

                 return;

             }

             setFunctionalInfo(localEnv, that, pt(), lambdaType, currentTarget, resultInfo.checkContext);

             if (lambdaType.hasTag(FORALL)) {

                 //lambda expression target desc cannot be a generic method

                 resultInfo.checkContext.report(that, diags.fragment("invalid.generic.lambda.target",

                         lambdaType, kindName(currentTarget.tsym), currentTarget.tsym));

                 result = that.type = types.createErrorType(pt());

                 return;

             }

             if (that.paramKind == JCLambda.ParameterKind.IMPLICIT) {

                 //add param type info in the AST

                 List<Type> actuals = lambdaType.getParameterTypes();

                 List<JCVariableDecl> params = that.params;

                 boolean arityMismatch = false;

                 while (params.nonEmpty()) {

                     if (actuals.isEmpty()) {

                         //not enough actuals to perform lambda parameter inference

                         arityMismatch = true;

                     }

                     //reset previously set info

                     Type argType = arityMismatch ?

                             syms.errType :

                             actuals.head;

                     params.head.vartype = make.at(Position.NOPOS).Type(argType);

                     params.head.sym = null;

                     actuals = actuals.isEmpty() ?

                             actuals :

                             actuals.tail;

                     params = params.tail;

                 }

                 //attribute lambda parameters

                 attribStats(that.params, localEnv);

                 if (arityMismatch) {

                     resultInfo.checkContext.report(that, diags.fragment("incompatible.arg.types.in.lambda"));

                         result = that.type = types.createErrorType(currentTarget);

                         return;

                 }

             }

             //from this point on, no recovery is needed; if we are in assignment context

             //we will be able to attribute the whole lambda body, regardless of errors;

             //if we are in a 'check' method context, and the lambda is not compatible

             //with the target-type, it will be recovered anyway in Attr.checkId

             needsRecovery = false;

             ResultInfo bodyResultInfo = localEnv.info.returnResult =

                     lambdaBodyResult(that, lambdaType, resultInfo);

             if (that.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {

                 attribTree(that.getBody(), localEnv, bodyResultInfo);

             } else {

                 JCBlock body = (JCBlock)that.body;

                 if (body == breakTree &&

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

                     throw new BreakAttr(copyEnv(localEnv), null);

                 }

                 attribStats(body.stats, localEnv);

             }

             result = check(that, currentTarget, KindSelector.VAL, resultInfo);

             boolean isSpeculativeRound =

                     resultInfo.checkContext.deferredAttrContext().mode == DeferredAttr.AttrMode.SPECULATIVE;

             preFlow(that);

             flow.analyzeLambda(env, that, make, isSpeculativeRound);

             that.type = currentTarget; //avoids recovery at this stage

             checkLambdaCompatible(that, lambdaType, resultInfo.checkContext);

             if (!isSpeculativeRound) {

                 //add thrown types as bounds to the thrown types free variables if needed:

                 if (resultInfo.checkContext.inferenceContext().free(lambdaType.getThrownTypes())) {

                     List<Type> inferredThrownTypes = flow.analyzeLambdaThrownTypes(env, that, make);

                     List<Type> thrownTypes = resultInfo.checkContext.inferenceContext().asUndetVars(lambdaType.getThrownTypes());