From be0dd84a06cfa59594ed6e05d561dfc5dad285e0 Mon Sep 17 00:00:00 2001 From: Tianyu Geng Date: Fri, 5 Mar 2021 00:12:36 +0300 Subject: [PATCH] FIR: check NAMED_ARGUMENTS_NOT_ALLOWED The check has already been partially implemented in org.jetbrains.kotlin.fir.resolve.calls.FirCallArgumentsProcessor. This change completes the missing piece that determines if a `FirFunction` has stable parameter names. --- .../diagnostics/FirDiagnosticsList.kt | 6 +++ .../fir/analysis/diagnostics/FirErrors.kt | 2 + .../diagnostics/FirDefaultErrorMessages.kt | 2 + .../coneDiagnosticToFirDiagnostic.kt | 5 ++ .../kotlin/fir/resolve/ResolveUtils.kt | 52 +++++++++++++++++++ .../calls/FirArgumentsToParametersMapper.kt | 18 +++---- .../fir/resolve/calls/ResolutionDiagnostic.kt | 4 +- .../kotlin/resolve/BadNamedArgumentsTarget.kt | 17 ++++++ .../tests/extensions/variableInvoke.fir.kt | 4 +- .../tests/multiplatform/namedArguments.fir.kt | 8 +-- .../disallowForJavaConstructor.fir.kt | 2 +- .../disallowForJavaMethods.fir.kt | 6 +-- .../disallowForSamAdapterConstructor.fir.kt | 2 +- .../disallowForSamAdapterFunction.fir.kt | 2 +- .../samAdapters/NoNamedArgsAllowed.fir.kt | 4 +- .../fir/generator/HLDiagnosticConverter.kt | 2 + .../diagnostics/KtFirDataClassConverters.kt | 7 +++ .../api/fir/diagnostics/KtFirDiagnostics.kt | 6 +++ .../fir/diagnostics/KtFirDiagnosticsImpl.kt | 9 ++++ 19 files changed, 133 insertions(+), 25 deletions(-) create mode 100644 compiler/frontend.common/src/org/jetbrains/kotlin/resolve/BadNamedArgumentsTarget.kt diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt index 010cd3bb156..d8373d3c2dc 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt @@ -10,6 +10,7 @@ import com.intellij.psi.PsiTypeElement import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.diagnostics.WhenMissingCase +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget import org.jetbrains.kotlin.fir.FirEffectiveVisibility import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.PrivateForInline @@ -197,6 +198,11 @@ object DIAGNOSTICS_LIST : DiagnosticList() { } val VARARG_OUTSIDE_PARENTHESES by error() + + // TODO: implement a position strategy that highlights the argument name instead of the whole named argument + val NAMED_ARGUMENTS_NOT_ALLOWED by error { + parameter("badNamedArgumentTarget") + } } val AMBIGUITY by object : DiagnosticGroup("Ambiguity") { diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index b341529683e..46ca0a62472 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -44,6 +44,7 @@ import org.jetbrains.kotlin.psi.KtTypeParameter import org.jetbrains.kotlin.psi.KtTypeParameterList import org.jetbrains.kotlin.psi.KtTypeReference import org.jetbrains.kotlin.psi.KtWhenExpression +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget /* * This file was generated automatically @@ -167,6 +168,7 @@ object FirErrors { val INAPPLICABLE_CANDIDATE by error1>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) val INAPPLICABLE_LATEINIT_MODIFIER by error1(SourceElementPositioningStrategies.LATEINIT_MODIFIER) val VARARG_OUTSIDE_PARENTHESES by error0() + val NAMED_ARGUMENTS_NOT_ALLOWED by error1() // Ambiguity val AMBIGUITY by error1>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt index a41609378ff..3aaff9a6bcb 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt @@ -119,6 +119,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NESTED_CLASS_NOT_ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MULTIPLE_VARARG_PARAMETERS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MUST_BE_INITIALIZED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MUST_BE_INITIALIZED_OR_BE_ABSTRACT +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NAMED_ARGUMENTS_NOT_ALLOWED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NONE_APPLICABLE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_FINAL_MEMBER_IN_FINAL_CLASS @@ -353,6 +354,7 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension { map.put(INAPPLICABLE_CANDIDATE, "Inapplicable candidate(s): {0}", SYMBOL) map.put(INAPPLICABLE_LATEINIT_MODIFIER, "''lateinit'' modifier {0}", TO_STRING) map.put(VARARG_OUTSIDE_PARENTHESES, "Passing value as a vararg is only allowed inside a parenthesized argument list") + map.put(NAMED_ARGUMENTS_NOT_ALLOWED, "Named arguments are not allowed for {0}", TO_STRING) // Ambiguity map.put(AMBIGUITY, "Ambiguity between candidates: {0}", SYMBOLS) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt index b6b19999871..6aecb710452 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.isInfix import org.jetbrains.kotlin.fir.declarations.isOperator import org.jetbrains.kotlin.fir.diagnostics.* import org.jetbrains.kotlin.fir.resolve.calls.InapplicableWrongReceiver +import org.jetbrains.kotlin.fir.resolve.calls.NamedArgumentNotAllowed import org.jetbrains.kotlin.fir.resolve.calls.ResolutionDiagnostic import org.jetbrains.kotlin.fir.resolve.calls.VarargArgumentOutsideParentheses import org.jetbrains.kotlin.fir.resolve.diagnostics.* @@ -115,6 +116,10 @@ private fun mapInapplicableCandidateError( when (rootCause) { is VarargArgumentOutsideParentheses -> FirErrors.VARARG_OUTSIDE_PARENTHESES.on(rootCause.argument.source ?: source) + is NamedArgumentNotAllowed -> FirErrors.NAMED_ARGUMENTS_NOT_ALLOWED.on( + rootCause.argument.source ?: source, + rootCause.badNamedArgumentsTarget + ) else -> null } }.ifEmpty { listOf(FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidate.symbol)) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index d9dd2183225..2de28bb1370 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -22,9 +22,12 @@ import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate import org.jetbrains.kotlin.fir.resolve.calls.ImplicitDispatchReceiverValue import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents +import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType import org.jetbrains.kotlin.fir.resolve.providers.* import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved +import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData +import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData import org.jetbrains.kotlin.fir.symbols.* import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* @@ -35,6 +38,7 @@ import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget fun List.toTypeProjections(): Array = asReversed().flatMap { it.typeArgumentList.typeArguments.map { typeArgument -> typeArgument.toConeTypeProjection() } }.toTypedArray() @@ -349,3 +353,51 @@ fun BodyResolveComponents.initialTypeOfCandidate(candidate: Candidate): ConeKotl private fun initialTypeOfCandidate(candidate: Candidate, typeRef: FirResolvedTypeRef): ConeKotlinType { return candidate.substitutor.substituteOrSelf(typeRef.type) } + +inline val FirCallableDeclaration<*>.containingClass: FirRegularClass? + get() = this.containingClassAttr?.let { lookupTag -> + session.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir as? FirRegularClass + } + +val FirFunction<*>.asBadForNamedArgumentTarget: BadNamedArgumentsTarget? + get() { + if (this is FirConstructor && this.isPrimary) { + this.containingClass?.let { containingClass -> + if (containingClass.classKind == ClassKind.ANNOTATION_CLASS) { + // Java annotation classes allow (actually require) named parameters. + return null + } + } + } + if (this is FirMemberDeclaration && status.isExpect) { + return BadNamedArgumentsTarget.EXPECTED_CLASS_MEMBER + } + return when (origin) { + FirDeclarationOrigin.Source, FirDeclarationOrigin.Library, FirDeclarationOrigin.BuiltIns -> null + FirDeclarationOrigin.Delegated -> delegatedWrapperData?.wrapped?.asBadForNamedArgumentTarget + FirDeclarationOrigin.ImportedFromObject -> importedFromObjectData?.original?.asBadForNamedArgumentTarget + // For intersection overrides, the logic in + // org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope#selectMostSpecificMember picks the most specific one and store + // it in originalForIntersectionOverrideAttr. This follows from FE1.0 behavior which selects the most specific function + // (org.jetbrains.kotlin.resolve.OverridingUtil#selectMostSpecificMember), from which the `hasStableParameterNames` status is + // copied. + FirDeclarationOrigin.IntersectionOverride -> originalForIntersectionOverrideAttr?.asBadForNamedArgumentTarget + FirDeclarationOrigin.Java, FirDeclarationOrigin.Enhancement -> BadNamedArgumentsTarget.NON_KOTLIN_FUNCTION + FirDeclarationOrigin.SamConstructor -> null + FirDeclarationOrigin.SubstitutionOverride -> originalForSubstitutionOverrideAttr?.asBadForNamedArgumentTarget + // referenced function of a Kotlin function type is synthetic + FirDeclarationOrigin.Synthetic -> { + if (dispatchReceiverClassOrNull()?.isBuiltinFunctionalType() == true) { + BadNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE + } else { + null + } + } + is FirDeclarationOrigin.Plugin -> null // TODO: figure out what to do with plugin generated functions + } + } + +// TODO: handle functions with non-stable parameter names, see also +// org.jetbrains.kotlin.fir.serialization.FirElementSerializer.functionProto +// org.jetbrains.kotlin.fir.serialization.FirElementSerializer.constructorProto +inline val FirFunction<*>.hasStableParameterNames: Boolean get() = asBadForNamedArgumentTarget == null diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt index e77990954d1..92136ee11a8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.calls +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.FirValueParameter @@ -15,11 +16,10 @@ import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression import org.jetbrains.kotlin.fir.expressions.builder.buildNamedArgumentExpression import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents +import org.jetbrains.kotlin.fir.resolve.asBadForNamedArgumentTarget import org.jetbrains.kotlin.fir.resolve.defaultParameterResolver import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.name.Name -import kotlin.collections.ArrayList -import kotlin.collections.LinkedHashMap import kotlin.collections.component1 import kotlin.collections.component2 import kotlin.collections.set @@ -108,6 +108,10 @@ private class FirCallArgumentsProcessor( private set val result: LinkedHashMap = LinkedHashMap(function.valueParameters.size) + val badForNamedArgumentTarget: BadNamedArgumentsTarget? by lazy { + function.asBadForNamedArgumentTarget + } + private enum class State { POSITION_ARGUMENTS, VARARG_POSITION, @@ -165,8 +169,8 @@ private class FirCallArgumentsProcessor( } private fun processNamedArgument(argument: FirExpression, name: Name) { - if (!function.hasStableParameterNames) { - addDiagnostic(NamedArgumentNotAllowed(argument, function)) + badForNamedArgumentTarget?.let { + addDiagnostic(NamedArgumentNotAllowed(argument, function, it)) } val stateAllowsMixedNamedAndPositionArguments = state != State.NAMED_ONLY_ARGUMENTS @@ -296,10 +300,4 @@ private class FirCallArgumentsProcessor( private val FirExpression.argumentName: Name? get() = (this as? FirNamedArgumentExpression)?.name - - // TODO: handle functions with non-stable parameter names, see also - // org.jetbrains.kotlin.fir.serialization.FirElementSerializer.functionProto - // org.jetbrains.kotlin.fir.serialization.FirElementSerializer.constructorProto - private val FirFunction<*>.hasStableParameterNames: Boolean - get() = true } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionDiagnostic.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionDiagnostic.kt index fa1ac80d2fd..3cf9b6d6234 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionDiagnostic.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionDiagnostic.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.calls +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget import org.jetbrains.kotlin.fir.declarations.FirFunction import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.expressions.FirExpression @@ -26,7 +27,8 @@ class TooManyArguments( class NamedArgumentNotAllowed( override val argument: FirExpression, - val function: FirFunction<*> + val function: FirFunction<*>, + val badNamedArgumentsTarget: BadNamedArgumentsTarget ) : InapplicableArgumentDiagnostic() class ArgumentPassedTwice( diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/resolve/BadNamedArgumentsTarget.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/resolve/BadNamedArgumentsTarget.kt new file mode 100644 index 00000000000..1447ac1d3ce --- /dev/null +++ b/compiler/frontend.common/src/org/jetbrains/kotlin/resolve/BadNamedArgumentsTarget.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.resolve + +enum class BadNamedArgumentsTarget(private val description:String) { + NON_KOTLIN_FUNCTION("non-Kotlin functions"), // a function provided by non-Kotlin artifact, ex: Java function + INVOKE_ON_FUNCTION_TYPE("function types"), + EXPECTED_CLASS_MEMBER("members of expected classes"), + // TODO: add the following when MPP support is available +// INTEROP_FUNCTION("interop functions with ambiguous parameter names"), // deserialized Kotlin function that serves as a bridge to a function written in another language, ex: Obj-C + ; + + override fun toString(): String = description +} diff --git a/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt b/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt index f63402666e6..150d7b92c6d 100644 --- a/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt +++ b/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt @@ -7,5 +7,5 @@ class A(foo: Int.() -> Unit) { fun test(foo: Int.(String) -> Unit) { 4.foo("") 4.foo(p1 = "") - 4.foo(p2 = "") -} \ No newline at end of file + 4.foo(p2 = "") +} diff --git a/compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt index bd800858adb..2295c0fe3da 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt @@ -12,10 +12,10 @@ expect class Foo(zzz: Int) { expect fun f2(xxx: Int) fun testCommon() { - Foo(zzz = 0) - val f = Foo(aaa = true) - f.f1(xxx = "") - f2(xxx = 42) + Foo(zzz = 0) + val f = Foo(aaa = true) + f.f1(xxx = "") + f2(xxx = 42) } // MODULE: m2-jvm(m1-common) diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt index 609f9cb2316..66c286e2287 100644 --- a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt @@ -6,4 +6,4 @@ public class A { // FILE: 1.kt -val test = A(x = 1, y = "2") +val test = A(x = 1, y = "2") diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt index 5cdaa97f87a..233a5e4f392 100644 --- a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt +++ b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt @@ -8,11 +8,11 @@ public class JavaSuperClass { // FILE: 1.kt -fun directInvocation() = JavaSuperClass().foo(javaName = 1) +fun directInvocation() = JavaSuperClass().foo(javaName = 1) open class KotlinSubClass : JavaSuperClass() -fun viaFakeOverride() = KotlinSubClass().foo(javaName = 2) +fun viaFakeOverride() = KotlinSubClass().foo(javaName = 2) class KotlinSubSubClass : KotlinSubClass() { override fun foo(kotlinName: Int) {} @@ -24,4 +24,4 @@ fun viaRealOverride() = KotlinSubSubClass().foo(kotlinName = 3) fun unresolvedParameter() = JavaSuperClass().foo(nonexistentName = 4) -fun multipleParameters() = JavaSuperClass().multipleParameters(first = 1, second = 2L, third = "3") +fun multipleParameters() = JavaSuperClass().multipleParameters(first = 1, second = 2L, third = "3") diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt index 0394f4ee7d6..cbc5d21c433 100644 --- a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt @@ -13,5 +13,5 @@ public class J { package test fun test() { - J("", r = { }, z = false) + J("", r = { }, z = false) } diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt index df2330f04be..888e9066a68 100644 --- a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt +++ b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt @@ -13,5 +13,5 @@ public class J { package test fun test() { - J.foo("", r = { }, z = false) + J.foo("", r = { }, z = false) } diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.fir.kt index ea53ff62635..77c5e172e97 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.fir.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.fir.kt @@ -1,7 +1,7 @@ // !WITH_NEW_INFERENCE // FILE: KotlinFile.kt fun foo(javaClass: JavaClass) { - javaClass.doSomething(p = 1) { + javaClass.doSomething(p = 1) { bar() } } @@ -11,4 +11,4 @@ fun bar(){} // FILE: JavaClass.java public class JavaClass { public void doSomething(int p, Runnable runnable) { runnable.run(); } -} \ No newline at end of file +} diff --git a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt index 3b7f4726fcf..a490fd3d8a8 100644 --- a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt +++ b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt @@ -9,6 +9,7 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.diagnostics.WhenMissingCase +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget import org.jetbrains.kotlin.fir.FirEffectiveVisibility import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticData import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticList @@ -173,6 +174,7 @@ private object FirToKtConversionCreator { KtModifierKeywordToken::class, Visibility::class, WhenMissingCase::class, + BadNamedArgumentsTarget::class, ) private val KType.kClass: KClass<*> diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt index 21b46909552..01bb47fd451 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -657,6 +657,13 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } + add(FirErrors.NAMED_ARGUMENTS_NOT_ALLOWED) { firDiagnostic -> + NamedArgumentsNotAllowedImpl( + firDiagnostic.a, + firDiagnostic as FirPsiDiagnostic<*>, + token, + ) + } add(FirErrors.AMBIGUITY) { firDiagnostic -> AmbiguityImpl( firDiagnostic.a.map { abstractFirBasedSymbol -> diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt index 3f0204d8b14..b68e330b50c 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt @@ -39,6 +39,7 @@ import org.jetbrains.kotlin.psi.KtTypeParameter import org.jetbrains.kotlin.psi.KtTypeParameterList import org.jetbrains.kotlin.psi.KtTypeReference import org.jetbrains.kotlin.psi.KtWhenExpression +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget /* * This file was generated automatically @@ -469,6 +470,11 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { override val diagnosticClass get() = VarargOutsideParentheses::class } + abstract class NamedArgumentsNotAllowed : KtFirDiagnostic() { + override val diagnosticClass get() = NamedArgumentsNotAllowed::class + abstract val badNamedArgumentTarget: BadNamedArgumentsTarget + } + abstract class Ambiguity : KtFirDiagnostic() { override val diagnosticClass get() = Ambiguity::class abstract val candidates: List diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index 0ef134e3334..ce2249bc42a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -41,6 +41,7 @@ import org.jetbrains.kotlin.psi.KtTypeParameter import org.jetbrains.kotlin.psi.KtTypeParameterList import org.jetbrains.kotlin.psi.KtTypeReference import org.jetbrains.kotlin.psi.KtWhenExpression +import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget /* * This file was generated automatically @@ -755,6 +756,14 @@ internal class VarargOutsideParenthesesImpl( override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) } +internal class NamedArgumentsNotAllowedImpl( + override val badNamedArgumentTarget: BadNamedArgumentsTarget, + firDiagnostic: FirPsiDiagnostic<*>, + override val token: ValidityToken, +) : KtFirDiagnostic.NamedArgumentsNotAllowed(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) +} + internal class AmbiguityImpl( override val candidates: List, firDiagnostic: FirPsiDiagnostic<*>,