@Override
public void visitNode(Long callNodeId) {
List<Long> arguments = getArgumentsByCallId(callNodeId);
if (arguments == null) return;
IndexHits<Long> dstIds = resolver.resolveByCallId(callNodeId);
if (dstIds == null) return;
connectArgumentsToDestinations(callNodeId, arguments, dstIds);
}
/**
* Builds a CallResolver based on call
*
* @param resolverClass tag of the resolver
* @param context used to instantiate the resolver
* @return An instance of a Resolver if a given call is valid null otherwise
*/
static CallResolver get(Class<? extends CallResolver> resolverClass, Context context) {
if (sCache.containsKey(resolverClass)) {
return sCache.get(resolverClass);
}
CallResolver resolver = null;
try {
L.d(TAG, "Instantiating " + resolverClass);
Constructor ctc = resolverClass.getConstructor();
resolver = (CallResolver) ctc.newInstance();
if (resolver.canBeCached()) {
sCache.put(resolverClass, resolver);
} else if (sCache.containsKey(resolverClass)) {
sCache.remove(resolverClass);
}
resolver.setContext(context);
return resolver;
} catch (Exception e) {
L.e(TAG, "Unable to create resolver for call " + resolverClass, e);
}
return resolver;
}
@NotNull
@Override
public Collection<MutableResolvedCall<FunctionDescriptor>> transformCall(
@NotNull CallCandidateResolutionContext<CallableDescriptor> context,
@NotNull CallResolver callResolver,
@NotNull ResolutionTask<CallableDescriptor, FunctionDescriptor> task) {
CallableDescriptor descriptor = context.candidateCall.getCandidateDescriptor();
if (descriptor instanceof FunctionDescriptor) {
return super.transformCall(context, callResolver, task);
}
assert descriptor instanceof VariableDescriptor;
JetType returnType = descriptor.getReturnType();
if (returnType == null) {
return Collections.emptyList();
}
final MutableResolvedCall<VariableDescriptor> variableResolvedCall =
(MutableResolvedCall) context.candidateCall;
JetExpression calleeExpression = task.call.getCalleeExpression();
if (calleeExpression == null) return Collections.emptyList();
ExpressionReceiver variableReceiver =
new ExpressionReceiver(
calleeExpression, variableResolvedCall.getResultingDescriptor().getType());
Call functionCall =
new CallForImplicitInvoke(
context.explicitExtensionReceiverForInvoke, variableReceiver, task.call);
DelegatingBindingTrace variableCallTrace = context.candidateCall.getTrace();
BasicCallResolutionContext basicCallResolutionContext =
BasicCallResolutionContext.create(
context
.replaceBindingTrace(variableCallTrace)
.replaceContextDependency(ContextDependency.DEPENDENT),
functionCall,
context.checkArguments,
context.dataFlowInfoForArguments);
// 'invoke' call resolve
TracingStrategyForInvoke tracingForInvoke =
new TracingStrategyForInvoke(
calleeExpression, functionCall, variableReceiver.getType());
OverloadResolutionResults<FunctionDescriptor> results =
callResolver.resolveCallForInvoke(basicCallResolutionContext, tracingForInvoke);
Collection<MutableResolvedCall<FunctionDescriptor>> calls =
((OverloadResolutionResultsImpl<FunctionDescriptor>) results).getResultingCalls();
return Collections2.transform(
calls,
new Function<
MutableResolvedCall<FunctionDescriptor>,
MutableResolvedCall<FunctionDescriptor>>() {
@Override
public MutableResolvedCall<FunctionDescriptor> apply(
MutableResolvedCall<FunctionDescriptor> functionResolvedCall) {
return new VariableAsFunctionResolvedCallImpl(
functionResolvedCall, variableResolvedCall);
}
});
}
