Package com.intellij.psi.impl.source.resolve.graphInference

Class InferenceSession

java.lang.Object

com.intellij.psi.impl.source.resolve.graphInference.InferenceSession

public class InferenceSession
extends java.lang.Object

Field Summary

Fields

Modifier and Type	Field and Description
InferenceIncorporationPhase	myIncorporationPhase
protected java.util.Set<InferenceVariable>	myInferenceVariables

Constructor Summary

Constructors

Constructor and Description
InferenceSession(com.intellij.psi.impl.source.resolve.graphInference.InitialInferenceState initialState, ParameterTypeInferencePolicy policy)
InferenceSession(PsiTypeParameter[] typeParams, PsiSubstitutor siteSubstitutor, PsiManager manager, PsiElement context)
InferenceSession(PsiTypeParameter[] typeParams, PsiSubstitutor siteSubstitutor, PsiManager manager, PsiElement context, ParameterTypeInferencePolicy policy)
InferenceSession(PsiTypeParameter[] typeParams, PsiType[] leftTypes, PsiType[] rightTypes, PsiSubstitutor siteSubstitutor, PsiManager manager, PsiElement context)

Method Summary

Modifier and Type	Method and Description
void	addConstraint(ConstraintFormula constraint)
static PsiSubstitutor	chooseSiteSubstitutor(MethodCandidateInfo currentMethod, JavaResolveResult resolveResult, PsiMethod method)
static boolean	chooseVarargsMode(MethodCandidateInfo currentMethod, JavaResolveResult resolveResult)
PsiSubstitutor	collectApplicabilityConstraints(PsiMethodReferenceExpression reference, MethodCandidateInfo candidateInfo, PsiType functionalInterfaceType)
boolean	collectDependencies(PsiType type, java.util.Set<? super InferenceVariable> dependencies)
static boolean	collectDependencies(PsiType type, java.util.Set<? super InferenceVariable> dependencies, Function<? super PsiClassType,? extends InferenceVariable> fun)
static PsiType	createTypeParameterTypeWithUpperBound(PsiType upperBound, PsiElement place)
static PsiClass	findParameterizationOfTheSameGenericClass(java.util.List<? extends PsiType> upperBounds, Processor<? super Pair<PsiType,PsiType>> processor)
PsiElement	getContext()
MethodCandidateInfo	getCurrentMethod(PsiExpressionList argumentList)
java.util.List<java.lang.String>	getIncompatibleErrorMessages()
ParameterTypeInferencePolicy	getInferencePolicy()
InferenceSessionContainer	getInferenceSessionContainer()
PsiSubstitutor	getInferenceSubstitution()
InferenceVariable	getInferenceVariable(PsiType psiType)
java.util.Collection<InferenceVariable>	getInferenceVariables()
PsiManager	getManager()
java.lang.String	getPresentableText(PsiType psiType)
PsiSubstitutor	getRestoreNameSubstitution()
GlobalSearchScope	getScope()
static PsiType	getTargetType(PsiElement context)
static PsiType	getTargetTypeByParent(PsiElement context)
static boolean	ignoreLambdaConstraintTree(PsiExpression arg)
PsiSubstitutor	infer()
PsiSubstitutor	infer(PsiParameter [] parameters, PsiExpression [] args, PsiElement parent, MethodCandidateInfo currentMethod)
InferenceVariable[]	initBounds(PsiElement context, PsiSubstitutor siteSubstitutor, PsiTypeParameter... typeParameters)
InferenceVariable[]	initBounds(PsiElement context, PsiTypeParameter... typeParameters)
void	initExpressionConstraints(PsiParameter[] parameters, PsiExpression[] args, PsiMethod method, boolean varargs)
void	initThrowsConstraints(PsiMethod method)
boolean	isErased()
static boolean	isFunctionalTypeMoreSpecificOnExpression(PsiType sType, PsiType tType, PsiExpression arg) 15.12.2.5 Choosing the Most Specific Method "a functional interface type S is more specific than a functional interface type T for an expression exp" part
static boolean	isMoreSpecific(PsiMethod m1, PsiMethod m2, PsiSubstitutor siteSubstitutor1, PsiExpression[] args, PsiElement context, boolean varargs) 18.5.4 More Specific Method Inference
static boolean	isPertinentToApplicability(PsiExpression expr, PsiMethod method) Definition from 15.12.2.2 Phase 1: Identify Matching Arity Methods Applicable by Subtyping Strict Invocation An argument expression is considered pertinent to applicability for a potentially-applicable method m unless it has one of the following forms: 1) An implicitly-typed lambda expression (15.27.1).
boolean	isProperType(PsiType type)
protected PsiSubstitutor	prepareSubstitution()
void	propagateVariables(InferenceSession from)
void	registerIncompatibleErrorMessage(java.util.Collection<InferenceVariable> variables, java.lang.String incompatibleTypesMessage)
void	registerIncompatibleErrorMessage(java.lang.String incompatibleBoundsMessage)
void	registerReturnTypeConstraints(PsiType returnType, PsiType targetType, PsiElement context)
boolean	repeatInferencePhases()
protected void	resolveBounds(java.util.Collection<InferenceVariable> inferenceVariables, PsiSubstitutor substitutor)
protected PsiSubstitutor	resolveSubset(java.util.Collection<InferenceVariable> vars, PsiSubstitutor substitutor)
void	setCurrentMethod(MethodCandidateInfo currentMethod)
void	setErased()
PsiType	startWithFreshVars(PsiType type)
PsiType	substituteWithInferenceVariables(PsiType type)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

myInferenceVariables

protected final java.util.Set<InferenceVariable> myInferenceVariables

myIncorporationPhase

public final InferenceIncorporationPhase myIncorporationPhase

Constructor Detail

InferenceSession

public InferenceSession(com.intellij.psi.impl.source.resolve.graphInference.InitialInferenceState initialState,
                        ParameterTypeInferencePolicy policy)

InferenceSession

public InferenceSession(PsiTypeParameter[] typeParams,
                        PsiType[] leftTypes,
                        PsiType[] rightTypes,
                        PsiSubstitutor siteSubstitutor,
                        PsiManager manager,
                        PsiElement context)

InferenceSession

public InferenceSession(PsiTypeParameter[] typeParams,
                        PsiSubstitutor siteSubstitutor,
                        PsiManager manager,
                        PsiElement context)

InferenceSession

public InferenceSession(PsiTypeParameter[] typeParams,
                        PsiSubstitutor siteSubstitutor,
                        PsiManager manager,
                        PsiElement context,
                        ParameterTypeInferencePolicy policy)

Method Detail

getCurrentMethod

public MethodCandidateInfo getCurrentMethod(PsiExpressionList argumentList)

setCurrentMethod

public void setCurrentMethod(MethodCandidateInfo currentMethod)

getInferencePolicy

public ParameterTypeInferencePolicy getInferencePolicy()

createTypeParameterTypeWithUpperBound

public static PsiType createTypeParameterTypeWithUpperBound(PsiType upperBound,
                                                            PsiElement place)

initExpressionConstraints

public void initExpressionConstraints(PsiParameter[] parameters,
                                      PsiExpression[] args,
                                      PsiMethod method,
                                      boolean varargs)

initThrowsConstraints

public void initThrowsConstraints(PsiMethod method)

isPertinentToApplicability

public static boolean isPertinentToApplicability(PsiExpression expr,
                                                 PsiMethod method)

Definition from 15.12.2.2 Phase 1: Identify Matching Arity Methods Applicable by Subtyping Strict Invocation An argument expression is considered pertinent to applicability for a potentially-applicable method m unless it has one of the following forms: 1) An implicitly-typed lambda expression (15.27.1). 2) An inexact method reference (15.13.1). 3) If m is a generic method and the method invocation does not provide explicit type arguments, an explicitly-typed lambda expression or an exact method reference for which the corresponding target type (as derived from the signature of m) is a type parameter of m. 4) An explicitly-typed lambda expression whose body is an expression that is not pertinent to applicability. 5) An explicitly-typed lambda expression whose body is a block, where at least one result expression is not pertinent to applicability. 6) A parenthesized expression (15.8.5) whose contained expression is not pertinent to applicability. 7) A conditional expression (15.25) whose second or third operand is not pertinent to applicability.

infer

public PsiSubstitutor infer()

infer

public PsiSubstitutor infer(PsiParameter [] parameters,
                            PsiExpression [] args,
                            PsiElement parent,
                            MethodCandidateInfo currentMethod)

ignoreLambdaConstraintTree

public static boolean ignoreLambdaConstraintTree(PsiExpression arg)

chooseSiteSubstitutor

public static PsiSubstitutor chooseSiteSubstitutor(MethodCandidateInfo currentMethod,
                                                   JavaResolveResult resolveResult,
                                                   PsiMethod method)

chooseVarargsMode

public static boolean chooseVarargsMode(MethodCandidateInfo currentMethod,
                                        JavaResolveResult resolveResult)

prepareSubstitution

protected PsiSubstitutor prepareSubstitution()

initBounds

public InferenceVariable[] initBounds(PsiElement context,
                                      PsiTypeParameter... typeParameters)

initBounds

public InferenceVariable[] initBounds(PsiElement context,
                                      PsiSubstitutor siteSubstitutor,
                                      PsiTypeParameter... typeParameters)

registerReturnTypeConstraints

public void registerReturnTypeConstraints(PsiType returnType,
                                          PsiType targetType,
                                          PsiElement context)

getTargetType

public static PsiType getTargetType(PsiElement context)

getTargetTypeByParent

public static PsiType getTargetTypeByParent(PsiElement context)

getInferenceVariable

public InferenceVariable getInferenceVariable(PsiType psiType)

isProperType

public boolean isProperType(PsiType type)

collectDependencies

public boolean collectDependencies(PsiType type,
                                   java.util.Set<? super InferenceVariable> dependencies)

collectDependencies

public static boolean collectDependencies(PsiType type,
                                          java.util.Set<? super InferenceVariable> dependencies,
                                          Function<? super PsiClassType,? extends InferenceVariable> fun)

repeatInferencePhases

public boolean repeatInferencePhases()

resolveBounds

protected void resolveBounds(java.util.Collection<InferenceVariable> inferenceVariables,
                             PsiSubstitutor substitutor)

resolveSubset

protected final PsiSubstitutor resolveSubset(java.util.Collection<InferenceVariable> vars,
                                             PsiSubstitutor substitutor)

getPresentableText

public java.lang.String getPresentableText(PsiType psiType)

registerIncompatibleErrorMessage

public void registerIncompatibleErrorMessage(java.util.Collection<InferenceVariable> variables,
                                             java.lang.String incompatibleTypesMessage)

registerIncompatibleErrorMessage

public void registerIncompatibleErrorMessage(java.lang.String incompatibleBoundsMessage)

getManager

public PsiManager getManager()

getScope

public GlobalSearchScope getScope()

getInferenceVariables

public java.util.Collection<InferenceVariable> getInferenceVariables()

addConstraint

public void addConstraint(ConstraintFormula constraint)

collectApplicabilityConstraints

public PsiSubstitutor collectApplicabilityConstraints(PsiMethodReferenceExpression reference,
                                                      MethodCandidateInfo candidateInfo,
                                                      PsiType functionalInterfaceType)

setErased

public void setErased()

isMoreSpecific

public static boolean isMoreSpecific(PsiMethod m1,
                                     PsiMethod m2,
                                     PsiSubstitutor siteSubstitutor1,
                                     PsiExpression[] args,
                                     PsiElement context,
                                     boolean varargs)

18.5.4 More Specific Method Inference

isFunctionalTypeMoreSpecificOnExpression

public static boolean isFunctionalTypeMoreSpecificOnExpression(PsiType sType,
                                                               PsiType tType,
                                                               PsiExpression arg)

15.12.2.5 Choosing the Most Specific Method "a functional interface type S is more specific than a functional interface type T for an expression exp" part

getContext

public PsiElement getContext()

propagateVariables

public final void propagateVariables(InferenceSession from)

substituteWithInferenceVariables

public PsiType substituteWithInferenceVariables(PsiType type)

getInferenceSubstitution

public PsiSubstitutor getInferenceSubstitution()

getRestoreNameSubstitution

public PsiSubstitutor getRestoreNameSubstitution()

getInferenceSessionContainer

public InferenceSessionContainer getInferenceSessionContainer()

startWithFreshVars

public PsiType startWithFreshVars(PsiType type)

findParameterizationOfTheSameGenericClass

public static PsiClass findParameterizationOfTheSameGenericClass(java.util.List<? extends PsiType> upperBounds,
                                                                 Processor<? super Pair<PsiType,PsiType>> processor)

getIncompatibleErrorMessages

public java.util.List<java.lang.String> getIncompatibleErrorMessages()

isErased

public boolean isErased()