Examples of org.eclipse.jdt.internal.compiler.lookup.InferenceContext18

Main class for new type inference as per JLS8 sect 18. Keeps contextual state and drives the algorithm.

Inference Basics

18.1.1 Inference variables: {@link InferenceVariable}
18.1.2 Constraint Formulas: subclasses of {@link ConstraintFormula}
18.1.3 Bounds: {@link TypeBound}
Capture bounds are directly captured in {@link BoundSet#captures}, throws-bounds in {@link BoundSet#inThrows}.
Also: {@link BoundSet}: main state during inference.

Each instance of {@link InferenceContext18} manages instances of the above and coordinates the inference process.

Queries and utilities

{@link TypeBinding#isProperType(boolean)}: used to exclude "types" that mention inference variables (18.1.1).
{@link TypeBinding#mentionsAny(TypeBinding[],int)}: does the receiver type binding mention any of the given types?
{@link TypeBinding#substituteInferenceVariable(InferenceVariable,TypeBinding)}: replace occurrences of an inference variable with a proper type.
{@link TypeBinding#collectInferenceVariables(Set)}: collect all inference variables mentioned in the receiver type into the given set.
{@link TypeVariableBinding#getTypeBounds(InferenceVariable,InferenceSubstitution)}: Compute the initial type bounds for one inference variable as per JLS8 sect 18.1.3.

Phases of Inference

18.2 Reduction: {@link #reduce()} with most work happening in implementations of{@link ConstraintFormula#reduce(InferenceContext18)}:
- 18.2.1 Expression Compatibility Constraints: {@link ConstraintExpressionFormula#reduce(InferenceContext18)}.
- 18.2.2 Type Compatibility Constraints ff. {@link ConstraintTypeFormula#reduce(InferenceContext18)}.
18.3 Incorporation: {@link BoundSet#incorporate(InferenceContext18)}; during inference new constraints are accepted via {@link BoundSet#reduceOneConstraint(InferenceContext18,ConstraintFormula)} (combining 18.2 & 18.3)
18.4 Resolution: {@link #resolve(InferenceVariable[])}.

Some of the above operations accumulate their results into {@link #currentBounds}, whereas the last phase returns the resulting bound set while keeping the previous state in {@link #currentBounds}.

18.5. Uses of Inference

These are the main entries from the compiler into the inference engine:

18.5.1 Invocation Applicability Inference: {@link #inferInvocationApplicability(MethodBinding,TypeBinding[],boolean)}. Prepare the initial state for inference of a generic invocation - no target type used at this point. Need to call {@link #solve()} afterwards to produce the intermediate result.
Called indirectly from {@link Scope#findMethod(ReferenceBinding,char[],TypeBinding[],InvocationSite,boolean)} et alto select applicable methods into overload resolution.
18.5.2 Invocation Type Inference: {@link InferenceContext18#inferInvocationType(BoundSet,TypeBinding,InvocationSite,MethodBinding)}. After a most specific method has been picked, and given a target type determine the final generic instantiation. As long as a target type is still unavailable this phase keeps getting deferred.
Different wrappers exist for the convenience of different callers.
18.5.3 Functional Interface Parameterization Inference: Controlled from {@link LambdaExpression#resolveType(BlockScope)}.
18.5.4 More Specific Method Inference: Not Yet Implemented

For 18.5.1 and 18.5.2 some high-level control is implemented in {@link ParameterizedGenericMethodBinding#computeCompatibleMethod(MethodBinding,TypeBinding[],Scope,InvocationSite,int)}.

Inference Lifecycle

The separation into 18.5.1 and 18.5.2 causes some complexity:

Calling both parts of inference is directly interwoven with overload resolution. See {@link ParameterizedGenericMethodBinding#computeCompatibleMethod(MethodBinding,TypeBinding[],Scope,InvocationSite,int) PGMB#computeCompatibleMethod()} for the basic protocol.
Intermediate state regarding inference must be stored between both phases. Inference is performed with different inputs for each pair of {@link Invocation} x {@link ParameterizedGenericMethodBinding}, see {@link Invocation#registerInferenceContext(ParameterizedGenericMethodBinding,InferenceContext18) Invocation.registerInferenceContext()} and{@link Invocation#getInferenceContext(ParameterizedMethodBinding) getInferenceContext()}.
As part of the lifecycle state, each instance of InferenceContext18 remembers the current {@link #inferenceKind}and {@link #stepCompleted}.
Nested inference/resolving: If an invocation argument is a poly expression itself, final resolving of the argument can only happened after Invocation Type Inference regarding the outer invocation. Outer inference must produce the target type that drives the inner inference / resolving. Two different protocols are applied:
- If the inner poly expression is an invocation, inner inference is directly incorporated into the {@link #currentBounds}, see block inside {@link ConstraintExpressionFormula#reduce(InferenceContext18)}.
  In this case the results of the combined inference need to be applied to all contained inner invocations, which happens in {@link #rebindInnerPolies(BoundSet,TypeBinding[])}, which must be called whenever 18.5.2 finishes.
- If the inner poly expression is a functional expression or a conditional expression no inference variables exist representing the inner. In this case the final target type is pushed into the inner using {@link Expression#checkAgainstFinalTargetType(TypeBinding,Scope)}, which, too, is called from {@link #rebindInnerPolies(BoundSet,TypeBinding[])}.
- For recursively pushing target types into arguments of an invocation method {@link ASTNode#resolvePolyExpressionArguments(Invocation,MethodBinding,TypeBinding[],Scope)} exists,which is called in two situations: (1) for non-generic outer invocations from MessageSend#findMethodBinding() and Statement#findConstructorBinding(); (2) for generic outer invocations from {@link #rebindInnerPolies(BoundSet,TypeBinding[])}.
- In some situations invocation arguments that are poly invocations need to be resolved in the middle of overload resolution to answer {@link Scope#parameterCompatibilityLevel18} (where the outer invocation did not involve any inference).
Pushing inference results into an inner invocation happens using {@link Invocation#updateBindings(MethodBinding,TypeBinding)}.
Decision whether or not an invocation is a variable-arity invocation is made by first attempting to solve 18.5.1 in mode {@link #CHECK_LOOSE}. Only if that fails, another attempt is made in mode {@link #CHECK_VARARG}. Which of these two attempts was successful is stored in {@link #inferenceKind}. This field must be consulted whenever arguments of an invocation should be further processed. See also {@link #getParameter(TypeBinding[],int,boolean)} and its clients.