Examples of SuspendedInferenceRecord

org.eclipse.jdt.internal.compiler.lookup.InferenceContext18.SuspendedInferenceRecord
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.

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

        MethodBinding method = previousMethod;
        // ignore previous (inner) inference result and do a fresh start:
        // avoid original(), since we only want to discard one level of instantiation 
        // (method type variables - not class type variables)!
        method = previousMethod.shallowOriginal();
        SuspendedInferenceRecord prevInvocation = inferenceContext.enterPolyInvocation(invocation, invocation.arguments());


        // Invocation Applicability Inference: 18.5.1 & Invocation Type Inference: 18.5.2
        try {
          Expression[] arguments = invocation.arguments();
          TypeBinding[] argumentTypes = arguments == null ? Binding.NO_PARAMETERS : new TypeBinding[arguments.length];

View Full Code Here

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

                          LambdaExpression lambda, ParameterizedTypeBinding targetTypeWithWildCards)
  {
    if (lambda.argumentsTypeElided()) {
      return lambda.findGroundTargetTypeForElidedLambda(scope, targetTypeWithWildCards);
    } else {
      SuspendedInferenceRecord previous = inferenceContext.enterLambda(lambda);
      try {
        return inferenceContext.inferFunctionalInterfaceParameterization(lambda, scope, targetTypeWithWildCards);
      } finally {
        inferenceContext.resumeSuspendedInference(previous);
      }

View Full Code Here

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

          && ((original.typeVariables() != Binding.NO_TYPE_VARIABLES && r.mentionsAny(original.typeVariables(), -1))
            || (original.isConstructor() && original.declaringClass.typeVariables() != Binding.NO_TYPE_VARIABLES)))
              // not checking r.mentionsAny for constructors, because A::new resolves to the raw type
              // whereas in fact the type of all expressions of this shape depends on their type variable (if any)
      {
        SuspendedInferenceRecord prevInvocation = inferenceContext.enterPolyInvocation(reference, null/*no invocation arguments available*/);


        // Invocation Applicability Inference: 18.5.1 & Invocation Type Inference: 18.5.2
        try {
          inferInvocationApplicability(inferenceContext, original, functionType.parameters, original.isConstructor()/*mimic a diamond?*/, inferenceContext.inferenceKind);
          if (!inferPolyInvocationType(inferenceContext, reference, r, original))

View Full Code Here

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of SuspendedInferenceRecord

Inference Basics

Queries and utilities

Phases of Inference

18.5. Uses of Inference

Inference Lifecycle

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

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

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