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

FIR: resolve conflicts around SAM calls properly

Browse Source
This commit is contained in:
Mikhail Glukhikh
2022-04-20 22:49:40 +03:00
committed by Space
parent 93dad4837c
commit 7c89f0188a
25 changed files with 107 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt
+1 -1
View File
@@ -68,7 +68,7 @@ class FirCallResolver(
)
val conflictResolver: ConeCallConflictResolver =
session.callConflictResolverFactory.create(TypeSpecificityComparator.NONE, session.inferenceComponents)
session.callConflictResolverFactory.create(TypeSpecificityComparator.NONE, session.inferenceComponents, components)
@PrivateForInline
var needTransformArguments: Boolean = true
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt
+52 -35
View File
@@ -7,6 +7,8 @@ package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.isExpect
import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
import org.jetbrains.kotlin.fir.resolve.FirSamResolver
import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.name.StandardClassIds
@@ -17,8 +19,12 @@ import org.jetbrains.kotlin.utils.addIfNotNull
abstract class AbstractConeCallConflictResolver(
private val specificityComparator: TypeSpecificityComparator,
protected val inferenceComponents: InferenceComponents
protected val inferenceComponents: InferenceComponents,
private val transformerComponents: BodyResolveComponents
) : ConeCallConflictResolver() {
private val samResolver: FirSamResolver get() = transformerComponents.samResolver
/**
* Returns `true` if [call1] is definitely more or equally specific [call2],
* `false` otherwise.
@@ -26,7 +32,8 @@ abstract class AbstractConeCallConflictResolver(
protected fun compareCallsByUsedArguments(
call1: FlatSignature<Candidate>,
call2: FlatSignature<Candidate>,
discriminateGenerics: Boolean
discriminateGenerics: Boolean,
useOriginalSamTypes: Boolean
): Boolean {
if (discriminateGenerics) {
val isGeneric1 = call1.isGeneric
@@ -48,7 +55,8 @@ abstract class AbstractConeCallConflictResolver(
call1,
call2,
SpecificityComparisonWithNumerics,
specificityComparator
specificityComparator,
useOriginalSamTypes
)
}
@@ -113,44 +121,44 @@ abstract class AbstractConeCallConflictResolver(
protected fun createFlatSignature(call: Candidate, variable: FirVariable): FlatSignature<Candidate> {
return FlatSignature(
call,
(variable as? FirProperty)?.typeParameters?.map { it.symbol.toLookupTag() }.orEmpty(),
computeSignatureTypes(call, variable),
variable.receiverTypeRef != null,
variable.contextReceivers.size,
false,
0,
(variable as? FirProperty)?.isExpect == true,
false // TODO
origin = call,
typeParameters = (variable as? FirProperty)?.typeParameters?.map { it.symbol.toLookupTag() }.orEmpty(),
valueParameterTypes = computeSignatureTypes(call, variable),
hasExtensionReceiver = variable.receiverTypeRef != null,
contextReceiverCount = variable.contextReceivers.size,
hasVarargs = false,
numDefaults = 0,
isExpect = (variable as? FirProperty)?.isExpect == true,
isSyntheticMember = false // TODO
)
}
protected fun createFlatSignature(call: Candidate, constructor: FirConstructor): FlatSignature<Candidate> {
return FlatSignature(
call,
constructor.typeParameters.map { it.symbol.toLookupTag() },
computeSignatureTypes(call, constructor),
origin = call,
typeParameters = constructor.typeParameters.map { it.symbol.toLookupTag() },
valueParameterTypes = computeSignatureTypes(call, constructor),
//constructor.receiverTypeRef != null,
false,
constructor.contextReceivers.size,
constructor.valueParameters.any { it.isVararg },
call.numDefaults,
constructor.isExpect,
false // TODO
hasExtensionReceiver = false,
contextReceiverCount = constructor.contextReceivers.size,
hasVarargs = constructor.valueParameters.any { it.isVararg },
numDefaults = call.numDefaults,
isExpect = constructor.isExpect,
isSyntheticMember = false // TODO
)
}
protected fun createFlatSignature(call: Candidate, function: FirSimpleFunction): FlatSignature<Candidate> {
return FlatSignature(
call,
function.typeParameters.map { it.symbol.toLookupTag() },
computeSignatureTypes(call, function),
function.receiverTypeRef != null,
function.contextReceivers.size,
function.valueParameters.any { it.isVararg },
call.numDefaults,
function.isExpect,
false // TODO
origin = call,
typeParameters = function.typeParameters.map { it.symbol.toLookupTag() },
valueParameterTypes = computeSignatureTypes(call, function),
hasExtensionReceiver = function.receiverTypeRef != null,
contextReceiverCount = function.contextReceivers.size,
hasVarargs = function.valueParameters.any { it.isVararg },
numDefaults = call.numDefaults,
isExpect = function.isExpect,
isSyntheticMember = false // TODO
)
}
@@ -163,19 +171,28 @@ abstract class AbstractConeCallConflictResolver(
private fun computeSignatureTypes(
call: Candidate,
called: FirCallableDeclaration
): List<ConeKotlinType> {
): List<TypeWithConversion> {
return buildList {
addIfNotNull(called.receiverTypeRef?.coneType)
addIfNotNull(called.receiverTypeRef?.coneType?.let { TypeWithConversion(it) })
val typeForCallableReference = call.resultingTypeForCallableReference
if (typeForCallableReference != null) {
// Return type isn't needed here v
typeForCallableReference.typeArguments.dropLast(1)
.mapTo(this) {
(it as ConeKotlinType).removeTypeVariableTypes(inferenceComponents.session.typeContext)
TypeWithConversion((it as ConeKotlinType).removeTypeVariableTypes(inferenceComponents.session.typeContext))
}
} else {
called.contextReceivers.mapTo(this) { it.typeRef.coneType }
call.argumentMapping?.mapTo(this) { it.value.argumentType() }
called.contextReceivers.mapTo(this) { TypeWithConversion(it.typeRef.coneType) }
call.argumentMapping?.mapTo(this) { (_, parameter) ->
val argumentType = parameter.argumentType()
if (!call.usesSAM) {
TypeWithConversion(argumentType)
} else {
val functionType = samResolver.getFunctionTypeForPossibleSamType(argumentType)?.second
if (functionType == null) TypeWithConversion(argumentType)
else TypeWithConversion(functionType, argumentType)
}
}
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt
+3 -5
View File
@@ -507,12 +507,10 @@ private fun Candidate.getExpectedTypeWithSAMConversion(
// TODO: resolvedCall.registerArgumentWithSamConversion(argument, SamConversionDescription(convertedTypeByOriginal, convertedTypeByCandidate!!))
val expectedFunctionType = context.bodyResolveComponents.samResolver.getFunctionTypeForPossibleSamType(candidateExpectedType)
?: return null
return runIf(argument.isFunctional(session, scopeSession, expectedFunctionType)) {
expectedFunctionType.apply {
// Even though the `expectedFunctionalType` could be `null`, we should mark the flag to indicate that the argument is a
// functional type. That will help avoid ambiguous `invoke` resolutions. See KT-39824
usesSAM = true
}
usesSAM = true
expectedFunctionType
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCallConflictResolver.kt
+6 -1
View File
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirSessionComponent
import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
@@ -25,7 +26,11 @@ abstract class ConeCallConflictResolver {
}
abstract class ConeCallConflictResolverFactory : FirSessionComponent {
abstract fun create(typeSpecificityComparator: TypeSpecificityComparator, components: InferenceComponents): ConeCallConflictResolver
abstract fun create(
typeSpecificityComparator: TypeSpecificityComparator,
components: InferenceComponents,
transformerComponents: BodyResolveComponents
): ConeCallConflictResolver
}
val FirSession.callConflictResolverFactory: ConeCallConflictResolverFactory by FirSession.sessionComponentAccessor()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeIntegerOperatorConflictResolver.kt
+4 -2
View File
@@ -5,14 +5,16 @@
package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
import org.jetbrains.kotlin.fir.scopes.impl.isWrappedIntegerOperator
import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
class ConeIntegerOperatorConflictResolver(
specificityComparator: TypeSpecificityComparator,
inferenceComponents: InferenceComponents
) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents) {
inferenceComponents: InferenceComponents,
transformerComponents: BodyResolveComponents
) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents, transformerComponents) {
override fun chooseMaximallySpecificCandidates(
candidates: Set<Candidate>,
discriminateGenerics: Boolean,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt
+16 -6
View File
@@ -10,9 +10,11 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.utils.modality
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
import org.jetbrains.kotlin.fir.resolve.inference.ConeTypeParameterBasedTypeVariable
import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl
@@ -29,8 +31,9 @@ typealias CandidateSignature = FlatSignature<Candidate>
class ConeOverloadConflictResolver(
specificityComparator: TypeSpecificityComparator,
inferenceComponents: InferenceComponents
) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents) {
inferenceComponents: InferenceComponents,
transformerComponents: BodyResolveComponents
) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents, transformerComponents) {
override fun chooseMaximallySpecificCandidates(
candidates: Set<Candidate>,
@@ -123,12 +126,18 @@ class ConeOverloadConflictResolver(
}
}
val filtered = candidates.filterTo(mutableSetOf()) { it.usesSAM }
if (filtered.isNotEmpty()) {
findMaximallySpecificCall(candidates, discriminateGenerics = false, useOriginalSamTypes = true)?.let { return setOf(it) }
}
return candidates
}
private fun findMaximallySpecificCall(
candidates: Set<Candidate>,
discriminateGenerics: Boolean
discriminateGenerics: Boolean,
useOriginalSamTypes: Boolean = false
): Candidate? {
if (candidates.size <= 1) return candidates.singleOrNull()
@@ -138,7 +147,7 @@ class ConeOverloadConflictResolver(
val bestCandidatesByParameterTypes = candidateSignatures.filter { signature ->
candidateSignatures.all { other ->
signature === other || isNotLessSpecificCallWithArgumentMapping(signature, other, discriminateGenerics)
signature === other || isNotLessSpecificCallWithArgumentMapping(signature, other, discriminateGenerics, useOriginalSamTypes)
}
}
@@ -151,9 +160,10 @@ class ConeOverloadConflictResolver(
private fun isNotLessSpecificCallWithArgumentMapping(
call1: CandidateSignature,
call2: CandidateSignature,
discriminateGenerics: Boolean
discriminateGenerics: Boolean,
useOriginalSamTypes: Boolean = false
): Boolean {
return compareCallsByUsedArguments(call1, call2, discriminateGenerics)
return compareCallsByUsedArguments(call1, call2, discriminateGenerics, useOriginalSamTypes)
}
private fun List<CandidateSignature>.exactMaxWith(): CandidateSignature? {