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

Don't commit trace with inapplicable provideDelegate operator

Browse Source 
This helps in NI as there we have different logic for delegates inference
This commit is contained in:
Mikhail Zarechenskiy
2017-08-09 02:54:34 +03:00
parent 82c3637d91
commit 20e105c274
1 changed files with 33 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyResolver.kt
+33 -13
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2010-2016 JetBrains s.r.o. * Copyright 2010-2017 JetBrains s.r.o.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -213,19 +213,30 @@ class DelegatedPropertyResolver(
delegateExpression: KtExpression, delegateExpression: KtExpression,
delegateType: KotlinType, delegateType: KotlinType,
operatorRequired: Boolean = true operatorRequired: Boolean = true
) { ): Boolean {
val expectedFunction = renderCall(delegateOperatorCall, trace.bindingContext) val expectedFunction = renderCall(delegateOperatorCall, trace.bindingContext)
when { val resolutionErrorFactory = when {
delegateOperatorResults.isSingleResult || delegateOperatorResults.isSingleResult ||
delegateOperatorResults.isIncomplete || delegateOperatorResults.isIncomplete ||
delegateOperatorResults.resultCode == OverloadResolutionResults.Code.MANY_FAILED_CANDIDATES -> delegateOperatorResults.resultCode == OverloadResolutionResults.Code.MANY_FAILED_CANDIDATES -> DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE
trace.report(DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE.on(delegateExpression, expectedFunction, delegateOperatorResults.resultingCalls))
delegateOperatorResults.isAmbiguity -> delegateOperatorResults.isAmbiguity -> DELEGATE_SPECIAL_FUNCTION_AMBIGUITY
trace.report(DELEGATE_SPECIAL_FUNCTION_AMBIGUITY.on(delegateExpression, expectedFunction, delegateOperatorResults.resultingCalls))
else -> else -> null
if (operatorRequired) trace.report(DELEGATE_SPECIAL_FUNCTION_MISSING.on(delegateExpression, expectedFunction, delegateType))
} }
if (resolutionErrorFactory != null) {
trace.report(resolutionErrorFactory.on(delegateExpression, expectedFunction, delegateOperatorResults.resultingCalls))
return true
}
if (operatorRequired) {
trace.report(DELEGATE_SPECIAL_FUNCTION_MISSING.on(delegateExpression, expectedFunction, delegateType))
return true
}
return false
} }
private fun resolveProvideDelegateMethod( private fun resolveProvideDelegateMethod(
@@ -239,16 +250,25 @@ class DelegatedPropertyResolver(
if (!isOperatorProvideDelegateSupported) return if (!isOperatorProvideDelegateSupported) return
if (trace.bindingContext.get(BindingContext.PROVIDE_DELEGATE_CALL, propertyDescriptor) != null) return if (trace.bindingContext.get(BindingContext.PROVIDE_DELEGATE_CALL, propertyDescriptor) != null) return
val traceForProvideDelegate = TemporaryBindingTrace.create(trace, "trace to resolve provideDelegate method")
val provideDelegateResults = getProvideDelegateMethod(propertyDescriptor, byExpression, byExpressionType, val provideDelegateResults = getProvideDelegateMethod(propertyDescriptor, byExpression, byExpressionType,
trace, initializerScope, dataFlowInfo) traceForProvideDelegate, initializerScope, dataFlowInfo)
if (!provideDelegateResults.isSuccess) { if (!provideDelegateResults.isSuccess) {
val call = trace.bindingContext.get(BindingContext.PROVIDE_DELEGATE_CALL, propertyDescriptor) val call = traceForProvideDelegate.bindingContext.get(BindingContext.PROVIDE_DELEGATE_CALL, propertyDescriptor)
?: throw AssertionError("'getDelegatedPropertyConventionMethod' didn't record a call") ?: throw AssertionError("'getDelegatedPropertyConventionMethod' didn't record a call")
reportDelegateOperatorResolutionError(trace, call, provideDelegateResults, byExpression, byExpressionType, val shouldCommitTrace = reportDelegateOperatorResolutionError(
operatorRequired = false) traceForProvideDelegate, call, provideDelegateResults, byExpression, byExpressionType, operatorRequired = false)
if (shouldCommitTrace) {
traceForProvideDelegate.commit()
}
return return
} }
traceForProvideDelegate.commit()
val resultingDescriptor = provideDelegateResults.resultingDescriptor val resultingDescriptor = provideDelegateResults.resultingDescriptor
if (!resultingDescriptor.isOperator) { if (!resultingDescriptor.isOperator) {
// TODO resolved 'provideDelegate' function, which is not an operator - warning? // TODO resolved 'provideDelegate' function, which is not an operator - warning?