import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
/**
* Lambda compatibility. Check that given return types, thrown types, parameter types
* are compatible with the expected functional interface descriptor. This means that:
* (i) parameter types must be identical to those of the target descriptor; (ii) return
* types must be compatible with the return type of the expected descriptor.
*/
private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
    Type returnType = checkContext.inferenceContext().asUndetVar(descriptor.getReturnType());

    //return values have already been checked - but if lambda has no return
    //values, we must ensure that void/value compatibility is correct;
    //this amounts at checking that, if a lambda body can complete normally,
    //the descriptor's return type must be void
    if (tree.getBodyKind() == JCLambda.BodyKind.STATEMENT && tree.canCompleteNormally &&
            !returnType.hasTag(VOID) && returnType != Type.recoveryType) {
        checkContext.report(tree, diags.fragment("incompatible.ret.type.in.lambda",
                diags.fragment("missing.ret.val", returnType)));
    }

    List<Type> argTypes = checkContext.inferenceContext().asUndetVars(descriptor.getParameterTypes());
    if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
        checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
    }
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
private ResultInfo methodCheckResult(final boolean varargsCheck, Type to,
        final DeferredAttr.DeferredAttrContext deferredAttrContext, Warner rsWarner) {
    CheckContext checkContext = new MethodCheckContext(!deferredAttrContext.phase.isBoxingRequired(), deferredAttrContext, rsWarner) {
        MethodCheckDiag methodDiag = varargsCheck ?
                         MethodCheckDiag.VARARG_MISMATCH : MethodCheckDiag.ARG_MISMATCH;

        @Override
        public boolean compatible(Type found, Type req, Warner warn) {
            found = pendingInferenceContext.asUndetVar(found);
            if (found.hasTag(UNDETVAR) && req.isPrimitive()) {
                req = types.boxedClass(req).type;
            }
            return super.compatible(found, req, warn);
        }

        @Override
        public void report(DiagnosticPosition pos, JCDiagnostic details) {
            reportMC(pos, methodDiag, deferredAttrContext.inferenceContext, details);
        }
    };
    return new MethodResultInfo(to, checkContext);
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
/**
* Lambda compatibility. Check that given return types, thrown types, parameter types
* are compatible with the expected functional interface descriptor. This means that:
* (i) parameter types must be identical to those of the target descriptor; (ii) return
* types must be compatible with the return type of the expected descriptor.
*/
void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
    Type returnType = checkContext.inferenceContext().asUndetVar(descriptor.getReturnType());

    //return values have already been checked - but if lambda has no return
    //values, we must ensure that void/value compatibility is correct;
    //this amounts at checking that, if a lambda body can complete normally,
    //the descriptor's return type must be void
    if (tree.getBodyKind() == JCLambda.BodyKind.STATEMENT && tree.canCompleteNormally &&
            !returnType.hasTag(VOID) && returnType != Type.recoveryType) {
        Fragment msg =
                Fragments.IncompatibleRetTypeInLambda(Fragments.MissingRetVal(returnType));
        checkContext.report(tree,
                            diags.fragment(msg));
    }

    List<Type> argTypes = checkContext.inferenceContext().asUndetVars(descriptor.getParameterTypes());
    if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
        checkContext.report(tree, diags.fragment(Fragments.IncompatibleArgTypesInLambda));
    }
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
/**
* Lambda compatibility. Check that given return types, thrown types, parameter types
* are compatible with the expected functional interface descriptor. This means that:
* (i) parameter types must be identical to those of the target descriptor; (ii) return
* types must be compatible with the return type of the expected descriptor.
*/
void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
    Type returnType = checkContext.inferenceContext().asUndetVar(descriptor.getReturnType());

    //return values have already been checked - but if lambda has no return
    //values, we must ensure that void/value compatibility is correct;
    //this amounts at checking that, if a lambda body can complete normally,
    //the descriptor's return type must be void
    if (tree.getBodyKind() == JCLambda.BodyKind.STATEMENT && tree.canCompleteNormally &&
            !returnType.hasTag(VOID) && returnType != Type.recoveryType) {
        checkContext.report(tree, diags.fragment("incompatible.ret.type.in.lambda",
                diags.fragment("missing.ret.val", returnType)));
    }

    List<Type> argTypes = checkContext.inferenceContext().asUndetVars(descriptor.getParameterTypes());
    if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
        checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
    }
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
/**
* Lambda compatibility. Check that given return types, thrown types, parameter types
* are compatible with the expected functional interface descriptor. This means that:
* (i) parameter types must be identical to those of the target descriptor; (ii) return
* types must be compatible with the return type of the expected descriptor.
*/
private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext) {
    Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType());

    //return values have already been checked - but if lambda has no return
    //values, we must ensure that void/value compatibility is correct;
    //this amounts at checking that, if a lambda body can complete normally,
    //the descriptor's return type must be void
    if (tree.getBodyKind() == JCLambda.BodyKind.STATEMENT && tree.canCompleteNormally &&
            !returnType.hasTag(VOID) && returnType != Type.recoveryType) {
        checkContext.report(tree, diags.fragment("incompatible.ret.type.in.lambda",
                diags.fragment("missing.ret.val", returnType)));
    }

    List<Type> argTypes = checkContext.inferenceContext().asFree(descriptor.getParameterTypes());
    if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
        checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
    }
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
private ResultInfo methodCheckResult(final boolean varargsCheck, Type to,
        final DeferredAttr.DeferredAttrContext deferredAttrContext, Warner rsWarner) {
    CheckContext checkContext = new MethodCheckContext(!deferredAttrContext.phase.isBoxingRequired(), deferredAttrContext, rsWarner) {
        MethodCheckDiag methodDiag = varargsCheck ?
                         MethodCheckDiag.VARARG_MISMATCH : MethodCheckDiag.ARG_MISMATCH;

        @Override
        public boolean compatible(Type found, Type req, Warner warn) {
            found = pendingInferenceContext.asFree(found);
            req = infer.returnConstraintTarget(found, req);
            return super.compatible(found, req, warn);
        }

        @Override
        public void report(DiagnosticPosition pos, JCDiagnostic details) {
            reportMC(pos, methodDiag, deferredAttrContext.inferenceContext, details);
        }
    };
    return new MethodResultInfo(to, checkContext);
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
@SuppressWarnings("fallthrough")
void checkReferenceCompatible(JCMemberReference tree, Type descriptor, Type refType, CheckContext checkContext, boolean speculativeAttr) {
    Type returnType = checkContext.inferenceContext().asUndetVar(descriptor.getReturnType());

    Type resType;
    switch (tree.getMode()) {
        case NEW:
            if (!tree.expr.type.isRaw()) {
                resType = tree.expr.type;
                break;
            }
        default:
            resType = refType.getReturnType();
    }

    Type incompatibleReturnType = resType;

    if (returnType.hasTag(VOID)) {
        incompatibleReturnType = null;
    }

    if (!returnType.hasTag(VOID) && !resType.hasTag(VOID)) {
        if (resType.isErroneous() ||
                new FunctionalReturnContext(checkContext).compatible(resType, returnType, types.noWarnings)) {
            incompatibleReturnType = null;
        }
    }

    if (incompatibleReturnType != null) {
        checkContext.report(tree, diags.fragment("incompatible.ret.type.in.mref",
                diags.fragment("inconvertible.types", resType, descriptor.getReturnType())));
    }

    if (!speculativeAttr) {
        List<Type> thrownTypes = checkContext.inferenceContext().asUndetVars(descriptor.getThrownTypes());
        if (chk.unhandled(refType.getThrownTypes(), thrownTypes).nonEmpty()) {
            log.error(tree, "incompatible.thrown.types.in.mref", refType.getThrownTypes());
        }
    }
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
protected ResultInfo(KindSelector pkind,
                     Type pt, CheckContext checkContext, CheckMode checkMode) {
    this.pkind = pkind;
    this.pt = pt;
    this.checkContext = checkContext;
    this.checkMode = checkMode;
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
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(Fragments.IncompatibleTypeInConditional(details)));
        }
    };
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
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(Fragments.CantApplyDiamond1(Fragments.Diamond(tsym), details)));
        }
    };
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
/** Check lambda against given target result */
private void checkLambdaCompatible(Type descriptor, ResultInfo resultInfo) {
    CheckContext checkContext = resultInfo.checkContext;
    ResultInfo bodyResultInfo = attr.lambdaBodyResult(speculativeTree, descriptor, resultInfo);
    for (JCReturn ret : returnExpressions()) {
        Type t = getReturnType(ret);
        if (speculativeTree.getBodyKind() == BodyKind.EXPRESSION || !t.hasTag(VOID)) {
            checkSpeculative(ret.expr, t, bodyResultInfo);
        }
    }

    attr.checkLambdaCompatible(speculativeTree, descriptor, checkContext);
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
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));
        }
    };
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
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));
        }
    };
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
@SuppressWarnings("fallthrough")
void checkReferenceCompatible(JCMemberReference tree, Type descriptor, Type refType, CheckContext checkContext, boolean speculativeAttr) {
    Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType());

    Type resType;
    switch (tree.getMode()) {
        case NEW:
            if (!tree.expr.type.isRaw()) {
                resType = tree.expr.type;
                break;
            }
        default:
            resType = refType.getReturnType();
    }

    Type incompatibleReturnType = resType;

    if (returnType.hasTag(VOID)) {
        incompatibleReturnType = null;
    }

    if (!returnType.hasTag(VOID) && !resType.hasTag(VOID)) {
        if (resType.isErroneous() ||
                new FunctionalReturnContext(checkContext).compatible(resType, returnType, types.noWarnings)) {
            incompatibleReturnType = null;
        }
    }

    if (incompatibleReturnType != null) {
        checkContext.report(tree, diags.fragment("incompatible.ret.type.in.mref",
                diags.fragment("inconvertible.types", resType, descriptor.getReturnType())));
    }

    if (!speculativeAttr) {
        List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes());
        if (chk.unhandled(refType.getThrownTypes(), thrownTypes).nonEmpty()) {
            log.error(tree, "incompatible.thrown.types.in.mref", refType.getThrownTypes());
        }
    }
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
protected ResultInfo(int pkind, Type pt, CheckContext checkContext) {
    this.pkind = pkind;
    this.pt = pt;
    this.checkContext = checkContext;
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
protected ResultInfo dup(CheckContext newContext) {
    return new ResultInfo(pkind, pt, newContext);
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
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(VAL, 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 == Kinds.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();
    }
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
FunctionalReturnContext(CheckContext enclosingContext) {
    super(enclosingContext);
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
ExpressionLambdaReturnContext(JCExpression expr, CheckContext enclosingContext) {
    super(enclosingContext);
    this.expr = expr;
}
 

import com.sun.tools.javac.comp.Check.CheckContext; //导入依赖的package包/类
public MethodResultInfo(Type pt, CheckContext checkContext) {
    attr.super(VAL, pt, checkContext);
}