Rename: BadNamedArgumentsTarget -> ForbiddenNamedArgumentsTarget

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -10,7 +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.resolve.ForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.PrivateForInline
@@ -201,7 +201,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
 
         // TODO: implement a position strategy that highlights the argument name instead of the whole named argument
         val NAMED_ARGUMENTS_NOT_ALLOWED by error<FirSourceElement, PsiElement> {
-            parameter<BadNamedArgumentsTarget>("badNamedArgumentTarget")
+            parameter<ForbiddenNamedArgumentsTarget>("forbiddenNamedArgumentsTarget")
         }
     }
 

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -44,7 +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
+import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 
 /*
  * This file was generated automatically
@@ -168,7 +168,7 @@ object FirErrors {
     val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val INAPPLICABLE_LATEINIT_MODIFIER by error1<FirSourceElement, KtModifierListOwner, String>(SourceElementPositioningStrategies.LATEINIT_MODIFIER)
     val VARARG_OUTSIDE_PARENTHESES by error0<FirSourceElement, KtExpression>()
-    val NAMED_ARGUMENTS_NOT_ALLOWED by error1<FirSourceElement, PsiElement, BadNamedArgumentsTarget>()
+    val NAMED_ARGUMENTS_NOT_ALLOWED by error1<FirSourceElement, PsiElement, ForbiddenNamedArgumentsTarget>()
 
     // Ambiguity
     val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt

@@ -118,7 +118,7 @@ private fun mapInapplicableCandidateError(
             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
+                rootCause.forbiddenNamedArgumentsTarget
             )
             else -> null
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -38,7 +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
+import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 
 fun List<FirQualifierPart>.toTypeProjections(): Array<ConeTypeProjection> =
     asReversed().flatMap { it.typeArgumentList.typeArguments.map { typeArgument -> typeArgument.toConeTypeProjection() } }.toTypedArray()
@@ -359,7 +359,7 @@ inline val FirCallableDeclaration<*>.containingClass: FirRegularClass?
         session.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir as? FirRegularClass
     }
 
-val FirFunction<*>.asBadForNamedArgumentTarget: BadNamedArgumentsTarget?
+val FirFunction<*>.asForbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget?
     get() {
         if (this is FirConstructor && this.isPrimary) {
             this.containingClass?.let { containingClass ->
@@ -370,25 +370,25 @@ val FirFunction<*>.asBadForNamedArgumentTarget: BadNamedArgumentsTarget?
             }
         }
         if (this is FirMemberDeclaration && status.isExpect) {
-            return BadNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
+            return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
         }
         return when (origin) {
             FirDeclarationOrigin.Source, FirDeclarationOrigin.Library, FirDeclarationOrigin.BuiltIns -> null
-            FirDeclarationOrigin.Delegated -> delegatedWrapperData?.wrapped?.asBadForNamedArgumentTarget
-            FirDeclarationOrigin.ImportedFromObject -> importedFromObjectData?.original?.asBadForNamedArgumentTarget
+            FirDeclarationOrigin.Delegated -> delegatedWrapperData?.wrapped?.asForbiddenNamedArgumentsTarget
+            FirDeclarationOrigin.ImportedFromObject -> importedFromObjectData?.original?.asForbiddenNamedArgumentsTarget
             // 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.IntersectionOverride -> originalForIntersectionOverrideAttr?.asForbiddenNamedArgumentsTarget
+            FirDeclarationOrigin.Java, FirDeclarationOrigin.Enhancement -> ForbiddenNamedArgumentsTarget.NON_KOTLIN_FUNCTION
             FirDeclarationOrigin.SamConstructor -> null
-            FirDeclarationOrigin.SubstitutionOverride -> originalForSubstitutionOverrideAttr?.asBadForNamedArgumentTarget
+            FirDeclarationOrigin.SubstitutionOverride -> originalForSubstitutionOverrideAttr?.asForbiddenNamedArgumentsTarget
             // referenced function of a Kotlin function type is synthetic
             FirDeclarationOrigin.Synthetic -> {
                 if (dispatchReceiverClassOrNull()?.isBuiltinFunctionalType() == true) {
-                    BadNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE
+                    ForbiddenNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE
                 } else {
                     null
                 }
@@ -400,4 +400,4 @@ val FirFunction<*>.asBadForNamedArgumentTarget: BadNamedArgumentsTarget?
 // 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
+inline val FirFunction<*>.hasStableParameterNames: Boolean get() = asForbiddenNamedArgumentsTarget == null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
-import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget
+import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
@@ -16,7 +16,7 @@ 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.asForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.fir.resolve.defaultParameterResolver
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.name.Name
@@ -108,8 +108,8 @@ private class FirCallArgumentsProcessor(
         private set
     val result: LinkedHashMap<FirValueParameter, ResolvedCallArgument> = LinkedHashMap(function.valueParameters.size)
 
-    val badForNamedArgumentTarget: BadNamedArgumentsTarget? by lazy {
-        function.asBadForNamedArgumentTarget
+    val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget? by lazy {
+        function.asForbiddenNamedArgumentsTarget
     }
 
     private enum class State {
@@ -169,7 +169,7 @@ private class FirCallArgumentsProcessor(
     }
 
     private fun processNamedArgument(argument: FirExpression, name: Name) {
-        badForNamedArgumentTarget?.let {
+        forbiddenNamedArgumentsTarget?.let {
             addDiagnostic(NamedArgumentNotAllowed(argument, function, it))
         }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionDiagnostic.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
-import org.jetbrains.kotlin.resolve.BadNamedArgumentsTarget
+import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -28,7 +28,7 @@ class TooManyArguments(
 class NamedArgumentNotAllowed(
     override val argument: FirExpression,
     val function: FirFunction<*>,
-    val badNamedArgumentsTarget: BadNamedArgumentsTarget
+    val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget
 ) : InapplicableArgumentDiagnostic()
 
 class ArgumentPassedTwice(

compiler/frontend.common/src/org/jetbrains/kotlin/resolve/ForbiddenNamedArgumentsTarget.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.resolve
 
-enum class BadNamedArgumentsTarget(private val description:String) {
+enum class ForbiddenNamedArgumentsTarget(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"),

idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt

@@ -9,7 +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.resolve.ForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticData
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticList
@@ -174,7 +174,7 @@ private object FirToKtConversionCreator {
         KtModifierKeywordToken::class,
         Visibility::class,
         WhenMissingCase::class,
-        BadNamedArgumentsTarget::class,
+        ForbiddenNamedArgumentsTarget::class,
     )
 
     private val KType.kClass: KClass<*>

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -39,7 +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
+import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 
 /*
  * This file was generated automatically
@@ -472,7 +472,7 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
 
     abstract class NamedArgumentsNotAllowed : KtFirDiagnostic<PsiElement>() {
         override val diagnosticClass get() = NamedArgumentsNotAllowed::class
-        abstract val badNamedArgumentTarget: BadNamedArgumentsTarget
+        abstract val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget
     }
 
     abstract class Ambiguity : KtFirDiagnostic<PsiElement>() {

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -41,7 +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
+import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 
 /*
  * This file was generated automatically
@@ -757,7 +757,7 @@ internal class VarargOutsideParenthesesImpl(
 }
 
 internal class NamedArgumentsNotAllowedImpl(
-    override val badNamedArgumentTarget: BadNamedArgumentsTarget,
+    override val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.NamedArgumentsNotAllowed(), KtAbstractFirDiagnostic<PsiElement> {