From 7c89f0188aabe70d8b77dca8b6f23426c7764f94 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 20 Apr 2022 22:49:40 +0300 Subject: [PATCH] FIR: resolve conflicts around SAM calls properly --- .../jvm/ConeEquivalentCallConflictResolver.kt | 10 ++- .../jvm/JvmCallConflictResolverFactory.kt | 13 +-- .../JvmPlatformOverloadsConflictResolver.kt | 7 +- .../jetbrains/kotlin/fir/FirCallResolver.kt | 2 +- .../calls/AbstractConeCallConflictResolver.kt | 87 +++++++++++-------- .../kotlin/fir/resolve/calls/Arguments.kt | 8 +- .../resolve/calls/ConeCallConflictResolver.kt | 7 +- .../ConeIntegerOperatorConflictResolver.kt | 6 +- .../calls/ConeOverloadConflictResolver.kt | 22 +++-- .../adapters/inheritedOverriddenAdapter.kt | 2 - .../boxInline/anonymousObject/sam/kt21671.kt | 2 - .../anonymousObject/sam/kt21671_2.kt | 2 - .../anonymousObject/sam/kt21671_3.kt | 2 - .../anonymousObject/sam/samOnCallSite.kt | 2 - .../overloadConflicts/allLambdas.fir.kt | 2 +- .../samConversions/OverloadPriority.fir.kt | 30 ------- .../tests/samConversions/OverloadPriority.kt | 1 + .../samConversions/OverloadPriorityKT.fir.kt | 29 ------- .../samConversions/OverloadPriorityKT.kt | 1 + .../resolve/samAgainstFunctionalType.fir.kt | 29 ------- .../resolve/samAgainstFunctionalType.kt | 1 + .../resolve/samOverloadsWithGenerics.fir.kt | 24 ----- .../resolve/samOverloadsWithGenerics.kt | 1 + .../resolve/samOverloadsWithKtFunction.fir.kt | 20 ----- .../resolve/samOverloadsWithKtFunction.kt | 1 + 25 files changed, 107 insertions(+), 204 deletions(-) delete mode 100644 compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt delete mode 100644 compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.fir.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.fir.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.fir.kt diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt index e3e85fc130c..a6f3423504c 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.calls.jvm import org.jetbrains.kotlin.fir.containingClass 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.calls.AbstractConeCallConflictResolver import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents @@ -19,8 +20,9 @@ import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator // like emptyArray() from intrinsics and built-ins class ConeEquivalentCallConflictResolver( specificityComparator: TypeSpecificityComparator, - inferenceComponents: InferenceComponents -) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents) { + inferenceComponents: InferenceComponents, + transformerComponents: BodyResolveComponents +) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents, transformerComponents) { override fun chooseMaximallySpecificCandidates( candidates: Set, discriminateGenerics: Boolean, @@ -64,8 +66,8 @@ class ConeEquivalentCallConflictResolver( } val firstSignature = createFlatSignature(firstCandidate, first) val secondSignature = createFlatSignature(secondCandidate, second) - return compareCallsByUsedArguments(firstSignature, secondSignature, false) && - compareCallsByUsedArguments(secondSignature, firstSignature, false) + return compareCallsByUsedArguments(firstSignature, secondSignature, discriminateGenerics = false, useOriginalSamTypes = false) && + compareCallsByUsedArguments(secondSignature, firstSignature, discriminateGenerics = false, useOriginalSamTypes = false) } private fun createFlatSignature(call: Candidate, declaration: FirCallableDeclaration): FlatSignature { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt index 7d66b240fa4..9fcfe132549 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt @@ -6,11 +6,13 @@ package org.jetbrains.kotlin.fir.resolve.calls.jvm import org.jetbrains.kotlin.fir.NoMutableState +import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory import org.jetbrains.kotlin.fir.resolve.calls.ConeCompositeConflictResolver import org.jetbrains.kotlin.fir.resolve.calls.ConeIntegerOperatorConflictResolver import org.jetbrains.kotlin.fir.resolve.calls.ConeOverloadConflictResolver import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer import org.jetbrains.kotlin.fir.types.typeContext import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator import org.jetbrains.kotlin.resolve.jvm.JvmTypeSpecificityComparator @@ -19,14 +21,15 @@ import org.jetbrains.kotlin.resolve.jvm.JvmTypeSpecificityComparator object JvmCallConflictResolverFactory : ConeCallConflictResolverFactory() { override fun create( typeSpecificityComparator: TypeSpecificityComparator, - components: InferenceComponents + components: InferenceComponents, + transformerComponents: BodyResolveComponents ): ConeCompositeConflictResolver { val specificityComparator = JvmTypeSpecificityComparator(components.session.typeContext) return ConeCompositeConflictResolver( - ConeOverloadConflictResolver(specificityComparator, components), - ConeEquivalentCallConflictResolver(specificityComparator, components), - JvmPlatformOverloadsConflictResolver(specificityComparator, components), - ConeIntegerOperatorConflictResolver(specificityComparator, components) + ConeOverloadConflictResolver(specificityComparator, components, transformerComponents), + ConeEquivalentCallConflictResolver(specificityComparator, components, transformerComponents), + JvmPlatformOverloadsConflictResolver(specificityComparator, components, transformerComponents), + ConeIntegerOperatorConflictResolver(specificityComparator, components, transformerComponents) ) } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmPlatformOverloadsConflictResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmPlatformOverloadsConflictResolver.kt index 72fa77c29b4..deec4daad3e 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmPlatformOverloadsConflictResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmPlatformOverloadsConflictResolver.kt @@ -10,15 +10,18 @@ import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.declarations.FirField import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.languageVersionSettings +import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.AbstractConeCallConflictResolver import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents +import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator class JvmPlatformOverloadsConflictResolver( specificityComparator: TypeSpecificityComparator, - inferenceComponents: InferenceComponents -) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents) { + inferenceComponents: InferenceComponents, + transformerComponents: BodyResolveComponents +) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents, transformerComponents) { override fun chooseMaximallySpecificCandidates( candidates: Set, discriminateGenerics: Boolean, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index 7185998ee87..ba9166be139 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt index 9a99ef8ae99..cad175c4da3 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt @@ -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, call2: FlatSignature, - 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 { 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 { 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 { 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 { + ): List { 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) + } + } } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt index 1d61383cb85..ed990b7f62e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt @@ -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 } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCallConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCallConflictResolver.kt index f690f087e90..c13310f98e8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCallConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCallConflictResolver.kt @@ -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() \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeIntegerOperatorConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeIntegerOperatorConflictResolver.kt index ae81b7b7efc..72487a876a8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeIntegerOperatorConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeIntegerOperatorConflictResolver.kt @@ -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, discriminateGenerics: Boolean, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt index f6c10bccefc..044fb24ec5f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt @@ -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 class ConeOverloadConflictResolver( specificityComparator: TypeSpecificityComparator, - inferenceComponents: InferenceComponents -) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents) { + inferenceComponents: InferenceComponents, + transformerComponents: BodyResolveComponents +) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents, transformerComponents) { override fun chooseMaximallySpecificCandidates( candidates: Set, @@ -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, - 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.exactMaxWith(): CandidateSignature? { diff --git a/compiler/testData/codegen/box/sam/adapters/inheritedOverriddenAdapter.kt b/compiler/testData/codegen/box/sam/adapters/inheritedOverriddenAdapter.kt index e6c3e9d98b3..a5fde7e54d2 100644 --- a/compiler/testData/codegen/box/sam/adapters/inheritedOverriddenAdapter.kt +++ b/compiler/testData/codegen/box/sam/adapters/inheritedOverriddenAdapter.kt @@ -1,6 +1,4 @@ // TARGET_BACKEND: JVM -// IGNORE_BACKEND_FIR: JVM_IR -// FIR status: OVERLOAD_RESOLUTION_AMBIGUITY on sub.foo {} // WITH_STDLIB // MODULE: lib // FILE: Super.java diff --git a/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671.kt b/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671.kt index 0669d797f1d..b65994d0ed3 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671.kt @@ -1,6 +1,4 @@ // FULL_JDK -// IGNORE_BACKEND_FIR: JVM_IR -// IGNORE_BACKEND_FIR_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE // TARGET_BACKEND: JVM // FILE: 1.kt diff --git a/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_2.kt b/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_2.kt index e13971bcacf..f58c56bd979 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_2.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_2.kt @@ -1,6 +1,4 @@ // FULL_JDK -// IGNORE_BACKEND_FIR: JVM_IR -// IGNORE_BACKEND_FIR_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE // TARGET_BACKEND: JVM // FILE: 1.kt diff --git a/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_3.kt b/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_3.kt index 5bb7ebb1ff3..915f31f1570 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_3.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_3.kt @@ -1,6 +1,4 @@ // FULL_JDK -// IGNORE_BACKEND_FIR: JVM_IR -// IGNORE_BACKEND_FIR_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE // TARGET_BACKEND: JVM // FILE: 1.kt diff --git a/compiler/testData/codegen/boxInline/anonymousObject/sam/samOnCallSite.kt b/compiler/testData/codegen/boxInline/anonymousObject/sam/samOnCallSite.kt index ab6c2861786..b32d922a937 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/sam/samOnCallSite.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/sam/samOnCallSite.kt @@ -1,7 +1,5 @@ // FULL_JDK // NO_CHECK_LAMBDA_INLINING -// IGNORE_BACKEND_FIR: JVM_IR -// IGNORE_BACKEND_FIR_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE // TARGET_BACKEND: JVM // FILE: 1.kt diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt index cdb0bf42b2b..326b937ef3c 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt @@ -6,4 +6,4 @@ object X2 fun foo(x: T1, f: (T1) -> T1) = X1 fun foo(xf: () -> T2, f: (T2) -> T2) = X2 -val test: X2 = foo({ 0 }, { it -> it + 1 }) +val test: X2 = foo({ 0 }, { it -> it + 1 }) diff --git a/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt b/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt deleted file mode 100644 index fef267e7937..00000000000 --- a/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt +++ /dev/null @@ -1,30 +0,0 @@ -// !LANGUAGE: +EliminateAmbiguitiesOnInheritedSamInterfaces -// !CHECK_TYPE -// FILE: Fn.java -public interface Fn { - R apply(T t); -} - -// FILE: Fn2.java -public interface Fn2 extends Fn {} - -// FILE: J.java -public interface J { - String foo(Fn f, Object o); - int foo(Fn f, String s); // (Any) -> Any <: (String) -> Any <=> String <: Any - - String bas(Fn f, Object o); - int bas(Fn f, String s); // (Any) -> String <: (Any) -> Any <=> String <: Any - - String bar(Fn f); - int bar(Fn2 f); // Fn2 seems more specific one even function type same -} - -// FILE: 1.kt -fun test(j: J) { - j.foo({ it checkType { _() }; "" }, "") checkType { _() } - - j.bas({ it checkType { _() }; "" }, "") checkType { _() } - - j.bar { it checkType { _() }; "" } checkType { _() } -} diff --git a/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt b/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt index 171c24fe535..eb89453ce67 100644 --- a/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt +++ b/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !LANGUAGE: +EliminateAmbiguitiesOnInheritedSamInterfaces // !CHECK_TYPE // FILE: Fn.java diff --git a/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt b/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt deleted file mode 100644 index 8c3da5d395d..00000000000 --- a/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt +++ /dev/null @@ -1,29 +0,0 @@ -// !LANGUAGE: +EliminateAmbiguitiesOnInheritedSamInterfaces +SamConversionForKotlinFunctions +SamConversionPerArgument -// !CHECK_TYPE -// FILE: Fn.java -public interface Fn { - R apply(T t); -} - -// FILE: Fn2.java -public interface Fn2 extends Fn {} - -// FILE: 1.kt -interface K { - fun foo(f: Fn): String - fun foo(f: Fn): Int - - fun bas(f: Fn): String - fun bas(f: Fn): Int - - fun bar(f: Fn): String - fun bar(f: Fn2): Int -} - -fun test(k: K) { - k.foo { it checkType { _() }; "" } checkType { _() } - - k.bas { it checkType { _() }; "" } checkType { _() } - - k.bar { it checkType { _() }; "" } checkType { _() } -} diff --git a/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt b/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt index 650d98a23b3..fdc77d2cfd6 100644 --- a/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt +++ b/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !LANGUAGE: +EliminateAmbiguitiesOnInheritedSamInterfaces +SamConversionForKotlinFunctions +SamConversionPerArgument // !CHECK_TYPE // FILE: Fn.java diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.fir.kt deleted file mode 100644 index f7eb59f9b20..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.fir.kt +++ /dev/null @@ -1,29 +0,0 @@ -// !CHECK_TYPE - -// FILE: StaticOverrides.java - -import kotlin.Unit; -import kotlin.jvm.functions.Function0; - -public class StaticOverrides { - public static class A { - public static int foo(Runnable x) { return 0; } - public static boolean foo(Function0 x) { return true; } - } - - public static class B { - public static String foo(Runnable x) { return ""; } - } - - public static class C extends A { - public static String foo(Runnable x) { return ""; } - } -} - -// FILE: test.kt - -fun test() { - StaticOverrides.A.foo {} checkType { _() } - StaticOverrides.B.foo {} checkType { _() } - StaticOverrides.C.foo {} checkType { _() } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt index 0568159f4fa..b2e5d20d2a7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !CHECK_TYPE // FILE: StaticOverrides.java diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.fir.kt deleted file mode 100644 index ec7b20b7b46..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.fir.kt +++ /dev/null @@ -1,24 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER -// !CHECK_TYPE - -// FILE: Foo.java -import kotlin.Unit; -import kotlin.jvm.functions.Function1; - -class Foo { - interface FObject { - void invoke(T i); - } - - public String foo(FObject f) { return ""; } - public int foo(Function1 f) { return 1; } - - public String bar(FObject f) { return ""; } - public int bar(Function1 f) { return 1; } -} - -// FILE: 1.kt -fun test() { - Foo().foo {} checkType { _() } - Foo().bar {} checkType { _() } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt index f66e9679830..75a86c35a63 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER // !CHECK_TYPE diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.fir.kt deleted file mode 100644 index 3726bfd96e5..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.fir.kt +++ /dev/null @@ -1,20 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER -// !CHECK_TYPE - -// FILE: Foo.java -import kotlin.Unit; -import kotlin.jvm.functions.Function1; - -public class Foo { - interface FObject { - void invoke(Object i); - } - - public String test(FObject f) { return ""; } - public int test(Function1 f) { return 1; } -} - -// FILE: 1.kt -fun bar() { - Foo().test {} checkType { _() } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt index f0ecaba389c..695774f3dc5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER // !CHECK_TYPE