Returns the set of all non-private, non-abstract, non-static methods that are not initializers and which are potentially callable by clients when we have an object that has the specified type and a method is called using org.opalj.br.instructions.INVOKEINTERFACE, org.opalj.br.instructions.INVOKEVIRTUAL or org.opalj.br.instructions.INVOKEDYNAMIC.

The array of methods is sorted using MethodDeclarationContextOrdering to enable fast look-up of the target method. (See MethodDeclarationContext's compareAccessibilityAware method for further details.)

Returns the nest host (see JVM 11 Spec. 5.4.4) for the given type, if explicitly given. For classes without an explicit NestHost or NestMembers attribute, the type itself is the nest host, but this is NOT recorded in this map.

Stores for each non-private, non-initializer method the set of methods which override a specific method. If the given method is a concrete method, this method is also included in the set of overridingMethods.

Computes the maximally specific superinterface method with the given name and descriptor

Computes the set of maximally specific superinterface methods with the given name and descriptor.

Tests if the given method belongs to the interface of an object identified by the given objectType. I.e., returns true if a virtual method call, where the receiver type is known to have the given objectType, would lead to the direct invocation of the given method. The given method can be an inherited method, but it will never return Yes if the given method is overridden by objectType or a supertype of it which is a sub type of the declaring type of method.

Returns the (instance) method that would be called when we have an instance of the given receiver type. I.e., using this method is suitable only when the runtime type, which is the receiver of the method call, is precisely known!

Examples

class A {def foo() = {} }
class B extends A {/*inherits, but does not override foo()*/}
class C extends B { def foo() = {} }
val b = new B();
b.foo() // <= in this case the method defined by A will be returned.
val c = new C();
c.foo() // <= in this case the method defined by C will be returned.

This method supports default methods and signature polymorphic calls; i.e., the descriptor of the retuned methods may not be equal to the given method descriptor.

Returns the methods that may be called by an org.opalj.br.instructions.INVOKEINTERFACE call if the precise runtime type is not known. (If the precise runtime type is known, use instanceCall to get the target method.)

Returns true if the signature is a signature polymorphic method for the given class type. (See JVM 9 Spec. for details.)

Returns true if the descriptor is a signature polymorphic method for the given class type. (See JVM 9 Spec. for details.)

Returns true if the method defined by the given class type is a signature polymorphic method. (See JVM 9 Spec. for details.)

Looks up the method (declaration context) which is accessible/callable by an org.opalj.br.instructions.INVOKEVIRTUAL or org.opalj.br.instructions.INVOKEINTERFACE call which was done by a method belonging to callingContextType. The callingContextType is only relevant in case the target method has default visibility; in this case it is checked whether the caller belongs to the same context.

Returns the set of methods which directly override the given method. Note that overriddenBy is not context aware. I.e., if a given method m is an interface method, then it may happen that we have an implementation of that method in a class which is inherited from a superclass which is not a subtype of the interface. That method - since it is not defined by a subtype of the interface - would not be included in the returned set. An example is shown next:

class X { void m(){ System.out.println("X.m"); }
interface Y { default void m(){ System.out.println("Y.m"); }
class Z extends X implements Y {
 // Z inherits m() from X; hence, X.m() (in this context) "overrides" Y.m(), but is not
 // returned by this function. To also identify X.m() you have to combine the results
 // of overridenBy and instanceMethods(!).
}

Resolves a method reference to all possible methods. I.e., this is identical to resolveMethodReference or resolveInterfaceMethodReference for class and interface types respectively except for the case where there are multiple maximally specific interface methods in which case all of them are returned instead of only a single one.

Resolves a symbolic reference to a method defined by a class (not interface) type.

Resolves a symbolic reference to a field. Basically, the search starts with the given class c and then continues with c's superinterfaces before the search is continued with c's superclass (as prescribed by the JVM specification for the resolution of unresolved symbolic references).

Resolving a symbolic reference is particularly required to, e.g., get a field's annotations or to get a field's value (if it is static, final and has a constant value).

Tries to resolve a method reference as specified by the JVM specification. I.e., the algorithm tries to find the class that actually declares the referenced method. Resolution of signature polymorphic method calls is also supported.

This method can be used as the basis for the implementation of the semantics of the invokeXXX instructions. However, it does not check whether the resolved method can be accessed by the caller or if it is abstract. Additionally, it is still necessary that the caller makes a distinction between the statically (at compile time) identified declaring class and the dynamic type of the receiver in case of invokevirtual and invokeinterface instructions. I.e., additional processing is necessary on the client side.

Returns the instance method/initializer which is called by an invokespecial instruction.

Returns the method that will be called by the respective invokestatic call.

Returns the set of methods that may be called by an invokevirtual call, if the receiver type is unknown or effectively encompasses all subtypes it is recommended to use instanceCall.