LightweightTypeReference (Xbase Runtime Library 2.9.0 API)

java.lang.Object
- org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference

Direct Known Subclasses:

AnyTypeReference, ArrayTypeReference, CompoundTypeReference, ParameterizedTypeReference, UnboundTypeReference, UnknownTypeReference, WildcardTypeReference
```
public abstract class LightweightTypeReference
extends Object
```
Author:

Sebastian Zarnekow - Initial contribution and API TODO document the purpose of this class - get rid of containment constraints - easier copying - isResolved - getSynonyms - getSuperTypes (resolved) - isAssignableFrom - collectSuperTypes - getAllSuperTypes ?? - getFeatures (returns feature handles?) - getFeatureByName

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`LightweightTypeReference.IdentifierFunction`
`static class`	`LightweightTypeReference.JavaIdentifierFunction`
`static class`	`LightweightTypeReference.SimpleNameFunction`
`static class`	`LightweightTypeReference.UniqueIdentifierFunction`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`KIND_ANY_TYPE_REFERENCE`
`static int`	`KIND_ARRAY_TYPE_REFERENCE`
`static int`	`KIND_COMPOUND_TYPE_REFERENCE`
`static int`	`KIND_FUNCTION_TYPE_REFERENCE`
`static int`	`KIND_INNER_FUNCTION_TYPE_REFERENCE`
`static int`	`KIND_INNER_TYPE_REFERENCE`
`static int`	`KIND_LIGHTWEIGHT_TYPE_REFERENCE`
`static int`	`KIND_PARAMETERIZED_TYPE_REFERENCE`
`static int`	`KIND_UNBOUND_TYPE_REFERENCE`
`static int`	`KIND_UNKNOWN_TYPE_REFERENCE`
`static int`	`KIND_WILDCARD_TYPE_REFERENCE`

Constructor Summary

Constructors
Modifier Constructor and Description

protected LightweightTypeReference(ITypeReferenceOwner owner)

Constructors
Modifier	Constructor and Description
`protected`	`LightweightTypeReference(ITypeReferenceOwner owner)`

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)`
`protected void`	`collectSuperTypes(int level, List<LightweightTypeReference> references, TypeParameterSubstitutor<?> substitutor, SuperTypeAcceptor acceptor, Set<JvmType> seenTypes)`
`void`	`collectSuperTypes(SuperTypeAcceptor acceptor)`
`LightweightTypeReference`	`copyInto(ITypeReferenceOwner owner)`
`protected TypeParameterSubstitutor<?>`	`createSubstitutor()`
`protected abstract LightweightTypeReference`	`doCopyInto(ITypeReferenceOwner owner)`
`protected <T> List<T>`	`expose(List<T> list)`
`protected JvmType`	`findNonNullType(Class<?> type)`
`protected JvmType`	`findType(Class<?> type)`
`List<LightweightTypeReference>`	`getAllSuperTypes()` Returns the list of all super types which includes the super class and the implemented interfaces.
`FunctionTypeReference`	`getAsFunctionTypeReference()` Returns the equivalent `FunctionTypeReference` if this reference points to a `function` or `procedure` or if it is already a function type reference.
`LightweightTypeReference`	`getComponentType()` Returns the component type of the current array type.
`FunctionTypeKind`	`getFunctionTypeKind()`
`String`	`getHumanReadableName()` Prints a human readable name of this type reference.
`abstract String`	`getIdentifier()` Returns the identifier of this type reference.
`LightweightTypeReference`	`getInvariantBoundSubstitute()`
`abstract String`	`getJavaIdentifier()`
`int`	`getKind()` Subclasses must override this method.
`LightweightTypeReference`	`getLowerBoundSubstitute()`
`List<LightweightTypeReference>`	`getMultiTypeComponents()`
`LightweightTypeReference`	`getNamedType()` Returns the named type if this is an anonymous type.
`protected List<LightweightTypeReference>`	`getNonInterfaceTypes(List<LightweightTypeReference> components)`
`LightweightTypeReference`	`getOuter()`
`ITypeReferenceOwner`	`getOwner()`
`LightweightTypeReference`	`getPrimitiveIfWrapperType()`
`Primitives.Primitive`	`getPrimitiveKind()`
`Primitives.Primitive`	`getPrimitiveKindIfWrapperType()`
`LightweightTypeReference`	`getRawTypeReference()`
`List<JvmType>`	`getRawTypes()`
`protected CommonTypeComputationServices`	`getServices()`
`abstract 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.
`List<LightweightTypeReference>`	`getSuperTypes()` Returns the list of immediate super types which includes the super class and the implemented interfaces.
`protected abstract List<LightweightTypeReference>`	`getSuperTypes(TypeParameterSubstitutor<?> substitutor)`
`abstract JvmType`	`getType()`
`List<LightweightTypeReference>`	`getTypeArguments()` Returns the type arguments of this reference if it has any.
`protected TypesFactory`	`getTypesFactory()`
`abstract String`	`getUniqueIdentifier()` Returns an identifier that allows to disambiguate type parameter names that have different origins.
`protected String`	`getUniqueIdentifier(JvmType type)`
`LightweightTypeReference`	`getUpperBoundSubstitute()`
`LightweightTypeReference`	`getWrapperTypeIfPrimitive()`
`boolean`	`hasTypeArguments()`
`protected LightweightTypeReference`	`internalFindTopLevelType(Class<?> rawType)`
`int`	`internalIsAssignableFrom(LightweightTypeReference reference, TypeConformanceComputationArgument argument)`
`boolean`	`isAnonymous()`
`boolean`	`isAny()`
`boolean`	`isArray()`
`boolean`	`isAssignableFrom(Class<?> clazz)` Determines if this type reference denotes the same type or a supertype of the given `clazz`.
`boolean`	`isAssignableFrom(JvmType type)` Determines if this type reference denotes the same type or a supertype of the given `type`.
`boolean`	`isAssignableFrom(LightweightTypeReference reference)` Determines if this type reference denotes the same or a supertype of the given `reference`.
`boolean`	`isAssignableFrom(LightweightTypeReference reference, TypeConformanceComputationArgument argument)`
`boolean`	`isFunctionType()`
`boolean`	`isInterfaceType()`
`boolean`	`isMultiType()`
`boolean`	`isOwnedBy(ITypeReferenceOwner owner)`
`boolean`	`isPrimitive()`
`boolean`	`isPrimitiveVoid()`
`boolean`	`isRawType()` Returns `true` is this type points to a raw type.
`boolean`	`isResolved()`
`boolean`	`isSubtypeOf(Class<?> clazz)` Determines if this type reference denotes the same type or a subtype of the given `clazz`.
`boolean`	`isSubtypeOf(JvmType type)` Determines if this type reference denotes the same type or a subtype of the given `type`.
`boolean`	`isSynonym()`
`abstract boolean`	`isType(Class<?> clazz)` Returns true if this type reference represents an type with the given raw type `clazz`.
`boolean`	`isUnknown()`
`boolean`	`isValidHint()` Primitive `void`, `any` and `unknown` types are not valid hints for `unbound references`.
`abstract boolean`	`isVisible(IVisibilityHelper visibilityHelper)` Returns `true` if this type is fully visible according to the given `visibilityHelper`.
`boolean`	`isWildcard()`
`boolean`	`isWrapper()`
`JvmTypeReference`	`toJavaCompliantTypeReference()` Converts this type reference to a `JvmTypeReference` that can be used in Java source code.
`abstract JvmTypeReference`	`toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper)` Converts this type reference to a `JvmTypeReference` that can be used in Java source code.
`protected JvmTypeReference`	`toJavaCompliantTypeReference(List<LightweightTypeReference> types, IVisibilityHelper visibilityHelper)`
`LightweightTypeReference`	`toJavaType()` Converts types to references that can be expressed as Java type references in source code.
`String`	`toString()`
`abstract 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`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - KIND_LIGHTWEIGHT_TYPE_REFERENCE
```
public static final int KIND_LIGHTWEIGHT_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_ANY_TYPE_REFERENCE
```
public static final int KIND_ANY_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_ARRAY_TYPE_REFERENCE
```
public static final int KIND_ARRAY_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_COMPOUND_TYPE_REFERENCE
```
public static final int KIND_COMPOUND_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_PARAMETERIZED_TYPE_REFERENCE
```
public static final int KIND_PARAMETERIZED_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_UNBOUND_TYPE_REFERENCE
```
public static final int KIND_UNBOUND_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_UNKNOWN_TYPE_REFERENCE
```
public static final int KIND_UNKNOWN_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_WILDCARD_TYPE_REFERENCE
```
public static final int KIND_WILDCARD_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_FUNCTION_TYPE_REFERENCE
```
public static final int KIND_FUNCTION_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_INNER_TYPE_REFERENCE
```
public static final int KIND_INNER_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
  - KIND_INNER_FUNCTION_TYPE_REFERENCE
```
public static final int KIND_INNER_FUNCTION_TYPE_REFERENCE
```
    See Also:
    Constant Field Values
- Constructor Detail
  - LightweightTypeReference
```
protected LightweightTypeReference(ITypeReferenceOwner owner)
```
- Method Detail
  - getKind
```
public int getKind()
```
    Subclasses must override this method.
  - getTypeArguments
```
public List<LightweightTypeReference> getTypeArguments()
```
    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.
  - getOuter
```
public LightweightTypeReference getOuter()
```
  - hasTypeArguments
```
public boolean hasTypeArguments()
```
  - isResolved
```
public boolean isResolved()
```
  - getOwner
```
public ITypeReferenceOwner getOwner()
```
  - getTypesFactory
```
protected TypesFactory getTypesFactory()
```
  - getServices
```
protected CommonTypeComputationServices getServices()
```
  - isOwnedBy
```
public boolean isOwnedBy(ITypeReferenceOwner owner)
```
  - expose
```
protected <T> List<T> expose(List<T> list)
```
  - toTypeReference
```
public abstract JvmTypeReference toTypeReference()
```
  - toJavaCompliantTypeReference
```
public final JvmTypeReference toJavaCompliantTypeReference()
```
    Converts this type reference to a JvmTypeReference that can be used in Java source code.
  - isVisible
```
public abstract boolean isVisible(IVisibilityHelper visibilityHelper)
```
    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.
  - toJavaCompliantTypeReference
```
public abstract JvmTypeReference toJavaCompliantTypeReference(IVisibilityHelper visibilityHelper)
```
    Converts this type reference to a JvmTypeReference that can be used in Java source code.
  - toJavaCompliantTypeReference
```
protected JvmTypeReference toJavaCompliantTypeReference(List<LightweightTypeReference> types,
                                            IVisibilityHelper visibilityHelper)
```
  - getNonInterfaceTypes
```
protected List<LightweightTypeReference> getNonInterfaceTypes(List<LightweightTypeReference> components)
```
  - getType
```
public abstract JvmType getType()
```
  - getWrapperTypeIfPrimitive
```
public LightweightTypeReference getWrapperTypeIfPrimitive()
```
  - getPrimitiveIfWrapperType
```
public LightweightTypeReference getPrimitiveIfWrapperType()
```
  - getPrimitiveKind
```
public Primitives.Primitive getPrimitiveKind()
```
  - getPrimitiveKindIfWrapperType
```
public Primitives.Primitive getPrimitiveKindIfWrapperType()
```
  - getRawTypes
```
public List<JvmType> getRawTypes()
```
  - getRawTypeReference
```
public LightweightTypeReference getRawTypeReference()
```
    Returns:
    the erasure type of this type reference
  - getUpperBoundSubstitute
```
public LightweightTypeReference getUpperBoundSubstitute()
```
  - getLowerBoundSubstitute
```
public LightweightTypeReference getLowerBoundSubstitute()
```
  - getInvariantBoundSubstitute
```
public LightweightTypeReference getInvariantBoundSubstitute()
```
  - isRawType
```
public boolean isRawType()
```
    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.
  - isArray
```
public boolean isArray()
```
  - isAny
```
public boolean isAny()
```
  - isAnonymous
```
public boolean isAnonymous()
```
  - getNamedType
```
public LightweightTypeReference getNamedType()
```
    Returns the named type if this is an anonymous type.
  - isUnknown
```
public boolean isUnknown()
```
  - isValidHint
```
public boolean isValidHint()
```
    Primitive void, any and unknown types are not valid hints for unbound references.
  - tryConvertToListType
```
public LightweightTypeReference tryConvertToListType()
```
    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.
    
    Returns:
    an equivalent list type or null.
  - getComponentType
```
public LightweightTypeReference getComponentType()
```
    Returns the component type of the current array type. Does not attempt to convert this reference from iterable to array, first.
    
    Returns:
    the compoent type of the current array or null.
    See Also:
    isArray()
  - getSuperTypes
```
public List<LightweightTypeReference> getSuperTypes()
```
    Returns the list of immediate super types which includes the super class and the implemented interfaces. The type parameters of the provided super types are resolved. That means, the super type of List<String> is Collection<String> rather than Collection<E>.
    
    Returns:
    the list of super types, can be empty.
  - getSuperType
```
public 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.
    
    Parameters:
    rawType - the raw type that should be resolved.
    
    Returns:
    the resolved super type.
  - getSuperType
```
public 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.
    
    Parameters:
    rawType - the raw type that should be resolved.
    
    Returns:
    the resolved super type.
  - getAllSuperTypes
```
public List<LightweightTypeReference> getAllSuperTypes()
```
    Returns the list of all super types which includes the super class and the implemented interfaces. The type parameters of the provided super types are resolved. That means, the super types of ArrayList<String> includes List<String> and Collection<String> rather than Collection<E>.
    
    Returns:
    the list of all super types, can be empty.
  - createSubstitutor
```
protected TypeParameterSubstitutor<?> createSubstitutor()
```
  - getSuperTypes
```
protected abstract List<LightweightTypeReference> getSuperTypes(TypeParameterSubstitutor<?> substitutor)
```
  - collectSuperTypes
```
public void collectSuperTypes(SuperTypeAcceptor acceptor)
```
  - collectSuperTypes
```
protected void collectSuperTypes(int level,
                     List<LightweightTypeReference> references,
                     TypeParameterSubstitutor<?> substitutor,
                     SuperTypeAcceptor acceptor,
                     Set<JvmType> seenTypes)
```
  - isPrimitive
```
public boolean isPrimitive()
```
  - isWrapper
```
public boolean isWrapper()
```
  - isPrimitiveVoid
```
public boolean isPrimitiveVoid()
```
  - isAssignableFrom
```
public boolean isAssignableFrom(LightweightTypeReference reference)
```
    Determines if this type reference denotes the same or a supertype of the given reference.
  - isAssignableFrom
```
public boolean isAssignableFrom(LightweightTypeReference reference,
                       TypeConformanceComputationArgument argument)
```
  - internalIsAssignableFrom
```
public int internalIsAssignableFrom(LightweightTypeReference reference,
                           TypeConformanceComputationArgument argument)
```
  - isAssignableFrom
```
public boolean isAssignableFrom(Class<?> clazz)
```
    Determines if this type reference denotes the same type or a supertype of the given clazz.
  - isAssignableFrom
```
public boolean isAssignableFrom(JvmType type)
```
    Determines if this type reference denotes the same type or a supertype of the given type.
  - isSubtypeOf
```
public boolean isSubtypeOf(Class<?> clazz)
```
    Determines if this type reference denotes the same type or a subtype of the given clazz.
  - isSubtypeOf
```
public boolean isSubtypeOf(JvmType type)
```
    Determines if this type reference denotes the same type or a subtype of the given type.
  - copyInto
```
public LightweightTypeReference copyInto(ITypeReferenceOwner owner)
```
  - doCopyInto
```
protected abstract LightweightTypeReference doCopyInto(ITypeReferenceOwner owner)
```
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object
  - getSimpleName
```
public abstract String getSimpleName()
```
    Prints the simple name of this type reference. Useful for testing.
  - getHumanReadableName
```
public String getHumanReadableName()
```
    Prints a human readable name of this type reference. May be specialized by means of a custom implementation. This is the variant that should be used in the UI.
  - getIdentifier
```
public abstract String getIdentifier()
```
    Returns the identifier of this type reference. Usually the qualified name with a dollar delimiter.
  - getUniqueIdentifier
```
public abstract String getUniqueIdentifier()
```
    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.
  - getUniqueIdentifier
```
protected String getUniqueIdentifier(JvmType type)
```
  - getJavaIdentifier
```
public abstract String getJavaIdentifier()
```
  - findType
```
protected JvmType findType(Class<?> type)
```
  - internalFindTopLevelType
```
protected LightweightTypeReference internalFindTopLevelType(Class<?> rawType)
```
  - findNonNullType
```
protected JvmType findNonNullType(Class<?> type)
```
  - isType
```
public abstract boolean isType(Class<?> clazz)
```
    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.
  - accept
```
public void accept(TypeReferenceVisitor visitor)
```
  - accept
```
public <Param> void accept(TypeReferenceVisitorWithParameter<Param> visitor,
                  Param param)
```
  - accept
```
public <Result> Result accept(TypeReferenceVisitorWithResult<Result> visitor)
```
  - accept
```
public <Param,Result> Result accept(TypeReferenceVisitorWithParameterAndResult<Param,Result> visitor,
                           Param param)
```
  - isFunctionType
```
public boolean isFunctionType()
```
  - isInterfaceType
```
public boolean isInterfaceType()
```
  - getFunctionTypeKind
```
public FunctionTypeKind getFunctionTypeKind()
```
  - getAsFunctionTypeReference
```
public FunctionTypeReference getAsFunctionTypeReference()
```
    Returns the equivalent FunctionTypeReference if this reference points to a function or procedure or if it is already a function type reference. Otherwise returns null.
    
    See Also:
    tryConvertToFunctionTypeReference(boolean)
  - tryConvertToFunctionTypeReference
```
public FunctionTypeReference tryConvertToFunctionTypeReference(boolean rawType)
```
    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.
    
    Parameters:
    rawType - if a raw view on the function type is sufficient.
    See Also:
    getAsFunctionTypeReference()
  - tryConvertToArray
```
public ArrayTypeReference tryConvertToArray()
```
    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.
    
    Returns:
    an equivalent ArrayTypeReference or null.
  - isWildcard
```
public boolean isWildcard()
```
  - isMultiType
```
public boolean isMultiType()
```
  - isSynonym
```
public boolean isSynonym()
```
  - toJavaType
```
public LightweightTypeReference toJavaType()
```
    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.
  - getMultiTypeComponents
```
public List<LightweightTypeReference> getMultiTypeComponents()
```

Class LightweightTypeReference

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

KIND_LIGHTWEIGHT_TYPE_REFERENCE

KIND_ANY_TYPE_REFERENCE

KIND_ARRAY_TYPE_REFERENCE

KIND_COMPOUND_TYPE_REFERENCE

KIND_PARAMETERIZED_TYPE_REFERENCE

KIND_UNBOUND_TYPE_REFERENCE

KIND_UNKNOWN_TYPE_REFERENCE

KIND_WILDCARD_TYPE_REFERENCE

KIND_FUNCTION_TYPE_REFERENCE

KIND_INNER_TYPE_REFERENCE

KIND_INNER_FUNCTION_TYPE_REFERENCE

Constructor Detail

LightweightTypeReference

Method Detail

getKind

getTypeArguments

getOuter

hasTypeArguments

isResolved

getOwner

getTypesFactory

getServices

isOwnedBy

expose

toTypeReference

toJavaCompliantTypeReference

isVisible

toJavaCompliantTypeReference

toJavaCompliantTypeReference

getNonInterfaceTypes

getType

getWrapperTypeIfPrimitive

getPrimitiveIfWrapperType

getPrimitiveKind

getPrimitiveKindIfWrapperType

getRawTypes

getRawTypeReference

getUpperBoundSubstitute

getLowerBoundSubstitute

getInvariantBoundSubstitute

isRawType

isArray

isAny

isAnonymous

getNamedType

isUnknown

isValidHint

tryConvertToListType

getComponentType

getSuperTypes

getSuperType

getSuperType

getAllSuperTypes

createSubstitutor

getSuperTypes

collectSuperTypes

collectSuperTypes

isPrimitive

isWrapper

isPrimitiveVoid

isAssignableFrom

isAssignableFrom

internalIsAssignableFrom

isAssignableFrom

isAssignableFrom

isSubtypeOf

isSubtypeOf

copyInto

doCopyInto

toString

getSimpleName

getHumanReadableName

getIdentifier