org.eclipse.xtext.xbase.typesystem.references

Class UnboundTypeReference

java.lang.Object

org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference

org.eclipse.xtext.xbase.typesystem.references.UnboundTypeReference

public class UnboundTypeReference
extends LightweightTypeReference

A type reference that points to a type parameter that is not yet resolved. UnboundTypeReference should be created with a concrete ITypeExpectation via the factory method ITypeExpectation.createUnboundTypeReference(XExpression, JvmTypeParameter) or create(ITypeExpectation, XExpression, JvmTypeParameter) respectively. Such type references may be produced in cases like val x = newArrayList where x has the inferred type ArrayList<Unbound[E]>. Unbound types may be enhanced with hints to allow the type inferrer to find the most suitable type.

Author:

Sebastian Zarnekow - Initial contribution and API

Nested Class Summary

Nested classes/interfaces inherited from class org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference

LightweightTypeReference.IdentifierFunction, LightweightTypeReference.JavaIdentifierFunction, LightweightTypeReference.SimpleNameFunction, LightweightTypeReference.UniqueIdentifierFunction

Field Summary

Fields inherited from class org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference

KIND_ANY_TYPE_REFERENCE, KIND_ARRAY_TYPE_REFERENCE, KIND_COMPOUND_TYPE_REFERENCE, KIND_FUNCTION_TYPE_REFERENCE, KIND_INNER_FUNCTION_TYPE_REFERENCE, KIND_INNER_TYPE_REFERENCE, KIND_LIGHTWEIGHT_TYPE_REFERENCE, KIND_PARAMETERIZED_TYPE_REFERENCE, KIND_UNBOUND_TYPE_REFERENCE, KIND_UNKNOWN_TYPE_REFERENCE, KIND_WILDCARD_TYPE_REFERENCE

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	UnboundTypeReference(ITypeReferenceOwner owner, XExpression expression, JvmTypeParameter typeParameter)
protected	UnboundTypeReference(ITypeReferenceOwner owner, XExpression expression, JvmTypeParameter typeParameter, Object handle)

Method Summary

Methods

Modifier and Type	Method and Description
void	accept(TypeReferenceVisitor visitor)
<Param> void	accept(TypeReferenceVisitorWithParameter<Param> visitor, Param param)
<Param,Result> Result	accept(TypeReferenceVisitorWithParameterAndResult<Param,Result> visitor, Param param)
<Result> Result	accept(TypeReferenceVisitorWithResult<Result> visitor)
void	acceptHint(LightweightBoundTypeArgument hint)
void	acceptHint(LightweightTypeReference hint, BoundTypeArgumentSource source, Object origin, VarianceInfo expectedVariance, VarianceInfo actualVariance) Attach a resolution hint to this unbound type reference.
void	acceptHint(VarianceInfo variance)
boolean	canResolveTo(LightweightTypeReference reference) Returns true if the existing hints would allow to resolve to the given reference.
protected boolean	canResolveTo(LightweightTypeReference reference, List<LightweightBoundTypeArgument> allHints)
LightweightTypeReference	copyInto(ITypeReferenceOwner owner) Always copies the reference since we want to reduce the nesting level of references if this one was resolved but points to something unresolved.
static UnboundTypeReference	create(ITypeExpectation expectation, XExpression expression, JvmTypeParameter typeParameter) Create a new, managed unbound type reference for the given type parameter which was first encountered for the given expression.
protected UnboundTypeReference	createCopy(ITypeReferenceOwner owner)
protected LightweightTypeReference	doCopyInto(ITypeReferenceOwner owner)
boolean	equalHandles(UnboundTypeReference reference)
List<LightweightBoundTypeArgument>	getAllHints()
LightweightTypeReference	getComponentType() Returns the component type of the current array type.
XExpression	getExpression()
FunctionTypeKind	getFunctionTypeKind()
Object	getHandle() Returns the identifying handle for this reference.
String	getIdentifier() Returns the identifier of this type reference.
LightweightTypeReference	getInvariantBoundSubstitute()
String	getJavaIdentifier()
int	getKind() Subclasses must override this method.
LightweightTypeReference	getLowerBoundSubstitute()
List<LightweightTypeReference>	getMultiTypeComponents()
LightweightTypeReference	getPrimitiveIfWrapperType()
Primitives.Primitive	getPrimitiveKind()
Primitives.Primitive	getPrimitiveKindIfWrapperType()
LightweightTypeReference	getResolvedTo() Returns the resolved reference for this unbound reference.
String	getSimpleName() Prints the simple name of this type reference.
LightweightTypeReference	getSuperType(Class<?> rawType) Returns the resolved super type for the given raw type or null if the raw type is not a valid super type of this type.
LightweightTypeReference	getSuperType(JvmType rawType) Returns the resolved super type for the given raw type or null if the raw type is not a valid super type of this type.
protected List<LightweightTypeReference>	getSuperTypes(TypeParameterSubstitutor<?> substitutor)
JvmType	getType()
List<LightweightTypeReference>	getTypeArguments() Returns the type arguments of this reference if it has any.
JvmTypeParameter	getTypeParameter()
String	getUniqueIdentifier() Returns an identifier that allows to disambiguate type parameter names that have different origins.
LightweightTypeReference	getUpperBoundSubstitute()
LightweightTypeReference	getWrapperTypeIfPrimitive()
boolean	hasSignificantHints()
boolean	hasSignificantHints(List<LightweightBoundTypeArgument> hints)
protected boolean	hasSignificantHints(List<LightweightBoundTypeArgument> hints, boolean constraintsAreSignificant)
boolean	hasTypeArguments()
LightweightTypeReference	internalGetResolvedTo()
boolean	internalIsResolved()
boolean	isAnonymous()
boolean	isAny()
boolean	isArray()
boolean	isInterfaceType()
boolean	isMultiType()
boolean	isPrimitive()
boolean	isPrimitiveVoid()
boolean	isRawType() Returns true is this type points to a raw type.
boolean	isResolved()
boolean	isSynonym()
boolean	isType(Class<?> clazz) Returns true if this type reference represents an type with the given raw type clazz.
boolean	isUnknown()
boolean	isVisible(IVisibilityHelper visibilityHelper) Returns true if this type is fully visible according to the given visibilityHelper.
boolean	isWildcard()
boolean	isWrapper()
protected void	propageResolvedTypeToConstraints(List<LightweightBoundTypeArgument> hints)
LightweightTypeReference	resolve() Force this reference to be resolved.
protected void	resolveAgainstConstraints()
protected boolean	resolveWithHints(List<LightweightBoundTypeArgument> allHints)
JvmTypeReference	toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper) Converts this type reference to a JvmTypeReference that can be used in Java source code.
LightweightTypeReference	toJavaType() Converts types to references that can be expressed as Java type references in source code.
JvmTypeReference	toTypeReference()
ArrayTypeReference	tryConvertToArray() Returns the array representation of this reference if its represents a subtype of Iterable or already an array itself.
FunctionTypeReference	tryConvertToFunctionTypeReference(boolean rawType) Converts this reference to a FunctionTypeReference if the referenced type is a SAM type.
LightweightTypeReference	tryConvertToListType() Returns the list representation of this reference if it represents an array or is already a subtype of List.
void	tryResolve() Try to resolve this reference iff there are hints available.
void	tryResolve(boolean constraintsAreSignificant) Try to resolve this reference iff there are hints available.

Methods inherited from class org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference

collectSuperTypes, collectSuperTypes, createSubstitutor, expose, findNonNullType, findType, getAllSuperTypes, getAsFunctionTypeReference, getHumanReadableName, getNamedType, getNonInterfaceTypes, getOuter, getOwner, getRawTypeReference, getRawTypes, getServices, getSuperTypes, getTypesFactory, getUniqueIdentifier, internalFindTopLevelType, internalIsAssignableFrom, isAssignableFrom, isAssignableFrom, isAssignableFrom, isAssignableFrom, isFunctionType, isOwnedBy, isSubtypeOf, isSubtypeOf, isValidHint, toJavaCompliantTypeReference, toJavaCompliantTypeReference, toString

Methods inherited from class java.lang.Object

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

Constructor Detail

UnboundTypeReference

protected UnboundTypeReference(ITypeReferenceOwner owner,
                    XExpression expression,
                    JvmTypeParameter typeParameter)

UnboundTypeReference

protected UnboundTypeReference(ITypeReferenceOwner owner,
                    XExpression expression,
                    JvmTypeParameter typeParameter,
                    Object handle)

Method Detail

create

public static UnboundTypeReference create(ITypeExpectation expectation,
                          XExpression expression,
                          JvmTypeParameter typeParameter)

Create a new, managed unbound type reference for the given type parameter which was first encountered for the given expression.

Parameters:

expression - the expression that used / referenced the type parameter

typeParameter - the type parameter

expectation - the decision path that uses the type parameter

getKind

public int getKind()

Subclasses must override this method.

Overrides:

getKind in class LightweightTypeReference

getExpression

public XExpression getExpression()

createCopy

protected UnboundTypeReference createCopy(ITypeReferenceOwner owner)

tryResolve

public void tryResolve()

Try to resolve this reference iff there are hints available. May be invoked multiple times since it will simply returns if the reference is already resolved. This is fully equivalent to tryResolve(true).

See Also:

tryResolve(boolean)

tryResolve

public void tryResolve(boolean constraintsAreSignificant)

Try to resolve this reference iff there are hints available. May be invoked multiple times since it will simply returns if the reference is already resolved. The caller can decide whether type constraints are considered to be significant hints or not.

canResolveTo

public boolean canResolveTo(LightweightTypeReference reference)

Returns true if the existing hints would allow to resolve to the given reference.

hasSignificantHints

public boolean hasSignificantHints()

hasSignificantHints

public boolean hasSignificantHints(List<LightweightBoundTypeArgument> hints)

hasSignificantHints

protected boolean hasSignificantHints(List<LightweightBoundTypeArgument> hints,
                          boolean constraintsAreSignificant)

toTypeReference

public JvmTypeReference toTypeReference()

Specified by:

toTypeReference in class LightweightTypeReference

toJavaCompliantTypeReference

public JvmTypeReference toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper)

Description copied from class: LightweightTypeReference

Converts this type reference to a JvmTypeReference that can be used in Java source code.

Specified by:

toJavaCompliantTypeReference in class LightweightTypeReference

isRawType

public boolean isRawType()

Description copied from class: LightweightTypeReference

Returns true is this type points to a raw type. That is, it points to a parameterized type but does not define type arguments or it points to an external type parameter that has a raw type constraint. Type parameters that are declared by the current owner are not considered to be raw types. A type is also a raw type if it inherits from a raw type.

Overrides:

isRawType in class LightweightTypeReference

isAnonymous

public boolean isAnonymous()

Overrides:

isAnonymous in class LightweightTypeReference

getTypeParameter

public JvmTypeParameter getTypeParameter()

getHandle

public Object getHandle()

Returns the identifying handle for this reference.

See Also:

handle

getResolvedTo

public LightweightTypeReference getResolvedTo()

Returns the resolved reference for this unbound reference. It does not try to resolve this reference but only returns the resolved representation if this one was resolved by other clients explicitly.

Returns:

the resolved reference or null.

getUpperBoundSubstitute

public LightweightTypeReference getUpperBoundSubstitute()

Overrides:

getUpperBoundSubstitute in class LightweightTypeReference

getLowerBoundSubstitute

public LightweightTypeReference getLowerBoundSubstitute()

Overrides:

getLowerBoundSubstitute in class LightweightTypeReference

getInvariantBoundSubstitute

public LightweightTypeReference getInvariantBoundSubstitute()

Overrides:

getInvariantBoundSubstitute in class LightweightTypeReference

resolve

public LightweightTypeReference resolve()

Force this reference to be resolved. If not hints are available, the reference is resolved to the constraints of the type parameters.

Returns:

the resolved representation. Never null.

resolveAgainstConstraints

protected void resolveAgainstConstraints()

canResolveTo

protected boolean canResolveTo(LightweightTypeReference reference,
                   List<LightweightBoundTypeArgument> allHints)

resolveWithHints

protected boolean resolveWithHints(List<LightweightBoundTypeArgument> allHints)

propageResolvedTypeToConstraints

protected void propageResolvedTypeToConstraints(List<LightweightBoundTypeArgument> hints)

copyInto

public LightweightTypeReference copyInto(ITypeReferenceOwner owner)

Always copies the reference since we want to reduce the nesting level of references if this one was resolved but points to something unresolved. In that case, we only want to copy the remaining unresolved parts. Otherwise we copy this reference.

Overrides:

copyInto in class LightweightTypeReference

isResolved

public boolean isResolved()

Overrides:

isResolved in class LightweightTypeReference

internalIsResolved

public boolean internalIsResolved()

internalGetResolvedTo

public LightweightTypeReference internalGetResolvedTo()

getTypeArguments

public List<LightweightTypeReference> getTypeArguments()

Description copied from class: LightweightTypeReference

Returns the type arguments of this reference if it has any. The type argument of List<String> is String. is also the type argument of a wildcard reference with upper bound ? extends List<String>. Raw types don't carry type arguments. Wildcards with more than one upper bound don't carry type arguments.

Overrides:

getTypeArguments in class LightweightTypeReference

hasTypeArguments

public boolean hasTypeArguments()

Overrides:

hasTypeArguments in class LightweightTypeReference

isArray

public boolean isArray()

Overrides:

isArray in class LightweightTypeReference

isVisible

public boolean isVisible(IVisibilityHelper visibilityHelper)

Description copied from class: LightweightTypeReference

Returns true if this type is fully visible according to the given visibilityHelper. All components and bounds are taken into account, e.g. arrays use their component type and generified types check their type arguments, too.

Specified by:

isVisible in class LightweightTypeReference

isAny

public boolean isAny()

Overrides:

isAny in class LightweightTypeReference

isUnknown

public boolean isUnknown()

Overrides:

isUnknown in class LightweightTypeReference

getFunctionTypeKind

public FunctionTypeKind getFunctionTypeKind()

Overrides:

getFunctionTypeKind in class LightweightTypeReference

tryConvertToArray

public ArrayTypeReference tryConvertToArray()

Description copied from class: LightweightTypeReference

Returns the array representation of this reference if its represents a subtype of Iterable or already an array itself. If the iterable's type is a primitive wrapper, the array is not the primitive array but the wrapper array. May return null if the conversion is not possible.

Overrides:

tryConvertToArray in class LightweightTypeReference

Returns:

an equivalent ArrayTypeReference or null.

tryConvertToFunctionTypeReference

public FunctionTypeReference tryConvertToFunctionTypeReference(boolean rawType)

Description copied from class: LightweightTypeReference

Converts this reference to a FunctionTypeReference if the referenced type is a SAM type. Returns null if this reference does not point to a valid function type.

Overrides:

tryConvertToFunctionTypeReference in class LightweightTypeReference

Parameters:

rawType - if a raw view on the function type is sufficient.

See Also:

LightweightTypeReference.getAsFunctionTypeReference()

tryConvertToListType

public LightweightTypeReference tryConvertToListType()

Description copied from class: LightweightTypeReference

Returns the list representation of this reference if it represents an array or is already a subtype of List. If the array's type is a primitive, the list's element type is the wrapper. May return null if the conversion is not possible.

Overrides:

tryConvertToListType in class LightweightTypeReference

Returns:

an equivalent list type or null.

getComponentType

public LightweightTypeReference getComponentType()

Description copied from class: LightweightTypeReference

Returns the component type of the current array type. Does not attempt to convert this reference from iterable to array, first.

Overrides:

getComponentType in class LightweightTypeReference

Returns:

the compoent type of the current array or null.

See Also:

LightweightTypeReference.isArray()

isWrapper

public boolean isWrapper()

Overrides:

isWrapper in class LightweightTypeReference

isPrimitive

public boolean isPrimitive()

Overrides:

isPrimitive in class LightweightTypeReference

getPrimitiveKind

public Primitives.Primitive getPrimitiveKind()

Overrides:

getPrimitiveKind in class LightweightTypeReference

getPrimitiveKindIfWrapperType

public Primitives.Primitive getPrimitiveKindIfWrapperType()

Overrides:

getPrimitiveKindIfWrapperType in class LightweightTypeReference

isPrimitiveVoid

public boolean isPrimitiveVoid()

Overrides:

isPrimitiveVoid in class LightweightTypeReference

isInterfaceType

public boolean isInterfaceType()

Overrides:

isInterfaceType in class LightweightTypeReference

getPrimitiveIfWrapperType

public LightweightTypeReference getPrimitiveIfWrapperType()

Overrides:

getPrimitiveIfWrapperType in class LightweightTypeReference

getType

public JvmType getType()

Specified by:

getType in class LightweightTypeReference

isType

public boolean isType(Class<?> clazz)

Description copied from class: LightweightTypeReference

Returns true if this type reference represents an type with the given raw type clazz. Returns false if this is not exactly the given type, but a sub type, a super type or a completely unrelated type.

Specified by:

isType in class LightweightTypeReference

getSuperTypes

protected List<LightweightTypeReference> getSuperTypes(TypeParameterSubstitutor<?> substitutor)

Specified by:

getSuperTypes in class LightweightTypeReference

getSuperType

public LightweightTypeReference getSuperType(JvmType rawType)

Description copied from class: LightweightTypeReference

Returns the resolved super type for the given raw type or null if the raw type is not a valid super type of this type.

Overrides:

getSuperType in class LightweightTypeReference

Parameters:

rawType - the raw type that should be resolved.

Returns:

the resolved super type.

getSuperType

public LightweightTypeReference getSuperType(Class<?> rawType)

Description copied from class: LightweightTypeReference

Returns the resolved super type for the given raw type or null if the raw type is not a valid super type of this type.

Overrides:

getSuperType in class LightweightTypeReference

Parameters:

rawType - the raw type that should be resolved.

Returns:

the resolved super type.

getWrapperTypeIfPrimitive

public LightweightTypeReference getWrapperTypeIfPrimitive()

Overrides:

getWrapperTypeIfPrimitive in class LightweightTypeReference

doCopyInto

protected LightweightTypeReference doCopyInto(ITypeReferenceOwner owner)

Specified by:

doCopyInto in class LightweightTypeReference

getSimpleName

public String getSimpleName()

Description copied from class: LightweightTypeReference

Prints the simple name of this type reference. Useful for testing.

Specified by:

getSimpleName in class LightweightTypeReference

getIdentifier

public String getIdentifier()

Description copied from class: LightweightTypeReference

Returns the identifier of this type reference. Usually the qualified name with a dollar delimiter.

Specified by:

getIdentifier in class LightweightTypeReference

getUniqueIdentifier

public String getUniqueIdentifier()

Description copied from class: LightweightTypeReference

Returns an identifier that allows to disambiguate type parameter names that have different origins. Rather than just giving the name of the type parameter, it also prints the declarator.

Specified by:

getUniqueIdentifier in class LightweightTypeReference

getJavaIdentifier

public String getJavaIdentifier()

Specified by:

getJavaIdentifier in class LightweightTypeReference

accept

public void accept(TypeReferenceVisitor visitor)

Overrides:

accept in class LightweightTypeReference

accept

public <Param> void accept(TypeReferenceVisitorWithParameter<Param> visitor,
                  Param param)

Overrides:

accept in class LightweightTypeReference

accept

public <Result> Result accept(TypeReferenceVisitorWithResult<Result> visitor)

Overrides:

accept in class LightweightTypeReference

accept

public <Param,Result> Result accept(TypeReferenceVisitorWithParameterAndResult<Param,Result> visitor,
                           Param param)

Overrides:

accept in class LightweightTypeReference

acceptHint

public void acceptHint(VarianceInfo variance)

acceptHint

public void acceptHint(LightweightTypeReference hint,
              BoundTypeArgumentSource source,
              Object origin,
              VarianceInfo expectedVariance,
              VarianceInfo actualVariance)

Attach a resolution hint to this unbound type reference.

Only valid hints can be accepted. The given source indicates the quality of this hint. The variances indicate how the hint was used and how it was expected to be used. A hint from a co-variant location may not have the same impact for a contra-variant usage as a contra-variant hint. Consider a return type of a method

<T> Collection<? extends T> m(..) { }

and its usage

Collection<? super CharSequence> variable = m(..)

The hint that stems from the variable declaration may not be very useful since the variances are not compatible. Nevertheless, it can be accepted to produce better error messages.

Parameters:

hint - the reference that provides the hint.

source - the source of this hint, e.g. an inferred hint, or an expectation.

origin - the object that produced the hint. Only for debugging purpose to trace the origin of a hint.

expectedVariance - the expected variance, e.g. where this unbound type reference is used.

actualVariance - how the hint is used.

See Also:

LightweightTypeReference.isValidHint()

acceptHint

public void acceptHint(LightweightBoundTypeArgument hint)

getAllHints

public List<LightweightBoundTypeArgument> getAllHints()

equalHandles

public boolean equalHandles(UnboundTypeReference reference)

isWildcard

public boolean isWildcard()

Overrides:

isWildcard in class LightweightTypeReference

isMultiType

public boolean isMultiType()

Overrides:

isMultiType in class LightweightTypeReference

isSynonym

public boolean isSynonym()

Overrides:

isSynonym in class LightweightTypeReference

toJavaType

public LightweightTypeReference toJavaType()

Description copied from class: LightweightTypeReference

Converts types to references that can be expressed as Java type references in source code. Any types will be expressed as Object whereas multi types will be expressed as their common super type. Unknown types are considered to be ok thus returned as is.

Overrides:

toJavaType in class LightweightTypeReference

getMultiTypeComponents

public List<LightweightTypeReference> getMultiTypeComponents()

Overrides:

getMultiTypeComponents in class LightweightTypeReference