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 concreteITypeExpectation
via the factory methodITypeExpectation.createUnboundTypeReference(XExpression, JvmTypeParameter)
orcreate(ITypeExpectation, XExpression, JvmTypeParameter)
respectively. Such type references may be produced in cases likeval x = newArrayList
wherex
has the inferred typeArrayList<Unbound[E]>
. Unbound types may be enhanced withhints
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 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 Description void
accept(TypeReferenceVisitor visitor)
<Param> void
accept(TypeReferenceVisitorWithParameter<Param> visitor, Param param)
<Param,Result>
Resultaccept(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.LightweightTypeReference
getConstraintSubstitute()
Returns the constraint type of this reference.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()
Returns the invariant bound of this reference.java.lang.String
getJavaIdentifier()
int
getKind()
Subclasses must override this method.LightweightTypeReference
getLowerBoundSubstitute()
Returns the lower bound of this reference.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 ornull
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()
Returns the upper bound of this reference.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()
Returnstrue
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 typeclazz
.boolean
isUnknown()
boolean
isVisible(IVisibilityHelper visibilityHelper)
Returnstrue
if this type is fully visible according to the givenvisibilityHelper
.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 aJvmTypeReference
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 ofIterable
or already an array itself.FunctionTypeReference
tryConvertToFunctionTypeReference(boolean rawType)
Converts this reference to aFunctionTypeReference
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 ofList
.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
-
-
-
-
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 parametertypeParameter
- the type parameterexpectation
- the decision path that uses the type parameter
-
getKind
public int getKind()
Subclasses must override this method.- Overrides:
getKind
in classLightweightTypeReference
-
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 totryResolve(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 classLightweightTypeReference
-
toJavaCompliantTypeReference
public org.eclipse.xtext.common.types.JvmTypeReference toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper)
Description copied from class:LightweightTypeReference
Converts this type reference to aJvmTypeReference
that can be used in Java source code.- Specified by:
toJavaCompliantTypeReference
in classLightweightTypeReference
-
isRawType
public boolean isRawType()
Description copied from class:LightweightTypeReference
Returnstrue
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 classLightweightTypeReference
-
isAnonymous
public boolean isAnonymous()
- Overrides:
isAnonymous
in classLightweightTypeReference
-
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()
Description copied from class:LightweightTypeReference
Returns the upper bound of this reference. The upper bound of a wildcard reference is its upper constraint, e.g.? extends CharSequence
has the upper boundCharSequence
.- Overrides:
getUpperBoundSubstitute
in classLightweightTypeReference
-
getLowerBoundSubstitute
public LightweightTypeReference getLowerBoundSubstitute()
Description copied from class:LightweightTypeReference
Returns the lower bound of this reference. The lower bound of a wildcard reference is its lower constraint, e.g.? super CharSequence
has the upper boundCharSequence
.- Overrides:
getLowerBoundSubstitute
in classLightweightTypeReference
-
getInvariantBoundSubstitute
public LightweightTypeReference getInvariantBoundSubstitute()
Description copied from class:LightweightTypeReference
Returns the invariant bound of this reference. The invariant bound of a wildcard reference is its lower constraint, if any. Otherwise it's the upper bound.- Overrides:
getInvariantBoundSubstitute
in classLightweightTypeReference
-
getConstraintSubstitute
public LightweightTypeReference getConstraintSubstitute()
Description copied from class:LightweightTypeReference
Returns the constraint type of this reference. The constraint of a type parameter is its declared super type.T extends CharSequence & Serializable
has a compound constraint substitute of the formCharSequence & Serializable
.- Overrides:
getConstraintSubstitute
in classLightweightTypeReference
-
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 classLightweightTypeReference
-
isResolved
public boolean isResolved()
- Overrides:
isResolved
in classLightweightTypeReference
-
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 ofList<String>
isString
.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 classLightweightTypeReference
-
hasTypeArguments
public boolean hasTypeArguments()
- Overrides:
hasTypeArguments
in classLightweightTypeReference
-
isArray
public boolean isArray()
- Overrides:
isArray
in classLightweightTypeReference
-
isVisible
public boolean isVisible(IVisibilityHelper visibilityHelper)
Description copied from class:LightweightTypeReference
Returnstrue
if this type is fully visible according to the givenvisibilityHelper
. All components and bounds are taken into account, e.g.arrays
use theircomponent type
andgenerified types
check their type arguments, too.- Specified by:
isVisible
in classLightweightTypeReference
-
isAny
public boolean isAny()
- Overrides:
isAny
in classLightweightTypeReference
-
isUnknown
public boolean isUnknown()
- Overrides:
isUnknown
in classLightweightTypeReference
-
getFunctionTypeKind
public FunctionTypeKind getFunctionTypeKind()
- Overrides:
getFunctionTypeKind
in classLightweightTypeReference
-
tryConvertToArray
public ArrayTypeReference tryConvertToArray()
Description copied from class:LightweightTypeReference
Returns the array representation of this reference if its represents a subtype ofIterable
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 returnnull
if the conversion is not possible.- Overrides:
tryConvertToArray
in classLightweightTypeReference
- Returns:
- an equivalent
ArrayTypeReference
ornull
.
-
tryConvertToFunctionTypeReference
public FunctionTypeReference tryConvertToFunctionTypeReference(boolean rawType)
Description copied from class:LightweightTypeReference
Converts this reference to aFunctionTypeReference
if the referenced type is a SAM type. Returnsnull
if this reference does not point to a valid function type.- Overrides:
tryConvertToFunctionTypeReference
in classLightweightTypeReference
- 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 ofList
. If the array's type is a primitive, the list's element type is the wrapper. May returnnull
if the conversion is not possible.- Overrides:
tryConvertToListType
in classLightweightTypeReference
- 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 classLightweightTypeReference
- Returns:
- the compoent type of the current array or
null
. - See Also:
LightweightTypeReference.isArray()
-
isWrapper
public boolean isWrapper()
- Overrides:
isWrapper
in classLightweightTypeReference
-
isPrimitive
public boolean isPrimitive()
- Overrides:
isPrimitive
in classLightweightTypeReference
-
getPrimitiveKind
public org.eclipse.xtext.common.types.util.Primitives.Primitive getPrimitiveKind()
- Overrides:
getPrimitiveKind
in classLightweightTypeReference
-
getPrimitiveKindIfWrapperType
public org.eclipse.xtext.common.types.util.Primitives.Primitive getPrimitiveKindIfWrapperType()
- Overrides:
getPrimitiveKindIfWrapperType
in classLightweightTypeReference
-
isPrimitiveVoid
public boolean isPrimitiveVoid()
- Overrides:
isPrimitiveVoid
in classLightweightTypeReference
-
isInterfaceType
public boolean isInterfaceType()
- Overrides:
isInterfaceType
in classLightweightTypeReference
-
getPrimitiveIfWrapperType
public LightweightTypeReference getPrimitiveIfWrapperType()
- Overrides:
getPrimitiveIfWrapperType
in classLightweightTypeReference
-
getType
public org.eclipse.xtext.common.types.JvmType getType()
- Specified by:
getType
in classLightweightTypeReference
-
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 typeclazz
. 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 classLightweightTypeReference
-
getSuperTypes
protected java.util.List<LightweightTypeReference> getSuperTypes(TypeParameterSubstitutor<?> substitutor)
- Specified by:
getSuperTypes
in classLightweightTypeReference
-
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 classLightweightTypeReference
- 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 ornull
if the raw type is not a valid super type of this type.- Overrides:
getSuperType
in classLightweightTypeReference
- Parameters:
rawType
- the raw type that should be resolved.- Returns:
- the resolved super type.
-
getWrapperTypeIfPrimitive
public LightweightTypeReference getWrapperTypeIfPrimitive()
- Overrides:
getWrapperTypeIfPrimitive
in classLightweightTypeReference
-
doCopyInto
protected LightweightTypeReference doCopyInto(ITypeReferenceOwner owner)
- Specified by:
doCopyInto
in classLightweightTypeReference
-
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 classLightweightTypeReference
-
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 classLightweightTypeReference
-
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 classLightweightTypeReference
-
getJavaIdentifier
public java.lang.String getJavaIdentifier()
- Specified by:
getJavaIdentifier
in classLightweightTypeReference
-
accept
public void accept(TypeReferenceVisitor visitor)
- Overrides:
accept
in classLightweightTypeReference
-
accept
public <Param> void accept(TypeReferenceVisitorWithParameter<Param> visitor, Param param)
- Overrides:
accept
in classLightweightTypeReference
-
accept
public <Result> Result accept(TypeReferenceVisitorWithResult<Result> visitor)
- Overrides:
accept
in classLightweightTypeReference
-
accept
public <Param,Result> Result accept(TypeReferenceVisitorWithParameterAndResult<Param,Result> visitor, Param param)
- Overrides:
accept
in classLightweightTypeReference
-
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. Thevariances
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(..) { }
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 classLightweightTypeReference
-
isMultiType
public boolean isMultiType()
- Overrides:
isMultiType
in classLightweightTypeReference
-
isSynonym
public boolean isSynonym()
- Overrides:
isSynonym
in classLightweightTypeReference
-
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 classLightweightTypeReference
-
getMultiTypeComponents
public java.util.List<LightweightTypeReference> getMultiTypeComponents()
- Overrides:
getMultiTypeComponents
in classLightweightTypeReference
-
-