Java InferenceContext类代码示例

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
protected void reportMC(DiagnosticPosition pos, MethodCheckDiag diag, InferenceContext inferenceContext, Object... args) {
    boolean inferDiag = inferenceContext != infer.emptyContext;
    InapplicableMethodException ex = inferDiag ?
            infer.inferenceException : inapplicableMethodException;
    if (inferDiag && (!diag.inferKey.equals(diag.basicKey))) {
        Object[] args2 = new Object[args.length + 1];
        System.arraycopy(args, 0, args2, 1, args.length);
        args2[0] = inferenceContext.inferenceVars();
        args = args2;
    }
    String key = inferDiag ? diag.inferKey : diag.basicKey;
    throw ex.setMessage(diags.create(DiagnosticType.FRAGMENT, log.currentSource(), pos, key, args));
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
@Override
ReferenceLookupHelper unboundLookup(InferenceContext inferenceContext) {
    if (TreeInfo.isStaticSelector(referenceTree.expr, names) &&
            argtypes.nonEmpty() &&
            (argtypes.head.hasTag(NONE) ||
            types.isSubtypeUnchecked(inferenceContext.asUndetVar(argtypes.head), site))) {
        return new UnboundMethodReferenceLookupHelper(referenceTree, name,
                site, argtypes, typeargtypes, maxPhase);
    } else {
        return super.unboundLookup(inferenceContext);
    }
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
DeferredAttrContext deferredAttrContext(Symbol sym, InferenceContext inferenceContext, ResultInfo pendingResult, Warner warn) {
    DeferredAttrContext parent = (pendingResult == null)
        ? deferredAttr.emptyDeferredAttrContext
        : pendingResult.checkContext.deferredAttrContext();
    return deferredAttr.new DeferredAttrContext(attrMode, sym, step,
            inferenceContext, parent, warn);
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
DeferredAttrContext(AttrMode mode, Symbol msym, MethodResolutionPhase phase,
        InferenceContext inferenceContext, DeferredAttrContext parent, Warner warn) {
    this.mode = mode;
    this.msym = msym;
    this.phase = phase;
    this.parent = parent;
    this.warn = warn;
    this.inferenceContext = inferenceContext;
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
@Override
ReferenceLookupHelper unboundLookup(InferenceContext inferenceContext) {
    if (TreeInfo.isStaticSelector(referenceTree.expr, names) &&
            argtypes.nonEmpty() &&
            (argtypes.head.hasTag(NONE) ||
            types.isSubtypeUnchecked(inferenceContext.asFree(argtypes.head), site))) {
        return new UnboundMethodReferenceLookupHelper(referenceTree, name,
                site, argtypes, typeargtypes, maxPhase);
    } else {
        return super.unboundLookup(inferenceContext);
    }
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
private void checkAccessibleTypes(final DiagnosticPosition pos, final Env<AttrContext> env,
        final InferenceContext inferenceContext, final Type... ts) {
    checkAccessibleTypes(pos, env, inferenceContext, List.from(ts));
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
MethodReferenceCheck(InferenceContext pendingInferenceContext) {
    this.pendingInferenceContext = pendingInferenceContext;
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
public boolean compatible(Type found, Type req, Warner warn) {
    InferenceContext inferenceContext = deferredAttrContext.inferenceContext;
    return strict ?
            types.isSubtypeUnchecked(inferenceContext.asUndetVar(found), inferenceContext.asUndetVar(req), warn) :
            types.isConvertible(inferenceContext.asUndetVar(found), inferenceContext.asUndetVar(req), warn);
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
public InferenceContext inferenceContext() {
    return deferredAttrContext.inferenceContext;
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
Symbol resolveMemberReferenceByArity(Env<AttrContext> env,
                              JCMemberReference referenceTree,
                              Type site,
                              Name name,
                              List<Type> argtypes,
                              InferenceContext inferenceContext) {

    boolean isStaticSelector = TreeInfo.isStaticSelector(referenceTree.expr, names);
    site = types.capture(site);

    ReferenceLookupHelper boundLookupHelper = makeReferenceLookupHelper(
            referenceTree, site, name, argtypes, null, VARARITY);
    //step 1 - bound lookup
    Env<AttrContext> boundEnv = env.dup(env.tree, env.info.dup());
    Symbol boundSym = lookupMethod(boundEnv, env.tree.pos(), site.tsym,
            arityMethodCheck, boundLookupHelper);
    if (isStaticSelector &&
        !name.equals(names.init) &&
        !boundSym.isStatic() &&
        boundSym.kind < ERRONEOUS) {
        boundSym = methodNotFound;
    }

    //step 2 - unbound lookup
    Symbol unboundSym = methodNotFound;
    ReferenceLookupHelper unboundLookupHelper = null;
    Env<AttrContext> unboundEnv = env.dup(env.tree, env.info.dup());
    if (isStaticSelector) {
        unboundLookupHelper = boundLookupHelper.unboundLookup(inferenceContext);
        unboundSym = lookupMethod(unboundEnv, env.tree.pos(), site.tsym,
                arityMethodCheck, unboundLookupHelper);
        if (unboundSym.isStatic() &&
            unboundSym.kind < ERRONEOUS) {
            unboundSym = methodNotFound;
        }
    }

    //merge results
    Symbol bestSym = choose(boundSym, unboundSym);
    env.info.pendingResolutionPhase = bestSym == unboundSym ?
            unboundEnv.info.pendingResolutionPhase :
            boundEnv.info.pendingResolutionPhase;

    return bestSym;
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
public Infer.InferenceContext inferenceContext() {
    return enclosingContext.inferenceContext();
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
/**
 * Process a deferred attribution node.
 * Invariant: a stuck node cannot be processed.
 */
@SuppressWarnings("fallthrough")
boolean process(final DeferredAttrContext deferredAttrContext) {
    switch (deferredAttrContext.mode) {
        case SPECULATIVE:
            if (deferredStuckPolicy.isStuck()) {
                dt.check(resultInfo, dummyStuckPolicy, new StructuralStuckChecker());
                return true;
            } else {
                Assert.error("Cannot get here");
            }
        case CHECK:
            if (deferredStuckPolicy.isStuck()) {
                //stuck expression - see if we can propagate
                if (deferredAttrContext.parent != emptyDeferredAttrContext &&
                        Type.containsAny(deferredAttrContext.parent.inferenceContext.inferencevars,
                                List.from(deferredStuckPolicy.stuckVars()))) {
                    deferredAttrContext.parent.addDeferredAttrNode(dt,
                            resultInfo.dup(new Check.NestedCheckContext(resultInfo.checkContext) {
                        @Override
                        public InferenceContext inferenceContext() {
                            return deferredAttrContext.parent.inferenceContext;
                        }
                        @Override
                        public DeferredAttrContext deferredAttrContext() {
                            return deferredAttrContext.parent;
                        }
                    }), deferredStuckPolicy);
                    dt.tree.type = Type.stuckType;
                    return true;
                } else {
                    return false;
                }
            } else {
                Assert.check(!deferredAttrContext.insideOverloadPhase(),
                        "attribution shouldn't be happening here");
                ResultInfo instResultInfo =
                        resultInfo.dup(deferredAttrContext.inferenceContext.asInstType(resultInfo.pt));
                dt.check(instResultInfo, dummyStuckPolicy, basicCompleter);
                return true;
            }
        default:
            throw new AssertionError("Bad mode");
    }
}
 

import com.sun.tools.javac.comp.Infer.InferenceContext; //导入依赖的package包/类
@Override
public void typesInferred(InferenceContext inferenceContext) {
    stuckVars.clear();
}