org.jetbrains.jet.lang.resolve.calls.inference
Interface ConstraintSystem

All Known Implementing Classes:

ConstraintSystemImpl

public interface ConstraintSystem

Method Summary

void	addSubtypeConstraint(JetType constrainingType, JetType subjectType, ConstraintPosition constraintPosition) Adds a constraint that the constraining type is a subtype of the subject type. Asserts that only subject type may contain registered type variables.
void	addSupertypeConstraint(JetType constrainingType, JetType subjectType, ConstraintPosition constraintPosition) Adds a constraint that the constraining type is a supertype of the subject type.
ConstraintSystem	copy()
TypeSubstitutor	getCurrentSubstitutor() Returns a current result of solving the constraint system (mapping from the type variable to the resulting type projection).
TypeSubstitutor	getResultingSubstitutor() Returns a result of solving the constraint system (mapping from the type variable to the resulting type projection).
TypeConstraints	getTypeConstraints(TypeParameterDescriptor typeVariable) Returns the resulting type constraints of solving the constraint system for specific type variable.
java.util.Set<TypeParameterDescriptor>	getTypeVariables() Returns a set of all registered type variables.
boolean	hasConflictingConstraints() Returns true if type constraints for some type variable are contradicting.
boolean	hasContradiction() Return true if constraint system has no contradiction (it can be not successful because of the lack of information for a type variable).
boolean	hasErrorInConstrainingTypes() Returns true if there is an error in constraining types.
boolean	hasOnlyExpectedTypeMismatch() Returns true if there is type constructor mismatch only in ConstraintPosition.EXPECTED_TYPE_POSITION.
boolean	hasTypeConstructorMismatch() Returns true if some constraint cannot be processed because of type constructor mismatch.
boolean	hasTypeConstructorMismatchAt(ConstraintPosition constraintPosition) Returns true if there is type constructor mismatch error at a specific constraintPosition.
boolean	hasUnknownParameters() Returns true if there is no information for some registered type variable.
boolean	isSuccessful() Returns true if constraint system has a solution (has no contradiction and has enough information to infer each registered type variable).
void	registerTypeVariable(TypeParameterDescriptor typeVariable, Variance positionVariance) Registers a variable in a constraint system.

Method Detail

registerTypeVariable

void registerTypeVariable(@NotNull
                          TypeParameterDescriptor typeVariable,
                          @NotNull
                          Variance positionVariance)

Registers a variable in a constraint system.

getTypeVariables

@NotNull
java.util.Set<TypeParameterDescriptor> getTypeVariables()

Returns a set of all registered type variables.

addSubtypeConstraint

void addSubtypeConstraint(@Nullable
                          JetType constrainingType,
                          @NotNull
                          JetType subjectType,
                          @NotNull
                          ConstraintPosition constraintPosition)

Adds a constraint that the constraining type is a subtype of the subject type.

Asserts that only subject type may contain registered type variables.

For example, for "fun <T> id(t: T) {}" to infer T in invocation "id(1)" should be generated a constraint "Int is a subtype of T" where T is a subject type, and Int is a constraining type.

addSupertypeConstraint

void addSupertypeConstraint(@Nullable
                            JetType constrainingType,
                            @NotNull
                            JetType subjectType,
                            @NotNull
                            ConstraintPosition constraintPosition)

Adds a constraint that the constraining type is a supertype of the subject type.

Asserts that only subject type may contain registered type variables.

For example, for "fun <T> create() : T" to infer T in invocation "val i: Int = create()" should be generated a constraint "Int is a supertype of T" where T is a subject type, and Int is a constraining type.

isSuccessful

boolean isSuccessful()

Returns true if constraint system has a solution (has no contradiction and has enough information to infer each registered type variable).

hasContradiction

boolean hasContradiction()

Return true if constraint system has no contradiction (it can be not successful because of the lack of information for a type variable).

hasConflictingConstraints

boolean hasConflictingConstraints()

Returns true if type constraints for some type variable are contradicting.

For example, for

fun <R> foo(r: R, t: java.util.List<R>) {}

in invocation foo(1, arrayList("s")) type variable R has two conflicting constraints:

- "R is a supertype of Int"

- "List<R> is a supertype of List<String>" which leads to "R is equal to String"

hasUnknownParameters

boolean hasUnknownParameters()

Returns true if there is no information for some registered type variable. For example, for

fun <E> newList()

in invocation "val nl = newList()" there is no information to infer type variable E.

hasTypeConstructorMismatch

boolean hasTypeConstructorMismatch()

Returns true if some constraint cannot be processed because of type constructor mismatch. For example, for

fun <R> foo(t: List<R>) {}

in invocation foo(hashSet("s")) there is type constructor mismatch: "HashSet<String> cannot be a subtype of List<R>".

hasTypeConstructorMismatchAt

boolean hasTypeConstructorMismatchAt(@NotNull
                                     ConstraintPosition constraintPosition)

Returns true if there is type constructor mismatch error at a specific constraintPosition. For example, for

fun <R> foo(t: List<R>) {}

in invocation foo(hashSet("s")) there is type constructor mismatch: "HashSet<String> cannot be a subtype of List<R>" at a constraint position ConstraintPosition.getValueParameterPosition(0).

hasOnlyExpectedTypeMismatch

boolean hasOnlyExpectedTypeMismatch()

Returns true if there is type constructor mismatch only in ConstraintPosition.EXPECTED_TYPE_POSITION.

hasErrorInConstrainingTypes

boolean hasErrorInConstrainingTypes()

Returns true if there is an error in constraining types.

Is used not to generate type inference error if there was one in argument types.

getTypeConstraints

@Nullable
TypeConstraints getTypeConstraints(@NotNull
                                            TypeParameterDescriptor typeVariable)

Returns the resulting type constraints of solving the constraint system for specific type variable.

Returns null if the type variable was not registered.

getResultingSubstitutor

@NotNull
TypeSubstitutor getResultingSubstitutor()

Returns a result of solving the constraint system (mapping from the type variable to the resulting type projection).

In the resulting substitution should be concerned:

- type constraints

- variance of the type variable // not implemented yet

- type parameter bounds (that can bind type variables with each other). // not implemented yet If the addition of the 'expected type' constraint made the system fail, this constraint is not included in the resulting substitution.

getCurrentSubstitutor

@NotNull
TypeSubstitutor getCurrentSubstitutor()

Returns a current result of solving the constraint system (mapping from the type variable to the resulting type projection). If there is no information for type parameter, returns type projection for DONT_CARE type.

copy

ConstraintSystem copy()