From c3bc6ef2fad87e155e9ffa024ab6fb32ba69a54d Mon Sep 17 00:00:00 2001 From: Mikhail Zarechenskiy Date: Thu, 4 Apr 2019 12:03:15 +0300 Subject: [PATCH] [NI] Make callable references more robust to overloads of outer call #KT-30676 Fixed --- .../fir/FirDiagnosticsSmokeTestGenerated.java | 10 ++++++++++ .../resolve/calls/tower/PSICallResolver.kt | 10 +++++++--- .../resolve/calls/KotlinCallResolver.kt | 10 ++++++++-- .../components/PostponeArgumentsChecks.kt | 20 +++++++++++++++---- .../components/PostponedArgumentsAnalyzer.kt | 4 +++- .../calls/components/ResolutionParts.kt | 4 +++- .../calls/model/KotlinResolverContext.kt | 9 ++++++--- .../calls/model/ResolutionCandidate.kt | 2 ++ .../function/extensionToSupertype.kt | 2 +- ...hooseOuterCallBySingleCallableReference.kt | 18 +++++++++++++++++ ...ooseOuterCallBySingleCallableReference.txt | 20 +++++++++++++++++++ ...ipleOutersAndMultipleCallableReferences.kt | 16 +++++++++++++++ ...pleOutersAndMultipleCallableReferences.txt | 20 +++++++++++++++++++ .../resolve/withPlaceholderTypes.kt | 2 +- .../resolve/withPlaceholderTypes.ni.txt | 2 +- .../checkers/DiagnosticsTestGenerated.java | 5 +++++ .../DiagnosticsUsingJavacTestGenerated.java | 10 ++++++++++ 17 files changed, 147 insertions(+), 17 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt create mode 100644 compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.txt create mode 100644 compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt create mode 100644 compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.txt diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java index 5b1dc7770bd..df1457880d2 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java @@ -2328,6 +2328,11 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byValType.kt"); } + @TestMetadata("chooseOuterCallBySingleCallableReference.kt") + public void testChooseOuterCallBySingleCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt"); + } + @TestMetadata("commonSupertypeFromReturnTypesOfCallableReference.kt") public void testCommonSupertypeFromReturnTypesOfCallableReference() throws Exception { runTest("compiler/testData/diagnostics/tests/callableReference/resolve/commonSupertypeFromReturnTypesOfCallableReference.kt"); @@ -2398,6 +2403,11 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok runTest("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificSimple.kt"); } + @TestMetadata("multipleOutersAndMultipleCallableReferences.kt") + public void testMultipleOutersAndMultipleCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt"); + } + @TestMetadata("noFakeDescriptorForObject.kt") public void testNoFakeDescriptorForObject() throws Exception { runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noFakeDescriptorForObject.kt"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt index f7fc1da4619..c0f8bb19f1d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.createLookupLocation import org.jetbrains.kotlin.resolve.calls.callUtil.getCall import org.jetbrains.kotlin.resolve.calls.callUtil.getCalleeExpressionIfAny import org.jetbrains.kotlin.resolve.calls.callUtil.isSafeCall +import org.jetbrains.kotlin.resolve.calls.components.CallableReferenceResolver import org.jetbrains.kotlin.resolve.calls.components.InferenceSession import org.jetbrains.kotlin.resolve.calls.components.PostponedArgumentsAnalyzer import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext @@ -67,7 +68,8 @@ class PSICallResolver( private val postponedArgumentsAnalyzer: PostponedArgumentsAnalyzer, private val kotlinConstraintSystemCompleter: KotlinConstraintSystemCompleter, private val deprecationResolver: DeprecationResolver, - private val moduleDescriptor: ModuleDescriptor + private val moduleDescriptor: ModuleDescriptor, + private val callableReferenceResolver: CallableReferenceResolver ) { private val givenCandidatesName = Name.special("") @@ -389,7 +391,9 @@ class PSICallResolver( override fun factoryForVariable(stripExplicitReceiver: Boolean): CandidateFactory { val explicitReceiver = if (stripExplicitReceiver) null else kotlinCall.explicitReceiver val variableCall = PSIKotlinCallForVariable(kotlinCall, explicitReceiver, kotlinCall.name) - return SimpleCandidateFactory(callComponents, scopeTower, variableCall, createResolutionCallbacks(context)) + return SimpleCandidateFactory( + callComponents, scopeTower, variableCall, createResolutionCallbacks(context), callableReferenceResolver + ) } override fun factoryForInvoke(variable: KotlinResolutionCandidate, useExplicitReceiver: Boolean): @@ -410,7 +414,7 @@ class PSICallResolver( } return variableCallArgument.receiver to SimpleCandidateFactory( - callComponents, scopeTower, callForInvoke, createResolutionCallbacks(context) + callComponents, scopeTower, callForInvoke, createResolutionCallbacks(context), callableReferenceResolver ) } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/KotlinCallResolver.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/KotlinCallResolver.kt index 8f44463cc9f..b5d77f733a7 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/KotlinCallResolver.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/KotlinCallResolver.kt @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.resolve.calls import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.resolve.calls.components.CallableReferenceResolver import org.jetbrains.kotlin.resolve.calls.components.KotlinCallCompleter import org.jetbrains.kotlin.resolve.calls.components.KotlinResolutionCallbacks import org.jetbrains.kotlin.resolve.calls.components.NewOverloadingConflictResolver @@ -32,6 +33,7 @@ class KotlinCallResolver( private val towerResolver: TowerResolver, private val kotlinCallCompleter: KotlinCallCompleter, private val overloadingConflictResolver: NewOverloadingConflictResolver, + private val callableReferenceResolver: CallableReferenceResolver, private val callComponents: KotlinCallComponents ) { @@ -45,7 +47,9 @@ class KotlinCallResolver( ): CallResolutionResult { kotlinCall.checkCallInvariants() - val candidateFactory = SimpleCandidateFactory(callComponents, scopeTower, kotlinCall, resolutionCallbacks) + val candidateFactory = SimpleCandidateFactory( + callComponents, scopeTower, kotlinCall, resolutionCallbacks, callableReferenceResolver + ) val processor = when (kotlinCall.callKind) { KotlinCallKind.VARIABLE -> { createVariableAndObjectProcessor(scopeTower, kotlinCall.name, candidateFactory, kotlinCall.explicitReceiver?.receiver) @@ -96,7 +100,9 @@ class KotlinCallResolver( collectAllCandidates: Boolean ): CallResolutionResult { kotlinCall.checkCallInvariants() - val candidateFactory = SimpleCandidateFactory(callComponents, scopeTower, kotlinCall, resolutionCallbacks) + val candidateFactory = SimpleCandidateFactory( + callComponents, scopeTower, kotlinCall, resolutionCallbacks, callableReferenceResolver + ) val resolutionCandidates = givenCandidates.map { candidateFactory.createCandidate(it).forceResolution() } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponeArgumentsChecks.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponeArgumentsChecks.kt index 767a37795b2..83533cbd0d8 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponeArgumentsChecks.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponeArgumentsChecks.kt @@ -29,15 +29,24 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs fun resolveKtPrimitive( csBuilder: ConstraintSystemBuilder, + callableReferenceResolver: CallableReferenceResolver, argument: KotlinCallArgument, expectedType: UnwrappedType?, diagnosticsHolder: KotlinDiagnosticsHolder, isReceiver: Boolean ): ResolvedAtom = when (argument) { - is SimpleKotlinCallArgument -> checkSimpleArgument(csBuilder, argument, expectedType, diagnosticsHolder, isReceiver) - is LambdaKotlinCallArgument -> preprocessLambdaArgument(csBuilder, argument, expectedType) - is CallableReferenceKotlinCallArgument -> preprocessCallableReference(csBuilder, argument, expectedType, diagnosticsHolder) - is CollectionLiteralKotlinCallArgument -> preprocessCollectionLiteralArgument(argument, expectedType) + is SimpleKotlinCallArgument -> + checkSimpleArgument(csBuilder, argument, expectedType, diagnosticsHolder, isReceiver) + + is LambdaKotlinCallArgument -> + preprocessLambdaArgument(csBuilder, argument, expectedType) + + is CallableReferenceKotlinCallArgument -> + preprocessCallableReference(csBuilder, callableReferenceResolver, argument, expectedType, diagnosticsHolder) + + is CollectionLiteralKotlinCallArgument -> + preprocessCollectionLiteralArgument(argument, expectedType) + else -> unexpectedArgument(argument) } @@ -133,11 +142,14 @@ fun LambdaWithTypeVariableAsExpectedTypeAtom.transformToResolvedLambda(csBuilder private fun preprocessCallableReference( csBuilder: ConstraintSystemBuilder, + callableReferenceResolver: CallableReferenceResolver, argument: CallableReferenceKotlinCallArgument, expectedType: UnwrappedType?, diagnosticsHolder: KotlinDiagnosticsHolder ): ResolvedAtom { val result = EagerCallableReferenceAtom(argument, expectedType) + callableReferenceResolver.processCallableReferenceArgument(csBuilder, result, diagnosticsHolder) + if (expectedType == null) return result val notCallableTypeConstructor = diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponedArgumentsAnalyzer.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponedArgumentsAnalyzer.kt index f8acd789502..7813424f5a7 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponedArgumentsAnalyzer.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/PostponedArgumentsAnalyzer.kt @@ -93,7 +93,9 @@ class PostponedArgumentsAnalyzer( returnArguments.forEach { c.addSubsystemFromArgument(it) } val subResolvedKtPrimitives = returnArguments.map { - resolveKtPrimitive(c.getBuilder(), it, lambda.returnType.let(::substitute), diagnosticHolder, isReceiver = false) + resolveKtPrimitive( + c.getBuilder(), callableReferenceResolver, it, lambda.returnType.let(::substitute), diagnosticHolder, isReceiver = false + ) } if (returnArguments.isEmpty()) { diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt index 9d91c7806fc..b379e28dc3c 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt @@ -275,7 +275,9 @@ private fun KotlinResolutionCandidate.resolveKotlinArgument( isReceiver: Boolean ) { val expectedType = candidateParameter?.let { prepareExpectedType(argument, candidateParameter) } - addResolvedKtPrimitive(resolveKtPrimitive(csBuilder, argument, expectedType, this, isReceiver)) + addResolvedKtPrimitive( + resolveKtPrimitive(csBuilder, callableReferenceResolver, argument, expectedType, this, isReceiver) + ) } private fun KotlinResolutionCandidate.prepareExpectedType( diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt index 970095fc034..cd0c0f090b5 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/KotlinResolverContext.kt @@ -25,7 +25,6 @@ import org.jetbrains.kotlin.resolve.calls.components.* import org.jetbrains.kotlin.resolve.calls.inference.addSubsystemFromArgument import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintInjector import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage -import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind import org.jetbrains.kotlin.resolve.calls.tower.* import org.jetbrains.kotlin.resolve.descriptorUtil.hasDynamicExtensionAnnotation @@ -50,7 +49,8 @@ class SimpleCandidateFactory( val callComponents: KotlinCallComponents, val scopeTower: ImplicitScopeTower, val kotlinCall: KotlinCall, - val resolutionCallbacks: KotlinResolutionCallbacks + val resolutionCallbacks: KotlinResolutionCallbacks, + val callableReferenceResolver: CallableReferenceResolver ) : CandidateFactory { val inferenceSession: InferenceSession = resolutionCallbacks.inferenceSession @@ -135,6 +135,7 @@ class SimpleCandidateFactory( if (ErrorUtils.isError(descriptor)) { return KotlinResolutionCandidate( callComponents, + callableReferenceResolver, scopeTower, baseSystem, resolvedKtCall, @@ -143,7 +144,9 @@ class SimpleCandidateFactory( ) } - val candidate = KotlinResolutionCandidate(callComponents, scopeTower, baseSystem, resolvedKtCall, knownSubstitutor) + val candidate = KotlinResolutionCandidate( + callComponents, callableReferenceResolver, scopeTower, baseSystem, resolvedKtCall, knownSubstitutor + ) initialDiagnostics.forEach(candidate::addDiagnostic) diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionCandidate.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionCandidate.kt index 60f07666be5..0e2157bcb18 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionCandidate.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/ResolutionCandidate.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.model import org.jetbrains.kotlin.descriptors.CallableDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.renderer.DescriptorRenderer +import org.jetbrains.kotlin.resolve.calls.components.CallableReferenceResolver import org.jetbrains.kotlin.resolve.calls.components.NewConstraintSystemImpl import org.jetbrains.kotlin.resolve.calls.components.TypeArgumentsToParametersMapper import org.jetbrains.kotlin.resolve.calls.inference.NewConstraintSystem @@ -64,6 +65,7 @@ fun KotlinDiagnosticsHolder.addDiagnosticIfNotNull(diagnostic: KotlinCallDiagnos */ class KotlinResolutionCandidate( val callComponents: KotlinCallComponents, + val callableReferenceResolver: CallableReferenceResolver, val scopeTower: ImplicitScopeTower, private val baseSystem: ConstraintStorage, val resolvedCall: MutableResolvedCallAtom, diff --git a/compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt b/compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt index 545511d6d28..96bce839d55 100644 --- a/compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt +++ b/compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt @@ -15,5 +15,5 @@ fun take(f: () -> Unit) {} fun test() { B::foo checkType { _>() } - take(B::foo) + take(B::foo) } diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt new file mode 100644 index 00000000000..c0c15118202 --- /dev/null +++ b/compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt @@ -0,0 +1,18 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_PARAMETER + +import kotlin.reflect.KProperty1 + +class Inv + +fun foo(prop: KProperty1, p: String = "") {} + +fun foo(prop: KProperty1>, p: Int = 42) {} + +class A { + val prop = 42 +} + +fun test() { + foo(A::prop) +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.txt b/compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.txt new file mode 100644 index 00000000000..aed07eb3935 --- /dev/null +++ b/compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.txt @@ -0,0 +1,20 @@ +package + +public fun foo(/*0*/ prop: kotlin.reflect.KProperty1>, /*1*/ p: kotlin.Int = ...): kotlin.Unit +public fun foo(/*0*/ prop: kotlin.reflect.KProperty1, /*1*/ p: kotlin.String = ...): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final val prop: kotlin.Int = 42 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class Inv { + public constructor Inv() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt new file mode 100644 index 00000000000..747a2ca2cad --- /dev/null +++ b/compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt @@ -0,0 +1,16 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_PARAMETER + +interface Base +class Inv : Base + +fun foo(x: Int): Inv = TODO() +fun foo(y: String): Inv = TODO() + +fun bar(f: (T) -> Inv, p: String = "") {} + +fun bar(f: (T) -> Inv, p: Int = 4) {} + +fun test() { + bar(::foo) +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.txt b/compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.txt new file mode 100644 index 00000000000..d903526a3e3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.txt @@ -0,0 +1,20 @@ +package + +public fun bar(/*0*/ f: (T) -> Inv, /*1*/ p: kotlin.Int = ...): kotlin.Unit +public fun bar(/*0*/ f: (T) -> Inv, /*1*/ p: kotlin.String = ...): kotlin.Unit +public fun foo(/*0*/ x: kotlin.Int): Inv +public fun foo(/*0*/ y: kotlin.String): Inv +public fun test(): kotlin.Unit + +public interface Base { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class Inv : Base { + public constructor Inv() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt index e228f497915..8a35e743d43 100644 --- a/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt +++ b/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt @@ -21,7 +21,7 @@ fun fn3(i: Int, f: (Int, Int, Int) -> Int): Int = f(i, i, i) val x1 = fn1(1, ::foo, ::foo) val x2 = fn1(1, ::foo, ::bar) -val x3 = fn2(::bar, ::foo) +val x3 = fn2(::bar, ::foo) val x4 = fn2(::foo, ::bar) val x5 = fn2(::foo, ::foo) diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.ni.txt b/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.ni.txt index 8f3221c71e5..fdcf82915be 100644 --- a/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.ni.txt +++ b/compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.ni.txt @@ -2,7 +2,7 @@ package public val x1: kotlin.String public val x2: kotlin.String -public val x3: [ERROR : Type for fn2(::bar, ::foo)] +public val x3: kotlin.String public val x4: [ERROR : Type for fn2(::foo, ::bar)] public val x5: [ERROR : Type for fn2(::foo, ::foo)] public val x6: kotlin.Int diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index fb1de81678c..925ecb86d58 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -2410,6 +2410,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { runTest("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificSimple.kt"); } + @TestMetadata("multipleOutersAndMultipleCallableReferences.kt") + public void testMultipleOutersAndMultipleCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt"); + } + @TestMetadata("noFakeDescriptorForObject.kt") public void testNoFakeDescriptorForObject() throws Exception { runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noFakeDescriptorForObject.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index 0a2b6897d01..f67b99875c5 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -2330,6 +2330,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byValType.kt"); } + @TestMetadata("chooseOuterCallBySingleCallableReference.kt") + public void testChooseOuterCallBySingleCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt"); + } + @TestMetadata("commonSupertypeFromReturnTypesOfCallableReference.kt") public void testCommonSupertypeFromReturnTypesOfCallableReference() throws Exception { runTest("compiler/testData/diagnostics/tests/callableReference/resolve/commonSupertypeFromReturnTypesOfCallableReference.kt"); @@ -2400,6 +2405,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing runTest("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificSimple.kt"); } + @TestMetadata("multipleOutersAndMultipleCallableReferences.kt") + public void testMultipleOutersAndMultipleCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt"); + } + @TestMetadata("noFakeDescriptorForObject.kt") public void testNoFakeDescriptorForObject() throws Exception { runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noFakeDescriptorForObject.kt");