java.lang.Object
- org.eclipse.xtext.xbase.typesystem.internal.AbstractTypeComputationState

All Implemented Interfaces:

ITypeComputationState

Direct Known Subclasses:

AbstractRootTypeComputationState, AbstractStackedTypeComputationState
```
public abstract class AbstractTypeComputationState
extends java.lang.Object
implements ITypeComputationState
```
Base implementation of ITypeComputationState.

Field Summary

Fields
Modifier and Type Field Description

protected ResolvedTypes resolvedTypes

Constructor Summary

Constructors
Modifier Constructor Description

protected AbstractTypeComputationState(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession)

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`acceptActualType(LightweightTypeReference type)`	Annotates the currently considered expression(s) with the given type.
`void`	`acceptActualType(LightweightTypeReference type, int flags)`	Annotates the currently considered expression(s) with the given type.
`void`	`acceptActualType(LightweightTypeReference type, java.util.EnumSet<ConformanceHint> hints)`	Annotates the currently considered expression(s) with the given type.
`void`	`acceptActualType(LightweightTypeReference type, ConformanceHint... hints)`	Annotates the currently considered expression(s) with the given type.
`void`	`acceptCandidate(XExpression expression, IApplicableCandidate candidate)`	Allows to register a candidate that gets the chance to validate or change the state of the AST in a subsequent processing step.
`protected abstract LightweightTypeReference`	`acceptType(ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)`
`protected abstract LightweightTypeReference`	`acceptType(XExpression alreadyHandled, ResolvedTypes types, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags)`
`void`	`addDiagnostic(org.eclipse.xtext.diagnostics.AbstractDiagnostic diagnostic)`	Adds the given diagnostic to the current state.
`void`	`addExtensionsToCurrentScope(java.util.List<? extends org.eclipse.xtext.common.types.JvmIdentifiableElement> extensionProviders)`	Adds the given elements as extension providers to the current scope.
`void`	`addExtensionToCurrentScope(org.eclipse.xtext.common.types.JvmIdentifiableElement extensionProvider)`	Adds the given element as an extension provider to the current scope.
`void`	`addImports(ITypeImporter.Client importer)`	Allows to add several imports in a bulk operation on a fine grained basis, e.g.
`void`	`addLocalToCurrentScope(org.eclipse.xtext.common.types.JvmIdentifiableElement element)`	Adds the given element as a local variable.
`protected void`	`addLocalToCurrentScope(org.eclipse.xtext.naming.QualifiedName elementName, org.eclipse.xtext.common.types.JvmIdentifiableElement element, boolean raiseIssueIfShadowing)`
`void`	`addTypeToStaticExtensionImportScope(org.eclipse.xtext.common.types.JvmDeclaredType type)`	Adds the given type to the static extension scope.
`void`	`addTypeToStaticImportScope(org.eclipse.xtext.common.types.JvmDeclaredType type)`	Adds the given type to the static scope.
`void`	`afterScope(org.eclipse.emf.ecore.EObject context)`	If the expression tree contains intermediate objects, e.g.
`AbstractTypeComputationState`	`assignType(org.eclipse.xtext.common.types.JvmIdentifiableElement element, LightweightTypeReference type)`	Assigns the type to the given element and makes the element available in the scope.
`AbstractTypeComputationState`	`assignType(org.eclipse.xtext.common.types.JvmIdentifiableElement element, LightweightTypeReference type, boolean addToChildScope)`	Assigns the given type to the given element and optionally adds the element to the scope.
`void`	`assignType(org.eclipse.xtext.naming.QualifiedName name, org.eclipse.xtext.common.types.JvmType rawType, LightweightTypeReference actualType)`	Assigns the given actual type to the raw type which shall be reachable with the given name.
`TypeAssigner`	`assignTypes()`	Obtain a new `ITypeAssigner` that allows to add a bulk of `elements` to this computation state.
`ITypeComputationResult`	`computeTypes(XExpression expression)`	Triggers type computation for a child expression of the currently considered expression.
`protected IFeatureLinkingCandidate`	`createCandidate(XAbstractFeatureCall featureCall, StackedResolvedTypes demandComputedTypes, IIdentifiableElementDescription description)`
`protected IConstructorLinkingCandidate`	`createCandidate(XConstructorCall constructorCall, IIdentifiableElementDescription description)`
`protected IFeatureLinkingCandidate`	`createCandidateWithReceiverType(XAbstractFeatureCall featureCall, StackedResolvedTypes demandComputedTypes, IIdentifiableElementDescription description)`
`protected ExpressionTypeComputationState`	`createExpressionComputationState(XExpression expression, StackedResolvedTypes typeResolution)`
`protected IFeatureLinkingCandidate`	`createResolvedLink(XAbstractFeatureCall featureCall, org.eclipse.xtext.common.types.JvmIdentifiableElement resolvedTo)`
`protected IConstructorLinkingCandidate`	`createResolvedLink(XConstructorCall constructorCall, org.eclipse.xtext.common.types.JvmConstructor resolvedTo)`
`protected TypeAssigner`	`createTypeAssigner(AbstractTypeComputationState state)`
`UnboundTypeReference`	`createUnboundTypeReference(XExpression expression, org.eclipse.xtext.common.types.JvmTypeParameter typeParameter)`	Create a new, managed `UnboundTypeReference` for the given type parameter which was first encountered for the given expression.
`void`	`discardReassignedTypes(org.eclipse.xtext.common.types.JvmIdentifiableElement refinable)`	A reassigned type may become obsolete due to assignments.
`protected ExpressionAwareStackedResolvedTypes`	`doComputeTypes(XExpression expression)`
`java.util.List<? extends ITypeExpectation>`	`getExpectations()`	The result is never empty.
`protected abstract java.util.List<AbstractTypeExpectation>`	`getExpectations(AbstractTypeComputationState actualState)`
`java.util.List<LightweightTypeReference>`	`getExpectedExceptions()`
`IFeatureScopeSession`	`getFeatureScopeSession()`
`java.util.List<IFeatureLinkingCandidate>`	`getLinkingCandidates(XAbstractFeatureCall featureCall)`	The result is never empty.
`java.util.List<IConstructorLinkingCandidate>`	`getLinkingCandidates(XConstructorCall constructorCall)`	The result is never empty.
`ITypeReferenceOwner`	`getReferenceOwner()`	The current type reference owner for newly converted type references.
`ResolvedTypes`	`getResolvedTypes()`
`protected DefaultReentrantTypeResolver`	`getResolver()`
`protected java.util.List<? extends ITypeExpectation>`	`getReturnExpectations()`
`protected abstract java.util.List<AbstractTypeExpectation>`	`getReturnExpectations(AbstractTypeComputationState actualState, boolean asActualExpectation)`
`protected org.eclipse.xtext.validation.IssueSeverities`	`getSeverities()`
`org.eclipse.xtext.diagnostics.Severity`	`getSeverity(java.lang.String issueCode)`	Returns the severity for the given `issueCode`.
`protected ITypeExpectation`	`getSingleExpectation(ITypeComputationState state)`
`protected ITypeComputer`	`getTypeComputer()`
`protected org.eclipse.xtext.common.types.util.TypeReferences`	`getTypeReferences()`
`boolean`	`isIgnored(java.lang.String issueCode)`	Returns `false` if no issues have to be produced for the given issueCode.
`protected ExpressionAwareStackedResolvedTypes`	`pushTypes(XExpression expression)`
`void`	`reassignType(org.eclipse.xtext.common.types.JvmIdentifiableElement refinable, LightweightTypeReference type)`	Allows to specialize the known type of an identifiable, that was already annotated with a type.
`void`	`refineExpectedType(XExpression expression, LightweightTypeReference expectation)`	After the fact refinement of the expected type.
`void`	`rewriteScope(org.eclipse.emf.ecore.EObject context)`	If the container of an expression decides to alter the scope after the expression was typed, its AFTER scope may be rewritten.
`protected IIdentifiableElementDescription`	`toIdentifiableDescription(org.eclipse.xtext.resource.IEObjectDescription description)`
`java.lang.String`	`toString()`
`TypeComputationStateWithExpectation`	`withExpectation(LightweightTypeReference expectation)`	The given expectation will be resolved if it contains unresolved type arguments, e.g.
`AbstractTypeComputationState`	`withExpectedExceptions(java.util.List<LightweightTypeReference> declaredExceptionTypes)`
`void`	`withinScope(org.eclipse.emf.ecore.EObject context)`	If the expression tree contains expressions that define a new scope, e.g.
`AbstractTypeComputationState`	`withNonVoidExpectation()`	Keep the current return expectation and assume an actual expectation that is not void.
`protected AbstractTypeComputationState`	`withNonVoidExpectation(ResolvedTypes resolvedTypes)`
`AbstractTypeComputationState`	`withoutExpectation()`	Keeps the return type expectation.
`TypeComputationStateWithRootExpectation`	`withoutRootExpectation()`	The outer context is ignored for child expressions and the newly produced context does not impose any restrictions on the expectation.
`AbstractTypeComputationState`	`withReturnExpectation()`	Transfers the available return type expectation to the actual expectation of this computation step.
`TypeComputationStateWithRootExpectation`	`withRootExpectation(LightweightTypeReference expectation)`	The given expectation becomes the expected return type and the expected type for the current context.
`TypeCheckpointComputationState`	`withTypeCheckpoint(org.eclipse.emf.ecore.EObject context)`	A type checkpoint allows to re-specify the type of an identifiable that was already type-computed.

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

- Field Detail
  - resolvedTypes
```
protected final ResolvedTypes resolvedTypes
```
- Constructor Detail
  - AbstractTypeComputationState
```
protected AbstractTypeComputationState(ResolvedTypes resolvedTypes,
                                       IFeatureScopeSession featureScopeSession)
```
- Method Detail
  - getResolvedTypes
```
public ResolvedTypes getResolvedTypes()
```
  - getFeatureScopeSession
```
public IFeatureScopeSession getFeatureScopeSession()
```
  - getTypeReferences
```
protected org.eclipse.xtext.common.types.util.TypeReferences getTypeReferences()
```
  - getTypeComputer
```
protected ITypeComputer getTypeComputer()
```
  - getResolver
```
protected DefaultReentrantTypeResolver getResolver()
```
  - acceptType
```
protected abstract LightweightTypeReference acceptType(ResolvedTypes types,
                                                       AbstractTypeExpectation expectation,
                                                       LightweightTypeReference type,
                                                       boolean returnType,
                                                       int flags)
```
  - acceptType
```
protected abstract LightweightTypeReference acceptType(XExpression alreadyHandled,
                                                       ResolvedTypes types,
                                                       AbstractTypeExpectation expectation,
                                                       LightweightTypeReference type,
                                                       boolean returnType,
                                                       int flags)
```
  - computeTypes
```
public final ITypeComputationResult computeTypes(XExpression expression)
```
    Description copied from interface: ITypeComputationState
    
    Triggers type computation for a child expression of the currently considered expression.
    
    Specified by:
    
    computeTypes in interface ITypeComputationState
  - doComputeTypes
```
protected ExpressionAwareStackedResolvedTypes doComputeTypes(XExpression expression)
```
  - pushTypes
```
protected ExpressionAwareStackedResolvedTypes pushTypes(XExpression expression)
```
  - createExpressionComputationState
```
protected ExpressionTypeComputationState createExpressionComputationState(XExpression expression,
                                                                          StackedResolvedTypes typeResolution)
```
  - withExpectation
```
public TypeComputationStateWithExpectation withExpectation(LightweightTypeReference expectation)
```
    Description copied from interface: ITypeComputationState
    
    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. <T> T foo(T, T) with foo<String>(null, 'string') will allow to pass the unresolved T as expectation where clients would be invoked with the better candidate 'string'.
    
    Specified by:
    
    withExpectation in interface ITypeComputationState
  - refineExpectedType
```
public void refineExpectedType(XExpression expression,
                               LightweightTypeReference expectation)
```
    Description copied from interface: ITypeComputationState
    After the fact refinement of the expected type. The expected type of a given expression may be changed after the real type of that expression is known. Example:
    for(double d: produceIntArray) { }
    Expressions are resolved in the context of an expected type, which may or may not exist (e.g. it may be null). The expectation for the call to produceIntArray is double[]. However, the method returns an array of int. The tricky part is, that an int[] is not assignable to a double[] which would lead to incompatible types. Nevertheless, the expression is valid, since the component type is relevant for the compatibility in the context of a for-loop. Therefore, the expectation is refined after the fact to int[] because the conformance could be validated.
    Specified by:
    
    refineExpectedType in interface ITypeComputationState
  - withRootExpectation
```
public TypeComputationStateWithRootExpectation withRootExpectation(LightweightTypeReference expectation)
```
    Description copied from interface: ITypeComputationState
    
    The given expectation becomes the expected return type and the expected type for the current context. Outer context is ignored for child expressions.
    
    Specified by:
    
    withRootExpectation in interface ITypeComputationState
  - withoutRootExpectation
```
public TypeComputationStateWithRootExpectation withoutRootExpectation()
```
    Description copied from interface: ITypeComputationState
    
    The outer context is ignored for child expressions and the newly produced context does not impose any restrictions on the expectation.
    
    Specified by:
    
    withoutRootExpectation in interface ITypeComputationState
  - withNonVoidExpectation
```
public AbstractTypeComputationState withNonVoidExpectation()
```
    Description copied from interface: ITypeComputationState
    Keep the current return expectation and assume an actual expectation that is not void. Example:
    val x = someExpression
    The expectation for the call to someExpression is anything but void.
    Specified by:
    
    withNonVoidExpectation in interface ITypeComputationState
  - withNonVoidExpectation
```
protected AbstractTypeComputationState withNonVoidExpectation(ResolvedTypes resolvedTypes)
```
  - withReturnExpectation
```
public AbstractTypeComputationState withReturnExpectation()
```
    Description copied from interface: ITypeComputationState
    Transfers the available return type expectation to the actual expectation of this computation step.
    op someMethod: String { return someExpression }
    The actual expectation of the child someExpression is the return expectation in that context, e.g. java.lang.String in the given example.
    Specified by:
    
    withReturnExpectation in interface ITypeComputationState
  - withoutExpectation
```
public AbstractTypeComputationState withoutExpectation()
```
    Description copied from interface: ITypeComputationState
    Keeps the return type expectation. Otherwise the new state does not have any expectations. Example:
    { someExpression subsequent }
    The expectation for the call to someExpression does not have any actual expectations.
    Specified by:
    
    withoutExpectation in interface ITypeComputationState
  - withTypeCheckpoint
```
public TypeCheckpointComputationState withTypeCheckpoint(org.eclipse.emf.ecore.EObject context)
```
    Description copied from interface: ITypeComputationState
    
    A type checkpoint allows to re-specify the type of an identifiable that was already type-computed. The refined type is discarded as soon as the state is left. In that sense, the type checkpoint describes the scope of certain type specializations.
    
    Specified by:
    
    withTypeCheckpoint in interface ITypeComputationState
    
    Parameters:
    
    context - an indicator that describes the context of this type checkpoint, e.g. an XCasePart.
  - withExpectedExceptions
```
public AbstractTypeComputationState withExpectedExceptions(java.util.List<LightweightTypeReference> declaredExceptionTypes)
```
    Specified by:
    
    withExpectedExceptions in interface ITypeComputationState
  - assignType
```
public AbstractTypeComputationState assignType(org.eclipse.xtext.common.types.JvmIdentifiableElement element,
                                               LightweightTypeReference type)
```
    Description copied from interface: ITypeComputationState
    
    Assigns the type to the given element and makes the element available in the scope. This is fully equivalent to assignType(element, type, true). Each element may only be typed once.
    
    Specified by:
    
    assignType in interface ITypeComputationState
    
    Parameters:
    
    element - the identifiable that will be annotated with the given type.
    
    type - the type of the element. null or other invalid types will be treated as error types.
    
    See Also:
    
    ITypeComputationState.assignType(JvmIdentifiableElement, LightweightTypeReference, boolean), ITypeComputationState.addLocalToCurrentScope(JvmIdentifiableElement), ITypeComputationState.assignTypes(), ITypeAssigner
  - assignType
```
public AbstractTypeComputationState assignType(org.eclipse.xtext.common.types.JvmIdentifiableElement element,
                                               LightweightTypeReference type,
                                               boolean addToChildScope)
```
    Description copied from interface: ITypeComputationState
    
    Assigns the given type to the given element and optionally adds the element to the scope. Each element may only be typed once.
    
    Specified by:
    
    assignType in interface ITypeComputationState
    
    Parameters:
    
    element - the identifiable that will be annotated with the given type.
    
    type - the type of the element. null or other invalid types will be treated as error types.
    
    addToChildScope - true if the element should be added to the child scope, false if only the type information should be recorded.
    
    See Also:
    
    ITypeAssigner, ITypeComputationState.assignTypes(), ITypeComputationState.addLocalToCurrentScope(JvmIdentifiableElement)
  - addLocalToCurrentScope
```
public void addLocalToCurrentScope(org.eclipse.xtext.common.types.JvmIdentifiableElement element)
```
    Description copied from interface: ITypeComputationState
    
    Adds the given element as a local variable. An issue is recorded if the new element will shadow an existing element. If the new element has a disallowed name, it will not be added to the scope.
    
    Specified by:
    
    addLocalToCurrentScope in interface ITypeComputationState
    
    Parameters:
    
    element - the newly added element (e.g. a variable or parameter.
    
    See Also:
    
    FeatureNameValidator
  - addExtensionToCurrentScope
```
public void addExtensionToCurrentScope(org.eclipse.xtext.common.types.JvmIdentifiableElement extensionProvider)
```
    Description copied from interface: ITypeComputationState
    
    Adds the given element as an extension provider to the current scope.
    
    Specified by:
    
    addExtensionToCurrentScope in interface ITypeComputationState
    
    Parameters:
    
    extensionProvider - the identifiable that points to the extension provider
  - addTypeToStaticImportScope
```
public void addTypeToStaticImportScope(org.eclipse.xtext.common.types.JvmDeclaredType type)
```
    Description copied from interface: ITypeComputationState
    
    Adds the given type to the static scope.
    
    Specified by:
    
    addTypeToStaticImportScope in interface ITypeComputationState
    
    Parameters:
    
    type - the type that is added to the static scope.
  - addTypeToStaticExtensionImportScope
```
public void addTypeToStaticExtensionImportScope(org.eclipse.xtext.common.types.JvmDeclaredType type)
```
    Description copied from interface: ITypeComputationState
    
    Adds the given type to the static extension scope.
    
    Specified by:
    
    addTypeToStaticExtensionImportScope in interface ITypeComputationState
    
    Parameters:
    
    type - the type that is added to the static extension scope.
  - addImports
```
public void addImports(ITypeImporter.Client importer)
```
    Description copied from interface: ITypeComputationState
    
    Allows to add several imports in a bulk operation on a fine grained basis, e.g. it supports to import only a subset of the members of a type.
    
    Specified by:
    
    addImports in interface ITypeComputationState
  - addExtensionsToCurrentScope
```
public void addExtensionsToCurrentScope(java.util.List<? extends org.eclipse.xtext.common.types.JvmIdentifiableElement> extensionProviders)
```
    Description copied from interface: ITypeComputationState
    
    Adds the given elements as extension providers to the current scope. The elements are all treated with equal priority, e.g. their contributed extensions may be ambiguous.
    
    Specified by:
    
    addExtensionsToCurrentScope in interface ITypeComputationState
    
    Parameters:
    
    extensionProviders - the identifiables that contribute to the extension scope
  - addLocalToCurrentScope
```
protected void addLocalToCurrentScope(org.eclipse.xtext.naming.QualifiedName elementName,
                                      org.eclipse.xtext.common.types.JvmIdentifiableElement element,
                                      boolean raiseIssueIfShadowing)
```
  - assignType
```
public void assignType(org.eclipse.xtext.naming.QualifiedName name,
                       org.eclipse.xtext.common.types.JvmType rawType,
                       LightweightTypeReference actualType)
```
    Description copied from interface: ITypeComputationState
    Assigns the given actual type to the raw type which shall be reachable with the given name. This is useful to refine the context of certain expression children, e.g. the body of a lambda expression shall use the visibility constraints of the implemented SAM type.
    assignType(IFeatureNames.SELF, 'java.util.Comparator', 'java.util.Comparator<String>');
    Specified by:
    
    assignType in interface ITypeComputationState
    
    Parameters:
    
    name - the name of the feature that should point to the given type, e.g. IFeatureNames.THIS
    
    rawType - the type that declares the context of the expression.
    
    actualType - the context type with bound type arguments (possibly unresolved).
  - assignTypes
```
public TypeAssigner assignTypes()
```
    Description copied from interface: ITypeComputationState
    
    Obtain a new ITypeAssigner that allows to add a bulk of elements to this computation state.
    
    Specified by:
    
    assignTypes in interface ITypeComputationState
  - addDiagnostic
```
public void addDiagnostic(org.eclipse.xtext.diagnostics.AbstractDiagnostic diagnostic)
```
    Description copied from interface: ITypeComputationState
    
    Adds the given diagnostic to the current state. If this state is later discarded in favor of a better solution, the diagnostic is discarded, too.
    
    Specified by:
    
    addDiagnostic in interface ITypeComputationState
  - createTypeAssigner
```
protected TypeAssigner createTypeAssigner(AbstractTypeComputationState state)
```
  - getExpectations
```
public final java.util.List<? extends ITypeExpectation> getExpectations()
```
    Description copied from interface: ITypeComputationState
    
    The result is never empty.
    
    Specified by:
    
    getExpectations in interface ITypeComputationState
  - getReturnExpectations
```
protected final java.util.List<? extends ITypeExpectation> getReturnExpectations()
```
  - getExpectations
```
protected abstract java.util.List<AbstractTypeExpectation> getExpectations(AbstractTypeComputationState actualState)
```
  - getReturnExpectations
```
protected abstract java.util.List<AbstractTypeExpectation> getReturnExpectations(AbstractTypeComputationState actualState,
                                                                                 boolean asActualExpectation)
```
  - acceptCandidate
```
public void acceptCandidate(XExpression expression,
                            IApplicableCandidate candidate)
```
    Description copied from interface: ITypeComputationState
    
    Allows to register a candidate that gets the chance to validate or change the state of the AST in a subsequent processing step.
    
    Specified by:
    
    acceptCandidate in interface ITypeComputationState
    
    Parameters:
    
    expression - the expression that the given candidate is associated with.
    
    candidate - the candidate to validate if it is still present at the root of the decision tree.
    
    See Also:
    
    IClosureCandidate
  - acceptActualType
```
public void acceptActualType(LightweightTypeReference type)
```
    Description copied from interface: ITypeComputationState
    
    Annotates the currently considered expression(s) with the given type. It is assumed that the type does not depend on the expectation.
    
    Specified by:
    
    acceptActualType in interface ITypeComputationState
  - acceptActualType
```
public void acceptActualType(LightweightTypeReference type,
                             ConformanceHint... hints)
```
    Description copied from interface: ITypeComputationState
    
    Annotates the currently considered expression(s) with the given type. It is assumed that the type does not depend on the expectation. The conformance hints are used to decide which variant will be finally chosen, if more than one type was given.
    
    Specified by:
    
    acceptActualType in interface ITypeComputationState
  - acceptActualType
```
public void acceptActualType(LightweightTypeReference type,
                             java.util.EnumSet<ConformanceHint> hints)
```
    Description copied from interface: ITypeComputationState
    
    Annotates the currently considered expression(s) with the given type. It is assumed that the type does not depend on the expectation. The conformance hints are used to decide which variant will be finally chosen, if more than one type was given.
    
    Specified by:
    
    acceptActualType in interface ITypeComputationState
  - acceptActualType
```
public void acceptActualType(LightweightTypeReference type,
                             int flags)
```
    Description copied from interface: ITypeComputationState
    
    Annotates the currently considered expression(s) with the given type. It is assumed that the type does not depend on the expectation. The flags are used to decide which variant will be finally chosen, if more than one type was given.
    
    Specified by:
    
    acceptActualType in interface ITypeComputationState
    
    See Also:
    
    ConformanceFlags
  - reassignType
```
public void reassignType(org.eclipse.xtext.common.types.JvmIdentifiableElement refinable,
                         LightweightTypeReference type)
```
    Description copied from interface: ITypeComputationState
    Allows to specialize the known type of an identifiable, that was already annotated with a type. Type refinements may be used to save casts. Usually only simple identifiables should be refined, e.g. local variables. It's the clients responsibility to decide about that. Example:
    val Object x = obtainInstance if (x instanceof String && x.length > 0) { x.substring(1) }
    The instanceof expression may refine the type for subsequent expressions, e.g. in boolean conditions or blocks.
    Specified by:
    
    reassignType in interface ITypeComputationState
  - discardReassignedTypes
```
public void discardReassignedTypes(org.eclipse.xtext.common.types.JvmIdentifiableElement refinable)
```
    Description copied from interface: ITypeComputationState
    A reassigned type may become obsolete due to assignments. Those should discard the reassign information. Example:
    var node = someNode; while(node instanceof ContainerNode) { node = node.container node.container // type error }
    After the assignment in the while loop, the node is no longer considered to be a ContainerNode.
    Specified by:
    
    discardReassignedTypes in interface ITypeComputationState
  - getLinkingCandidates
```
public java.util.List<IFeatureLinkingCandidate> getLinkingCandidates(XAbstractFeatureCall featureCall)
```
    Description copied from interface: ITypeComputationState
    
    The result is never empty.
    
    Specified by:
    
    getLinkingCandidates in interface ITypeComputationState
  - createResolvedLink
```
protected IFeatureLinkingCandidate createResolvedLink(XAbstractFeatureCall featureCall,
                                                      org.eclipse.xtext.common.types.JvmIdentifiableElement resolvedTo)
```
  - createCandidate
```
protected IFeatureLinkingCandidate createCandidate(XAbstractFeatureCall featureCall,
                                                   StackedResolvedTypes demandComputedTypes,
                                                   IIdentifiableElementDescription description)
```
  - getSingleExpectation
```
protected ITypeExpectation getSingleExpectation(ITypeComputationState state)
```
  - createCandidateWithReceiverType
```
protected IFeatureLinkingCandidate createCandidateWithReceiverType(XAbstractFeatureCall featureCall,
                                                                   StackedResolvedTypes demandComputedTypes,
                                                                   IIdentifiableElementDescription description)
```
  - getLinkingCandidates
```
public java.util.List<IConstructorLinkingCandidate> getLinkingCandidates(XConstructorCall constructorCall)
```
    Description copied from interface: ITypeComputationState
    
    The result is never empty.
    
    Specified by:
    
    getLinkingCandidates in interface ITypeComputationState
  - toIdentifiableDescription
```
protected IIdentifiableElementDescription toIdentifiableDescription(org.eclipse.xtext.resource.IEObjectDescription description)
```
  - createResolvedLink
```
protected IConstructorLinkingCandidate createResolvedLink(XConstructorCall constructorCall,
                                                          org.eclipse.xtext.common.types.JvmConstructor resolvedTo)
```
  - createCandidate
```
protected IConstructorLinkingCandidate createCandidate(XConstructorCall constructorCall,
                                                       IIdentifiableElementDescription description)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getReferenceOwner
```
public ITypeReferenceOwner getReferenceOwner()
```
    Description copied from interface: ITypeComputationState
    
    The current type reference owner for newly converted type references.
    
    Specified by:
    
    getReferenceOwner in interface ITypeComputationState
  - createUnboundTypeReference
```
public UnboundTypeReference createUnboundTypeReference(XExpression expression,
                                                       org.eclipse.xtext.common.types.JvmTypeParameter typeParameter)
```
    Description copied from interface: ITypeComputationState
    
    Create a new, managed UnboundTypeReference for the given type parameter which was first encountered for the given expression.
    
    Specified by:
    
    createUnboundTypeReference in interface ITypeComputationState
    
    Parameters:
    
    expression - the expression that used / referenced the type parameter
    
    typeParameter - the type parameter
  - getExpectedExceptions
```
public java.util.List<LightweightTypeReference> getExpectedExceptions()
```
    Specified by:
    
    getExpectedExceptions in interface ITypeComputationState
  - getSeverities
```
protected org.eclipse.xtext.validation.IssueSeverities getSeverities()
```
  - getSeverity
```
public org.eclipse.xtext.diagnostics.Severity getSeverity(java.lang.String issueCode)
```
    Description copied from interface: ITypeComputationState
    
    Returns the severity for the given issueCode.
    
    Specified by:
    
    getSeverity in interface ITypeComputationState
  - isIgnored
```
public boolean isIgnored(java.lang.String issueCode)
```
    Description copied from interface: ITypeComputationState
    
    Returns false if no issues have to be produced for the given issueCode.
    
    Specified by:
    
    isIgnored in interface ITypeComputationState
  - withinScope
```
public void withinScope(org.eclipse.emf.ecore.EObject context)
```
    Description copied from interface: ITypeComputationState
    
    If the expression tree contains expressions that define a new scope, e.g. add local variables to the scope as a XForLoopExpression would do, the scope for contained expressions may be explicitly recorded by announcing that the inference is now done within that newly created scope.
    
    Specified by:
    
    withinScope in interface ITypeComputationState
  - afterScope
```
public void afterScope(org.eclipse.emf.ecore.EObject context)
```
    Description copied from interface: ITypeComputationState
    
    If the expression tree contains intermediate objects, e.g. XCasePart or XCatchClause, one can explicitly record the scope of these objects as these won't be processed by the inference infrastructure.
    
    Specified by:
    
    afterScope in interface ITypeComputationState
  - rewriteScope
```
public void rewriteScope(org.eclipse.emf.ecore.EObject context)
```
    Description copied from interface: ITypeComputationState
    
    If the container of an expression decides to alter the scope after the expression was typed, its AFTER scope may be rewritten.
    
    Specified by:
    
    rewriteScope in interface ITypeComputationState

Class AbstractTypeComputationState

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

resolvedTypes

Constructor Detail

AbstractTypeComputationState

Method Detail

getResolvedTypes

getFeatureScopeSession

getTypeReferences

getTypeComputer

getResolver

acceptType

acceptType

computeTypes

doComputeTypes

pushTypes

createExpressionComputationState

withExpectation

refineExpectedType

withRootExpectation

withoutRootExpectation

withNonVoidExpectation

withNonVoidExpectation

withReturnExpectation

withoutExpectation

withTypeCheckpoint

withExpectedExceptions

assignType

assignType

addLocalToCurrentScope

addExtensionToCurrentScope

addTypeToStaticImportScope

addTypeToStaticExtensionImportScope

addImports

addExtensionsToCurrentScope

addLocalToCurrentScope

assignType

assignTypes

addDiagnostic

createTypeAssigner

getExpectations

getReturnExpectations

getExpectations

getReturnExpectations

acceptCandidate

acceptActualType

acceptActualType

acceptActualType

acceptActualType

reassignType

discardReassignedTypes

getLinkingCandidates

createResolvedLink

createCandidate

getSingleExpectation

createCandidateWithReceiverType

getLinkingCandidates

toIdentifiableDescription

createResolvedLink

createCandidate

toString

getReferenceOwner

createUnboundTypeReference

getExpectedExceptions

getSeverities

getSeverity

isIgnored

withinScope

afterScope

rewriteScope