public interface IResolvedOperation extends IResolvedExecutable
JvmOperation
.
Parameter types, return type, declared exceptions and type arguments are put into the context of a specific declaring
reference, e.g. List#add(Object)
becomes List#add(String)
in the context of an
ArrayList<String>
Modifier and Type | Method and Description |
---|---|
IResolvedOperation |
getAsBottom()
Returns the current method as a
bottom method . |
JvmOperation |
getDeclaration()
Returns the declared operation that is resolved.
|
java.util.List<LightweightTypeReference> |
getIllegallyDeclaredExceptions()
Returns the list of exceptions that are declared in this operation
but do not match the super implementation.
|
java.util.List<JvmOperation> |
getOverriddenAndImplementedMethodCandidates()
Returns the inherited methods with the same simple name as this method.
|
java.util.List<IResolvedOperation> |
getOverriddenAndImplementedMethods()
Returns overridden and implemented methods for this method.
|
IResolvedOperation |
getOverriddenMethod()
Returns the overridden method, if any.
|
IOverrideCheckResult |
getOverrideCheckResult()
The override check result that is associated with this operation.
|
LightweightTypeReference |
getResolvedReturnType()
Returns the resolved return types in the current context.
|
java.util.List<LightweightTypeReference> |
getResolvedTypeParameterConstraints(int idx)
Returns the list of resolved constraints for the given type parameter index.
|
java.util.List<JvmTypeParameter> |
getResolvedTypeParameters()
Returns the resolved type parameters for a given operation.
|
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. |
IOverrideCheckResult |
isOverridingOrImplementing(JvmOperation operation)
Transitively check whether this operation if implementing or overriding the given operation.
|
getResolvedExceptions, getResolvedParameterTypes, getTypeParameters
getContextType, getResolvedDeclarator, getResolvedErasureSignature, getResolvedSignature, getSimpleSignature
java.util.List<IResolvedOperation> getOverriddenAndImplementedMethods()
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.getOverriddenAndImplementedMethodCandidates()
IResolvedOperation getOverriddenMethod()
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.
null
if none.getOverriddenAndImplementedMethods()
java.util.List<JvmOperation> getOverriddenAndImplementedMethodCandidates()
getOverriddenAndImplementedMethods()
,
isOverridingOrImplementing(JvmOperation)
IOverrideCheckResult isOverridingOrImplementing(JvmOperation operation)
IOverrideCheckResult getOverrideCheckResult()
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.java.util.List<LightweightTypeReference> getIllegallyDeclaredExceptions()
java.util.List<JvmTypeParameter> getResolvedTypeParameters()
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
.java.util.List<LightweightTypeReference> getResolvedTypeParameterConstraints(int idx) throws java.lang.IndexOutOfBoundsException
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
.idx
- the index of the considered type parameter.idx
.java.lang.IndexOutOfBoundsException
- if the idx does not match the resolved type parameter list.getResolvedTypeParameterConstraints(int)
LightweightTypeReference getResolvedReturnType()
IResolvedFeature.getContextType()
,
getResolvedTypeParameters()
boolean isBottomInContext()
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
.getAsBottom()
IResolvedOperation getAsBottom()
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.isBottomInContext()
JvmOperation getDeclaration()
getDeclaration
in interface IResolvedExecutable
getDeclaration
in interface IResolvedFeature