Package org.eclipse.xtext.xbase.typesystem.computation

Interface ITypeComputationState

    • Method Detail

      • withExpectation

        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. <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'.

      • refineExpectedType

        void refineExpectedType​(XExpression expression,
                        LightweightTypeReference expectation)
        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.

      • withRootExpectation

        ITypeComputationState withRootExpectation​(LightweightTypeReference expectation)
        The given expectation becomes the expected return type and the expected type for the current context. Outer context is ignored for child expressions.

      • withoutRootExpectation

        ITypeComputationState withoutRootExpectation()
        The outer context is ignored for child expressions and the newly produced context does not impose any restrictions on the expectation.

      • withNonVoidExpectation

        ITypeComputationState withNonVoidExpectation()
        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.

      • withReturnExpectation

        ITypeComputationState withReturnExpectation()
        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.

      • withoutExpectation

        ITypeComputationState withoutExpectation()
        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.

      • withTypeCheckpoint

        ITypeComputationState withTypeCheckpoint​(org.eclipse.emf.ecore.EObject context)
        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.
        Parameters:
        context - an indicator that describes the context of this type checkpoint, e.g. an XCasePart.

      • computeTypes

        ITypeComputationResult computeTypes​(XExpression expression)
        Triggers type computation for a child expression of the currently considered expression.
        Throws:
        java.lang.IllegalArgumentException - if the given expression is the currently computed expression.

      • assignType

        ITypeComputationState 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. Each element may only be typed once.
        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, assignTypes(), addLocalToCurrentScope(JvmIdentifiableElement)

      • assignTypes

        ITypeAssigner assignTypes()
        Obtain a new ITypeAssigner that allows to add a bulk of elements to this computation state.

      • addLocalToCurrentScope

        void addLocalToCurrentScope​(org.eclipse.xtext.common.types.JvmIdentifiableElement element)
        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.
        Parameters:
        element - the newly added element (e.g. a variable or parameter.
        See Also:
        FeatureNameValidator

      • addExtensionToCurrentScope

        void addExtensionToCurrentScope​(org.eclipse.xtext.common.types.JvmIdentifiableElement extensionProvider)
        Adds the given element as an extension provider to the current scope.
        Parameters:
        extensionProvider - the identifiable that points to the extension provider

      • addTypeToStaticImportScope

        void addTypeToStaticImportScope​(org.eclipse.xtext.common.types.JvmDeclaredType type)
        Adds the given type to the static scope.
        Parameters:
        type - the type that is added to the static scope.

      • addTypeToStaticExtensionImportScope

        void addTypeToStaticExtensionImportScope​(org.eclipse.xtext.common.types.JvmDeclaredType type)
        Adds the given type to the static extension scope.
        Parameters:
        type - the type that is added to the static extension scope.
        Since:
        2.6

      • addImports

        void addImports​(ITypeImporter.Client importer)
        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.
        Since:
        2.6

      • addExtensionsToCurrentScope

        void addExtensionsToCurrentScope​(java.util.List<? extends org.eclipse.xtext.common.types.JvmIdentifiableElement> extensionProviders)
        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.
        Parameters:
        extensionProviders - the identifiables that contribute to the extension scope

      • withinScope

        void withinScope​(org.eclipse.emf.ecore.EObject context)
        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.

      • afterScope

        void afterScope​(org.eclipse.emf.ecore.EObject context)
        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.

      • rewriteScope

        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.

      • assignType

        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. 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>');
        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).

      • getExpectations

        java.util.List<? extends ITypeExpectation> getExpectations()
        The result is never empty.

      • acceptActualType

        void acceptActualType​(LightweightTypeReference type)
        Annotates the currently considered expression(s) with the given type. It is assumed that the type does not depend on the expectation.

      • acceptCandidate

        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.
        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

        void acceptActualType​(LightweightTypeReference type,
                      ConformanceHint... hints)
        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.

      • acceptActualType

        void acceptActualType​(LightweightTypeReference type,
                      java.util.EnumSet<ConformanceHint> hints)
        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.

      • acceptActualType

        void acceptActualType​(LightweightTypeReference type,
                      int flags)
        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.
        See Also:
        ConformanceFlags

      • reassignType

        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. 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.

      • discardReassignedTypes

        void discardReassignedTypes​(org.eclipse.xtext.common.types.JvmIdentifiableElement refinable)
        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.

      • getReferenceOwner

        ITypeReferenceOwner getReferenceOwner()
        The current type reference owner for newly converted type references.

      • createUnboundTypeReference

        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.
        Parameters:
        expression - the expression that used / referenced the type parameter
        typeParameter - the type parameter

      • addDiagnostic

        void addDiagnostic​(org.eclipse.xtext.diagnostics.AbstractDiagnostic diagnostic)
        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.

      • getSeverity

        org.eclipse.xtext.diagnostics.Severity getSeverity​(java.lang.String issueCode)
        Returns the severity for the given issueCode.

      • isIgnored

        boolean isIgnored​(java.lang.String issueCode)
        Returns false if no issues have to be produced for the given issueCode.