Package org.eclipse.xtext.xbase.typesystem.override

Interface IResolvedOperation

    • Method Detail

      • getOverriddenAndImplementedMethods

        java.util.List<IResolvedOperation> getOverriddenAndImplementedMethods()
        Returns overridden and implemented methods for this method. Example: 
         interface I {
   void method()
 }
 abstract class C {
   abstract void method()
 }
 class D extends C implements I {
   void method() {}
 }
        The resolved representation of D#method will return a list with two elements: C#method, I#method. The first element in the list is always the overridden implementation or the inherited abstract method from the superclass, if any. Thus the list is sorted. The elements in the list are not transitively collected. 
         interface I1 {
   void method()
 }
 interface I2 {
   void method()
 }
 interface I3 extends I1, I2 {
 }
 interface I4 {
   void method()
 }
 interface I5 extends I4 {
   void method()
 }
 class C implements I5, I3 {
   void method()
 }
        The list of resolved inherited methods for C#method will be I1#method, I2#method, I5#method thus it will not contain and of I4#method. Only methods that would be successfully checked for isOverridingOrImplementing(JvmOperation) will be returned.
        Returns:
        a list of overridden and implemented methods.
        See Also:
        getOverriddenAndImplementedMethodCandidates()

      • getOverriddenMethod

        IResolvedOperation getOverriddenMethod()
        Returns the overridden method, if any. A candidate is considered to be the overridden method if this method itself is not abstract, the candidate is contained in the list of overridden and implemented methods, and the candidate is not abstract. It may happen that two methods are overridden, e.g. 
         class A<T> {
        void m(T t) {
        }
 
        void m(String s) {
        }
 }
 
 class B extends A<String> {
        @Override
        void m(String s) {
        }
 }
        In that case, the first match is returned thus it depends on the order in the super type.
        Returns:
        a super implementation or null if none.
        See Also:
        getOverriddenAndImplementedMethods()

      • isOverridingOrImplementing

        IOverrideCheckResult isOverridingOrImplementing​(org.eclipse.xtext.common.types.JvmOperation operation)
        Transitively check whether this operation if implementing or overriding the given operation.
        Returns:
        the check result.

      • getOverrideCheckResult

        IOverrideCheckResult getOverrideCheckResult()
        The override check result that is associated with this operation. If this is a bottom, the details will only include the current detail. In other cases, the actual information about the relationship of the hierarchy function to its specialization in the context is returned.
        Returns:
        the computed check result

      • getIllegallyDeclaredExceptions

        java.util.List<LightweightTypeReference> getIllegallyDeclaredExceptions()
        Returns the list of exceptions that are declared in this operation but do not match the super implementation.
        Returns:
        the list of illegally declared exceptions.

      • getResolvedTypeParameters

        java.util.List<org.eclipse.xtext.common.types.JvmTypeParameter> getResolvedTypeParameters()
        Returns the resolved type parameters for a given operation. If this operation represents an overridden operation, the type parameters are the ones that are declared on the initially requested resolved operation. Consider the following interface and implementation class: 
         interface I {
   <T extends CharSequence> T method()
 }
 class C implements I {
   public <V extends CharSequence> V method() {
     return null;
   }
 }
        If the initially requested method was C#method and the current handle points to I#method, the type parameters will contain V instead of T. The list may contain a different number of type parameters than the actual operation. 
         interface I {
   <T> T method()
 }
 class C implements I {
   public String method() {
     return null;
   }
 }
        The method I#method in the context of class C will yield an empty list of resolved type parameters even though it declares T.
        Returns:
        the list of resolved type parameters.

      • getResolvedTypeParameterConstraints

        java.util.List<LightweightTypeReference> getResolvedTypeParameterConstraints​(int idx)
                                                                      throws java.lang.IndexOutOfBoundsException
        Returns the list of resolved constraints for the given type parameter index. Consider the following example: 
         interface I<T> {
   <V extends T> V method(Class<? extends V> c);
 }
 
 abstract class C implements I<CharSequence> {
 }
        The resolved constraint of I#method<V> in the context of class C is CharSequence.
        Parameters:
        idx - the index of the considered type parameter.
        Returns:
        a list of resolved upper bound constraints for the type parameter at index idx.
        Throws:
        java.lang.IndexOutOfBoundsException - if the idx does not match the resolved type parameter list.
        See Also:
        getResolvedTypeParameterConstraints(int)

      • isBottomInContext

        boolean isBottomInContext()
        Returns true if the bottom of this resolved method hierachy, which that there is no specialization of this method in the current context. 
         interface I1 {
   void m()
 }
 interface I2 {
   void m()
 }
 abstract class C implements I1, I2 {
 }
        If you get hold on the abstract method I1#m or I2#m both will return true.
        See Also:
        getAsBottom()

      • getAsBottom

        IResolvedOperation getAsBottom()
        Returns the current method as a bottom method. That implies, that the context type of the result is the resolved declarator of the current declaration. 
         interface I<T> {
   <K> T m(K k);
 }
 class C implements I<V< {
   <U> V m(U u);
 }
        If this resolved method represents I#m in the context of class C (thus the return type will be V and the resolved type parameters include U, getAsBottom() will yield I#m in the context of I<V<. That is, the return type is still resolved to V. Nevertheless, the local type parameter of I#m is now resolved to its declaration K. This implies that the parameter type is no longer resolved to U but K instead. The bottom representation can be used to create descriptive error messages. If the current resolved method is already a bottom type, it is returned itself.
        Returns:
        the current operation as bottom type.
        See Also:
        isBottomInContext()