azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed resolve for callable references

Browse Source 
functions and properties have the same priority
This commit is contained in:
Svetlana Isakova
2014-12-22 14:05:17 +03:00
parent f0bb6c58fc
commit 62c8a6f79a
6 changed files with 83 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
+37 -25
View File
@@ -119,10 +119,19 @@ public class CallResolver {
else {
callableDescriptorCollectors = CallableDescriptorCollectors.VARIABLES;
}
TracingStrategy tracing = TracingStrategyImpl.create(nameExpression, context.call);
List<ResolutionTask<VariableDescriptor, VariableDescriptor>> prioritizedTasks =
taskPrioritizer.<VariableDescriptor, VariableDescriptor>computePrioritizedTasks(context, referencedName, tracing, callableDescriptorCollectors);
return doResolveCallOrGetCachedResults(context, prioritizedTasks, CallTransformer.PROPERTY_CALL_TRANSFORMER, tracing);
return computeTasksAndResolveCall(
context, referencedName, nameExpression,
callableDescriptorCollectors, CallTransformer.VARIABLE_CALL_TRANSFORMER);
}
@NotNull
public OverloadResolutionResults<CallableDescriptor> resolveCallForMember(
@NotNull JetSimpleNameExpression nameExpression,
@NotNull BasicCallResolutionContext context
) {
return computeTasksAndResolveCall(
context, nameExpression.getReferencedNameAsName(), nameExpression,
CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.MEMBER_CALL_TRANSFORMER);
}
@NotNull
@@ -132,21 +141,10 @@ public class CallResolver {
@NotNull JetReferenceExpression functionReference,
@NotNull Name name
) {
return resolveCallWithGivenName(
BasicCallResolutionContext.create(context, call, CheckValueArgumentsMode.ENABLED),
functionReference,
name
);
}
@NotNull
public OverloadResolutionResults<FunctionDescriptor> resolveCallWithGivenName(
@NotNull BasicCallResolutionContext context,
@NotNull JetReferenceExpression functionReference,
@NotNull Name name
) {
TracingStrategy tracing = TracingStrategyImpl.create(functionReference, context.call);
return resolveCallWithGivenName(context, name, tracing, CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES);
BasicCallResolutionContext callResolutionContext = BasicCallResolutionContext.create(context, call, CheckValueArgumentsMode.ENABLED);
return computeTasksAndResolveCall(
callResolutionContext, name, functionReference,
CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER);
}
@NotNull
@@ -154,19 +152,33 @@ public class CallResolver {
@NotNull BasicCallResolutionContext context,
@NotNull TracingStrategy tracing
) {
return resolveCallWithGivenName(context, Name.identifier("invoke"), tracing, CallableDescriptorCollectors.FUNCTIONS);
return computeTasksAndResolveCall(
context, Name.identifier("invoke"), tracing,
CallableDescriptorCollectors.FUNCTIONS, CallTransformer.FUNCTION_CALL_TRANSFORMER);
}
@NotNull
public OverloadResolutionResults<FunctionDescriptor> resolveCallWithGivenName(
private <D extends CallableDescriptor, F extends D> OverloadResolutionResults<F> computeTasksAndResolveCall(
@NotNull BasicCallResolutionContext context,
@NotNull Name name,
@NotNull JetReferenceExpression referenceExpression,
@NotNull CallableDescriptorCollectors<D> collectors,
@NotNull CallTransformer<D, F> callTransformer
) {
TracingStrategy tracing = TracingStrategyImpl.create(referenceExpression, context.call);
return computeTasksAndResolveCall(context, name, tracing, collectors, callTransformer);
}
@NotNull
private <D extends CallableDescriptor, F extends D> OverloadResolutionResults<F> computeTasksAndResolveCall(
@NotNull BasicCallResolutionContext context,
@NotNull Name name,
@NotNull TracingStrategy tracing,
@NotNull CallableDescriptorCollectors<CallableDescriptor> collectors
@NotNull CallableDescriptorCollectors<D> collectors,
@NotNull CallTransformer<D, F> callTransformer
) {
List<ResolutionTask<CallableDescriptor, FunctionDescriptor>> tasks =
taskPrioritizer.<CallableDescriptor, FunctionDescriptor>computePrioritizedTasks(context, name, tracing, collectors);
return doResolveCallOrGetCachedResults(context, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
List<ResolutionTask<D, F>> tasks = taskPrioritizer.<D, F>computePrioritizedTasks(context, name, tracing, collectors);
return doResolveCallOrGetCachedResults(context, tasks, callTransformer, tracing);
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java
+3 -1
View File
@@ -91,7 +91,9 @@ public class CallTransformer<D extends CallableDescriptor, F extends D> {
}
public static CallTransformer<VariableDescriptor, VariableDescriptor> PROPERTY_CALL_TRANSFORMER = new CallTransformer<VariableDescriptor, VariableDescriptor>();
public static CallTransformer<CallableDescriptor, CallableDescriptor> MEMBER_CALL_TRANSFORMER = new CallTransformer<CallableDescriptor, CallableDescriptor>();
public static CallTransformer<VariableDescriptor, VariableDescriptor> VARIABLE_CALL_TRANSFORMER = new CallTransformer<VariableDescriptor, VariableDescriptor>();
public static CallTransformer<CallableDescriptor, FunctionDescriptor> FUNCTION_CALL_TRANSFORMER = new CallTransformer<CallableDescriptor, FunctionDescriptor>() {
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java
+12 -31
View File
@@ -639,41 +639,22 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
@NotNull boolean[] result
) {
Call call = CallMaker.makeCall(reference, receiver, null, reference, ThrowingList.<ValueArgument>instance());
TemporaryTraceAndCache funTrace = TemporaryTraceAndCache.create(context, "trace to resolve callable reference as function",
TemporaryTraceAndCache temporaryTrace = TemporaryTraceAndCache.create(context, "trace to resolve callable reference as function",
reference);
ResolvedCall<FunctionDescriptor> function = components.expressionTypingServices.getCallExpressionResolver()
.getResolvedCallForFunction(call, reference, context.replaceTraceAndCache(funTrace).replaceExpectedType(NO_EXPECTED_TYPE),
CheckValueArgumentsMode.DISABLED, result);
if (result[0]) {
funTrace.commit();
if (function instanceof VariableAsFunctionResolvedCall) {
context.trace.report(UNSUPPORTED.on(reference, "References to variables aren't supported yet"));
return null;
}
return function != null ? function.getResultingDescriptor() : null;
}
TemporaryTraceAndCache varTrace = TemporaryTraceAndCache.create(context, "trace to resolve callable reference as variable",
reference);
OverloadResolutionResults<VariableDescriptor> variableResults =
components.expressionTypingServices.getCallResolver().resolveSimpleProperty(
BasicCallResolutionContext.create(context.replaceTraceAndCache(varTrace).replaceExpectedType(NO_EXPECTED_TYPE),
call, CheckValueArgumentsMode.DISABLED)
);
if (!variableResults.isNothing()) {
ResolvedCall<VariableDescriptor> variable =
OverloadResolutionResultsUtil.getResultingCall(variableResults, context.contextDependency);
varTrace.commit();
if (variable != null) {
result[0] = true;
return variable.getResultingDescriptor();
BasicCallResolutionContext callResolutionContext = BasicCallResolutionContext.create(
context.replaceTraceAndCache(temporaryTrace).replaceExpectedType(NO_EXPECTED_TYPE), call, CheckValueArgumentsMode.DISABLED);
OverloadResolutionResults<CallableDescriptor> results =
components.expressionTypingServices.getCallResolver().resolveCallForMember(reference, callResolutionContext);
if (!results.isNothing()) {
temporaryTrace.commit();
result[0] = true;
ResolvedCall<CallableDescriptor> callable =
OverloadResolutionResultsUtil.getResultingCall(results, context.contextDependency);
if (callable != null) {
return callable.getResultingDescriptor();
}
}
return null;
}