diff --git a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/callResolver/Fe10IdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/callResolver/Fe10IdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java index 54833a576f7..2b140f70d31 100644 --- a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/callResolver/Fe10IdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java +++ b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/callResolver/Fe10IdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java @@ -297,6 +297,30 @@ public class Fe10IdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated ext runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithSpreadArgument.kt"); } + @Test + @TestMetadata("functionCallWithTooFewTypeArguments.kt") + public void testFunctionCallWithTooFewTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.kt"); + } + + @Test + @TestMetadata("functionCallWithTooFewTypeArguments2.kt") + public void testFunctionCallWithTooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("functionCallWithTooManyTypeArguments.kt") + public void testFunctionCallWithTooManyTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.kt"); + } + + @Test + @TestMetadata("functionCallWithTooManyTypeArguments2.kt") + public void testFunctionCallWithTooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.kt"); + } + @Test @TestMetadata("functionCallWithTypeArgument.kt") public void testFunctionCallWithTypeArgument() throws Exception { diff --git a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/references/Fe10IdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/references/Fe10IdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java index 4b586d1daad..25246f7e932 100644 --- a/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/references/Fe10IdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java +++ b/analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/references/Fe10IdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java @@ -622,6 +622,48 @@ public class Fe10IdeNormalAnalysisSourceModuleReferenceResolveTestGenerated exte runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot.kt"); } + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1.kt") + public void testTypeArgument_tooFewTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1a.kt") + public void testTypeArgument_tooFewTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments2.kt") + public void testTypeArgument_tooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1.kt") + public void testTypeArgument_tooManyTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1a.kt") + public void testTypeArgument_tooManyTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2.kt") + public void testTypeArgument_tooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2a.kt") + public void testTypeArgument_tooManyTypeArguments2a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt"); + } + @Test @TestMetadata("ValueParameter.kt") public void testValueParameter() throws Exception { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt index 6a658fb9616..816bf5dcce6 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt @@ -30,8 +30,8 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.AllCandidatesRes import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment -import org.jetbrains.kotlin.analysis.utils.errors.rethrowExceptionWithDetails import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry +import org.jetbrains.kotlin.analysis.utils.errors.rethrowExceptionWithDetails import org.jetbrains.kotlin.analysis.utils.printer.parentOfType import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol @@ -798,21 +798,29 @@ internal class KtFirCallResolver( return toTypeArgumentsMapping(typeArguments, partiallyAppliedSymbol) } + /** + * Maps [typeArguments] to the type parameters of [partiallyAppliedSymbol]. + * + * If too many type arguments are provided, a mapping is still created. Extra type arguments are simply ignored. If this wasn't the + * case, the resulting [KtCall] would contain no type arguments at all, which can cause problems later. If too few type arguments are + * provided, an empty map is returned defensively so that [toTypeArgumentsMapping] doesn't conjure any error types. If you want to map + * too few type arguments meaningfully, please provide filler types explicitly. + */ private fun toTypeArgumentsMapping( typeArguments: List, partiallyAppliedSymbol: KtPartiallyAppliedSymbol<*, *> ): Map { val typeParameters = partiallyAppliedSymbol.symbol.typeParameters if (typeParameters.isEmpty()) return emptyMap() - if (typeParameters.size != typeArguments.size) return emptyMap() + if (typeArguments.size < typeParameters.size) return emptyMap() val result = mutableMapOf() - for ((index, argument) in typeArguments.withIndex()) { + for ((index, typeParameter) in typeParameters.withIndex()) { // After resolution all type arguments should be usual types (not FirPlaceholderProjection) - if (argument !is FirTypeProjectionWithVariance || argument.variance != Variance.INVARIANT) return emptyMap() - val argumentKtType = argument.typeRef.coneType.asKtType() - result[typeParameters[index]] = argumentKtType + val typeArgument = typeArguments[index] + if (typeArgument !is FirTypeProjectionWithVariance || typeArgument.variance != Variance.INVARIANT) return emptyMap() + result[typeParameter] = typeArgument.typeRef.coneType.asKtType() } return result diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/callResolver/FirIdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/callResolver/FirIdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java index d61472a9f42..bb890a7c64e 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/callResolver/FirIdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/components/callResolver/FirIdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java @@ -297,6 +297,30 @@ public class FirIdeNormalAnalysisSourceModuleResolveCandidatesTestGenerated exte runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithSpreadArgument.kt"); } + @Test + @TestMetadata("functionCallWithTooFewTypeArguments.kt") + public void testFunctionCallWithTooFewTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.kt"); + } + + @Test + @TestMetadata("functionCallWithTooFewTypeArguments2.kt") + public void testFunctionCallWithTooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("functionCallWithTooManyTypeArguments.kt") + public void testFunctionCallWithTooManyTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.kt"); + } + + @Test + @TestMetadata("functionCallWithTooManyTypeArguments2.kt") + public void testFunctionCallWithTooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.kt"); + } + @Test @TestMetadata("functionCallWithTypeArgument.kt") public void testFunctionCallWithTypeArgument() throws Exception { diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeDependentAnalysisSourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeDependentAnalysisSourceModuleReferenceResolveTestGenerated.java index 994cd1ce0eb..e115109d2a1 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeDependentAnalysisSourceModuleReferenceResolveTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeDependentAnalysisSourceModuleReferenceResolveTestGenerated.java @@ -622,6 +622,48 @@ public class FirIdeDependentAnalysisSourceModuleReferenceResolveTestGenerated ex runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot.kt"); } + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1.kt") + public void testTypeArgument_tooFewTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1a.kt") + public void testTypeArgument_tooFewTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments2.kt") + public void testTypeArgument_tooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1.kt") + public void testTypeArgument_tooManyTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1a.kt") + public void testTypeArgument_tooManyTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2.kt") + public void testTypeArgument_tooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2a.kt") + public void testTypeArgument_tooManyTypeArguments2a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt"); + } + @Test @TestMetadata("ValueParameter.kt") public void testValueParameter() throws Exception { diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisLibrarySourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisLibrarySourceModuleReferenceResolveTestGenerated.java index 747219ba8fd..dff0c1cef73 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisLibrarySourceModuleReferenceResolveTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisLibrarySourceModuleReferenceResolveTestGenerated.java @@ -622,6 +622,48 @@ public class FirIdeNormalAnalysisLibrarySourceModuleReferenceResolveTestGenerate runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot.kt"); } + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1.kt") + public void testTypeArgument_tooFewTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1a.kt") + public void testTypeArgument_tooFewTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments2.kt") + public void testTypeArgument_tooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1.kt") + public void testTypeArgument_tooManyTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1a.kt") + public void testTypeArgument_tooManyTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2.kt") + public void testTypeArgument_tooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2a.kt") + public void testTypeArgument_tooManyTypeArguments2a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt"); + } + @Test @TestMetadata("ValueParameter.kt") public void testValueParameter() throws Exception { diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java index 4b1d3c0cea1..09c7f512d9f 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceResolveTestGenerated.java @@ -622,6 +622,48 @@ public class FirIdeNormalAnalysisSourceModuleReferenceResolveTestGenerated exten runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot.kt"); } + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1.kt") + public void testTypeArgument_tooFewTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1a.kt") + public void testTypeArgument_tooFewTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments2.kt") + public void testTypeArgument_tooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1.kt") + public void testTypeArgument_tooManyTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1a.kt") + public void testTypeArgument_tooManyTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2.kt") + public void testTypeArgument_tooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2a.kt") + public void testTypeArgument_tooManyTypeArguments2a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt"); + } + @Test @TestMetadata("ValueParameter.kt") public void testValueParameter() throws Exception { diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java index be60f27c24c..b18f61a79a5 100644 --- a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/components/callResolver/FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerated.java @@ -297,6 +297,30 @@ public class FirStandaloneNormalAnalysisSourceModuleResolveCandidatesTestGenerat runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithSpreadArgument.kt"); } + @Test + @TestMetadata("functionCallWithTooFewTypeArguments.kt") + public void testFunctionCallWithTooFewTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.kt"); + } + + @Test + @TestMetadata("functionCallWithTooFewTypeArguments2.kt") + public void testFunctionCallWithTooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("functionCallWithTooManyTypeArguments.kt") + public void testFunctionCallWithTooManyTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.kt"); + } + + @Test + @TestMetadata("functionCallWithTooManyTypeArguments2.kt") + public void testFunctionCallWithTooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.kt"); + } + @Test @TestMetadata("functionCallWithTypeArgument.kt") public void testFunctionCallWithTypeArgument() throws Exception { diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java index 23d2a067283..d91474bc04e 100644 --- a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerated.java @@ -622,6 +622,48 @@ public class FirStandaloneNormalAnalysisSourceModuleReferenceResolveTestGenerate runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot.kt"); } + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1.kt") + public void testTypeArgument_tooFewTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments1a.kt") + public void testTypeArgument_tooFewTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooFewTypeArguments2.kt") + public void testTypeArgument_tooFewTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1.kt") + public void testTypeArgument_tooManyTypeArguments1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments1a.kt") + public void testTypeArgument_tooManyTypeArguments1a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2.kt") + public void testTypeArgument_tooManyTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt"); + } + + @Test + @TestMetadata("typeArgument_tooManyTypeArguments2a.kt") + public void testTypeArgument_tooManyTypeArguments2a() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt"); + } + @Test @TestMetadata("ValueParameter.kt") public void testValueParameter() throws Exception { diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/groupBy.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/groupBy.txt index 559bf0df790..9879441a049 100644 --- a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/groupBy.txt +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/multipleCandidates/groupBy.txt @@ -71,7 +71,10 @@ KtInapplicableCallCandidateInfo: callableIdIfNonLocal = null ] callableIdIfNonLocal = kotlin/collections/groupBy - typeArgumentsMapping = {} + typeArgumentsMapping = { + T -> (kotlin.collections.IndexedValue), + K -> (kotlin.Int) + } argumentMapping = { { (_, value) -> value } -> (KtVariableLikeSignature: name = keySelector @@ -111,7 +114,9 @@ KtInapplicableCallCandidateInfo: callableIdIfNonLocal = null ] callableIdIfNonLocal = /groupBy - typeArgumentsMapping = {} + typeArgumentsMapping = { + K -> (kotlin.collections.IndexedValue) + } argumentMapping = { { (_, value) -> value } -> (KtVariableLikeSignature: name = keySelector diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.descriptors.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.descriptors.txt new file mode 100644 index 00000000000..dd4799d1c3b --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.descriptors.txt @@ -0,0 +1,20 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(): kotlin.Unit + valueParameters = [] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (ERROR_TYPE), + B -> (ERROR_TYPE), + C -> (ERROR_TYPE) + } + argumentMapping = {} + isInBestCandidates = true diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.kt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.kt new file mode 100644 index 00000000000..33014987695 --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.kt @@ -0,0 +1,5 @@ +fun generic() { } + +fun foo() { + generic() +} diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.txt new file mode 100644 index 00000000000..ef8e23e4dc2 --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments.txt @@ -0,0 +1,20 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR generic(): Unit> + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(): kotlin.Unit + valueParameters = [] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (kotlin.String), + B -> (kotlin.String), + C -> (ERROR CLASS: Cannot infer argument for type parameter C) + } + argumentMapping = {} + isInBestCandidates = true \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.descriptors.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.descriptors.txt new file mode 100644 index 00000000000..662cc1e701a --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.descriptors.txt @@ -0,0 +1,58 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(a: A, b: B, c: C): kotlin.Unit + valueParameters = [ + KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.String + symbol = a: A + callableIdIfNonLocal = null, + KtVariableLikeSignature: + name = b + receiverType = null + returnType = kotlin.String + symbol = b: B + callableIdIfNonLocal = null, + KtVariableLikeSignature: + name = c + receiverType = null + returnType = kotlin.String + symbol = c: C + callableIdIfNonLocal = null + ] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (kotlin.String), + B -> (kotlin.String), + C -> (kotlin.String) + } + argumentMapping = { + "a" -> (KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.String + symbol = a: A + callableIdIfNonLocal = null), + "b" -> (KtVariableLikeSignature: + name = b + receiverType = null + returnType = kotlin.String + symbol = b: B + callableIdIfNonLocal = null), + "c" -> (KtVariableLikeSignature: + name = c + receiverType = null + returnType = kotlin.String + symbol = c: C + callableIdIfNonLocal = null) + } + isInBestCandidates = true \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.kt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.kt new file mode 100644 index 00000000000..86cf8c957eb --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.kt @@ -0,0 +1,5 @@ +fun generic(a: A, b: B, c: C) { } + +fun foo() { + generic("a", "b", "c") +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.txt new file mode 100644 index 00000000000..c8f6fe2b23e --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooFewTypeArguments2.txt @@ -0,0 +1,58 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR generic(a: A, b: B, c: C): Unit> + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(a: A, b: B, c: C): kotlin.Unit + valueParameters = [ + KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.String + symbol = a: A + callableIdIfNonLocal = null, + KtVariableLikeSignature: + name = b + receiverType = null + returnType = kotlin.String + symbol = b: B + callableIdIfNonLocal = null, + KtVariableLikeSignature: + name = c + receiverType = null + returnType = kotlin.String + symbol = c: C + callableIdIfNonLocal = null + ] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (kotlin.String), + B -> (kotlin.String), + C -> (kotlin.String) + } + argumentMapping = { + "a" -> (KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.String + symbol = a: A + callableIdIfNonLocal = null), + "b" -> (KtVariableLikeSignature: + name = b + receiverType = null + returnType = kotlin.String + symbol = b: B + callableIdIfNonLocal = null), + "c" -> (KtVariableLikeSignature: + name = c + receiverType = null + returnType = kotlin.String + symbol = c: C + callableIdIfNonLocal = null) + } + isInBestCandidates = true \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.descriptors.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.descriptors.txt new file mode 100644 index 00000000000..b7d8b39bb2b --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.descriptors.txt @@ -0,0 +1,18 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(): kotlin.Unit + valueParameters = [] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (ERROR_TYPE) + } + argumentMapping = {} + isInBestCandidates = true diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.kt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.kt new file mode 100644 index 00000000000..815b41c1727 --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.kt @@ -0,0 +1,5 @@ +fun generic() { } + +fun foo() { + generic() +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.txt new file mode 100644 index 00000000000..cefe6715cf6 --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments.txt @@ -0,0 +1,18 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR generic(): Unit> + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(): kotlin.Unit + valueParameters = [] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (kotlin.String) + } + argumentMapping = {} + isInBestCandidates = true \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.descriptors.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.descriptors.txt new file mode 100644 index 00000000000..3db801d4c51 --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.descriptors.txt @@ -0,0 +1,32 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(a: A): kotlin.Unit + valueParameters = [ + KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.Int + symbol = a: A + callableIdIfNonLocal = null + ] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (kotlin.Int) + } + argumentMapping = { + 5 -> (KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.Int + symbol = a: A + callableIdIfNonLocal = null) + } + isInBestCandidates = true \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.kt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.kt new file mode 100644 index 00000000000..5a17196b6d7 --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.kt @@ -0,0 +1,5 @@ +fun generic(a: A) { } + +fun foo() { + generic(5) +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.txt b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.txt new file mode 100644 index 00000000000..ff404668caf --- /dev/null +++ b/analysis/analysis-api/testData/components/callResolver/resolveCandidates/singleCandidate/functionCallWithTooManyTypeArguments2.txt @@ -0,0 +1,32 @@ +KtInapplicableCallCandidateInfo: + diagnostic = ERROR generic(a: A): Unit> + candidate = KtSimpleFunctionCall: + isImplicitInvoke = false + partiallyAppliedSymbol = KtPartiallyAppliedSymbol: + dispatchReceiver = null + extensionReceiver = null + signature = KtFunctionLikeSignature: + receiverType = null + returnType = kotlin.Unit + symbol = /generic(a: A): kotlin.Unit + valueParameters = [ + KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.Int + symbol = a: A + callableIdIfNonLocal = null + ] + callableIdIfNonLocal = /generic + typeArgumentsMapping = { + A -> (kotlin.Int) + } + argumentMapping = { + 5 -> (KtVariableLikeSignature: + name = a + receiverType = null + returnType = kotlin.Int + symbol = a: A + callableIdIfNonLocal = null) + } + isInBestCandidates = true diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt new file mode 100644 index 00000000000..032a0e4e6b0 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.kt @@ -0,0 +1,6 @@ +// COMPILATION_ERRORS +fun generic() { } + +fun foo() { + generic<String, String>() +} diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.txt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.txt new file mode 100644 index 00000000000..5ba1863fe78 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in kotlin) class String : kotlin.Comparable, kotlin.CharSequence, java.io.Serializable diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt new file mode 100644 index 00000000000..c7169d9bfc7 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.kt @@ -0,0 +1,8 @@ +// COMPILATION_ERRORS +interface X + +fun generic() { } + +fun foo() { + genericX>() +} diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.txt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.txt new file mode 100644 index 00000000000..decfe043a1a --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments1a.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in ROOT) interface X diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt new file mode 100644 index 00000000000..2a35753a341 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.kt @@ -0,0 +1,6 @@ +// COMPILATION_ERRORS +fun generic(a: A, b: B, c: C) { } + +fun foo() { + generic<String, String>("a", "b", "c") +} diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.txt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.txt new file mode 100644 index 00000000000..5ba1863fe78 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooFewTypeArguments2.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in kotlin) class String : kotlin.Comparable, kotlin.CharSequence, java.io.Serializable diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt new file mode 100644 index 00000000000..d5f542d3e71 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.kt @@ -0,0 +1,9 @@ +// COMPILATION_ERRORS +interface X +interface Y + +fun generic() { } + +fun foo() { + genericY>() +} diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.txt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.txt new file mode 100644 index 00000000000..f069e253712 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in ROOT) interface Y diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt new file mode 100644 index 00000000000..4bd58735637 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.kt @@ -0,0 +1,9 @@ +// COMPILATION_ERRORS +interface X +interface Y + +fun generic() { } + +fun foo() { + generic<X, Y>() +} diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.txt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.txt new file mode 100644 index 00000000000..decfe043a1a --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments1a.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in ROOT) interface X diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt new file mode 100644 index 00000000000..9a1c3169703 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.kt @@ -0,0 +1,8 @@ +// COMPILATION_ERRORS +interface X + +fun generic(a: A) { } + +fun foo() { + genericX>(5) +} diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.txt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.txt new file mode 100644 index 00000000000..decfe043a1a --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in ROOT) interface X diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt new file mode 100644 index 00000000000..2b9311a46c4 --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.kt @@ -0,0 +1,8 @@ +// COMPILATION_ERRORS +interface X + +fun generic(a: A) { } + +fun foo() { + generic<Int, X>(5) +} diff --git a/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.txt b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.txt new file mode 100644 index 00000000000..97ad92801ec --- /dev/null +++ b/analysis/analysis-api/testData/referenceResolve/typeArgument_tooManyTypeArguments2a.txt @@ -0,0 +1,2 @@ +Resolved to: +0: (in kotlin) class Intprivate constructor : kotlin.Number(), kotlin.Comparable, java.io.Serializable diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt index fc3d3f81b97..cc60ae29411 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt @@ -11,11 +11,15 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol import org.jetbrains.kotlin.analysis.utils.printer.parentsOfType import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.resolve.calls.InapplicableCandidate import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext import org.jetbrains.kotlin.fir.resolve.calls.tower.FirTowerResolver +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag @@ -25,6 +29,7 @@ import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtElement +import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability class AllCandidatesResolver(private val firSession: FirSession) { private val scopeSession = ScopeSession() @@ -66,6 +71,7 @@ class AllCandidatesResolver(private val firSession: FirSession) { return bodyResolveComponents.context.withFile(firFile, bodyResolveComponents) { bodyResolveComponents.callResolver .collectAllCandidates(functionCall, calleeName, bodyResolveComponents.context.containers, resolutionContext) + .apply { postProcessCandidates() } } } @@ -84,6 +90,7 @@ class AllCandidatesResolver(private val firSession: FirSession) { .resolveDelegatingConstructorCall(delegatedConstructorCall, constructedType, derivedClassLookupTag) bodyResolveComponents.collector.allCandidates .map { OverloadCandidate(it, isInBestCandidates = it in bodyResolveComponents.collector.bestCandidates()) } + .apply { postProcessCandidates() } } } @@ -96,4 +103,28 @@ class AllCandidatesResolver(private val firSession: FirSession) { element.parentsOfType().map { it.resolveToFirSymbol(firResolveSession).fir }.toList().asReversed() bodyResolveComponents.context.containers.addAll(containingDeclarations) } + + private fun List.postProcessCandidates() { + forEach { it.preserveCalleeInapplicability() } + } + + /** + * Post-processes a candidate to carry the callee's inapplicability over into the candidate. Without this post-processing, an issue may + * arise where [getAllCandidates] produces "applicable" candidates with inapplicable callee references. + * + * For example, a function call `generic` of function `fun generic() { }` is correctly marked as inapplicable + * by the compiler (due to the missing type argument), but the `firFile` built during [getAllCandidates] will contain an inapplicable + * function call `generic` (with the missing type argument inferred as an error type). The *subsequent* + * resolution by `bodyResolveComponents.callResolver.collectAllCandidates` feeds this call to + * [org.jetbrains.kotlin.fir.resolve.calls.CandidateFactory], which doesn't make any guarantees for inapplicable calls. Hence, the + * resulting candidate is *not* marked as inapplicable and needs to be post-processed. + */ + private fun OverloadCandidate.preserveCalleeInapplicability() { + val callSite = candidate.callInfo.callSite as? FirQualifiedAccess ?: return + val calleeReference = callSite.calleeReference as? FirDiagnosticHolder ?: return + val diagnostic = calleeReference.diagnostic as? ConeInapplicableCandidateError ?: return + if (diagnostic.applicability != CandidateApplicability.INAPPLICABLE) return + + candidate.addDiagnostic(InapplicableCandidate) + } } \ No newline at end of file diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.fir.txt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.fir.txt index d65d2596596..f26b998783f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.fir.txt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.fir.txt @@ -24,9 +24,9 @@ FILE: typeArgumentsNotAllowed.kt } } - public final val a: = Q|rest|.# + public final val a: = Q|rest|.# public get(): - public final val b: = Q|rest/Best|.# + public final val b: = Q|rest/Best|.# public get(): public final class B : R|kotlin/Any| { public constructor(): R|rest/B| { diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/propertyAccessWithExplicitTypeArguments.fir.txt b/compiler/fir/analysis-tests/testData/resolve/expresssions/propertyAccessWithExplicitTypeArguments.fir.txt index 83e4d64aea4..043765ff909 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/propertyAccessWithExplicitTypeArguments.fir.txt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/propertyAccessWithExplicitTypeArguments.fir.txt @@ -58,21 +58,21 @@ FILE: propertyAccessWithExplicitTypeArguments.kt R|/receiver|.R|/hello1| R|/receiver|.R|/hello1|.R|/invoke|() R|/receiver|.R|/hello1| - R|/receiver|.R|/hello1| - R|/receiver|.R|/hello1| + R|/receiver|.R|/hello1| + R|/receiver|.R|/hello1| R|kotlin/with||, R|kotlin/String|>(R|/ContextImpl.ContextImpl|(), = with@fun R|ContextImpl|.(): R|kotlin/String| { R|/hello2| R|/hello2| R|/hello2|.R|/invoke|() R|/hello2| - R|/hello2| - R|/hello2| + R|/hello2| + R|/hello2| R|/receiver|.R|/hello3| R|/receiver|.R|/hello3| R|/receiver|.R|/hello3|.R|/invoke|() R|/receiver|.R|/hello3| R|/receiver|.R|/hello3| - ^ R|/receiver|.R|/hello3| + ^ R|/receiver|.R|/hello3| } ) } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt index d3a67f7ae3d..b76acb7a9f7 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaGenericVarianceViolationTypeChecker.kt @@ -14,8 +14,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors import org.jetbrains.kotlin.fir.declarations.isJavaOrEnhancement import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.resolvedArgumentMapping -import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.originalOrSelf +import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.TypeApproximatorConfiguration import org.jetbrains.kotlin.types.model.TypeConstructorMarker import org.jetbrains.kotlin.types.model.typeConstructor +import kotlin.math.min /** * Checks compatibility of variance of type argument for Java collections. @@ -53,7 +54,7 @@ object FirJavaGenericVarianceViolationTypeChecker : FirFunctionCallChecker() { } val argumentMapping = expression.resolvedArgumentMapping ?: return val typeArgumentMap = mutableMapOf() - for (i in 0 until expression.typeArguments.size) { + for (i in 0 until min(expression.typeArguments.size, calleeFunction.typeParameterSymbols.size)) { val type = (expression.typeArguments[i] as? FirTypeProjectionWithVariance)?.typeRef?.coneType if (type != null) { typeArgumentMap[calleeFunction.typeParameterSymbols[i]] = type diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt index b7147b95848..5567953cbf2 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt @@ -43,6 +43,10 @@ class CandidateFactory private constructor( constructor(context: ResolutionContext, callInfo: CallInfo) : this(context, buildBaseSystem(context, callInfo)) + /** + * [createCandidate] doesn't make any guarantees for inapplicable calls. Errors in the call or callee do not necessarily result in an + * inapplicable [Candidate]. + */ fun createCandidate( callInfo: CallInfo, symbol: FirBasedSymbol<*>, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TypeArgumentMapping.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TypeArgumentMapping.kt index 8c4d3671ebe..e3771c3a787 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TypeArgumentMapping.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/TypeArgumentMapping.kt @@ -52,7 +52,10 @@ internal object MapTypeArguments : ResolutionStage() { ) { candidate.typeArgumentMapping = TypeArgumentMapping.Mapped(typeArguments) } else { - candidate.typeArgumentMapping = TypeArgumentMapping.Mapped(emptyList()) + candidate.typeArgumentMapping = TypeArgumentMapping.Mapped( + if (typeArguments.size > owner.typeParameters.size) typeArguments.take(owner.typeParameters.size) + else typeArguments + ) sink.yieldDiagnostic(InapplicableCandidate) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index 811fcc78f50..4e646cc172e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -513,7 +513,7 @@ class FirCallCompletionResultsWriterTransformer( access: FirQualifiedAccess, candidate: Candidate ): List { - return computeTypeArgumentTypes(candidate) + val typeArguments = computeTypeArgumentTypes(candidate) .mapIndexed { index, type -> when (val argument = access.typeArguments.getOrNull(index)) { is FirTypeProjectionWithVariance -> { @@ -540,6 +540,12 @@ class FirCallCompletionResultsWriterTransformer( } } } + + // We must ensure that all extra type arguments are preserved in the result, so that they can still be resolved later (e.g. for + // navigation in the IDE). + return if (typeArguments.size < access.typeArguments.size) { + typeArguments + access.typeArguments.subList(typeArguments.size, access.typeArguments.size) + } else typeArguments } private fun computeTypeArgumentTypes( diff --git a/compiler/testData/codegen/boxError/semantic/mismatchTypeParameters.kt b/compiler/testData/codegen/boxError/semantic/mismatchTypeParameters.kt index 013a67991d8..fd6e79cde85 100644 --- a/compiler/testData/codegen/boxError/semantic/mismatchTypeParameters.kt +++ b/compiler/testData/codegen/boxError/semantic/mismatchTypeParameters.kt @@ -1,5 +1,6 @@ // IGNORE_ERRORS // ERROR_POLICY: SEMANTIC +// IGNORE_BACKEND_K2: JS_IR // MODULE: lib // FILE: t.kt diff --git a/compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.fir.kt b/compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.fir.kt deleted file mode 100644 index 61b9805ec34..00000000000 --- a/compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.fir.kt +++ /dev/null @@ -1,2 +0,0 @@ -val u = Unresolved::class -val g = UnresolvedGeneric::class diff --git a/compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt b/compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt index bd769c15913..24b7a1d2d4b 100644 --- a/compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt +++ b/compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt @@ -1,2 +1,3 @@ +// FIR_IDENTICAL val u = Unresolved::class val g = UnresolvedGeneric<UnresolvedTypeArg>::class diff --git a/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.fir.kt b/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.fir.kt index e495e235d2a..25f411bf227 100644 --- a/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.fir.kt @@ -10,6 +10,6 @@ fun test1() { fun test2() { val m0 = java.util.HashMap() - val m1 = java.util.HashMap<String, String, String>() - val m2 = java.util.HashMap<String>() + val m1 = java.util.HashMap() + val m2 = java.util.HashMap() } diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/kt51148.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/kt51148.fir.kt index 8b4a41722c9..29865b6f296 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/kt51148.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/kt51148.fir.kt @@ -1,5 +1,5 @@ fun box(): String { - return someFunction<SomeEnum>() + return someFunction() } interface SomeInterface { diff --git a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.fir.kt b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.fir.kt index f1e6e105b98..21ba398e55f 100644 --- a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.fir.kt +++ b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.fir.kt @@ -6,4 +6,4 @@ class Outer { fun nested() = Outer.Nested() fun noArguments() = Outer.Nested() fun noArgumentsExpectedType(): Outer.Nested = Outer.Nested() -fun manyArguments() = Outer.Nested<String, Int>() +fun manyArguments() = Outer.Nested() diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt index 63b6c07acf1..140bcd68c3a 100644 --- a/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt @@ -1,3 +1,3 @@ //KT-13330 AssertionError: Illegal resolved call to variable with invoke -fun foo(exec: (String.() -> Unit)?) = "".exec() // is test data tag here +fun foo(exec: (String.() -> Unit)?) = "".exec<caret>() // is test data tag here diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt b/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt index 37517d4e75f..3a79d7d2fed 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt @@ -1 +1 @@ -val unwrapped = some<sdf()()::unwrap +val unwrapped = some<sdf()()<out Any>::unwrap diff --git a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt index 070fda67ea9..8eb526b467f 100644 --- a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt @@ -3,12 +3,12 @@ fun foo(t: T) = t fun test1() { - foo("") + foo(0) } fun bar(t: T, r: R) {} fun test2() { - bar("", "") + bar(0, "") } diff --git a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt index d2f66177bbe..121dbfbca68 100644 --- a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt +++ b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt @@ -3,12 +3,12 @@ fun foo(t: T) = t fun test1() { - foo("") + foo(0) } fun bar(t: T, r: R) {} fun test2() { - bar("", "") + bar(0, "") } diff --git a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt index f1c7c3defdb..70be9cf1a44 100644 --- a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt @@ -20,10 +20,10 @@ val test2p2 = P2(1, 1) val test3p2 = P2(1, 1) val test0pr = PR(1, "") -val test1pr = PR(1, "") +val test1pr = PR("", 1) val test2pr = PR(1, "") val test2pra = PR(1, "") -val test3pr = P2(1, "") +val test3pr = PR(1, "") class Num(val x: T) typealias N = Num diff --git a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt index bc5a996214f..fbbca54f6e1 100644 --- a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt +++ b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt @@ -20,10 +20,10 @@ val test2p2 = P2(1, 1) val test3p2 = P2(1, 1) val test0pr = PR(1, "") -val test1pr = PR(1, "") +val test1pr = PR("", 1) val test2pr = PR(1, "") val test2pra = PR(1, "") -val test3pr = P2(1, "") +val test3pr = PR(1, "") class Num(val x: T) typealias N = Num diff --git a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.ni.txt b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.ni.txt index be9b0aa0ebb..f9059a1d175 100644 --- a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.ni.txt +++ b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.ni.txt @@ -6,14 +6,14 @@ public val test0p2a: Pair public val test0pr: PR /* = Pair */ public val test1: P /* = Pair */ public val test1p2: P2 /* = Pair */ -public val test1pr: PR /* = Pair */ +public val test1pr: PR /* = Pair */ public val test2: P /* = Pair */ public val test2p2: P2 /* = Pair */ public val test2pr: PR /* = Pair */ public val test2pra: PR /* = Pair */ public val test3: P /* = Pair */ public val test3p2: P2 /* = Pair */ -public val test3pr: Pair +public val test3pr: PR /* = Pair */ public val testMP0: MP /* = MyPair */ public val testMP1: MP /* = MyPair */ public val testMP2: MP /* = MyPair */