private void onMethodCalled(@Nonnull JvmClassInfo callingClass, @Nonnull MutableMethodVertex callingVertex,
	                            int opcode, @Nonnull String owner, @Nonnull String name,
	                            @Nonnull String descriptor, boolean isInterface) {
		MethodRef ref = new MethodRef(owner, name, descriptor);

		// Resolve the method
		Result<Resolution<JvmClassInfo, MethodMember>> resolutionResult = resolve(opcode, owner, name, descriptor, isInterface);

		// Handle result
		CallingContext callContext = new CallingContext(callingClass, callingVertex.getMethod(), opcode, isInterface);
		if (resolutionResult.isSuccess()) {
			// Extract vertex from resolution
			Resolution<JvmClassInfo, MethodMember> resolution = resolutionResult.value();
			ClassMethodsContainer resolvedClass = getClassMethodsContainer(resolution.owner().innerValue());
			MutableMethodVertex resolvedMethodCallVertex = (MutableMethodVertex) resolvedClass.getVertex(resolution.member().innerValue());

			// Link the vertices
			callingVertex.getCalls().add(resolvedMethodCallVertex);
			resolvedMethodCallVertex.getCallers().add(callingVertex);

			// Remove tracked unresolved call if any exist
			Set<MethodRef> unresolvedWithinOwner = unresolvedDeclarations.get(owner);
			if (unresolvedWithinOwner.remove(ref)) {
				if (unresolvedWithinOwner.isEmpty()) unresolvedDeclarations.remove(owner);
				logger.debugging(l -> l.info("Satisfy unresolved call {}", ref));
			}

			// Remove tracking of unresolved declarations/references
			boolean resolvedPriorUnknown = false;
			resolvedPriorUnknown |= unresolvedDeclarations.remove(owner, ref);
			resolvedPriorUnknown |= unresolvedReferences.remove(owner, callContext);
			if (resolvedPriorUnknown) logger.debugging(l -> l.warn("Found previous unresolved reference: {}", ref));
		} else {
			unresolvedDeclarations.put(owner, ref);
			unresolvedReferences.put(owner, callContext);
			logger.debugging(l -> l.warn("Cannot resolve method: {} - {}", ref, resolutionResult.error()));
		}
	}
Called from the {@link ClassReader} in {@link #visit(JvmClassInfo)}.
Links the given vertex to the remote {@link MethodVertex} of the resolved method call,
if resolution is a success.
<p>
When not successful, the call is recorded as an unresolved reference in two directions.
<ul>
    <li>{@link #unresolvedDeclarations Class names --> Missing method declarations}</li>
    <li>{@link #unresolvedReferences  Class names --> Methods that have calls to missing method declarations</li>
</ul>

@param callingClass
		The class that defines the calling method.
@param callingVertex
		The method that is doing the call.
@param opcode
		Call opcode.
@param owner
		Call owner.
@param name
		Method call name.
@param descriptor
		Method call descriptor.
@param isInterface
		Method interface flag.
recaf-core/src/main/java/software/coley/recaf/services/callgraph/CallGraph.java