UnboundTypeReference (org.eclipse.xtext.xbase 2.12.0.M1 API)

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.

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, org.eclipse.xtext.common.types.JvmTypeParameter typeParameter)`
`protected`	`UnboundTypeReference(ITypeReferenceOwner owner, XExpression expression, org.eclipse.xtext.common.types.JvmTypeParameter typeParameter, java.lang.Object handle)`

Method Summary

All Methods Static Methods Instance Methods Concrete 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, java.lang.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, java.util.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, org.eclipse.xtext.common.types.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)`
`java.util.List<LightweightBoundTypeArgument>`	`getAllHints()`
`LightweightTypeReference`	`getComponentType()` Returns the component type of the current array type.
`XExpression`	`getExpression()`
`FunctionTypeKind`	`getFunctionTypeKind()`
`java.lang.Object`	`getHandle()` Returns the identifying handle for this reference.
`java.lang.String`	`getIdentifier()` Returns the identifier of this type reference.
`LightweightTypeReference`	`getInvariantBoundSubstitute()`
`java.lang.String`	`getJavaIdentifier()`
`int`	`getKind()` Subclasses must override this method.
`LightweightTypeReference`	`getLowerBoundSubstitute()`
`java.util.List<LightweightTypeReference>`	`getMultiTypeComponents()`
`LightweightTypeReference`	`getPrimitiveIfWrapperType()`
`org.eclipse.xtext.common.types.util.Primitives.Primitive`	`getPrimitiveKind()`
`org.eclipse.xtext.common.types.util.Primitives.Primitive`	`getPrimitiveKindIfWrapperType()`
`LightweightTypeReference`	`getResolvedTo()` Returns the resolved reference for this unbound reference.
`java.lang.String`	`getSimpleName()` Prints the simple name of this type reference.
`LightweightTypeReference`	`getSuperType(java.lang.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(org.eclipse.xtext.common.types.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 java.util.List<LightweightTypeReference>`	`getSuperTypes(TypeParameterSubstitutor<?> substitutor)`
`org.eclipse.xtext.common.types.JvmType`	`getType()`
`java.util.List<LightweightTypeReference>`	`getTypeArguments()` Returns the type arguments of this reference if it has any.
`org.eclipse.xtext.common.types.JvmTypeParameter`	`getTypeParameter()`
`java.lang.String`	`getUniqueIdentifier()` Returns an identifier that allows to disambiguate type parameter names that have different origins.
`LightweightTypeReference`	`getUpperBoundSubstitute()`
`LightweightTypeReference`	`getWrapperTypeIfPrimitive()`
`boolean`	`hasSignificantHints()`
`boolean`	`hasSignificantHints(java.util.List<LightweightBoundTypeArgument> hints)`
`protected boolean`	`hasSignificantHints(java.util.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(java.lang.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(java.util.List<LightweightBoundTypeArgument> hints)`
`LightweightTypeReference`	`resolve()` Force this reference to be resolved.
`protected void`	`resolveAgainstConstraints()`
`protected boolean`	`resolveWithHints(java.util.List<LightweightBoundTypeArgument> allHints)`
`org.eclipse.xtext.common.types.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.
`org.eclipse.xtext.common.types.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,
                               org.eclipse.xtext.common.types.JvmTypeParameter typeParameter)
```
  - UnboundTypeReference
```
protected UnboundTypeReference(ITypeReferenceOwner owner,
                               XExpression expression,
                               org.eclipse.xtext.common.types.JvmTypeParameter typeParameter,
                               java.lang.Object handle)
```
- Method Detail
  - create
```
public static UnboundTypeReference create(ITypeExpectation expectation,
                                          XExpression expression,
                                          org.eclipse.xtext.common.types.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(java.util.List<LightweightBoundTypeArgument> hints)
```
  - hasSignificantHints
```
protected boolean hasSignificantHints(java.util.List<LightweightBoundTypeArgument> hints,
                                      boolean constraintsAreSignificant)
```
  - toTypeReference
```
public org.eclipse.xtext.common.types.JvmTypeReference toTypeReference()
```
    Specified by:
    
    toTypeReference in class LightweightTypeReference
  - toJavaCompliantTypeReference
```
public org.eclipse.xtext.common.types.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 org.eclipse.xtext.common.types.JvmTypeParameter getTypeParameter()
```
  - getHandle
```
public java.lang.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,
                               java.util.List<LightweightBoundTypeArgument> allHints)
```
  - resolveWithHints
```
protected boolean resolveWithHints(java.util.List<LightweightBoundTypeArgument> allHints)
```
  - propageResolvedTypeToConstraints
```
protected void propageResolvedTypeToConstraints(java.util.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 java.util.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 org.eclipse.xtext.common.types.util.Primitives.Primitive getPrimitiveKind()
```
    Overrides:
    
    getPrimitiveKind in class LightweightTypeReference
  - getPrimitiveKindIfWrapperType
```
public org.eclipse.xtext.common.types.util.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 org.eclipse.xtext.common.types.JvmType getType()
```
    Specified by:
    
    getType in class LightweightTypeReference
  - isType
```
public boolean isType(java.lang.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 java.util.List<LightweightTypeReference> getSuperTypes(TypeParameterSubstitutor<?> substitutor)
```
    Specified by:
    
    getSuperTypes in class LightweightTypeReference
  - getSuperType
```
public LightweightTypeReference getSuperType(org.eclipse.xtext.common.types.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(java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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,
                       java.lang.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 java.util.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 java.util.List<LightweightTypeReference> getMultiTypeComponents()
```
    Overrides:
    
    getMultiTypeComponents in class LightweightTypeReference

Class UnboundTypeReference

Nested Class Summary

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

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

UnboundTypeReference

UnboundTypeReference

Method Detail

create

getKind

getExpression

createCopy

tryResolve

tryResolve

canResolveTo

hasSignificantHints

hasSignificantHints

hasSignificantHints

toTypeReference

toJavaCompliantTypeReference

isRawType

isAnonymous

getTypeParameter

getHandle

getResolvedTo

getUpperBoundSubstitute

getLowerBoundSubstitute

getInvariantBoundSubstitute

resolve

resolveAgainstConstraints

canResolveTo

resolveWithHints

propageResolvedTypeToConstraints

copyInto

isResolved

internalIsResolved

internalGetResolvedTo

getTypeArguments

hasTypeArguments

isArray

isVisible

isAny

isUnknown

getFunctionTypeKind

tryConvertToArray

tryConvertToFunctionTypeReference

tryConvertToListType

getComponentType

isWrapper

isPrimitive

getPrimitiveKind

getPrimitiveKindIfWrapperType

isPrimitiveVoid

isInterfaceType

getPrimitiveIfWrapperType

getType

isType

getSuperTypes

getSuperType

getSuperType

getWrapperTypeIfPrimitive

doCopyInto

getSimpleName

getIdentifier

getUniqueIdentifier

getJavaIdentifier

accept

accept

accept

accept

acceptHint

acceptHint

acceptHint

getAllHints

equalHandles