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

Minor. Remove unnecessary trace parameter

Browse Source
This commit is contained in:
Stanislav Erokhin
2015-07-15 23:46:34 +03:00
parent 97d41be42e
commit d5f7fc52e0
2 changed files with 18 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
+1 -2
View File
@@ -171,8 +171,7 @@ public class CallCompleter(
tracing: TracingStrategy tracing: TracingStrategy
) { ) {
val contextWithResolvedCall = CallCandidateResolutionContext.createForCallBeingAnalyzed(this, context, tracing) val contextWithResolvedCall = CallCandidateResolutionContext.createForCallBeingAnalyzed(this, context, tracing)
val valueArgumentsCheckingResult = candidateResolver.checkAllValueArguments( val valueArgumentsCheckingResult = candidateResolver.checkAllValueArguments(contextWithResolvedCall, RESOLVE_FUNCTION_ARGUMENTS)
contextWithResolvedCall, context.trace, RESOLVE_FUNCTION_ARGUMENTS)
val status = getStatus() val status = getStatus()
if (getConstraintSystem()!!.getStatus().isSuccessful()) { if (getConstraintSystem()!!.getStatus().isSuccessful()) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
+17 -31
View File
@@ -280,27 +280,17 @@ public class CandidateResolver(
return if (descriptor is ClassDescriptor) descriptor else null return if (descriptor is ClassDescriptor) descriptor else null
} }
private fun <D : CallableDescriptor> checkAllValueArguments(
context: CallCandidateResolutionContext<D>,
resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult {
return checkAllValueArguments(context, context.candidateCall.getTrace(), resolveFunctionArgumentBodies)
}
public fun <D : CallableDescriptor> checkAllValueArguments( public fun <D : CallableDescriptor> checkAllValueArguments(
context: CallCandidateResolutionContext<D>, context: CallCandidateResolutionContext<D>,
trace: BindingTrace,
resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult { resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult {
val checkingResult = checkValueArgumentTypes( val checkingResult = checkValueArgumentTypes(context, context.candidateCall, resolveFunctionArgumentBodies)
context, context.candidateCall, trace, resolveFunctionArgumentBodies)
var resultStatus = checkingResult.status var resultStatus = checkingResult.status
resultStatus = resultStatus.combine(checkReceivers(context, trace)) resultStatus = resultStatus.combine(checkReceivers(context))
return ValueArgumentsCheckingResult(resultStatus, checkingResult.argumentTypes) return ValueArgumentsCheckingResult(resultStatus, checkingResult.argumentTypes)
} }
private fun <D : CallableDescriptor> checkReceivers( private fun <D : CallableDescriptor> checkReceivers(context: CallCandidateResolutionContext<D>): ResolutionStatus {
context: CallCandidateResolutionContext<D>,
trace: BindingTrace): ResolutionStatus {
var resultStatus = SUCCESS var resultStatus = SUCCESS
val candidateCall = context.candidateCall val candidateCall = context.candidateCall
@@ -309,13 +299,12 @@ public class CandidateResolver(
// both 'b' (receiver) and 'foo' (this object) might be nullable. In the first case we mark dot, in the second 'foo'. // both 'b' (receiver) and 'foo' (this object) might be nullable. In the first case we mark dot, in the second 'foo'.
// Class 'CallForImplicitInvoke' helps up to recognise this case, and parameter 'implicitInvokeCheck' helps us to distinguish whether we check receiver or this object. // Class 'CallForImplicitInvoke' helps up to recognise this case, and parameter 'implicitInvokeCheck' helps us to distinguish whether we check receiver or this object.
resultStatus = resultStatus.combine(checkReceiver( resultStatus = resultStatus.combine(context.checkReceiver(
context, candidateCall, trace, candidateCall,
candidateCall.getResultingDescriptor().getExtensionReceiverParameter(), candidateCall.getResultingDescriptor().getExtensionReceiverParameter(),
candidateCall.getExtensionReceiver(), candidateCall.getExplicitReceiverKind().isExtensionReceiver(), false)) candidateCall.getExtensionReceiver(), candidateCall.getExplicitReceiverKind().isExtensionReceiver(), false))
resultStatus = resultStatus.combine(checkReceiver( resultStatus = resultStatus.combine(context.checkReceiver(candidateCall,
context, candidateCall, trace,
candidateCall.getResultingDescriptor().getDispatchReceiverParameter(), candidateCall.getDispatchReceiver(), candidateCall.getResultingDescriptor().getDispatchReceiverParameter(), candidateCall.getDispatchReceiver(),
candidateCall.getExplicitReceiverKind().isDispatchReceiver(), candidateCall.getExplicitReceiverKind().isDispatchReceiver(),
// for the invocation 'foo(1)' where foo is a variable of function type we should mark 'foo' if there is unsafe call error // for the invocation 'foo(1)' where foo is a variable of function type we should mark 'foo' if there is unsafe call error
@@ -326,7 +315,6 @@ public class CandidateResolver(
private fun <D : CallableDescriptor, C : CallResolutionContext<C>> checkValueArgumentTypes( private fun <D : CallableDescriptor, C : CallResolutionContext<C>> checkValueArgumentTypes(
context: CallResolutionContext<C>, context: CallResolutionContext<C>,
candidateCall: MutableResolvedCall<D>, candidateCall: MutableResolvedCall<D>,
trace: BindingTrace,
resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult { resolveFunctionArgumentBodies: ResolveArgumentsMode): ValueArgumentsCheckingResult {
var resultStatus = SUCCESS var resultStatus = SUCCESS
val argumentTypes = Lists.newArrayList<JetType>() val argumentTypes = Lists.newArrayList<JetType>()
@@ -341,7 +329,7 @@ public class CandidateResolver(
val expectedType = getEffectiveExpectedType(parameterDescriptor, argument) val expectedType = getEffectiveExpectedType(parameterDescriptor, argument)
val newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument)).replaceBindingTrace(trace).replaceExpectedType(expectedType) val newContext = context.replaceDataFlowInfo(infoForArguments.getInfo(argument)).replaceExpectedType(expectedType)
val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo( val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(
expression, newContext, resolveFunctionArgumentBodies) expression, newContext, resolveFunctionArgumentBodies)
val type = typeInfoForCall.type val type = typeInfoForCall.type
@@ -416,10 +404,8 @@ public class CandidateResolver(
} }
} }
private fun <D : CallableDescriptor> checkReceiver( private fun <D : CallableDescriptor> CallCandidateResolutionContext<D>.checkReceiver(
context: CallCandidateResolutionContext<D>,
candidateCall: ResolvedCall<D>, candidateCall: ResolvedCall<D>,
trace: BindingTrace,
receiverParameter: ReceiverParameterDescriptor?, receiverParameter: ReceiverParameterDescriptor?,
receiverArgument: ReceiverValue, receiverArgument: ReceiverValue,
isExplicitReceiver: Boolean, isExplicitReceiver: Boolean,
@@ -430,12 +416,12 @@ public class CandidateResolver(
val safeAccess = isExplicitReceiver && !implicitInvokeCheck && candidateCall.getCall().isExplicitSafeCall() val safeAccess = isExplicitReceiver && !implicitInvokeCheck && candidateCall.getCall().isExplicitSafeCall()
val isSubtypeBySmartCast = isSubTypeBySmartCastIgnoringNullability( val isSubtypeBySmartCast = isSubTypeBySmartCastIgnoringNullability(
receiverArgument, receiverParameter.getType(), context) receiverArgument, receiverParameter.getType(), this)
if (!isSubtypeBySmartCast) { if (!isSubtypeBySmartCast) {
context.tracing.wrongReceiverType(trace, receiverParameter, receiverArgument) tracing.wrongReceiverType(trace, receiverParameter, receiverArgument)
return OTHER_ERROR return OTHER_ERROR
} }
if (!recordSmartCastIfNecessary(receiverArgument, receiverParameter.getType(), context, safeAccess)) { if (!recordSmartCastIfNecessary(receiverArgument, receiverParameter.getType(), this, safeAccess)) {
return OTHER_ERROR return OTHER_ERROR
} }
@@ -443,17 +429,17 @@ public class CandidateResolver(
val bindingContext = trace.getBindingContext() val bindingContext = trace.getBindingContext()
if (!safeAccess && !receiverParameter.getType().isMarkedNullable() && receiverArgumentType.isMarkedNullable()) { if (!safeAccess && !receiverParameter.getType().isMarkedNullable() && receiverArgumentType.isMarkedNullable()) {
if (!canBeSmartCast(receiverParameter, receiverArgument, context)) { if (!canBeSmartCast(receiverParameter, receiverArgument, this)) {
context.tracing.unsafeCall(trace, receiverArgumentType, implicitInvokeCheck) tracing.unsafeCall(trace, receiverArgumentType, implicitInvokeCheck)
return UNSAFE_CALL_ERROR return UNSAFE_CALL_ERROR
} }
} }
val receiverValue = DataFlowValueFactory.createDataFlowValue(receiverArgument, bindingContext, context.scope.getContainingDeclaration()) val receiverValue = DataFlowValueFactory.createDataFlowValue(receiverArgument, bindingContext, scope.getContainingDeclaration())
if (safeAccess && !context.dataFlowInfo.getNullability(receiverValue).canBeNull()) { if (safeAccess && !dataFlowInfo.getNullability(receiverValue).canBeNull()) {
context.tracing.unnecessarySafeCall(trace, receiverArgumentType) tracing.unnecessarySafeCall(trace, receiverArgumentType)
} }
context.additionalTypeChecker.checkReceiver(receiverParameter, receiverArgument, safeAccess, context) additionalTypeChecker.checkReceiver(receiverParameter, receiverArgument, safeAccess, this)
return SUCCESS return SUCCESS
} }