@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); } }); }