Uses of Class
org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference

Packages that use LightweightTypeReference

Package	Description
org.eclipse.xtext.xbase.compiler
org.eclipse.xtext.xbase.compiler.output
org.eclipse.xtext.xbase.interpreter.impl
org.eclipse.xtext.xbase.scoping.batch
org.eclipse.xtext.xbase.typesystem	This package is the entry point for clients of the Xbase type inference.
org.eclipse.xtext.xbase.typesystem.arguments	Encapsulated handling of feature call arguments.
org.eclipse.xtext.xbase.typesystem.computation	This package contains the primary hooks for the actual type computation in Xbase as well as their respective base implementations.
org.eclipse.xtext.xbase.typesystem.conformance
org.eclipse.xtext.xbase.typesystem.internal
org.eclipse.xtext.xbase.typesystem.internal.util
org.eclipse.xtext.xbase.typesystem.override
org.eclipse.xtext.xbase.typesystem.references	Lightweight representations for the various JvmTypeReference which offer some rich API.
org.eclipse.xtext.xbase.typesystem.util
org.eclipse.xtext.xbase.util
org.eclipse.xtext.xbase.validation

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.compiler

Methods in org.eclipse.xtext.xbase.compiler that return LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	XbaseCompiler.appendVariableTypeAndName(XVariableDeclaration varDeclaration, ITreeAppendable appendable)
protected LightweightTypeReference	XbaseCompiler.getClosureOperationParameterType(LightweightTypeReference closureType, JvmOperation operation, int i)
protected LightweightTypeReference	XbaseCompiler.getClosureOperationReturnType(LightweightTypeReference closureType, JvmOperation operation)
protected LightweightTypeReference	XbaseCompiler.getCollectionElementType(XCollectionLiteral literal)
protected LightweightTypeReference	AbstractXbaseCompiler.getLightweightExpectedType(XExpression expr)
protected LightweightTypeReference	AbstractXbaseCompiler.getLightweightReturnType(XExpression expr)
protected LightweightTypeReference	AbstractXbaseCompiler.getLightweightType(JvmIdentifiableElement identifiable)
protected LightweightTypeReference	AbstractXbaseCompiler.getLightweightType(XExpression expr)
protected LightweightTypeReference	AbstractXbaseCompiler.getTypeForVariableDeclaration(XExpression expr)
protected LightweightTypeReference	XbaseCompiler.resolveType(XExpression element, Class<?> clazz)
protected LightweightTypeReference	AbstractXbaseCompiler.toLightweight(JvmTypeReference reference, org.eclipse.emf.ecore.EObject context)

Methods in org.eclipse.xtext.xbase.compiler with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
ISourceAppender	ISourceAppender.append(LightweightTypeReference typeRef)
IAppendable	IAppendable.append(LightweightTypeReference typeRef)
IAppendable	AbstractStringBuilderBasedAppendable.append(LightweightTypeReference typeRef)
protected void	XbaseCompiler.appendClosureParameter(JvmFormalParameter closureParam, LightweightTypeReference parameterType, ITreeAppendable appendable)
protected void	AbstractXbaseCompiler.appendDefaultLiteral(ITreeAppendable b, LightweightTypeReference type)
protected void	FeatureCallCompiler.appendNullValueUntyped(LightweightTypeReference type, org.eclipse.emf.ecore.EObject context, ITreeAppendable b)
protected boolean	XbaseCompiler.canCompileToJavaLambda(XClosure closure, LightweightTypeReference typeRef, JvmOperation operation)
ITreeAppendable	AbstractXbaseCompiler.compile(XBlockExpression expr, ITreeAppendable b, LightweightTypeReference expectedReturnType) this one trims the outer block
ITreeAppendable	AbstractXbaseCompiler.compile(XExpression obj, ITreeAppendable appendable, LightweightTypeReference expectedReturnType)
ITreeAppendable	AbstractXbaseCompiler.compile(XExpression obj, ITreeAppendable parentAppendable, LightweightTypeReference expectedReturnType, Set<JvmTypeReference> declaredExceptions)
ITreeAppendable	AbstractXbaseCompiler.compileAsJavaExpression(XExpression obj, ITreeAppendable parentAppendable, LightweightTypeReference expectedType)
protected void	TypeConvertingCompiler.doConversion(LightweightTypeReference left, LightweightTypeReference right, ITreeAppendable appendable, XExpression context, Later expression)
protected JvmOperation	TypeConvertingCompiler.findImplementingOperation(LightweightTypeReference closureType)
protected LightweightTypeReference	XbaseCompiler.getClosureOperationParameterType(LightweightTypeReference closureType, JvmOperation operation, int i)
protected LightweightTypeReference	XbaseCompiler.getClosureOperationReturnType(LightweightTypeReference closureType, JvmOperation operation)
protected void	TypeConvertingCompiler.internalToConvertedExpression(XExpression obj, ITreeAppendable appendable, LightweightTypeReference toBeConvertedTo)
protected abstract void	AbstractXbaseCompiler.internalToConvertedExpression(XExpression obj, ITreeAppendable appendable, LightweightTypeReference toBeConvertedTo)
protected boolean	AbstractXbaseCompiler.isJavaConformant(LightweightTypeReference left, LightweightTypeReference right)
protected boolean	AbstractXbaseCompiler.isUnhandledException(LightweightTypeReference thrownException, Collection<JvmTypeReference> declaredExceptions)
protected boolean	XbaseCompiler.needSyntheticSelfVariable(XClosure closure, LightweightTypeReference typeRef)
protected ITreeAppendable	XbaseCompiler.toAnonymousClass(XClosure closure, ITreeAppendable b, LightweightTypeReference type, JvmOperation operation)
protected ITreeAppendable	XbaseCompiler.toLambda(XClosure closure, ITreeAppendable b, LightweightTypeReference type, JvmOperation operation, boolean writeExplicitTargetType)

Method parameters in org.eclipse.xtext.xbase.compiler with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected boolean	AbstractXbaseCompiler.hasUnhandledException(List<LightweightTypeReference> thrownExceptions, Collection<JvmTypeReference> declaredExceptions)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.compiler.output

Methods in org.eclipse.xtext.xbase.compiler.output with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected String	ImportingStringConcatenation._getStringRepresentation(LightweightTypeReference object)
ITreeAppendable	TreeAppendable.append(LightweightTypeReference typeRef)
ITreeAppendable	ITreeAppendable.append(LightweightTypeReference typeRef)
ITreeAppendable	FakeTreeAppendable.append(LightweightTypeReference typeRef)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.interpreter.impl

Methods in org.eclipse.xtext.xbase.interpreter.impl that return LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	XbaseInterpreter.resolveType(XExpression element, Class<?> clazz)

Methods in org.eclipse.xtext.xbase.interpreter.impl with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected Object	XbaseInterpreter.getDefaultObjectValue(LightweightTypeReference type)
protected Object	XbaseInterpreter.wrapOrUnwrapArray(Object result, LightweightTypeReference expectedType)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.scoping.batch

Methods in org.eclipse.xtext.xbase.scoping.batch that return LightweightTypeReference

Modifier and Type	Method and Description
LightweightTypeReference	StaticExtensionFeatureDescriptionWithImplicitFirstArgument.getImplicitFirstArgumentType()
LightweightTypeReference	SimpleIdentifiableElementDescription.getImplicitFirstArgumentType()
LightweightTypeReference	InstanceExtensionDescriptionWithImplicitFirstArgument.getImplicitFirstArgumentType()
LightweightTypeReference	IIdentifiableElementDescription.getImplicitFirstArgumentType()
LightweightTypeReference	BucketedEObjectDescription.getImplicitFirstArgumentType()
LightweightTypeReference	StaticFeatureDescriptionWithImplicitReceiver.getImplicitReceiverType()
LightweightTypeReference	SimpleIdentifiableElementDescription.getImplicitReceiverType()
LightweightTypeReference	InstanceFeatureDescriptionWithImplicitReceiver.getImplicitReceiverType()
LightweightTypeReference	InstanceExtensionDescription.getImplicitReceiverType()
LightweightTypeReference	IIdentifiableElementDescription.getImplicitReceiverType()
LightweightTypeReference	BucketedEObjectDescription.getImplicitReceiverType()
protected LightweightTypeReference	StaticFeatureScope.getReceiverType()
LightweightTypeReference	TypeLiteralDescription.getSyntacticReceiverType()
LightweightTypeReference	StaticFeatureDescriptionWithSyntacticReceiver.getSyntacticReceiverType()
LightweightTypeReference	StaticExtensionFeatureDescriptionWithImplicitFirstArgument.getSyntacticReceiverType()
LightweightTypeReference	StaticExtensionFeatureDescription.getSyntacticReceiverType()
LightweightTypeReference	SimpleIdentifiableElementDescription.getSyntacticReceiverType()
LightweightTypeReference	QualifiedThisOrSuperDescription.getSyntacticReceiverType()
LightweightTypeReference	InstanceFeatureDescriptionWithImplicitReceiver.getSyntacticReceiverType()
LightweightTypeReference	InstanceFeatureDescription.getSyntacticReceiverType()
LightweightTypeReference	InstanceExtensionDescriptionWithImplicitFirstArgument.getSyntacticReceiverType()
LightweightTypeReference	InstanceExtensionDescription.getSyntacticReceiverType()
LightweightTypeReference	IIdentifiableElementDescription.getSyntacticReceiverType()
LightweightTypeReference	BucketedEObjectDescription.getSyntacticReceiverType()

Methods in org.eclipse.xtext.xbase.scoping.batch that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
Map<XExpression,LightweightTypeReference>	ExpressionBucket.getExtensionProviders()

Methods in org.eclipse.xtext.xbase.scoping.batch with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected void	DynamicExtensionsScope.addDescriptions(JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> receiverTypeParameterMapping, ExpressionBucket bucket, List<IEObjectDescription> result)
protected IScope	FeatureScopes.createConstructorDelegateScope(org.eclipse.emf.ecore.EObject featureCall, LightweightTypeReference type, IScope parent, IFeatureScopeSession session) A constructor delegate scope provides the descriptions for this() and super() calls in a constructor body.
protected IScope	FeatureScopes.createDynamicExtensionsScope(org.eclipse.emf.ecore.EObject featureCall, XExpression firstArgument, LightweightTypeReference firstArgumentType, boolean implicitArgument, IScope parent, IFeatureScopeSession session) Create a scope that contains dynamic extension features, which are features that are contributed by an instance of a type.
protected IScope	FeatureScopes.createDynamicExtensionsScope(XExpression firstArgument, LightweightTypeReference firstArgumentType, org.eclipse.emf.ecore.EObject featureCall, IScope parent, IFeatureScopeSession captureLayer, IFeatureScopeSession session, IResolvedTypes resolvedTypes)
protected IScope	FeatureScopes.createDynamicExtensionsScope(XExpression firstArgument, LightweightTypeReference firstArgumentType, org.eclipse.emf.ecore.EObject featureCall, IScope parent, IFeatureScopeSession session, IResolvedTypes resolvedTypes)
protected BucketedEObjectDescription	DynamicExtensionsScope.createExtensionDescription(QualifiedName name, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> receiverTypeParameterMapping, ExpressionBucket bucket, boolean validStaticState)
protected IScope	FeatureScopes.createFeatureScopeForTypeRef(XExpression receiver, LightweightTypeReference featureDeclarator, boolean implicit, org.eclipse.emf.ecore.EObject featureCall, IFeatureScopeSession session, JvmIdentifiableElement receiverFeature, IScope parent, boolean validStaticScope)
protected IScope	FeatureScopes.createFollowUpErrorScope(LightweightTypeReference receiverType)
protected IScope	FeatureScopes.createNestedTypeLiteralScope(org.eclipse.emf.ecore.EObject featureCall, LightweightTypeReference enclosingType, JvmDeclaredType rawEnclosingType, IScope parent, IFeatureScopeSession session) Create a scope that returns nested types.
protected BucketedEObjectDescription	DynamicExtensionsScope.createReceiverDescription(QualifiedName name, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> receiverTypeParameterMapping, ExpressionBucket bucket, boolean validStaticState)
protected IScope	FeatureScopes.createReceiverFeatureScope(org.eclipse.emf.ecore.EObject featureCall, XExpression receiver, LightweightTypeReference receiverType, JvmIdentifiableElement receiverFeature, boolean implicitReceiver, boolean validStatic, TypeBucket receiverBucket, IScope parent, IFeatureScopeSession session) Creates a scope that returns the features of a given receiver type.
protected IScope	FeatureScopes.createStaticExtensionsScope(org.eclipse.emf.ecore.EObject featureCall, XExpression firstArgument, LightweightTypeReference firstArgumentType, boolean implicitArgument, IScope parent, IFeatureScopeSession session) Create a scope that contains static extension features, which are features that are contributed statically via an import.
protected IScope	FeatureScopes.createStaticExtensionsScope(XExpression receiver, LightweightTypeReference receiverType, org.eclipse.emf.ecore.EObject featureCall, IScope parent, IFeatureScopeSession session, IResolvedTypes resolvedTypes)
protected IScope	FeatureScopes.createStaticFeatureOnTypeLiteralScope(org.eclipse.emf.ecore.EObject featureCall, XExpression receiver, LightweightTypeReference receiverType, TypeBucket receiverBucket, IScope parent, IFeatureScopeSession session) Creates a scope for the static features that are exposed by a type that was used, e.g.
protected IScope	FeatureScopes.createStaticFeatureOnTypeLiteralScope(XAbstractFeatureCall featureCall, JvmType type, XExpression receiver, LightweightTypeReference receiverType, IScope parent, IFeatureScopeSession session)
protected IScope	FeatureScopes.createStaticFeatureScope(XAbstractFeatureCall featureCall, XExpression receiver, LightweightTypeReference receiverType, TypeBucket receiverBucket, IScope parent, IFeatureScopeSession session) Create a scope that contains static features.
protected IScope	FeatureScopes.createStaticScope(XAbstractFeatureCall featureCall, XExpression receiver, LightweightTypeReference receiverType, IScope parent, IFeatureScopeSession session, IResolvedTypes resolvedTypes)
protected IScope	FeatureScopes.createTypeLiteralScope(XExpression featureCall, XExpression receiver, IFeatureScopeSession session, IResolvedTypes resolvedTypes, LightweightTypeReference receiverType, JvmIdentifiableElement linkedReceiver)
protected BucketedEObjectDescription	DynamicExtensionsScope.doCreateExtensionDescription(QualifiedName name, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> receiverTypeParameterMapping, ExpressionBucket bucket, boolean validStaticState)
protected Boolean	ExtensionScopeHelper.IsResolvedKnownTypeParamHelper.doVisitTypeReference(LightweightTypeReference reference)
protected Set<JvmFeature>	DynamicExtensionsScope.getAllFeatures(LightweightTypeReference extensionType, IResolvedFeatures.Provider resolvedFeaturesProvider)
protected boolean	ExtensionScopeHelper.isResolvedOrKnownTypeParam(LightweightTypeReference type)
protected boolean	FeatureScopes.isUnknownReceiverType(LightweightTypeReference receiverType)
boolean	RootFeatureScopeSession.isVisible(JvmMember member, LightweightTypeReference receiverType, JvmIdentifiableElement receiverFeature) Returns true if the member is visible according to the JvmVisibility and the local context when invoked on the given receiver feature which resolves to the given type.
boolean	IFeatureScopeSession.isVisible(JvmMember member, LightweightTypeReference receiverType, JvmIdentifiableElement receiverFeature) Returns true if the member is visible according to the JvmVisibility and the local context when invoked on the given receiver feature which resolves to the given type.
boolean	FeatureScopeSessionWithContext.isVisible(JvmMember member, LightweightTypeReference receiverType, JvmIdentifiableElement receiverFeature)
boolean	AbstractNestedFeatureScopeSession.isVisible(JvmMember member, LightweightTypeReference receiverType, JvmIdentifiableElement receiverFeature)

Method parameters in org.eclipse.xtext.xbase.scoping.batch with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
IFeatureScopeSession	IFeatureScopeSession.addToExtensionScope(Map<XExpression,LightweightTypeReference> extensionProviders) Add receivers to the session that contribute extensions.
IFeatureScopeSession	AbstractFeatureScopeSession.addToExtensionScope(Map<XExpression,LightweightTypeReference> extensionProviders)
protected boolean	ExtensionScopeHelper.IsResolvedKnownTypeParamHelper.visit(List<LightweightTypeReference> list)

Constructors in org.eclipse.xtext.xbase.scoping.batch with parameters of type LightweightTypeReference

Constructor and Description
ConstructorDelegateScope(IScope parent, LightweightTypeReference contextType, IFeatureScopeSession session, XAbstractFeatureCall featureCall)
DynamicExtensionsScope(IScope parent, IFeatureScopeSession session, XExpression firstArgument, LightweightTypeReference argumentType, boolean implicit, XAbstractFeatureCall context, OperatorMapping operatorMapping)
ExtensionScopeHelper(LightweightTypeReference argumentType)
FeatureScopeSessionWithContext(AbstractFeatureScopeSession parent, LightweightTypeReference contextType)
FeatureScopeSessionWithContext(AbstractFeatureScopeSession parent, LightweightTypeReference contextType, String packageName)
InstanceExtensionDescription(QualifiedName qualifiedName, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> typeParameterMapping, int receiverConformanceFlags, XExpression firstArgument, LightweightTypeReference firstArgumentType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> firstArgumentTypeParameterMapping, int firstArgumentConformanceFlags, int bucketId, boolean visible, boolean validStaticState)
InstanceExtensionDescriptionWithImplicitFirstArgument(QualifiedName qualifiedName, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> receiverTypeParameterMapping, int receiverConformanceFlags, XExpression firstArgument, LightweightTypeReference firstArgumentType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> firstArgumentTypeParameterMapping, int bucketId, boolean visible, boolean validStaticState)
InstanceFeatureDescription(QualifiedName qualifiedName, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> receiverTypeParameterMapping, int receiverConformanceFlags, int bucketId, boolean visible)
InstanceFeatureDescriptionWithImplicitReceiver(QualifiedName qualifiedName, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> typeParameterMapping, int receiverConformanceFlags, int bucketId, boolean visible, boolean validStaticState)
NestedTypeLiteralScope(IScope parent, IFeatureScopeSession session, XAbstractFeatureCall featureCall, LightweightTypeReference enclosingType, JvmType rawEnclosingType)
QualifiedThisOrSuperDescription(QualifiedName qualifiedName, LightweightTypeReference typeReference, int bucketId, boolean visible, XExpression receiver)
ReceiverFeatureScope(IScope parent, IFeatureScopeSession session, XExpression receiver, LightweightTypeReference receiverType, boolean implicit, XAbstractFeatureCall featureCall, TypeBucket bucket, JvmIdentifiableElement receiverFeature, OperatorMapping operatorMapping, boolean validStaticState)
StaticExtensionFeatureDescription(QualifiedName qualifiedName, JvmFeature feature, XExpression syntacticReceiver, LightweightTypeReference syntacticReceiverType, int bucketId, boolean visible)
StaticExtensionFeatureDescriptionWithImplicitFirstArgument(QualifiedName qualifiedName, JvmFeature feature, XExpression firstArgument, LightweightTypeReference firstArgumentType, int bucketId, boolean visible)
StaticExtensionImportsScope(IScope parent, IFeatureScopeSession session, XExpression receiver, LightweightTypeReference receiverType, boolean implicit, XAbstractFeatureCall context, OperatorMapping operatorMapping)
StaticFeatureDescriptionWithImplicitReceiver(QualifiedName qualifiedName, JvmFeature feature, LightweightTypeReference receiverType, int bucketId, boolean visible)
StaticFeatureDescriptionWithSyntacticReceiver(QualifiedName qualifiedName, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, int bucketId, boolean visible)
StaticFeatureDescriptionWithTypeLiteralReceiver(QualifiedName qualifiedName, JvmFeature feature, XExpression receiver, LightweightTypeReference receiverType, int bucketId, boolean visible)
StaticFeatureOnTypeLiteralScope(IScope parent, IFeatureScopeSession session, XAbstractFeatureCall featureCall, XExpression receiver, LightweightTypeReference receiverType, TypeBucket bucket, OperatorMapping operatorMapping)
StaticFeatureScope(IScope parent, IFeatureScopeSession session, XAbstractFeatureCall featureCall, XExpression receiver, LightweightTypeReference receiverType, TypeBucket bucket, OperatorMapping operatorMapping)
TypeLiteralDescription(IEObjectDescription delegate, LightweightTypeReference enclosingType, boolean visible)

Constructor parameters in org.eclipse.xtext.xbase.scoping.batch with type arguments of type LightweightTypeReference

Constructor and Description
ExpressionBucket(int id, Map<XExpression,LightweightTypeReference> extensionProviders, IResolvedFeatures.Provider resolvedFeaturesProvider)
FeatureScopeSessionWithDynamicExtensions(AbstractFeatureScopeSession parent, Map<XExpression,LightweightTypeReference> extensionProviders, IResolvedFeatures.Provider resolvedFeaturesProvider)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem

Methods in org.eclipse.xtext.xbase.typesystem that return LightweightTypeReference

Modifier and Type	Method and Description
LightweightTypeReference	IResolvedTypes.getActualType(JvmIdentifiableElement identifiable) Returns the actually inferred or declared type for the given identifiable or null if none.
LightweightTypeReference	IResolvedTypes.NullResolvedTypes.getActualType(JvmIdentifiableElement identifiable)
LightweightTypeReference	IResolvedTypes.getActualType(XExpression expression) Returns the actually inferred type for the given expression or null if none.
LightweightTypeReference	IResolvedTypes.NullResolvedTypes.getActualType(XExpression expression)
LightweightTypeReference	IResolvedTypes.getExpectedReturnType(XExpression expression) Returns the expected return type for the given expression or null if none.
LightweightTypeReference	IResolvedTypes.NullResolvedTypes.getExpectedReturnType(XExpression expression)
LightweightTypeReference	IResolvedTypes.getExpectedType(XExpression expression) Returns the actually expected type for the given expression or null if none.
LightweightTypeReference	IResolvedTypes.NullResolvedTypes.getExpectedType(XExpression expression)
LightweightTypeReference	IResolvedTypes.getReturnType(XExpression expression) Returns the actually inferred return type for the given expression or null if none.
LightweightTypeReference	IResolvedTypes.NullResolvedTypes.getReturnType(XExpression expression)

Methods in org.eclipse.xtext.xbase.typesystem that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
List<LightweightTypeReference>	IResolvedTypes.getActualTypeArguments(XExpression expression) Returns the resolved type arguments.
List<LightweightTypeReference>	IResolvedTypes.NullResolvedTypes.getActualTypeArguments(XExpression expression)
List<LightweightTypeReference>	IResolvedTypes.getThrownExceptions(XExpression obj)
List<LightweightTypeReference>	IResolvedTypes.NullResolvedTypes.getThrownExceptions(XExpression obj)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.arguments

Methods in org.eclipse.xtext.xbase.typesystem.arguments that return LightweightTypeReference

Modifier and Type	Method and Description
protected static LightweightTypeReference	VarArgFeatureCallArguments.getComponentTypeIfLast(LightweightTypeReference type, List<JvmFormalParameter> parameter, int idx)
LightweightTypeReference	SuperfluousFeatureCallArgumentSlot.getDeclaredType()
LightweightTypeReference	StandardFeatureCallArgumentSlot.getDeclaredType()
LightweightTypeReference	IFeatureCallArgumentSlot.getDeclaredType()
LightweightTypeReference	AssignmentFeatureCallArguments.getDeclaredType()
LightweightTypeReference	StandardFeatureCallArguments.getDeclaredTypeForLambda(int idx)
LightweightTypeReference	IFeatureCallArguments.getDeclaredTypeForLambda(int idx) Returns the declared parameter type for the argument at index idx.
LightweightTypeReference	AssignmentFeatureCallArguments.getDeclaredTypeForLambda(int idx)
protected LightweightTypeReference	StandardFeatureCallArguments.internalGetParameterType(int idx)
protected LightweightTypeReference	ReorderedVarArgFeatureCallArguments.internalGetParameterType(int idx)
protected LightweightTypeReference	ReorderedFeatureCallArguments.internalGetParameterType(int idx)
protected LightweightTypeReference	VarArgFeatureCallArguments.internalGetParameterTypeForLambda(int idx)
protected LightweightTypeReference	StandardFeatureCallArguments.internalGetParameterTypeForLambda(int idx)
protected LightweightTypeReference	ReorderedVarArgFeatureCallArguments.internalGetParameterTypeForLambda(int idx)
protected LightweightTypeReference	ReorderedFeatureCallArguments.internalGetParameterTypeForLambda(int idx)
protected LightweightTypeReference	StandardFeatureCallArguments.toLightweightTypeReference(JvmFormalParameter parameter)

Methods in org.eclipse.xtext.xbase.typesystem.arguments with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected static LightweightTypeReference	VarArgFeatureCallArguments.getComponentTypeIfLast(LightweightTypeReference type, List<JvmFormalParameter> parameter, int idx)

Constructors in org.eclipse.xtext.xbase.typesystem.arguments with parameters of type LightweightTypeReference

Constructor and Description
AssignmentFeatureCallArguments(XExpression expression, LightweightTypeReference type)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.computation

Methods in org.eclipse.xtext.xbase.typesystem.computation that return LightweightTypeReference

Modifier and Type	Method and Description
static LightweightTypeReference	ElementOrComponentTypeComputer.compute(LightweightTypeReference iterableOrArray, ITypeReferenceOwner owner)
protected LightweightTypeReference	XbaseTypeComputer.computeForLoopParameterType(XForLoopExpression object, ITypeComputationState state)
protected LightweightTypeReference	CollectionLiteralsTypeComputer.createCollectionTypeReference(JvmGenericType collectionType, LightweightTypeReference elementType, LightweightTypeReference expectedType, ITypeReferenceOwner owner) Creates a collection type reference that comes as close as possible / necessary to its expected type.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.createMapTypeReference(JvmGenericType mapType, LightweightTypeReference pairType, LightweightTypeReference expectation, ITypeReferenceOwner owner) Creates a map type reference that comes as close as possible / necessary to its expected type.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.createNormalizedPairType(LightweightTypeReference pairType, LightweightTypeReference mapType, ITypeReferenceOwner owner) The map type may be constructed from different pairs, e.g. the pair's type arguments don't need to be as strict as the map suggests.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.doNormalizeElementType(LightweightTypeReference actual, LightweightTypeReference expected) If the expected type is not a wildcard, it may supersede the actual element type.
protected LightweightTypeReference	ElementOrComponentTypeComputer.doVisitAnyTypeReference(AnyTypeReference reference)
LightweightTypeReference	ElementOrComponentTypeComputer.doVisitArrayTypeReference(ArrayTypeReference reference)
LightweightTypeReference	ElementOrComponentTypeComputer.doVisitParameterizedTypeReference(ParameterizedTypeReference reference)
protected LightweightTypeReference	ElementOrComponentTypeComputer.doVisitUnboundTypeReference(UnboundTypeReference reference)
protected LightweightTypeReference	ElementOrComponentTypeComputer.doVisitUnknownTypeReference(UnknownTypeReference reference)
LightweightTypeReference	ITypeComputationResult.getActualExpressionType() Returns the type of the expression (if known).
protected LightweightTypeReference	XbaseTypeComputer.getAndEnhanceIterableOrArrayFromComponent(LightweightTypeReference parameterType, JvmGenericType iterableType, CompoundTypeReference compoundResult)
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeComputationState state) Specializes the super implementation such that is allows an empty list of types.
protected LightweightTypeReference	AbstractTypeComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeComputationState state) Computes the common super type for the given list of types.
protected LightweightTypeReference	AbstractTypeComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeReferenceOwner owner) Computes the common super type for the given list of types.
protected LightweightTypeReference	XbaseTypeComputer.getDeclaredParameterType(JvmFormalParameter declaredParam, ITypeComputationState state)
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getElementOrComponentType(LightweightTypeReference iterableOrArray, ITypeComputationState state)
protected LightweightTypeReference	XbaseTypeComputer.getElementOrComponentType(LightweightTypeReference iterableOrArray, ITypeReferenceOwner owner) Delegates to ElementOrComponentTypeComputer.compute(LightweightTypeReference, ITypeReferenceOwner).
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getElementOrComponentType(LightweightTypeReference iterableOrArray, ITypeReferenceOwner owner) Delegates to ElementOrComponentTypeComputer.compute(LightweightTypeReference, ITypeReferenceOwner).
LightweightTypeReference	ITypeComputationResult.getExpectedExpressionType() Returns the type of the expectation (if any).
LightweightTypeReference	ITypeComputationResult.getExpectedReturnType() Returns the type of the return expectation (if any).
LightweightTypeReference	ITypeExpectation.getExpectedType() Returns the expected type.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getMapExpectation(LightweightTypeReference expectation) If the expected type is a subtype of Map, the resolved super type is returned.
protected LightweightTypeReference	AbstractTypeComputer.getPrimitiveVoid(ITypeComputationState state)
protected LightweightTypeReference	AbstractTypeComputer.getRawTypeForName(Class<?> clazz, ITypeComputationState state)
protected LightweightTypeReference	AbstractTypeComputer.getRawTypeForName(Class<?> clazz, ITypeReferenceOwner owner) Deprecated. use ITypeReferenceOwner.newReferenceTo(Class) instead.
LightweightTypeReference	ITypeComputationResult.getReturnType() Returns the return type of the expression (if known).
protected LightweightTypeReference	AbstractTypeComputer.getTypeForName(Class<?> clazz, ITypeComputationState state)
protected LightweightTypeReference	CollectionLiteralsTypeComputer.normalizeElementType(LightweightTypeReference collectionElementType, LightweightTypeReference expectedCollectionType, ITypeReferenceOwner owner) The expected collection type may drive the type of the elements in the collection if the type is used as an invariant type.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.normalizeFunctionTypeReference(LightweightTypeReference type) A function type reference may be known to have the type argument Number but still use a more specific return type Integer.
LightweightTypeReference	ITypeAssigner.toLightweightTypeReference(JvmTypeReference reference) Can be used to convert JvmTypeReferences in the context of the newly forked state.

Methods in org.eclipse.xtext.xbase.typesystem.computation that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected List<LightweightTypeReference>	CollectionLiteralsTypeComputer.computeCollectionTypeCandidates(XCollectionLiteral literal, JvmGenericType collectionType, LightweightTypeReference elementTypeExpectation, ITypeComputationState state) Creates a list of collection type references from the element types of a collection literal.
List<LightweightTypeReference>	ITypeComputationState.getExpectedExceptions()
List<LightweightTypeReference>	ILinkingCandidate.getTypeArguments() The resolved type arguments.
List<LightweightTypeReference>	IConstructorLinkingCandidate.getTypeArguments() The resolved type arguments.

Methods in org.eclipse.xtext.xbase.typesystem.computation with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected boolean	SynonymTypesProvider.Acceptor.accept(LightweightTypeReference synonym, ConformanceHint hint)
protected boolean	SynonymTypesProvider.Acceptor.accept(LightweightTypeReference synonym, EnumSet<ConformanceHint> hints)
protected abstract boolean	SynonymTypesProvider.Acceptor.accept(LightweightTypeReference synonym, int flags)
void	ITypeComputationState.acceptActualType(LightweightTypeReference type) Annotates the currently considered expression(s) with the given type.
void	ITypeExpectation.acceptActualType(LightweightTypeReference type, ConformanceHint... hints)
void	ITypeComputationState.acceptActualType(LightweightTypeReference type, ConformanceHint... hints) Annotates the currently considered expression(s) with the given type.
void	ITypeExpectation.acceptActualType(LightweightTypeReference type, EnumSet<ConformanceHint> hints)
void	ITypeComputationState.acceptActualType(LightweightTypeReference type, EnumSet<ConformanceHint> hints) Annotates the currently considered expression(s) with the given type.
void	ITypeExpectation.acceptActualType(LightweightTypeReference type, int flags)
void	ITypeComputationState.acceptActualType(LightweightTypeReference type, int flags) Annotates the currently considered expression(s) with the given type.
protected boolean	SynonymTypesProvider.addArrayAndListSynonyms(LightweightTypeReference type, SynonymTypesProvider.Acceptor acceptor)
protected boolean	SynonymTypesProvider.announceSynonym(LightweightTypeReference synonym, ConformanceHint hint, SynonymTypesProvider.Acceptor acceptor) Announce a synonym type with the given conformance hint.
protected boolean	SynonymTypesProvider.announceSynonym(LightweightTypeReference synonym, EnumSet<ConformanceHint> hints, SynonymTypesProvider.Acceptor acceptor) Announce a synonym type with the given conformance hints.
protected boolean	SynonymTypesProvider.announceSynonym(LightweightTypeReference synonym, int flags, SynonymTypesProvider.Acceptor acceptor) Announce a synonym type with the given conformance flags.
protected ITypeComputationState	XbaseTypeComputer.assignType(JvmFormalParameter param, LightweightTypeReference type, ITypeComputationState state)
ITypeComputationState	ITypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type) Assigns the type to the given element and makes the element available in the scope.
void	ITypeAssigner.assignType(JvmIdentifiableElement element, LightweightTypeReference actualType) The given element is tagged with the given type.
ITypeComputationState	ITypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type, boolean addToChildScope) Assigns the given type to the given element and optionally adds the element to the scope.
void	ITypeComputationState.assignType(QualifiedName name, JvmType rawType, LightweightTypeReference actualType) Assigns the given actual type to the raw type which shall be reachable with the given name.
protected boolean	SynonymTypesProvider.collectCustomSynonymTypes(LightweightTypeReference type, SynonymTypesProvider.Acceptor acceptor) This is the hook to announce more synonym types.
void	SynonymTypesProvider.collectSynonymTypes(LightweightTypeReference type, SynonymTypesProvider.Acceptor acceptor)
static LightweightTypeReference	ElementOrComponentTypeComputer.compute(LightweightTypeReference iterableOrArray, ITypeReferenceOwner owner)
protected void	CollectionLiteralsTypeComputer.computeArrayLiteralType(XListLiteral literal, LightweightTypeReference expectedArrayType, ITypeExpectation expectation, ITypeComputationState state)
protected List<LightweightTypeReference>	CollectionLiteralsTypeComputer.computeCollectionTypeCandidates(XCollectionLiteral literal, JvmGenericType collectionType, LightweightTypeReference elementTypeExpectation, ITypeComputationState state) Creates a list of collection type references from the element types of a collection literal.
protected ITypeComputationResult	CollectionLiteralsTypeComputer.computeTypes(XExpression element, LightweightTypeReference expectation, ITypeComputationState state)
protected LightweightTypeReference	CollectionLiteralsTypeComputer.createCollectionTypeReference(JvmGenericType collectionType, LightweightTypeReference elementType, LightweightTypeReference expectedType, ITypeReferenceOwner owner) Creates a collection type reference that comes as close as possible / necessary to its expected type.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.createMapTypeReference(JvmGenericType mapType, LightweightTypeReference pairType, LightweightTypeReference expectation, ITypeReferenceOwner owner) Creates a map type reference that comes as close as possible / necessary to its expected type.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.createNormalizedPairType(LightweightTypeReference pairType, LightweightTypeReference mapType, ITypeReferenceOwner owner) The map type may be constructed from different pairs, e.g. the pair's type arguments don't need to be as strict as the map suggests.
protected void	AbstractClosureTypeHelper.deferredBindTypeArgument(LightweightTypeReference declared, LightweightTypeReference actual, BoundTypeArgumentSource source)
protected void	AbstractTypeComputer.deferredBindTypeArgument(LightweightTypeReference declared, LightweightTypeReference actual, ITypeComputationState state)
protected LightweightTypeReference	CollectionLiteralsTypeComputer.doNormalizeElementType(LightweightTypeReference actual, LightweightTypeReference expected) If the expected type is not a wildcard, it may supersede the actual element type.
protected LightweightTypeReference	XbaseTypeComputer.getAndEnhanceIterableOrArrayFromComponent(LightweightTypeReference parameterType, JvmGenericType iterableType, CompoundTypeReference compoundResult)
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getElementOrComponentType(LightweightTypeReference iterableOrArray, ITypeComputationState state)
protected LightweightTypeReference	XbaseTypeComputer.getElementOrComponentType(LightweightTypeReference iterableOrArray, ITypeReferenceOwner owner) Delegates to ElementOrComponentTypeComputer.compute(LightweightTypeReference, ITypeReferenceOwner).
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getElementOrComponentType(LightweightTypeReference iterableOrArray, ITypeReferenceOwner owner) Delegates to ElementOrComponentTypeComputer.compute(LightweightTypeReference, ITypeReferenceOwner).
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getMapExpectation(LightweightTypeReference expectation) If the expected type is a subtype of Map, the resolved super type is returned.
protected boolean	CollectionLiteralsTypeComputer.isExpectedType(LightweightTypeReference expectation, Class<?> clazz)
protected boolean	CollectionLiteralsTypeComputer.isIterableExpectation(LightweightTypeReference expectation)
protected boolean	CollectionLiteralsTypeComputer.isMapExpectation(LightweightTypeReference expectation)
protected boolean	CollectionLiteralsTypeComputer.isMapLiteral(LightweightTypeReference expectation, LightweightTypeReference elementType)
protected boolean	CollectionLiteralsTypeComputer.isSubtypeButNotSynonym(LightweightTypeReference expectation, Class<?> clazz) Same as isSubtypeOf(Class) but does not accept synonym types as subtypes.
protected boolean	CollectionLiteralsTypeComputer.matchesExpectation(LightweightTypeReference elementType, LightweightTypeReference expectation) Implements fall-back strategy.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.normalizeElementType(LightweightTypeReference collectionElementType, LightweightTypeReference expectedCollectionType, ITypeReferenceOwner owner) The expected collection type may drive the type of the elements in the collection if the type is used as an invariant type.
protected LightweightTypeReference	CollectionLiteralsTypeComputer.normalizeFunctionTypeReference(LightweightTypeReference type) A function type reference may be known to have the type argument Number but still use a more specific return type Integer.
void	ITypeComputationState.reassignType(JvmIdentifiableElement refinable, LightweightTypeReference type) Allows to specialize the known type of an identifiable, that was already annotated with a type.
protected void	CollectionLiteralsTypeComputer.refineElementTypeExpectation(XCollectionLiteral literal, LightweightTypeReference expectation, ITypeComputationState state)
void	ITypeComputationState.refineExpectedType(XExpression expression, LightweightTypeReference expectation) After the fact refinement of the expected type.
protected void	CollectionLiteralsTypeComputer.setUnboundCollectionType(XCollectionLiteral literal, JvmGenericType collectionType, ITypeExpectation expectation, LightweightTypeReference elementTypeExpectation, ITypeComputationState state)
ITypeComputationState	ITypeComputationState.withExpectation(LightweightTypeReference expectation) The given expectation will be resolved if it contains unresolved type arguments, e.g. an operation that declares two parameters of the very same type argument will yield a more detailed expectation if possible.
ITypeComputationState	ITypeComputationState.withRootExpectation(LightweightTypeReference expectation) The given expectation becomes the expected return type and the expected type for the current context.

Method parameters in org.eclipse.xtext.xbase.typesystem.computation with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	CollectionLiteralsTypeComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeComputationState state) Specializes the super implementation such that is allows an empty list of types.
protected LightweightTypeReference	AbstractTypeComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeComputationState state) Computes the common super type for the given list of types.
protected LightweightTypeReference	AbstractTypeComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeReferenceOwner owner) Computes the common super type for the given list of types.
ITypeComputationState	ITypeComputationState.withExpectedExceptions(List<LightweightTypeReference> declaredExceptionTypes)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.conformance

Methods in org.eclipse.xtext.xbase.typesystem.conformance that return LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	TypeConformanceComputer.conformsToAll(LightweightTypeReference type, List<LightweightTypeReference> types)
LightweightTypeReference	TypeConformanceComputer.getCommonParameterSuperType(List<LightweightTypeReference> types, List<LightweightTypeReference> initiallyRequested, ITypeReferenceOwner owner)
LightweightTypeReference	TypeConformanceComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeReferenceOwner owner) Compute the common super type for the given types.
protected LightweightTypeReference	TypeConformanceComputer.getFirstForRawType(com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, JvmType rawType)
LightweightTypeReference	TypeConformanceComputer.getMostSpecialType(List<LightweightTypeReference> candidates)
LightweightTypeReference	IRawTypeHelper.getRawTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
protected LightweightTypeReference	TypeConformanceComputer.getSuperType(ParameterizedTypeReference current, JvmType type)
protected LightweightTypeReference	RawTypeConformanceComputer.getSuperType(ParameterizedTypeReference current, JvmType type) This is a hook for the TypeConformanceComputer to provide the resolved super type.
protected LightweightTypeReference	TypeConformanceComputer.getTypeParametersForSupertype(com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, JvmType rawType, ITypeReferenceOwner owner, List<LightweightTypeReference> initiallyRequested)

Methods in org.eclipse.xtext.xbase.typesystem.conformance that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected List<LightweightTypeReference>	TypeConformanceComputer.replacePrimitivesAndRemoveAnyReferences(List<LightweightTypeReference> types)

Methods in org.eclipse.xtext.xbase.typesystem.conformance with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
boolean	TypeConformanceComputer.MaxDistanceRawTypeAcceptor.accept(LightweightTypeReference superType, int distance)
boolean	SuperTypeAcceptor.accept(LightweightTypeReference superType, int distance)
protected void	TypeConformanceComputer.addComponentType(LightweightTypeReference reference, List<LightweightTypeReference> result)
protected int	RawTypeConformanceComputer.addHintAndAnnounceSuccess(UnboundTypeReference left, LightweightTypeReference hint, int flags)
protected LightweightTypeReference	TypeConformanceComputer.conformsToAll(LightweightTypeReference type, List<LightweightTypeReference> types)
protected int	RawTypeConformanceComputer.doIsConformant(LightweightTypeReference left, LightweightTypeReference right, int flags)
protected int	RawTypeConformanceComputer.doIsConformant(LightweightTypeReference left, UnboundTypeReference right, int flags)
protected int	RawTypeConformanceComputer.doIsConformant(LightweightTypeReference left, WildcardTypeReference right, int flags)
protected int	RawTypeConformanceComputer.doIsConformant(WildcardTypeReference left, LightweightTypeReference right, int flags)
protected int	RawTypeConformanceComputer.doIsConformantOuter(LightweightTypeReference left, LightweightTypeReference right, int nestedResult, int flags)
protected int	TypeConformanceComputer.doIsConformantOuterType(LightweightTypeReference left, LightweightTypeReference right, int flags)
protected int	TypeConformanceComputer.doIsConformantTypeArguments(LightweightTypeReference left, LightweightTypeReference right, int flags)
protected int	RawTypeConformanceComputer.doIsConformantTypeArguments(LightweightTypeReference left, LightweightTypeReference right, int flags) This is a hook for the TypeConformanceComputer to implement the type argument check.
List<JvmType>	IRawTypeHelper.getAllRawTypes(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	IRawTypeHelper.getRawTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
protected void	TypeConformanceComputer.initializeDistance(LightweightTypeReference firstType, com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, com.google.common.collect.Multiset<JvmType> cumulatedDistance)
boolean	TypeConformanceComputer.isConformant(LightweightTypeReference left, LightweightTypeReference right)
int	TypeConformanceComputer.isConformant(LightweightTypeReference left, LightweightTypeReference right, int flags)
int	RawTypeConformanceComputer.isConformant(LightweightTypeReference left, LightweightTypeReference right, int flags)
int	TypeConformanceComputer.isConformant(LightweightTypeReference left, LightweightTypeReference right, TypeConformanceComputationArgument argument)
protected int	RawTypeConformanceComputer.isConformantMergeResult(LightweightMergedBoundTypeArgument mergeResult, LightweightTypeReference right, int flags)
protected int	RawTypeConformanceComputer.isConformantToConstraints(UnboundTypeReference left, LightweightTypeReference right, List<LightweightBoundTypeArgument> leftHints, int flags)
protected int	RawTypeConformanceComputer.isSynonymConformant(int originalConformance, LightweightTypeReference left, LightweightTypeReference right, int flags)
protected int	RawTypeConformanceComputer.tryResolveAndCheckConformance(UnboundTypeReference left, LightweightTypeReference right, int flags)
protected int	RawTypeConformanceComputer.tryResolveAndCheckConformance(UnboundTypeReference left, List<LightweightBoundTypeArgument> leftHints, LightweightTypeReference right, int flags)

Method parameters in org.eclipse.xtext.xbase.typesystem.conformance with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected void	TypeConformanceComputer.addComponentType(LightweightTypeReference reference, List<LightweightTypeReference> result)
protected LightweightTypeReference	TypeConformanceComputer.conformsToAll(LightweightTypeReference type, List<LightweightTypeReference> types)
protected boolean	TypeConformanceComputer.containsPrimitiveOrAnyReferences(List<LightweightTypeReference> types)
protected void	TypeConformanceComputer.cumulateDistance(List<LightweightTypeReference> references, com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, com.google.common.collect.Multiset<JvmType> cumulatedDistance) Keeps the cumulated distance for all the common raw super types of the given references.
protected void	TypeConformanceComputer.cumulateDistance(List<LightweightTypeReference> references, com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, com.google.common.collect.Multiset<JvmType> cumulatedDistance) Keeps the cumulated distance for all the common raw super types of the given references.
protected boolean	TypeConformanceComputer.enhanceSuperType(List<LightweightTypeReference> superTypes, List<LightweightTypeReference> initiallyRequested, ParameterizedTypeReference result)
protected boolean	TypeConformanceComputer.enhanceSuperType(List<LightweightTypeReference> superTypes, List<LightweightTypeReference> initiallyRequested, ParameterizedTypeReference result)
LightweightTypeReference	TypeConformanceComputer.getCommonParameterSuperType(List<LightweightTypeReference> types, List<LightweightTypeReference> initiallyRequested, ITypeReferenceOwner owner)
LightweightTypeReference	TypeConformanceComputer.getCommonParameterSuperType(List<LightweightTypeReference> types, List<LightweightTypeReference> initiallyRequested, ITypeReferenceOwner owner)
LightweightTypeReference	TypeConformanceComputer.getCommonSuperType(List<LightweightTypeReference> types, ITypeReferenceOwner owner) Compute the common super type for the given types.
protected LightweightTypeReference	TypeConformanceComputer.getFirstForRawType(com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, JvmType rawType)
LightweightTypeReference	TypeConformanceComputer.getMostSpecialType(List<LightweightTypeReference> candidates)
protected LightweightTypeReference	TypeConformanceComputer.getTypeParametersForSupertype(com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, JvmType rawType, ITypeReferenceOwner owner, List<LightweightTypeReference> initiallyRequested)
protected LightweightTypeReference	TypeConformanceComputer.getTypeParametersForSupertype(com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, JvmType rawType, ITypeReferenceOwner owner, List<LightweightTypeReference> initiallyRequested)
protected void	TypeConformanceComputer.initializeDistance(LightweightTypeReference firstType, com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all, com.google.common.collect.Multiset<JvmType> cumulatedDistance)
protected boolean	TypeConformanceComputer.isRecursiveRequest(List<LightweightTypeReference> types, Set<String> allNames, List<LightweightTypeReference> initiallyRequested)
protected boolean	TypeConformanceComputer.isRecursiveRequest(List<LightweightTypeReference> types, Set<String> allNames, List<LightweightTypeReference> initiallyRequested)
protected List<LightweightTypeReference>	TypeConformanceComputer.replacePrimitivesAndRemoveAnyReferences(List<LightweightTypeReference> types)

Constructor parameters in org.eclipse.xtext.xbase.typesystem.conformance with type arguments of type LightweightTypeReference

Constructor and Description
TypeConformanceComputer.MaxDistanceRawTypeAcceptor(com.google.common.collect.Multiset<JvmType> result, com.google.common.collect.Multimap<JvmType,LightweightTypeReference> all)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.internal

Fields in org.eclipse.xtext.xbase.typesystem.internal with type parameters of type LightweightTypeReference

Modifier and Type	Field and Description
protected List<LightweightTypeReference>	AbstractLinkingCandidate.typeArguments

Methods in org.eclipse.xtext.xbase.typesystem.internal that return LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	TypeCheckpointComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ReturnExpectationTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpressionTypeComputationState.acceptType(ResolvedTypes resolvedTypes, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpectedExceptionTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected abstract LightweightTypeReference	AbstractTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractStackedTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractRootTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ResolvedTypes.acceptType(XExpression expression, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	TypeComputationStateWithNonVoidExpectation.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	TypeCheckpointComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ReturnExpectationTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpressionTypeComputationStateWithExpectation.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpressionTypeComputationState.acceptType(XExpression expression, ResolvedTypes resolvedTypes, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpectedExceptionTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected abstract LightweightTypeReference	AbstractTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractStackedTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractRootTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	LogicalContainerAwareReentrantTypeResolver.DemandTypeReferenceProvider.convertLocalType(LightweightTypeReference reference)
protected LightweightTypeReference	ConstructorLinkingCandidate.deferredBindTypeArgument(ITypeExpectation expectation, LightweightTypeReference type)
protected LightweightTypeReference	AbstractLinkingCandidate.deferredBindTypeArgument(ITypeExpectation expectation, LightweightTypeReference type)
protected LightweightTypeReference	ResolvedTypes.doGetActualType(JvmIdentifiableElement identifiable, boolean ignoreReassignedTypes)
protected LightweightTypeReference	ResolvedTypes.doGetActualType(XExpression expression)
protected LightweightTypeReference	StackedResolvedTypes.doGetActualTypeNoDeclaration(JvmIdentifiableElement identifiable, boolean ignoreReassignedTypes)
protected LightweightTypeReference	ResolvedTypes.doGetActualTypeNoDeclaration(JvmIdentifiableElement identifiable, boolean ignoreReassignedTypes)
protected LightweightTypeReference	StackedResolvedTypes.doGetDeclaredType(JvmIdentifiableElement identifiable)
protected LightweightTypeReference	ResolvedTypes.doGetDeclaredType(JvmIdentifiableElement identifiable)
protected LightweightTypeReference	ResolvedTypes.doGetExpectedType(XExpression expression, boolean returnType)
protected LightweightTypeReference	ResolvedTypes.doGetReturnType(XExpression expression)
LightweightTypeReference	ResolutionBasedComputationResult.getActualExpressionType()
LightweightTypeReference	NoTypeResult.getActualExpressionType()
LightweightTypeReference	TypeData.getActualType()
LightweightTypeReference	ResolvedTypes.getActualType(JvmIdentifiableElement identifiable)
LightweightTypeReference	ForwardingResolvedTypes.getActualType(JvmIdentifiableElement identifiable)
LightweightTypeReference	CompoundReentrantTypeResolver.getActualType(JvmIdentifiableElement identifiable)
protected LightweightTypeReference	AbstractLinkingCandidate.getActualType(JvmIdentifiableElement element, boolean ignoreReassignedTypes) Returns the actual type of the given element.
LightweightTypeReference	ResolvedTypes.getActualType(XExpression expression)
LightweightTypeReference	ForwardingResolvedTypes.getActualType(XExpression expression)
LightweightTypeReference	CompoundReentrantTypeResolver.getActualType(XExpression expression)
protected LightweightTypeReference	AbstractLinkingCandidate.getActualType(XExpression expression)
protected LightweightTypeReference	TypeLiteralHelper.getAsClassLiteral(JvmIdentifiableElement feature)
protected LightweightTypeReference	TypeLiteralLinkingCandidate.getDeclaredType(JvmIdentifiableElement feature)
protected LightweightTypeReference	ResolvedTypeLiteral.getDeclaredType(JvmIdentifiableElement feature)
protected LightweightTypeReference	ResolvedFeature.getDeclaredType(JvmIdentifiableElement feature)
protected LightweightTypeReference	FeatureLinkingCandidate.getDeclaredType(JvmIdentifiableElement feature)
protected LightweightTypeReference	AbstractLinkingCandidate.getDeclaredType(JvmIdentifiableElement feature)
LightweightTypeReference	ResolutionBasedComputationResult.getExpectedExpressionType()
LightweightTypeReference	NoTypeResult.getExpectedExpressionType()
LightweightTypeReference	FeatureLinkHelper.getExpectedReceiverType(JvmIdentifiableElement linkedFeature, LightweightTypeReference receiverType)
LightweightTypeReference	ResolutionBasedComputationResult.getExpectedReturnType()
LightweightTypeReference	NoTypeResult.getExpectedReturnType()
LightweightTypeReference	ResolvedTypes.getExpectedReturnType(XExpression expression)
LightweightTypeReference	ForwardingResolvedTypes.getExpectedReturnType(XExpression expression)
LightweightTypeReference	CompoundReentrantTypeResolver.getExpectedReturnType(XExpression expression)
LightweightTypeReference	TypeExpectation.getExpectedType()
protected LightweightTypeReference	TypeComputationStateWithExpectation.getExpectedType()
LightweightTypeReference	RootTypeExpectation.getExpectedType()
LightweightTypeReference	RootNoExpectation.getExpectedType()
LightweightTypeReference	RootExpressionTypeComputationState.PendingRootExpectation.getExpectedType()
protected LightweightTypeReference	OperationBodyComputationState.getExpectedType()
LightweightTypeReference	NoExpectation.getExpectedType()
protected LightweightTypeReference	FieldTypeComputationState.getExpectedType()
protected LightweightTypeReference	ExpressionBasedRootTypeComputationState.getExpectedType()
protected LightweightTypeReference	ConstructorBodyComputationState.getExpectedType()
protected LightweightTypeReference	AnnotationValueTypeComputationState.getExpectedType()
protected abstract LightweightTypeReference	AbstractRootTypeComputationState.getExpectedType()
protected LightweightTypeReference	AbstractLinkingCandidate.ArgumentTypeComputationState.getExpectedType()
LightweightTypeReference	ResolvedTypes.getExpectedType(XExpression expression)
LightweightTypeReference	ForwardingResolvedTypes.getExpectedType(XExpression expression)
LightweightTypeReference	CompoundReentrantTypeResolver.getExpectedType(XExpression expression)
protected LightweightTypeReference	AbstractLinkingCandidate.getExpectedType(XExpression expression)
protected LightweightTypeReference	StackedResolvedTypes.getExpectedTypeForAssociatedExpression(JvmMember member, XExpression expression)
protected LightweightTypeReference	RootResolvedTypes.getExpectedTypeForAssociatedExpression(JvmMember member, XExpression expression)
protected abstract LightweightTypeReference	ResolvedTypes.getExpectedTypeForAssociatedExpression(JvmMember member, XExpression expression)
protected LightweightTypeReference	FeatureLinkingCandidate.getFirstArgumentType()
protected LightweightTypeReference	ExpressionScope.Scope.getFirstParameterType(IIdentifiableElementDescription candidate)
LightweightTypeReference	ScopeProviderAccess.ErrorDescription.getImplicitFirstArgumentType()
protected LightweightTypeReference	ResolvedFeature.getImplicitFirstArgumentType()
protected LightweightTypeReference	FeatureLinkingCandidate.getImplicitFirstArgumentType()
LightweightTypeReference	ScopeProviderAccess.ErrorDescription.getImplicitReceiverType()
protected LightweightTypeReference	ResolvedFeature.getImplicitReceiverType()
protected LightweightTypeReference	FeatureLinkingCandidate.getImplicitReceiverType()
protected LightweightTypeReference	ResolvedTypes.getMergedType(List<LightweightTypeReference> types)
protected LightweightTypeReference	ExpressionScope.Scope.getParameterType(JvmFormalParameter p)
protected LightweightTypeReference	TypeLiteralHelper.getRawTypeForName(Class<?> clazz, ITypeReferenceOwner owner) Deprecated. use ITypeReferenceOwner.newReferenceTo(Class) instead.
protected LightweightTypeReference	ResolvedFeature.getReceiverType()
protected LightweightTypeReference	FeatureLinkingCandidate.getReceiverType()
LightweightTypeReference	ResolutionBasedComputationResult.getReturnType()
LightweightTypeReference	NoTypeResult.getReturnType()
LightweightTypeReference	ResolvedTypes.getReturnType(XExpression expression)
LightweightTypeReference	ForwardingResolvedTypes.getReturnType(XExpression expression)
LightweightTypeReference	CompoundReentrantTypeResolver.getReturnType(XExpression expression)
protected LightweightTypeReference	LogicalContainerAwareReentrantTypeResolver.getReturnTypeOfOverriddenOperation(JvmOperation operation, ResolvedTypes resolvedTypes, IFeatureScopeSession session) Returns null if the given operation declares it's own return type or if it does not override another operation.
protected LightweightTypeReference	TypeLiteralLinkingCandidate.getSubstitutedExpectedType(int argumentIndex)
protected LightweightTypeReference	ResolvedFeature.getSubstitutedExpectedType(int idx)
protected LightweightTypeReference	FeatureLinkingCandidate.getSubstitutedExpectedType(int idx)
protected LightweightTypeReference	AbstractLinkingCandidate.getSubstitutedExpectedType(int argumentIndex) Returns the substituted expected type for the argument at argumentIndex.
LightweightTypeReference	ScopeProviderAccess.ErrorDescription.getSyntacticReceiverType()
protected LightweightTypeReference	ResolvedFeature.getSyntacticReceiverType()
protected LightweightTypeReference	FeatureLinkingCandidate.getSyntacticReceiverType()
LightweightTypeReference	TypeAssigner.toLightweightTypeReference(JvmTypeReference reference)
LightweightTypeReference	CompoundTypeComputationState.toLightweightTypeReference(JvmTypeReference reference)
LightweightTypeReference	CompoundTypeAssigner.toLightweightTypeReference(JvmTypeReference reference)
protected LightweightTypeReference	ResolvedTypes.toOwnedReference(LightweightTypeReference result)

Methods in org.eclipse.xtext.xbase.typesystem.internal that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected Map<JvmIdentifiableElement,LightweightTypeReference>	ResolvedTypes.basicGetReassignedTypes()
protected Map<JvmIdentifiableElement,LightweightTypeReference>	ResolvedTypes.basicGetTypes()
protected List<LightweightTypeReference>	StackedResolvedTypes.doGetActualTypeArguments(XExpression expression)
protected List<LightweightTypeReference>	ResolvedTypes.doGetActualTypeArguments(XExpression expression)
List<LightweightTypeReference>	ResolvedTypes.getActualTypeArguments(XExpression expression)
List<LightweightTypeReference>	ForwardingResolvedTypes.getActualTypeArguments(XExpression expression)
List<LightweightTypeReference>	CompoundReentrantTypeResolver.getActualTypeArguments(XExpression expression)
List<LightweightTypeReference>	StackedResolvedTypes.getExpectedExceptions()
protected List<LightweightTypeReference>	ResolvedTypes.getExpectedExceptions()
List<LightweightTypeReference>	ForwardingTypeComputationState.getExpectedExceptions()
List<LightweightTypeReference>	ExpectedExceptionsStackedResolvedTypes.getExpectedExceptions()
List<LightweightTypeReference>	CompoundTypeComputationState.getExpectedExceptions()
List<LightweightTypeReference>	AbstractTypeComputationState.getExpectedExceptions()
protected Map<JvmIdentifiableElement,LightweightTypeReference>	StackedResolvedTypes.getFlattenedReassignedTypes()
protected Map<JvmIdentifiableElement,LightweightTypeReference>	ResolvedTypes.getFlattenedReassignedTypes()
List<LightweightTypeReference>	TypeInsteadOfConstructorLinkingCandidate.getSyntacticTypeArguments()
protected List<LightweightTypeReference>	AbstractLinkingCandidate.getSyntacticTypeArguments()
List<LightweightTypeReference>	ResolvedTypes.getThrownExceptions(XExpression obj)
List<LightweightTypeReference>	ForwardingResolvedTypes.getThrownExceptions(XExpression obj)
List<LightweightTypeReference>	CompoundReentrantTypeResolver.getThrownExceptions(XExpression obj)
List<LightweightTypeReference>	UnresolvableFeatureCall.getTypeArguments()
List<LightweightTypeReference>	UnresolvableConstructorCall.getTypeArguments()
List<LightweightTypeReference>	TypeLiteralLinkingCandidate.getTypeArguments()
List<LightweightTypeReference>	TypeInsteadOfConstructorLinkingCandidate.getTypeArguments()
List<LightweightTypeReference>	SuspiciouslyOverloadedCandidate.getTypeArguments()
List<LightweightTypeReference>	ResolvedTypeLiteral.getTypeArguments()
List<LightweightTypeReference>	ITypeLiteralLinkingCandidate.getTypeArguments() A linked type literal does never have type arguments.
List<LightweightTypeReference>	FollowUpError.getTypeArguments()
List<LightweightTypeReference>	AppliedFeatureLinkingCandidate.getTypeArguments()
List<LightweightTypeReference>	AbstractNullLinkingCandidate.getTypeArguments()
List<LightweightTypeReference>	AbstractLinkingCandidate.getTypeArguments()
List<LightweightTypeReference>	AbstractImplicitFeature.getTypeArguments()
List<LightweightTypeReference>	AbstractAmbiguousLinkingCandidate.getTypeArguments()

Methods in org.eclipse.xtext.xbase.typesystem.internal with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected void	AbstractLinkingCandidate.accept(AbstractLinkingCandidate.ObservableTypeExpectation expectation, LightweightTypeReference actual)
void	ForwardingTypeComputationState.acceptActualType(LightweightTypeReference type)
void	CompoundTypeComputationState.acceptActualType(LightweightTypeReference type)
void	AbstractTypeComputationState.acceptActualType(LightweightTypeReference type)
void	CompoundTypeComputationState.acceptActualType(LightweightTypeReference type, ConformanceHint... hints)
void	AbstractTypeExpectation.acceptActualType(LightweightTypeReference type, ConformanceHint... hints)
void	AbstractTypeComputationState.acceptActualType(LightweightTypeReference type, ConformanceHint... hints)
void	CompoundTypeComputationState.acceptActualType(LightweightTypeReference type, EnumSet<ConformanceHint> hints)
void	AbstractTypeExpectation.acceptActualType(LightweightTypeReference type, EnumSet<ConformanceHint> hints)
void	AbstractTypeComputationState.acceptActualType(LightweightTypeReference type, EnumSet<ConformanceHint> hints)
void	RootExpressionTypeComputationState.PendingRootExpectation.acceptActualType(LightweightTypeReference type, int flags)
void	ForwardingTypeComputationState.acceptActualType(LightweightTypeReference type, int flags)
void	CompoundTypeComputationState.acceptActualType(LightweightTypeReference type, int flags)
void	AbstractTypeComputationState.acceptActualType(LightweightTypeReference type, int flags)
void	AbstractRootTypeExpectation.acceptActualType(LightweightTypeReference type, int flags)
void	AbstractReturnAwareTypeExpectation.acceptActualType(LightweightTypeReference type, int flags)
void	AbstractLinkingCandidate.ObservableTypeExpectation.acceptActualType(LightweightTypeReference type, int flags)
protected LightweightTypeReference	TypeCheckpointComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ReturnExpectationTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpressionTypeComputationState.acceptType(ResolvedTypes resolvedTypes, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpectedExceptionTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected abstract LightweightTypeReference	AbstractTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractStackedTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractRootTypeComputationState.acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ResolvedTypes.acceptType(XExpression expression, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	TypeComputationStateWithNonVoidExpectation.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	TypeCheckpointComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ReturnExpectationTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpressionTypeComputationStateWithExpectation.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpressionTypeComputationState.acceptType(XExpression expression, ResolvedTypes resolvedTypes, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	ExpectedExceptionTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected abstract LightweightTypeReference	AbstractTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractStackedTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
protected LightweightTypeReference	AbstractRootTypeComputationState.acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)
void	TypeAssigner.assignType(JvmIdentifiableElement element, LightweightTypeReference actualType)
ITypeComputationState	ForwardingTypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type)
ITypeComputationState	CompoundTypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type)
void	CompoundTypeAssigner.assignType(JvmIdentifiableElement element, LightweightTypeReference actualType)
AbstractTypeComputationState	AbstractTypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type)
protected void	TypeAssigner.assignType(JvmIdentifiableElement element, LightweightTypeReference actualType, boolean addToChildScope)
ITypeComputationState	ForwardingTypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type, boolean addToChildScope)
ITypeComputationState	CompoundTypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type, boolean addToChildScope)
AbstractTypeComputationState	AbstractTypeComputationState.assignType(JvmIdentifiableElement element, LightweightTypeReference type, boolean addToChildScope)
void	ForwardingTypeComputationState.assignType(QualifiedName name, JvmType rawType, LightweightTypeReference actualType)
void	CompoundTypeComputationState.assignType(QualifiedName name, JvmType rawType, LightweightTypeReference actualType)
void	AbstractTypeComputationState.assignType(QualifiedName name, JvmType rawType, LightweightTypeReference actualType)
protected int	AbstractPendingLinkingCandidate.compareDeclaredTypes(LightweightTypeReference left, LightweightTypeReference right, boolean leftResolved, boolean rightResolved)
protected LightweightTypeReference	LogicalContainerAwareReentrantTypeResolver.DemandTypeReferenceProvider.convertLocalType(LightweightTypeReference reference)
protected LightweightBoundTypeArgument	ResolvedTypes.copyBoundTypeArgument(LightweightTypeReference typeReference, LightweightBoundTypeArgument boundTypeArgument)
protected AbstractLinkingCandidate.ArgumentTypeComputationState	AbstractLinkingCandidate.createLinkingTypeComputationState(LightweightTypeReference expectedType)
protected AbstractDiagnostic	RootResolvedTypes.createTypeDiagnostic(XExpression expression, LightweightTypeReference actualType, LightweightTypeReference expectedType)
protected AbstractTypeExpectation	TypeComputationStateWithNonVoidExpectation.createTypeExpectation(LightweightTypeReference expectedType, AbstractTypeComputationState actualState)
protected AbstractTypeExpectation	TypeComputationStateWithRootExpectation.createTypeExpectation(LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean returnType)
protected AbstractTypeExpectation	TypeComputationStateWithExpectation.createTypeExpectation(LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean returnType)
protected AbstractTypeExpectation	RootExpressionTypeComputationStateWithNonVoidExpectation.createTypeExpectation(LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean voidAllowed, boolean returnType)
protected AbstractTypeExpectation	RootExpressionTypeComputationState.createTypeExpectation(LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean voidAllowed, boolean returnType)
protected AbstractTypeExpectation	AbstractLinkingCandidate.ArgumentTypeComputationState.createTypeExpectation(LightweightTypeReference expectedType, AbstractTypeComputationState actualState, boolean returnType, int flags)
protected AbstractLinkingCandidate.ArgumentTypeComputationState	AbstractLinkingCandidate.createVarArgTypeComputationState(LightweightTypeReference componentType)
protected LightweightTypeReference	ConstructorLinkingCandidate.deferredBindTypeArgument(ITypeExpectation expectation, LightweightTypeReference type)
protected LightweightTypeReference	AbstractLinkingCandidate.deferredBindTypeArgument(ITypeExpectation expectation, LightweightTypeReference type)
LightweightTypeReference	FeatureLinkHelper.getExpectedReceiverType(JvmIdentifiableElement linkedFeature, LightweightTypeReference receiverType)
void	StackedResolvedTypes.reassignType(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
void	ResolvedTypes.reassignType(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
void	ForwardingTypeComputationState.reassignType(JvmIdentifiableElement refinable, LightweightTypeReference type)
void	ExpectedExceptionsStackedResolvedTypes.reassignType(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
void	CompoundTypeComputationState.reassignType(JvmIdentifiableElement refinable, LightweightTypeReference type)
void	AbstractTypeComputationState.reassignType(JvmIdentifiableElement refinable, LightweightTypeReference type)
void	ResolvedTypes.reassignTypeWithoutMerge(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
void	ExpectedExceptionsStackedResolvedTypes.reassignTypeWithoutMerge(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
void	ForwardingTypeComputationState.refineExpectedType(XExpression expression, LightweightTypeReference expectation)
void	CompoundTypeComputationState.refineExpectedType(XExpression expression, LightweightTypeReference expectation)
void	AbstractTypeComputationState.refineExpectedType(XExpression expression, LightweightTypeReference expectation)
protected void	ResolvedFeature.resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, AbstractTypeComputationState state)
protected void	FeatureLinkingCandidate.resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, AbstractTypeComputationState state)
protected void	AbstractLinkingCandidate.resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, AbstractTypeComputationState state)
protected void	ResolvedFeature.resolveArgumentType(XExpression argument, LightweightTypeReference declaredType, ITypeComputationState argumentState)
protected void	FeatureLinkingCandidate.resolveArgumentType(XExpression argument, LightweightTypeReference declaredType, ITypeComputationState argumentState)
protected void	AbstractLinkingCandidate.resolveArgumentType(XExpression argument, LightweightTypeReference declaredType, ITypeComputationState argumentState)
protected void	ResolvedFeature.resolveKnownArgumentType(XExpression argument, LightweightTypeReference knownType, LightweightTypeReference declaredType, ITypeComputationState argumentState)
protected void	FeatureLinkingCandidate.resolveKnownArgumentType(XExpression argument, LightweightTypeReference knownType, LightweightTypeReference declaredType, ITypeComputationState argumentState)
void	ResolvedTypes.setType(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
void	ReassigningStackedResolvedTypes.setType(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
void	ExpectedExceptionsStackedResolvedTypes.setType(JvmIdentifiableElement identifiable, LightweightTypeReference reference)
protected JvmTypeReference	LogicalContainerAwareReentrantTypeResolver.toJavaCompliantTypeReference(LightweightTypeReference result, IFeatureScopeSession session)
protected CompoundTypeReference	ResolvedTypes.toMultiType(LightweightTypeReference first, LightweightTypeReference second)
protected LightweightTypeReference	ResolvedTypes.toOwnedReference(LightweightTypeReference result)
ITypeComputationState	ForwardingTypeComputationState.withExpectation(LightweightTypeReference expectation)
TypeComputationStateWithExpectation	ExpressionTypeComputationState.withExpectation(LightweightTypeReference expectation)
ITypeComputationState	CompoundTypeComputationState.withExpectation(LightweightTypeReference expectation)
TypeComputationStateWithExpectation	AbstractTypeComputationState.withExpectation(LightweightTypeReference expectation)
ITypeComputationState	ForwardingTypeComputationState.withRootExpectation(LightweightTypeReference expectation)
ITypeComputationState	CompoundTypeComputationState.withRootExpectation(LightweightTypeReference expectation)
TypeComputationStateWithRootExpectation	AbstractTypeComputationState.withRootExpectation(LightweightTypeReference expectation)

Method parameters in org.eclipse.xtext.xbase.typesystem.internal with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	ResolvedTypes.getMergedType(List<LightweightTypeReference> types)
protected String	AbstractPendingLinkingCandidate.getTypeArgumentsAsString(List<? extends LightweightTypeReference> typeArguments) Returns the resolved string representation of the type arguments.
protected ResolvedTypes	ResolvedTypes.pushExpectedExceptions(List<LightweightTypeReference> exceptions)
ITypeComputationState	ForwardingTypeComputationState.withExpectedExceptions(List<LightweightTypeReference> declaredExceptionTypes)
ITypeComputationState	CompoundTypeComputationState.withExpectedExceptions(List<LightweightTypeReference> declaredExceptionTypes)
AbstractTypeComputationState	AbstractTypeComputationState.withExpectedExceptions(List<LightweightTypeReference> declaredExceptionTypes)

Constructors in org.eclipse.xtext.xbase.typesystem.internal with parameters of type LightweightTypeReference

Constructor and Description
AbstractLinkingCandidate.ArgumentTypeComputationState(AbstractTypeComputationState parent, LightweightTypeReference expectedType, int defaultFlags)
AbstractLinkingCandidate.ObservableTypeExpectation(LightweightTypeReference expectedType, AbstractTypeComputationState state, boolean returnType, int flags)
ExpressionBasedRootTypeComputationState(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, XExpression expression, LightweightTypeReference expectedType)
ExpressionTypeComputationStateWithExpectation(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, AbstractTypeComputationState parent, LightweightTypeReference expectation)
RootExpressionTypeComputationState(StackedResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, AbstractTypeComputationState parent, XExpression expression, LightweightTypeReference expectedType)
RootExpressionTypeComputationStateWithNonVoidExpectation(StackedResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, AbstractTypeComputationState parent, XExpression expression, LightweightTypeReference expectedType)
RootTypeExpectation(LightweightTypeReference reference, AbstractTypeComputationState state)
ScopeProviderAccess.ErrorDescription(LightweightTypeReference syntacticReceiverType)
TypeComputationStateWithExpectation(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, AbstractTypeComputationState parent, LightweightTypeReference typeReference)
TypeComputationStateWithRootExpectation(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, AbstractTypeComputationState parent, LightweightTypeReference typeReference)
TypeData(XExpression expression, ITypeExpectation expectation, LightweightTypeReference type, int flags, boolean returnType)
TypeExpectation(LightweightTypeReference reference, AbstractTypeComputationState state, boolean returnType)

Constructor parameters in org.eclipse.xtext.xbase.typesystem.internal with type arguments of type LightweightTypeReference

Constructor and Description
ExpectedExceptionsStackedResolvedTypes(ResolvedTypes parent, List<LightweightTypeReference> expectedExceptions)
ExpectedExceptionTypeComputationState(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, AbstractTypeComputationState parent, List<LightweightTypeReference> exceptions)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.internal.util

Methods in org.eclipse.xtext.xbase.typesystem.internal.util that return LightweightTypeReference

Modifier and Type	Method and Description
static LightweightTypeReference	WrapperTypeLookup.getWrapperType(LightweightTypeReference context, Primitives.Primitive primitiveKind)

Methods in org.eclipse.xtext.xbase.typesystem.internal.util with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
static LightweightTypeReference	WrapperTypeLookup.getWrapperType(LightweightTypeReference context, Primitives.Primitive primitiveKind)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.override

Methods in org.eclipse.xtext.xbase.typesystem.override that return LightweightTypeReference

Modifier and Type	Method and Description
LightweightTypeReference	IResolvedFeature.getContextType() Returns the current context type.
LightweightTypeReference	AbstractResolvedFeature.getContextType()
protected LightweightTypeReference	InvokedResolvedOperation.Provider.getReceiverType(XAbstractFeatureCall featureCall, IResolvedTypes resolvedTypes, ITypeReferenceOwner owner)
LightweightTypeReference	IResolvedFeature.getResolvedDeclarator() Returns the resolved type of the declarator of this declaration.
LightweightTypeReference	AbstractResolvedFeature.getResolvedDeclarator()
protected LightweightTypeReference	AbstractResolvedFeature.getResolvedReference(JvmTypeReference unresolved)
LightweightTypeReference	IResolvedOperation.getResolvedReturnType() Returns the resolved return types in the current context.
LightweightTypeReference	AbstractResolvedOperation.getResolvedReturnType()
LightweightTypeReference	ResolvedField.getResolvedType()
LightweightTypeReference	IResolvedField.getResolvedType() Returns the resolved type in the current context.
LightweightTypeReference	OverrideHelper.getReturnTypeOfOverriddenOperation(JvmOperation operation, ITypeReferenceOwner owner, IVisibilityHelper visibilityHelper) Returns null if the given operation declares it's own return type or if it does not override another operation.
LightweightTypeReference	OverrideHelper.getReturnTypeOfOverriddenOperation(JvmOperation operation, LightweightTypeReference context) Returns null if the given operation declares it's own return type or if it does not override another operation.
LightweightTypeReference	AbstractResolvedFeatures.getType()

Methods in org.eclipse.xtext.xbase.typesystem.override that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
List<LightweightTypeReference>	IResolvedOperation.getIllegallyDeclaredExceptions() Returns the list of exceptions that are declared in this operation but do not match the super implementation.
List<LightweightTypeReference>	AbstractResolvedOperation.getIllegallyDeclaredExceptions()
List<LightweightTypeReference>	IResolvedExecutable.getResolvedExceptions() Returns the resolved declared exceptions in the current context.
List<LightweightTypeReference>	AbstractResolvedExecutable.getResolvedExceptions()
List<LightweightTypeReference>	IResolvedExecutable.getResolvedParameterTypes() Returns the resolved parameter types in the current context.
List<LightweightTypeReference>	AbstractResolvedExecutable.getResolvedParameterTypes()
protected List<LightweightTypeReference>	AbstractResolvedFeature.getResolvedReferences(List<JvmTypeReference> unresolved)
List<LightweightTypeReference>	InvokedResolvedOperation.getResolvedTypeArguments()
List<LightweightTypeReference>	IResolvedOperation.getResolvedTypeParameterConstraints(int idx) Returns the list of resolved constraints for the given type parameter index.
List<LightweightTypeReference>	AbstractResolvedOperation.getResolvedTypeParameterConstraints(int idx)

Methods in org.eclipse.xtext.xbase.typesystem.override with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected BottomResolvedOperation	AbstractResolvedFeatures.createResolvedOperation(JvmOperation operation, LightweightTypeReference context)
protected TypeParameterSubstitutor<?>	OverrideHelper.createSubstitutor(ITypeReferenceOwner owner, LightweightTypeReference declaringType)
protected JvmOperation	OverrideHelper.findOverriddenOperation(JvmOperation operation, LightweightTypeReference declaringType, TypeParameterSubstitutor<?> substitutor, ITypeReferenceOwner owner, IVisibilityHelper visibilityHelper)
IResolvedFeatures	RawResolvedFeatures.getParameterizedView(LightweightTypeReference concrete)
IResolvedFeatures	ParameterizedResolvedFeatures.getParameterizedView(LightweightTypeReference concrete)
IResolvedFeatures	IResolvedFeatures.getParameterizedView(LightweightTypeReference concrete) Applies concretely bound type arguments to this instance of IResolvedFeatures.
ResolvedFeatures	OverrideHelper.getResolvedFeatures(LightweightTypeReference contextType) Returns the resolved features that are defined in the given context type and its supertypes.
ResolvedFeatures	OverrideHelper.getResolvedFeatures(LightweightTypeReference contextType, JavaVersion targetVersion) Returns the resolved features targeting a specific Java version in order to support new language features.
LightweightTypeReference	OverrideHelper.getReturnTypeOfOverriddenOperation(JvmOperation operation, LightweightTypeReference context) Returns null if the given operation declares it's own return type or if it does not override another operation.
protected boolean	AbstractResolvedOperation.isIllegallyDeclaredException(LightweightTypeReference exception, List<IResolvedOperation> overriddenAndImplemented)
protected boolean	AbstractResolvedFeature.isResolvedTypeParameter(LightweightTypeReference typeReference, JvmTypeParameter typeParameter)

Constructors in org.eclipse.xtext.xbase.typesystem.override with parameters of type LightweightTypeReference

Constructor and Description
AbstractResolvedExecutable(T declaration, LightweightTypeReference contextType)
AbstractResolvedFeature(T declaration, LightweightTypeReference contextType)
AbstractResolvedFeatures(LightweightTypeReference type, OverrideTester overrideTester)
AbstractResolvedOperation(JvmOperation declaration, LightweightTypeReference contextType)
BottomResolvedOperation(JvmOperation declaration, LightweightTypeReference contextType, OverrideTester overrideTester)
ConflictingDefaultOperation(JvmOperation declaration, LightweightTypeReference contextType, OverrideTester overrideTester, IResolvedOperation... conflictingOperations)
InvokedResolvedOperation(JvmOperation operation, LightweightTypeReference contextType, List<LightweightTypeReference> typeArguments, OverrideTester overrideTester)
ParameterizedResolvedFeatures(LightweightTypeReference type, RawResolvedFeatures parent)
RawResolvedFeatures(LightweightTypeReference type, OverrideTester overrideTester)
ResolvedConstructor(JvmConstructor constructor, LightweightTypeReference contextType)
ResolvedFeatures(LightweightTypeReference type)
ResolvedFeatures(LightweightTypeReference type, OverrideTester overrideTester)
ResolvedFeatures(LightweightTypeReference type, OverrideTester overrideTester, JavaVersion targetVersion)
ResolvedField(JvmField field, LightweightTypeReference contextType)

Constructor parameters in org.eclipse.xtext.xbase.typesystem.override with type arguments of type LightweightTypeReference

Constructor and Description
InvokedResolvedOperation(JvmOperation operation, LightweightTypeReference contextType, List<LightweightTypeReference> typeArguments, OverrideTester overrideTester)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.references

Classes in org.eclipse.xtext.xbase.typesystem.references with type parameters of type LightweightTypeReference

Modifier and Type	Interface and Description
interface	TypeReferenceInitializer<Ref extends LightweightTypeReference> Functional interface that is used to initialize newly created type references from ITypeReferenceOwner.newReferenceTo(Class, TypeReferenceInitializer).

Subclasses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.references

Modifier and Type	Class and Description
class	AnyTypeReference
class	ArrayTypeReference
class	CompoundTypeReference
class	FunctionTypeReference
class	InnerFunctionTypeReference
class	InnerTypeReference
class	ParameterizedTypeReference
class	UnboundTypeReference A type reference that points to a type parameter that is not yet resolved.
class	UnknownTypeReference Represents a JvmType that could not be resolved, e.g. a proxy or null.
class	WildcardTypeReference

Methods in org.eclipse.xtext.xbase.typesystem.references that return LightweightTypeReference

Modifier and Type	Method and Description
LightweightTypeReference	OwnedConverter.apply(JvmTypeReference reference) Deprecated.
LightweightTypeReference	ArrayTypes.convertToList(ArrayTypeReference type)
LightweightTypeReference	UnboundTypeReference.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.
LightweightTypeReference	LightweightTypeReference.copyInto(ITypeReferenceOwner owner)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.createObjectReference(ITypeReferenceOwner owner, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
protected LightweightTypeReference	ParameterizedTypeReference.createRawTypeReference(JvmType rawType)
protected LightweightTypeReference	UnknownTypeReference.doCopyInto(ITypeReferenceOwner owner)
protected LightweightTypeReference	UnboundTypeReference.doCopyInto(ITypeReferenceOwner owner)
protected abstract LightweightTypeReference	LightweightTypeReference.doCopyInto(ITypeReferenceOwner owner)
protected LightweightTypeReference	CompoundTypeReference.doCopyInto(ITypeReferenceOwner owner)
protected LightweightTypeReference	ArrayTypeReference.doCopyInto(ITypeReferenceOwner owner)
protected LightweightTypeReference	AnyTypeReference.doCopyInto(ITypeReferenceOwner owner)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitAnyTypeReference(JvmAnyTypeReference reference)
protected LightweightTypeReference	LightweightTypeReferenceFactory.doVisitCompoundReference(JvmCompoundTypeReference reference, boolean synonym)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.doVisitCompoundTypeReference(CompoundTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitComputedTypeReference(XComputedTypeReference reference)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitFunctionTypeReference(XFunctionTypeRef reference)
LightweightTypeReference	IndexingLightweightTypeReferenceFactory.doVisitFunctionTypeReference(XFunctionTypeRef reference)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitGenericArrayTypeReference(JvmGenericArrayTypeReference reference)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitInnerTypeReference(JvmInnerTypeReference reference)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitMultiTypeReference(JvmMultiTypeReference reference)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitParameterizedTypeReference(JvmParameterizedTypeReference reference)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.doVisitParameterizedTypeReference(ParameterizedTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.doVisitSynonymTypeReference(CompoundTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitSynonymTypeReference(JvmSynonymTypeReference reference)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitTypeReference(JvmTypeReference reference)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.doVisitTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitUnknownTypeReference(JvmUnknownTypeReference reference)
LightweightTypeReference	LightweightTypeReferenceFactory.doVisitWildcardTypeReference(JvmWildcardTypeReference reference)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.doVisitWildcardTypeReference(WildcardTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	TypeReferenceInitializer.enhance(Ref reference) Enhance the given reference and return itself or a wrapper around it, e.g.
LightweightTypeReference	UnboundTypeReference.getComponentType()
LightweightTypeReference	LightweightTypeReference.getComponentType() Returns the component type of the current array type.
LightweightTypeReference	ArrayTypeReference.getComponentType()
LightweightTypeReference	WildcardTypeReference.getInvariantBoundSubstitute()
LightweightTypeReference	UnboundTypeReference.getInvariantBoundSubstitute()
LightweightTypeReference	LightweightTypeReference.getInvariantBoundSubstitute()
protected LightweightTypeReference	IndexingLightweightTypeReferenceFactory.getJavaLangObjectTypeReference()
LightweightTypeReference	WildcardTypeReference.getLowerBound()
LightweightTypeReference	WildcardTypeReference.getLowerBoundSubstitute()
LightweightTypeReference	UnboundTypeReference.getLowerBoundSubstitute()
LightweightTypeReference	LightweightTypeReference.getLowerBoundSubstitute()
LightweightTypeReference	LightweightTypeReference.getNamedType() Returns the named type if this is an anonymous type.
LightweightTypeReference	ArrayTypeReference.getNamedType()
protected LightweightTypeReference	LightweightTypeReferenceFactory.getObjectReference()
LightweightTypeReference	LightweightTypeReference.getOuter()
LightweightTypeReference	InnerTypeReference.getOuter()
LightweightTypeReference	InnerFunctionTypeReference.getOuter()
LightweightTypeReference	UnboundTypeReference.getPrimitiveIfWrapperType()
LightweightTypeReference	ParameterizedTypeReference.getPrimitiveIfWrapperType()
LightweightTypeReference	LightweightTypeReference.getPrimitiveIfWrapperType()
LightweightTypeReference	ParameterizedTypeReference.getRawSuperType(JvmType rawType)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.getRawTypeFromConstraints(ITypeReferenceOwner owner, JvmTypeParameter typeParameter, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	ParameterizedTypeReference.getRawTypeReference()
LightweightTypeReference	LightweightTypeReference.getRawTypeReference()
LightweightTypeReference	InnerTypeReference.getRawTypeReference()
LightweightTypeReference	InnerFunctionTypeReference.getRawTypeReference()
LightweightTypeReference	CompoundTypeReference.getRawTypeReference()
LightweightTypeReference	ArrayTypeReference.getRawTypeReference()
LightweightTypeReference	RawTypeHelper.getRawTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.getRawTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	UnboundTypeReference.getResolvedTo() Returns the resolved reference for this unbound reference.
LightweightTypeReference	FunctionTypeReference.getReturnType()
LightweightTypeReference	WildcardTypeReference.getSuperType(Class<?> rawType)
LightweightTypeReference	UnboundTypeReference.getSuperType(Class<?> rawType)
LightweightTypeReference	ParameterizedTypeReference.getSuperType(Class<?> rawType)
LightweightTypeReference	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	CompoundTypeReference.getSuperType(Class<?> rawType)
LightweightTypeReference	ArrayTypeReference.getSuperType(Class<?> rawType)
LightweightTypeReference	WildcardTypeReference.getSuperType(JvmType rawType)
LightweightTypeReference	UnboundTypeReference.getSuperType(JvmType rawType)
LightweightTypeReference	ParameterizedTypeReference.getSuperType(JvmType rawType)
LightweightTypeReference	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.
LightweightTypeReference	CompoundTypeReference.getSuperType(JvmType rawType)
LightweightTypeReference	ArrayTypeReference.getSuperType(JvmType rawType)
LightweightTypeReference	LightweightMergedBoundTypeArgument.getTypeReference()
LightweightTypeReference	LightweightBoundTypeArgument.getTypeReference()
LightweightTypeReference	WildcardTypeReference.getUpperBoundSubstitute()
LightweightTypeReference	UnboundTypeReference.getUpperBoundSubstitute()
LightweightTypeReference	LightweightTypeReference.getUpperBoundSubstitute()
LightweightTypeReference	UnboundTypeReference.getWrapperTypeIfPrimitive()
LightweightTypeReference	ParameterizedTypeReference.getWrapperTypeIfPrimitive()
LightweightTypeReference	LightweightTypeReference.getWrapperTypeIfPrimitive()
protected LightweightTypeReference	LightweightTypeReferenceFactory.handleNullReference()
protected LightweightTypeReference	LightweightTypeReference.internalFindTopLevelType(Class<?> rawType)
LightweightTypeReference	UnboundTypeReference.internalGetResolvedTo()
LightweightTypeReference	StandardTypeReferenceOwner.newReferenceTo(Class<?> type) Creates a references to the given class or returns an UnknownTypeReference if no JRE is available.
LightweightTypeReference	ITypeReferenceOwner.newReferenceTo(Class<?> type) Creates a reference to the given class or returns an UnknownTypeReference if no JRE is available.
LightweightTypeReference	StandardTypeReferenceOwner.newReferenceTo(Class<?> type, TypeReferenceInitializer<? super ParameterizedTypeReference> init) Creates a references to the given class or returns an UnknownTypeReference if no JRE is available.
LightweightTypeReference	ITypeReferenceOwner.newReferenceTo(Class<?> type, TypeReferenceInitializer<? super ParameterizedTypeReference> init) Creates a reference to the given class or returns an UnknownTypeReference if no JRE is available.
LightweightTypeReference	StandardTypeReferenceOwner.newReferenceToObject() Creates a references to Object or returns an UnknownTypeReference if no JRE is available.
LightweightTypeReference	ITypeReferenceOwner.newReferenceToObject() Creates a reference to Object or returns an UnknownTypeReference if no JRE is available.
LightweightTypeReference	UnboundTypeReference.resolve() Force this reference to be resolved.
LightweightTypeReference	UnboundTypeReference.toJavaType()
LightweightTypeReference	LightweightTypeReference.toJavaType() Converts types to references that can be expressed as Java type references in source code.
LightweightTypeReference	CompoundTypeReference.toJavaType()
LightweightTypeReference	AnyTypeReference.toJavaType()
LightweightTypeReference	LightweightTypeReferenceFactory.toLightweightReference(JvmType type)
LightweightTypeReference	LightweightTypeReferenceFactory.toLightweightReference(JvmTypeReference reference)
LightweightTypeReference	StandardTypeReferenceOwner.toLightweightTypeReference(JvmType type)
LightweightTypeReference	ITypeReferenceOwner.toLightweightTypeReference(JvmType type) Creates a new type reference that points to the given type.
LightweightTypeReference	StandardTypeReferenceOwner.toLightweightTypeReference(JvmTypeReference type)
LightweightTypeReference	ITypeReferenceOwner.toLightweightTypeReference(JvmTypeReference type) Transforms the given EMF based type reference to its equivalent in the LightweightTypeReference hierarchy.
LightweightTypeReference	StandardTypeReferenceOwner.toPlainTypeReference(JvmType type)
LightweightTypeReference	LightweightTypeReferenceFactory.toPlainTypeReference(JvmType type)
LightweightTypeReference	ITypeReferenceOwner.toPlainTypeReference(JvmType type) Creates a new type reference that points to the given type.
LightweightTypeReference	OwnedConverter.toRawLightweightReference(JvmType type) Deprecated.
LightweightTypeReference	UnboundTypeReference.tryConvertToListType()
LightweightTypeReference	ParameterizedTypeReference.tryConvertToListType()
LightweightTypeReference	LightweightTypeReference.tryConvertToListType() Returns the list representation of this reference if it represents an array or is already a subtype of List.
LightweightTypeReference	ArrayTypeReference.tryConvertToListType()

Methods in org.eclipse.xtext.xbase.typesystem.references that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
List<LightweightTypeReference>	LightweightTypeReference.getAllSuperTypes() Returns the list of all super types which includes the super class and the implemented interfaces.
List<LightweightTypeReference>	UnboundTypeReference.getMultiTypeComponents()
List<LightweightTypeReference>	LightweightTypeReference.getMultiTypeComponents()
List<LightweightTypeReference>	CompoundTypeReference.getMultiTypeComponents()
protected List<LightweightTypeReference>	LightweightTypeReference.getNonInterfaceTypes(List<LightweightTypeReference> components)
List<LightweightTypeReference>	FunctionTypeReference.getParameterTypes()
List<LightweightTypeReference>	LightweightTypeReference.getSuperTypes() Returns the list of immediate super types which includes the super class and the implemented interfaces.
protected List<LightweightTypeReference>	WildcardTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
protected List<LightweightTypeReference>	UnknownTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
protected List<LightweightTypeReference>	UnboundTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
protected List<LightweightTypeReference>	ParameterizedTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
protected abstract List<LightweightTypeReference>	LightweightTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
protected List<LightweightTypeReference>	CompoundTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
protected List<LightweightTypeReference>	ArrayTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
protected List<LightweightTypeReference>	AnyTypeReference.getSuperTypes(TypeParameterSubstitutor<?> substitutor)
List<LightweightTypeReference>	WildcardTypeReference.getTypeArguments()
List<LightweightTypeReference>	UnboundTypeReference.getTypeArguments()
List<LightweightTypeReference>	ParameterizedTypeReference.getTypeArguments()
List<LightweightTypeReference>	LightweightTypeReference.getTypeArguments() Returns the type arguments of this reference if it has any.
List<LightweightTypeReference>	CompoundTypeReference.getTypeArguments()
List<LightweightTypeReference>	WildcardTypeReference.getUpperBounds()

Methods in org.eclipse.xtext.xbase.typesystem.references with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
void	UnboundTypeReference.acceptHint(LightweightTypeReference hint, BoundTypeArgumentSource source, Object origin, VarianceInfo expectedVariance, VarianceInfo actualVariance) Attach a resolution hint to this unbound type reference.
void	CompoundTypeReference.addComponent(LightweightTypeReference component)
void	FunctionTypeReference.addParameterType(LightweightTypeReference parameterType)
void	ParameterizedTypeReference.addTypeArgument(LightweightTypeReference argument)
void	WildcardTypeReference.addUpperBound(LightweightTypeReference upperBound)
String	LightweightTypeReference.IdentifierFunction.apply(LightweightTypeReference reference)
String	LightweightTypeReference.UniqueIdentifierFunction.apply(LightweightTypeReference reference)
String	LightweightTypeReference.JavaIdentifierFunction.apply(LightweightTypeReference reference)
String	LightweightTypeReference.SimpleNameFunction.apply(LightweightTypeReference reference)
boolean	UnboundTypeReference.canResolveTo(LightweightTypeReference reference) Returns true if the existing hints would allow to resolve to the given reference.
protected boolean	UnboundTypeReference.canResolveTo(LightweightTypeReference reference, List<LightweightBoundTypeArgument> allHints)
List<JvmTypeParameter>	FunctionTypes.collectAllTypeParameters(LightweightTypeReference closureType, JvmOperation operation)
FunctionTypeReference	FunctionTypes.createFunctionTypeRef(ITypeReferenceOwner owner, LightweightTypeReference functionType, List<LightweightTypeReference> parameterTypes, LightweightTypeReference returnType)
protected Result	TypeReferenceVisitorWithResult.doVisitTypeReference(LightweightTypeReference reference)
protected void	TypeReferenceVisitor.doVisitTypeReference(LightweightTypeReference reference)
protected Result	TypeReferenceVisitorWithParameterAndResult.doVisitTypeReference(LightweightTypeReference reference, Param param)
protected void	TypeReferenceVisitorWithParameter.doVisitTypeReference(LightweightTypeReference reference, Param param)
protected List<JvmType>	RawTypeHelper.RawTypeImplementation.doVisitTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
protected LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.doVisitTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
JvmOperation	FunctionTypes.findImplementingOperation(LightweightTypeReference functionType)
List<JvmType>	RawTypeHelper.getAllRawTypes(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
List<JvmType>	RawTypeHelper.RawTypeImplementation.getAllRawTypes(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
Map<JvmTypeParameter,List<LightweightBoundTypeArgument>>	FunctionTypes.getFunctionTypeParameterMapping(LightweightTypeReference functionType, JvmOperation operation, ActualTypeArgumentCollector typeArgumentCollector, ITypeReferenceOwner owner)
LightweightTypeReference	RawTypeHelper.getRawTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
LightweightTypeReference	RawTypeHelper.RawTypeReferenceImplementation.getRawTypeReference(LightweightTypeReference reference, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
int	LightweightTypeReference.internalIsAssignableFrom(LightweightTypeReference reference, TypeConformanceComputationArgument argument)
boolean	LightweightTypeReference.isAssignableFrom(LightweightTypeReference reference) Determines if this type reference denotes the same or a supertype of the given reference.
boolean	LightweightTypeReference.isAssignableFrom(LightweightTypeReference reference, TypeConformanceComputationArgument argument)
ArrayTypeReference	StandardTypeReferenceOwner.newArrayTypeReference(LightweightTypeReference componentTypeReference)
ArrayTypeReference	ITypeReferenceOwner.newArrayTypeReference(LightweightTypeReference componentTypeReference) Creates a new ArrayTypeReference with the given component type.
InnerFunctionTypeReference	StandardTypeReferenceOwner.newFunctionTypeReference(LightweightTypeReference outer, JvmType type)
InnerFunctionTypeReference	ITypeReferenceOwner.newFunctionTypeReference(LightweightTypeReference outer, JvmType type) Create a new InnerFunctionTypeReference that is backed by the given type and has to defined outer type.
InnerTypeReference	StandardTypeReferenceOwner.newParameterizedTypeReference(LightweightTypeReference outer, JvmType type)
InnerTypeReference	ITypeReferenceOwner.newParameterizedTypeReference(LightweightTypeReference outer, JvmType type) Creates a new InnerTypeReference.
void	WildcardTypeReference.setLowerBound(LightweightTypeReference lowerBound)
void	FunctionTypeReference.setReturnType(LightweightTypeReference returnType)

Method parameters in org.eclipse.xtext.xbase.typesystem.references with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected void	LightweightTypeReferenceSerializer.appendCommaSeparated(List<LightweightTypeReference> references)
protected List<JvmType>	RawTypeHelper.RawTypeImplementation.collectRawTypes(List<LightweightTypeReference> references, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
protected void	LightweightTypeReference.collectSuperTypes(int level, List<LightweightTypeReference> references, TypeParameterSubstitutor<?> substitutor, SuperTypeAcceptor acceptor, Set<JvmType> seenTypes)
FunctionTypeReference	FunctionTypes.createFunctionTypeRef(ITypeReferenceOwner owner, LightweightTypeReference functionType, List<LightweightTypeReference> parameterTypes, LightweightTypeReference returnType)
protected void	RawTypeHelper.RawTypeReferenceImplementation.enhanceCompoundReference(List<LightweightTypeReference> references, CompoundTypeReference result, org.eclipse.emf.ecore.resource.ResourceSet resourceSet)
protected String	ParameterizedTypeReference.getAsString(String type, com.google.common.base.Function<LightweightTypeReference,String> format)
protected String	InnerTypeReference.getAsString(String type, com.google.common.base.Function<LightweightTypeReference,String> format)
protected String	InnerFunctionTypeReference.getAsString(String type, com.google.common.base.Function<LightweightTypeReference,String> format)
protected String	FunctionTypeReference.getAsString(String type, com.google.common.base.Function<LightweightTypeReference,String> format)
protected String	InnerFunctionTypeReference.getAsStringNoFunctionType(String type, com.google.common.base.Function<LightweightTypeReference,String> format)
protected String	FunctionTypeReference.getAsStringNoFunctionType(String type, com.google.common.base.Function<LightweightTypeReference,String> format)
protected List<LightweightTypeReference>	LightweightTypeReference.getNonInterfaceTypes(List<LightweightTypeReference> components)
protected JvmTypeReference	LightweightTypeReference.toJavaCompliantTypeReference(List<LightweightTypeReference> types, IVisibilityHelper visibilityHelper)
protected boolean	FunctionTypes.tryAssignTypeArguments(List<LightweightTypeReference> typeArguments, FunctionTypeReference result)

Constructors in org.eclipse.xtext.xbase.typesystem.references with parameters of type LightweightTypeReference

Constructor and Description
ArrayTypeReference(ITypeReferenceOwner owner, LightweightTypeReference component)
InnerFunctionTypeReference(ITypeReferenceOwner owner, LightweightTypeReference outer, JvmType type)
InnerTypeReference(ITypeReferenceOwner owner, LightweightTypeReference outer, JvmType type)
LightweightBoundTypeArgument(LightweightTypeReference typeReference, BoundTypeArgumentSource source, Object origin, VarianceInfo declaredVariance, VarianceInfo actualVariance)
LightweightMergedBoundTypeArgument(LightweightTypeReference typeReference, VarianceInfo variance)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.typesystem.util

Methods in org.eclipse.xtext.xbase.typesystem.util that return LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	TypeParameterSubstitutor.copy(LightweightTypeReference reference)
protected LightweightTypeReference	DeferredTypeParameterHintCollector.copy(UnboundTypeReference reference)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitAnyTypeReference(AnyTypeReference reference, Visiting visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitArrayTypeReference(ArrayTypeReference reference, Visiting visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitCompoundTypeReference(CompoundTypeReference reference, Visiting visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitFunctionTypeReference(FunctionTypeReference reference, Visiting visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitInnerFunctionTypeReference(InnerFunctionTypeReference reference, Visiting visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitInnerTypeReference(InnerTypeReference reference, Visiting visiting)
LightweightTypeReference	CustomTypeParameterSubstitutor.doVisitParameterizedTypeReference(ParameterizedTypeReference reference, ConstraintVisitingInfo visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitParameterizedTypeReference(ParameterizedTypeReference reference, JvmType type, Visiting visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitParameterizedTypeReference(ParameterizedTypeReference reference, Visiting visiting)
LightweightTypeReference	TypeParameterByUnboundSubstitutor.doVisitUnboundTypeReference(UnboundTypeReference reference, ConstraintVisitingInfo param)
protected LightweightTypeReference	TypeParameterByConstraintSubstitutor.doVisitUnboundTypeReference(UnboundTypeReference reference, ConstraintVisitingInfo visiting)
protected LightweightTypeReference	UnboundTypeParameterPreservingSubstitutor.doVisitUnboundTypeReference(UnboundTypeReference reference, Set<JvmTypeParameter> visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitUnknownTypeReference(UnknownTypeReference reference, Visiting param)
protected LightweightTypeReference	TypeParameterSubstitutor.doVisitWildcardTypeReference(WildcardTypeReference reference, Visiting visiting)
protected LightweightTypeReference	CustomTypeParameterSubstitutor.enhanceParameterizedTypeReference(ParameterizedTypeReference origin, JvmType type, ParameterizedTypeReference result, ConstraintVisitingInfo visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.enhanceParameterizedTypeReference(ParameterizedTypeReference origin, JvmType type, ParameterizedTypeReference result, Visiting visiting)
LightweightTypeReference	IThrownExceptionDelegate.getActualType(XExpression expr)
LightweightTypeReference	ExtendedEarlyExitComputer.ThrownExceptionDelegate.getActualType(XExpression expr)
LightweightTypeReference	ExtendedEarlyExitComputer.FilteringThrownExceptionDelegate.getActualType(XExpression expr)
protected LightweightTypeReference	UnboundTypeParameterPreservingSubstitutor.getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type, Set<JvmTypeParameter> visiting)
protected LightweightTypeReference	TypeParameterSubstitutor.getBoundTypeArgument(ParameterizedTypeReference reference, JvmTypeParameter type, Visiting visiting)
protected LightweightTypeReference	TypeParameterByConstraintSubstitutor.getDeclaredUpperBound(JvmTypeParameter typeParameter, ConstraintVisitingInfo visiting)
protected LightweightTypeReference	CustomTypeParameterSubstitutor.getDeclaredUpperBound(JvmTypeParameter typeParameter, ConstraintVisitingInfo visiting)
protected LightweightTypeReference	CustomTypeParameterSubstitutor.getDeclaredUpperBound(JvmTypeParameterDeclarator type, int parameterIndex, ConstraintVisitingInfo visiting)
protected LightweightTypeReference	BoundTypeArgumentMerger.getMostSpecialType(List<LightweightTypeReference> candidates)
protected LightweightTypeReference	CustomTypeParameterSubstitutor.getObjectReference()
protected LightweightTypeReference	DeferredTypeParameterHintCollector.getStricterConstraint(UnboundTypeReference typeParameter, LightweightTypeReference hint)
protected LightweightTypeReference	ThrownExceptionSwitch.getType(XExpression expr)
protected LightweightTypeReference	TypeParameterByUnboundSubstitutor.getUnmappedSubstitute(ParameterizedTypeReference reference, JvmTypeParameter type, ConstraintVisitingInfo visiting)
protected LightweightTypeReference	TypeParameterByConstraintSubstitutor.getUnmappedSubstitute(ParameterizedTypeReference reference, JvmTypeParameter type, ConstraintVisitingInfo visiting)
protected abstract LightweightTypeReference	CustomTypeParameterSubstitutor.getUnmappedSubstitute(ParameterizedTypeReference reference, JvmTypeParameter type, ConstraintVisitingInfo visiting)
LightweightTypeReference	TypeParameterByConstraintSubstitutor.substitute(JvmTypeParameter original)
LightweightTypeReference	TypeParameterSubstitutor.substitute(JvmTypeReference original)
LightweightTypeReference	TypeParameterSubstitutor.substitute(LightweightTypeReference original)
LightweightTypeReference	RawTypeSubstitutor.substitute(LightweightTypeReference original)
LightweightTypeReference	CustomTypeParameterSubstitutor.substitute(LightweightTypeReference original)
LightweightTypeReference	IThrownExceptionDelegate.toLightweightReference(JvmTypeReference exception)
LightweightTypeReference	ExtendedEarlyExitComputer.ThrownExceptionDelegate.toLightweightReference(JvmTypeReference exception)
LightweightTypeReference	ExtendedEarlyExitComputer.FilteringThrownExceptionDelegate.toLightweightReference(JvmTypeReference exception)
protected LightweightTypeReference	TypeParameterByConstraintSubstitutor.visitTypeArgument(LightweightTypeReference reference, ConstraintVisitingInfo visiting, boolean lowerBound)
protected LightweightTypeReference	TypeParameterSubstitutor.visitTypeArgument(LightweightTypeReference reference, Visiting visiting) This is equivalent to visitTypeArgument(reference, visiting, false).
protected LightweightTypeReference	TypeParameterSubstitutor.visitTypeArgument(LightweightTypeReference reference, Visiting visiting, boolean lowerBound)
LightweightTypeReference	LocalTypeSubstitutor.withoutLocalTypes(LightweightTypeReference original)

Methods in org.eclipse.xtext.xbase.typesystem.util that return types with arguments of type LightweightTypeReference

Modifier and Type	Method and Description
List<LightweightTypeReference>	ExtendedEarlyExitComputer.getThrownExceptions(XExpression obj, IResolvedTypes types, ITypeReferenceOwner owner)

Methods in org.eclipse.xtext.xbase.typesystem.util with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected void	ThrownExceptionSwitch.accept(LightweightTypeReference type)
void	IThrownExceptionDelegate.accept(LightweightTypeReference type)
void	ExtendedEarlyExitComputer.ThrownExceptionDelegate.accept(LightweightTypeReference type)
void	ExtendedEarlyExitComputer.FilteringThrownExceptionDelegate.accept(LightweightTypeReference type)
protected void	UnboundTypeParameterAwareTypeArgumentCollector.acceptHint(UnboundTypeReference reference, LightweightTypeReference param)
protected void	TypeArgumentFromComputedTypeCollector.acceptHint(UnboundTypeReference reference, LightweightTypeReference param)
protected void	DeferredTypeParameterHintCollector.addHint(UnboundTypeReference typeParameter, LightweightTypeReference reference)
protected LightweightBoundTypeArgument	ActualTypeArgumentCollector.boundByConstraint(LightweightTypeReference reference, Object origin)
protected LightweightBoundTypeArgument	ActualTypeArgumentCollector.boundByDefaultSource(LightweightTypeReference reference)
protected LightweightTypeReference	TypeParameterSubstitutor.copy(LightweightTypeReference reference)
protected void	AbstractTypeReferencePairWalker.doVisitAnyTypeReference(AnyTypeReference reference, LightweightTypeReference param)
protected void	AbstractTypeReferencePairWalker.doVisitArrayTypeReference(ArrayTypeReference declaredReference, LightweightTypeReference param)
protected void	AbstractTypeReferencePairWalker.doVisitCompoundTypeReference(CompoundTypeReference declaredReference, LightweightTypeReference param)
protected void	AbstractTypeReferencePairWalker.doVisitParameterizedTypeReference(ParameterizedTypeReference reference, LightweightTypeReference param)
protected void	AbstractTypeReferencePairWalker.CompoundTypeReferenceTraverser.doVisitTypeReference(LightweightTypeReference reference, CompoundTypeReference declaration)
protected Boolean	DeclaratorTypeArgumentCollector.doVisitTypeReference(LightweightTypeReference reference, LightweightTraversalData data)
protected void	HumanReadableTypeNames.doVisitTypeReference(LightweightTypeReference reference, StringBuilder param)
protected void	UnboundTypeParameterAwareTypeArgumentCollector.UnboundTypeParameterAwareUnboundTypeReferenceTraverser.doVisitTypeReference(LightweightTypeReference reference, UnboundTypeReference declaration)
protected void	DeferredTypeParameterHintCollector.UnboundTypeParameterHintCollector.doVisitTypeReference(LightweightTypeReference reference, UnboundTypeReference declaration)
protected void	AbstractTypeReferencePairWalker.UnboundTypeReferenceTraverser.doVisitTypeReference(LightweightTypeReference reference, UnboundTypeReference declaration)
protected org.eclipse.xtext.xbase.typesystem.util.LocalTypeSubstitutor.SubstitutionResult	LocalTypeSubstitutor.doVisitTypeReference(LightweightTypeReference reference, VarianceInfo param)
void	AbstractTypeReferencePairWalker.WildcardTypeReferenceTraverser.doVisitTypeReference(LightweightTypeReference reference, WildcardTypeReference declaration)
protected void	AbstractTypeReferencePairWalker.doVisitUnboundTypeReference(UnboundTypeReference reference, LightweightTypeReference param)
protected void	AbstractTypeReferencePairWalker.doVisitUnknownTypeReference(UnknownTypeReference reference, LightweightTypeReference param)
protected void	AbstractTypeReferencePairWalker.doVisitWildcardTypeReference(WildcardTypeReference declaredReference, LightweightTypeReference param)
protected LightweightTypeReference	DeferredTypeParameterHintCollector.getStricterConstraint(UnboundTypeReference typeParameter, LightweightTypeReference hint)
Map<JvmTypeParameter,LightweightMergedBoundTypeArgument>	DeclaratorTypeArgumentCollector.getTypeParameterMapping(LightweightTypeReference reference)
boolean	BoundTypeArgumentMerger.isPossibleMergeResult(List<LightweightBoundTypeArgument> allArguments, LightweightTypeReference candidate)
protected void	AbstractTypeReferencePairWalker.outerVisit(LightweightTypeReference declaredType, LightweightTypeReference actualType)
protected void	AbstractTypeReferencePairWalker.outerVisit(LightweightTypeReference declaredType, LightweightTypeReference actualType, Object origin, VarianceInfo expectedVariance, VarianceInfo actualVariance)
void	ActualTypeArgumentCollector.populateTypeParameterMapping(LightweightTypeReference declaredType, LightweightTypeReference actualType)
void	ActualTypeArgumentCollector.processPairedReferences(LightweightTypeReference declaredType, LightweightTypeReference actualType)
void	AbstractTypeReferencePairWalker.processPairedReferences(LightweightTypeReference declaredType, LightweightTypeReference actualType)
protected void	ActualTypeArgumentCollector.processTypeParameter(JvmTypeParameter typeParameter, LightweightTypeReference reference)
protected void	AbstractTypeReferencePairWalker.processTypeParameter(JvmTypeParameter typeParameter, LightweightTypeReference reference)
static void	TypeArgumentFromComputedTypeCollector.resolveAgainstActualType(LightweightTypeReference declaredType, LightweightTypeReference actualType, Collection<JvmTypeParameter> typeParameters, Map<JvmTypeParameter,LightweightMergedBoundTypeArgument> typeParameterMapping, BoundTypeArgumentSource source, ITypeReferenceOwner owner)
LightweightTypeReference	TypeParameterSubstitutor.substitute(LightweightTypeReference original)
LightweightTypeReference	RawTypeSubstitutor.substitute(LightweightTypeReference original)
LightweightTypeReference	CustomTypeParameterSubstitutor.substitute(LightweightTypeReference original)
protected LightweightTypeReference	TypeParameterByConstraintSubstitutor.visitTypeArgument(LightweightTypeReference reference, ConstraintVisitingInfo visiting, boolean lowerBound)
protected org.eclipse.xtext.xbase.typesystem.util.LocalTypeSubstitutor.SubstitutionResult	LocalTypeSubstitutor.visitTypeArgument(LightweightTypeReference reference, VarianceInfo varianceInfo)
protected LightweightTypeReference	TypeParameterSubstitutor.visitTypeArgument(LightweightTypeReference reference, Visiting visiting) This is equivalent to visitTypeArgument(reference, visiting, false).
protected LightweightTypeReference	TypeParameterSubstitutor.visitTypeArgument(LightweightTypeReference reference, Visiting visiting, boolean lowerBound)
LightweightTypeReference	LocalTypeSubstitutor.withoutLocalTypes(LightweightTypeReference original)

Method parameters in org.eclipse.xtext.xbase.typesystem.util with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
IThrownExceptionDelegate	IThrownExceptionDelegate.catchExceptions(List<LightweightTypeReference> caughtExceptions)
IThrownExceptionDelegate	ExtendedEarlyExitComputer.AbstractThrownExceptionDelegate.catchExceptions(List<LightweightTypeReference> caughtExceptions)
protected ExtendedEarlyExitComputer.ThrownExceptionDelegate	ExtendedEarlyExitComputer.createDelegate(List<LightweightTypeReference> result, IResolvedTypes types, ITypeReferenceOwner owner)
protected LightweightTypeReference	BoundTypeArgumentMerger.getMostSpecialType(List<LightweightTypeReference> candidates)

Constructors in org.eclipse.xtext.xbase.typesystem.util with parameters of type LightweightTypeReference

Constructor and Description
ContextualVisibilityHelper(IVisibilityHelper parent, LightweightTypeReference contextType)
ContextualVisibilityHelper(IVisibilityHelper parent, LightweightTypeReference contextType, String packageName)
ContextualVisibilityHelper(LightweightTypeReference contextType)

Constructor parameters in org.eclipse.xtext.xbase.typesystem.util with type arguments of type LightweightTypeReference

Constructor and Description
ExtendedEarlyExitComputer.FilteringThrownExceptionDelegate(IThrownExceptionDelegate delegate, List<LightweightTypeReference> caughtExceptions)
ExtendedEarlyExitComputer.ThrownExceptionDelegate(List<LightweightTypeReference> result, IResolvedTypes types, ITypeReferenceOwner owner)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.util

Methods in org.eclipse.xtext.xbase.util that return LightweightTypeReference

Modifier and Type	Method and Description
LightweightTypeReference	XSwitchExpressions.getSwitchVariableType(XSwitchExpression it)

Methods in org.eclipse.xtext.xbase.util with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
boolean	TypesOrderUtil.isHandled(LightweightTypeReference actualTypeReference, Collection<LightweightTypeReference> collection)
boolean	TypesOrderUtil.isHandled(LightweightTypeReference actualTypeReference, LightweightTypeReference previousTypeReference)

Method parameters in org.eclipse.xtext.xbase.util with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
boolean	TypesOrderUtil.isHandled(LightweightTypeReference actualTypeReference, Collection<LightweightTypeReference> collection)

Uses of LightweightTypeReference in org.eclipse.xtext.xbase.validation

Methods in org.eclipse.xtext.xbase.validation that return LightweightTypeReference

Modifier and Type	Method and Description
protected LightweightTypeReference	XbaseValidator.getActualType(org.eclipse.emf.ecore.EObject context, JvmIdentifiableElement element)
protected LightweightTypeReference	XbaseValidator.getActualType(JvmIdentifiableElement identifiable)
protected LightweightTypeReference	XbaseValidator.getActualType(XExpression expression)
protected LightweightTypeReference	XbaseValidator.getExpectedType(XExpression expression)
protected LightweightTypeReference	XbaseValidator.toLightweightTypeReference(JvmTypeReference typeRef)
protected LightweightTypeReference	XbaseValidator.toLightweightTypeReference(JvmTypeReference typeRef, boolean keepUnboundWildcardInformation)

Methods in org.eclipse.xtext.xbase.validation with parameters of type LightweightTypeReference

Modifier and Type	Method and Description
protected String	XbaseValidator.canonicalName(LightweightTypeReference typeRef)
protected void	XbaseValidator.checkCast(JvmTypeReference concreteSyntax, LightweightTypeReference toType, LightweightTypeReference fromType)
protected boolean	XbaseValidator.containsTypeArgs(LightweightTypeReference instanceOfType)
protected String	XbaseValidator.getNameOfTypes(LightweightTypeReference expectedType)
protected boolean	XbaseValidator.isFinal(LightweightTypeReference expressionTypeRef)
protected boolean	XbaseValidator.isHandled(LightweightTypeReference actualTypeReference, Collection<LightweightTypeReference> collection)
protected boolean	XbaseValidator.memberOfTypeHierarchy(LightweightTypeReference type, LightweightTypeReference potentialMember)
protected String	UIStrings.referenceToString(LightweightTypeReference reference)

Method parameters in org.eclipse.xtext.xbase.validation with type arguments of type LightweightTypeReference

Modifier and Type	Method and Description
protected boolean	XbaseValidator.isHandled(LightweightTypeReference actualTypeReference, Collection<LightweightTypeReference> collection)