FIR checkers: report specific errors instead of INAPPLICABLE_CANDIDATE

Specifically, the report the following 4 errors.

* NON_VARARG_SPREAD
* ARGUMENT_PASSED_TWICE
* TOO_MANY_ARGUMENTS
* NO_VALUE_FOR_PARAMETER

Also added/updated the following position strategies.
* NAME_OF_NAMED_ARGUMENT
* VALUE_ARGUMENTS

compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt

@@ -5,5 +5,5 @@ class A
 
 annotation class AnnVarargs(val x: Int, vararg val y: String, val z: Int)
 
-<!INAPPLICABLE_CANDIDATE!>@AnnVarargs(1, "a", "b", "c", 2)<!>
+@AnnVarargs(1, "a", "b", "c", 2<!NO_VALUE_FOR_PARAMETER!>)<!>
 class B

compiler/fir/analysis-tests/testData/resolve/arguments/default.kt

@@ -8,14 +8,14 @@ fun test() {
     foo(1, 2.0, true)
     foo(1, third = true)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>()
+    foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "")
+    foo(0, 0.0, false, <!TOO_MANY_ARGUMENTS!>""<!>)
 
     bar(1, third = true)
     bar(1, 2.0, true)
     bar(1, 2.0, true, "my")
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(1, true)
+    bar(1, true<!NO_VALUE_FOR_PARAMETER!>)<!>
 
     baz(1)
     baz(1, "my", "yours")

compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt

@@ -15,8 +15,8 @@ fun foo(a: A) {
     a.foo()
     a.foo(1)
 
-    a.<!INAPPLICABLE_CANDIDATE!>bar<!>()
+    a.bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    a.<!INAPPLICABLE_CANDIDATE!>bar<!>("")
+    a.bar(""<!NO_VALUE_FOR_PARAMETER!>)<!>
     a.bar(y = 1)
     a.bar("", 2)
 }

compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt

@@ -10,8 +10,8 @@ fun test() {
     foo({})
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1) {}
+    foo(1) <!TOO_MANY_ARGUMENTS!>{}<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {}
+    foo(f = {}) <!TOO_MANY_ARGUMENTS!>{}<!>
 
     // OK
     bar(1) {}
@@ -20,15 +20,15 @@ fun test() {
     bar(x = 1, f = {})
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>bar<!> {}
+    <!NO_VALUE_FOR_PARAMETER!>bar {}<!>
-    <!INAPPLICABLE_CANDIDATE!>bar<!>({})
+    bar({}<!NO_VALUE_FOR_PARAMETER!>)<!>
 
     // OK
     baz(other = false, f = {})
     baz({}, false)
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>baz<!> {}
+    <!NO_VALUE_FOR_PARAMETER!>baz {}<!>
-    <!INAPPLICABLE_CANDIDATE!>baz<!>() {}
+    baz(<!NO_VALUE_FOR_PARAMETER!>)<!> {}
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(other = false) {}
+    baz(other = false<!NO_VALUE_FOR_PARAMETER!>)<!> <!TOO_MANY_ARGUMENTS!>{}<!>
 }

compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt

@@ -7,11 +7,11 @@ fun test() {
     foo(1, second = 3.14, third = false, fourth = "!?")
     foo(third = false, second = 2.71, fourth = "?!", first = 0)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>()
+    foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
     <!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
     foo(1, 2.0, third = true, "")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(second = 0.0, first = 0, fourth = "")
+    foo(second = 0.0, first = 0, fourth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
     <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)
+    foo(first = 0, second = 0.0, third = false, fourth = "", <!ARGUMENT_PASSED_TWICE!>first<!> = 1)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, foth = "")
+    foo(0, 0.0, false, foth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/fir/analysis-tests/testData/resolve/arguments/vararg.fir.txt

@@ -13,4 +13,5 @@ FILE: vararg.kt
         R|/bar|(Int(1), z = Boolean(true), vararg(y = *R|kotlin/arrayOf|<R|kotlin/String|>(vararg(String(my), String(yours)))))
         <Inapplicable(INAPPLICABLE): /bar>#(Int(0), z = Boolean(false), y = String(), y = String(other))
         <Inapplicable(INAPPLICABLE_ARGUMENTS_MAPPING_ERROR): /bar>#(Int(0), String(), Boolean(true))
+        <Inapplicable(INAPPLICABLE): /bar>#(Int(0), z = Boolean(false), y = String(), y = String(other), y = String(yet other))
     }

compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt

@@ -12,6 +12,7 @@ fun test() {
 
     bar(1, z = true, y = *arrayOf("my", "yours"))
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(0, z = false, y = "", y = "other")
+    bar(0, z = false, y = "", <!ARGUMENT_PASSED_TWICE!>y<!> = "other")
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(0, "", true)
+    bar(0, "", true<!NO_VALUE_FOR_PARAMETER!>)<!>
+    bar(0, z = false, y = "", <!ARGUMENT_PASSED_TWICE!>y<!> = "other", <!ARGUMENT_PASSED_TWICE!>y<!> = "yet other")
 }

compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt

@@ -2,7 +2,7 @@ class A
 class B : <!SUPERTYPE_NOT_INITIALIZED!>A<!>
 
 class C(x: Int)
-<!INAPPLICABLE_CANDIDATE!>class D : <!SUPERTYPE_NOT_INITIALIZED!>C<!><!>
+<!NO_VALUE_FOR_PARAMETER!>class D : <!SUPERTYPE_NOT_INITIALIZED!>C<!><!>
 class E : C(10)
 class F() : C(10)
 

compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt

@@ -21,7 +21,7 @@ class CallBasedInExpressionGenerator(
         gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE!>Invert<!>(it) else it }
 
     private fun gen(argument: StackValue): BranchedValue =
-        object : <!INAPPLICABLE_CANDIDATE!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.IFEQ) {
+        object : BranchedValue(<!TOO_MANY_ARGUMENTS!>argument<!>, <!TOO_MANY_ARGUMENTS!>null<!>, <!TOO_MANY_ARGUMENTS!>argument.<!UNRESOLVED_REFERENCE!>type<!><!>, <!TOO_MANY_ARGUMENTS!><!UNRESOLVED_REFERENCE!>Opcodes<!>.IFEQ<!>) {
             override fun putSelector(type: Type, kotlinType: KotlinType?, v: InstructionAdapter) {
                 invokeFunction(v)
                 <!UNRESOLVED_REFERENCE!>coerceTo<!>(type, kotlinType, v)

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

@@ -50,8 +50,9 @@ enum class PositioningStrategy(private val strategy: String? = null) {
     PRIVATE_MODIFIER,
     COMPANION_OBJECT,
     CONST_MODIFIER,
-    ARRAY_ACCESS
+    ARRAY_ACCESS,
-
+    NAME_OF_NAMED_ARGUMENT,
+    VALUE_ARGUMENTS,
     ;
 
     val expressionToCreate get() = "SourceElementPositioningStrategies.${strategy ?: name}"

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.checkers.generator.diagnostics
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiTypeElement
+import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
@@ -18,6 +19,7 @@ import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -219,10 +221,18 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
 
         val VARARG_OUTSIDE_PARENTHESES by error<FirSourceElement, KtExpression>()
 
-        // TODO: implement a position strategy that highlights the argument name instead of the whole named argument
+        val NAMED_ARGUMENTS_NOT_ALLOWED by error<FirSourceElement, KtValueArgument>(PositioningStrategy.NAME_OF_NAMED_ARGUMENT) {
-        val NAMED_ARGUMENTS_NOT_ALLOWED by error<FirSourceElement, PsiElement> {
             parameter<ForbiddenNamedArgumentsTarget>("forbiddenNamedArgumentsTarget")
         }
+
+        val NON_VARARG_SPREAD by error<FirSourceElement, LeafPsiElement>()
+        val ARGUMENT_PASSED_TWICE by error<FirSourceElement, KtValueArgument>(PositioningStrategy.NAME_OF_NAMED_ARGUMENT)
+        val TOO_MANY_ARGUMENTS by error<FirSourceElement, PsiElement> {
+            parameter<FirCallableDeclaration<*>>("function")
+        }
+        val NO_VALUE_FOR_PARAMETER by error<FirSourceElement, KtElement>(PositioningStrategy.VALUE_ARGUMENTS) {
+            parameter<FirValueParameter>("violatedParameter")
+        }
     }
 
     val AMBIGUITY by object : DiagnosticGroup("Ambiguity") {

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiTypeElement
+import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
@@ -18,6 +19,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStr
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -48,6 +50,7 @@ import org.jetbrains.kotlin.psi.KtTypeAlias
 import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.psi.KtTypeParameterList
 import org.jetbrains.kotlin.psi.KtTypeReference
+import org.jetbrains.kotlin.psi.KtValueArgument
 import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 
@@ -179,7 +182,11 @@ 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, ForbiddenNamedArgumentsTarget>()
+    val NAMED_ARGUMENTS_NOT_ALLOWED by error1<FirSourceElement, KtValueArgument, ForbiddenNamedArgumentsTarget>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
+    val NON_VARARG_SPREAD by error0<FirSourceElement, LeafPsiElement>()
+    val ARGUMENT_PASSED_TWICE by error0<FirSourceElement, KtValueArgument>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
+    val TOO_MANY_ARGUMENTS by error1<FirSourceElement, PsiElement, FirCallableDeclaration<*>>()
+    val NO_VALUE_FOR_PARAMETER by error1<FirSourceElement, KtElement, FirValueParameter>(SourceElementPositioningStrategies.VALUE_ARGUMENTS)
 
     // Ambiguity
     val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)

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

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUME
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_MEMBER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARGUMENT_PASSED_TWICE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNED_VALUE_IS_NEVER_READ
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGN_OPERATOR_AMBIGUITY
@@ -139,6 +140,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_FINAL_MEMBER_
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_MEMBER_FUNCTION_NO_BODY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PRIVATE_CONSTRUCTOR_IN_ENUM
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PRIVATE_OR_PROTECTED_CONSTRUCTOR_IN_SEALED
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_VARARG_SPREAD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOTHING_TO_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOT_AN_ANNOTATION_CLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOT_A_LOOP_LABEL
@@ -147,6 +149,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_ELSE_IN_WHEN
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_GET_METHOD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_SET_METHOD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_THIS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_VALUE_FOR_PARAMETER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_IN_CLASS_LITERAL_LHS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_OF_ANNOTATION_MEMBER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OTHER_ERROR
@@ -193,6 +196,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPERTYPE_NOT_INI
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_IS_NOT_AN_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_NOT_AVAILABLE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SYNTAX
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOO_MANY_ARGUMENTS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOPLEVEL_TYPEALIASES_ONLY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_ARGUMENTS_NOT_ALLOWED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_MISMATCH
@@ -386,6 +390,10 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             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)
+            map.put(NON_VARARG_SPREAD, "The spread operator (*foo) may only be applied in a vararg position")
+            map.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", FQ_NAMES_IN_TYPES)
+            map.put(ARGUMENT_PASSED_TWICE, "An argument is already passed for this parameter")
+            map.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter ''{0}''", NAME)
 
             // Ambiguity
             map.put(AMBIGUITY, "Ambiguity between candidates: {0}", SYMBOLS)

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.MODALITY_MODIFIERS
 import org.jetbrains.kotlin.lexer.KtTokens.VISIBILITY_MODIFIERS
 import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
+import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
 object LightTreePositioningStrategies {
     val DEFAULT = object : LightTreePositioningStrategy() {
@@ -336,6 +337,34 @@ object LightTreePositioningStrategies {
         }
     }
 
+    val NAME_OF_NAMED_ARGUMENT: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
+        override fun mark(
+            node: LighterASTNode,
+            startOffset: Int,
+            endOffset: Int,
+            tree: FlyweightCapableTreeStructure<LighterASTNode>
+        ): List<TextRange> {
+            return tree.findChildByType(node, KtNodeTypes.VALUE_ARGUMENT_NAME)?.let { valueArgumentName ->
+                markElement(valueArgumentName, startOffset, endOffset, tree, node)
+            } ?: markElement(node, startOffset, endOffset, tree, node)
+        }
+    }
+
+    val VALUE_ARGUMENTS: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
+        override fun mark(
+            node: LighterASTNode,
+            startOffset: Int,
+            endOffset: Int,
+            tree: FlyweightCapableTreeStructure<LighterASTNode>
+        ): List<TextRange> {
+            return tree.findDescendantByType(node, KtNodeTypes.VALUE_ARGUMENT_LIST)?.let { valueArgumentList ->
+                tree.findLastChildByType(valueArgumentList, KtTokens.RPAR)?.let { rpar ->
+                    markElement(rpar, startOffset, endOffset, tree, node)
+                }
+            } ?: markElement(node, startOffset, endOffset, tree, node)
+        }
+    }
+
     val DOT_BY_QUALIFIED: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
         override fun mark(
             node: LighterASTNode,
@@ -604,13 +633,31 @@ fun FlyweightCapableTreeStructure<LighterASTNode>.findChildByType(node: LighterA
     return childrenRef.get()?.firstOrNull { it?.tokenType == type }
 }
 
+fun FlyweightCapableTreeStructure<LighterASTNode>.findLastChildByType(node: LighterASTNode, type: IElementType): LighterASTNode? {
+    val childrenRef = Ref<Array<LighterASTNode?>>()
+    getChildren(node, childrenRef)
+    return childrenRef.get()?.lastOrNull { it?.tokenType == type }
+}
+
+fun FlyweightCapableTreeStructure<LighterASTNode>.findDescendantByType(node: LighterASTNode, type: IElementType): LighterASTNode? {
+    val childrenRef = Ref<Array<LighterASTNode?>>()
+    getChildren(node, childrenRef)
+    return childrenRef.get()?.firstOrNull { it?.tokenType == type } ?: childrenRef.get()
+        ?.firstNotNullResult { child -> child?.let { findDescendantByType(it, type) } }
+}
+
 private fun FlyweightCapableTreeStructure<LighterASTNode>.findChildByType(node: LighterASTNode, type: TokenSet): LighterASTNode? {
     val childrenRef = Ref<Array<LighterASTNode?>>()
     getChildren(node, childrenRef)
     return childrenRef.get()?.firstOrNull { it?.tokenType in type }
 }
 
-private fun FlyweightCapableTreeStructure<LighterASTNode>.findParentOfType(node: LighterASTNode, type: IElementType): LighterASTNode? {
+private fun FlyweightCapableTreeStructure<LighterASTNode>.findParentOfType(
+    node: LighterASTNode,
+    type: IElementType,
+    strict: Boolean = true
+): LighterASTNode? {
+    if (!strict && node.tokenType == type) return node
     var parent = getParent(node)
     while (parent != null) {
         if (parent.tokenType == type) return parent

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

@@ -107,7 +107,7 @@ object SourceElementPositioningStrategies {
         LightTreePositioningStrategies.OPERATOR,
         PositioningStrategies.OPERATOR
     )
-    
+
     val PARAMETER_DEFAULT_VALUE = SourceElementPositioningStrategy(
         LightTreePositioningStrategies.PARAMETER_DEFAULT_VALUE,
         PositioningStrategies.PARAMETER_DEFAULT_VALUE
@@ -118,6 +118,16 @@ object SourceElementPositioningStrategies {
         PositioningStrategies.PARAMETER_VARARG_MODIFIER
     )
 
+    val NAME_OF_NAMED_ARGUMENT = SourceElementPositioningStrategy(
+        LightTreePositioningStrategies.NAME_OF_NAMED_ARGUMENT,
+        PositioningStrategies.NAME_OF_NAMED_ARGUMENT
+    )
+
+    val VALUE_ARGUMENTS = SourceElementPositioningStrategy(
+        LightTreePositioningStrategies.VALUE_ARGUMENTS,
+        PositioningStrategies.VALUE_ARGUMENTS
+    )
+
     val DOT_BY_QUALIFIED = SourceElementPositioningStrategy(
         LightTreePositioningStrategies.DOT_BY_QUALIFIED,
         PositioningStrategies.DOT_BY_QUALIFIED

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

@@ -13,10 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 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.*
-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.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -137,9 +134,13 @@ private fun mapInapplicableCandidateError(
                 rootCause.argument.source ?: qualifiedAccessSource
             )
             is NamedArgumentNotAllowed -> FirErrors.NAMED_ARGUMENTS_NOT_ALLOWED.on(
-                rootCause.argument.source ?: qualifiedAccessSource,
+                rootCause.argument.source,
                 rootCause.forbiddenNamedArgumentsTarget
             )
+            is NonVarargSpread -> FirErrors.NON_VARARG_SPREAD.on(rootCause.argument.source?.getChild(KtTokens.MUL, depth = 1)!!)
+            is ArgumentPassedTwice -> FirErrors.ARGUMENT_PASSED_TWICE.on(rootCause.argument.source)
+            is TooManyArguments -> FirErrors.TOO_MANY_ARGUMENTS.on(rootCause.argument.source ?: source, rootCause.function)
+            is NoValueForParameter -> FirErrors.NO_VALUE_FOR_PARAMETER.on(qualifiedAccessSource ?: source, rootCause.valueParameter)
             else -> null
         }
     }.ifEmpty { listOf(FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidate.symbol)) }

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt

@@ -470,6 +470,17 @@ object PositioningStrategies {
         }
     }
 
+    /**
+     * Mark the name of a named argument. If the given element is not a named argument or doesn't have a name, then the entire given element
+     * is marked instead.
+     */
+    @JvmField
+    val NAME_OF_NAMED_ARGUMENT: PositioningStrategy<KtValueArgument> = object : PositioningStrategy<KtValueArgument>() {
+        override fun mark(element: KtValueArgument): List<TextRange> {
+            return markElement(element.getArgumentName() ?: element)
+        }
+    }
+
     @JvmField
     val CALL_ELEMENT: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
         override fun mark(element: PsiElement): List<TextRange> {
@@ -563,7 +574,7 @@ object PositioningStrategies {
     @JvmField
     val VALUE_ARGUMENTS: PositioningStrategy<KtElement> = object : PositioningStrategy<KtElement>() {
         override fun mark(element: KtElement): List<TextRange> {
-            return markElement((element as? KtValueArgumentList)?.rightParenthesis ?: element)
+            return markElement(element.findDescendantOfType<KtValueArgumentList>()?.rightParenthesis ?: element)
         }
     }
 

compiler/testData/diagnostics/tests/Basic.fir.kt

@@ -10,7 +10,7 @@ fun test() : Int {
 }
 
 class A() {
-    val x : Int = <!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>xx<!>)
+    val x : Int = foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
 }
 
 fun foo1() {}

compiler/testData/diagnostics/tests/CharacterLiterals.fir.kt

@@ -2,12 +2,12 @@ fun test(c : Char) {
   test(<!ILLEGAL_CONST_EXPRESSION!>''<!>)
   test('a')
   test(<!ILLEGAL_CONST_EXPRESSION!>'aa'<!>)
-  <!INAPPLICABLE_CANDIDATE!>test<!>(<!ILLEGAL_CONST_EXPRESSION!>'a)<!>
+  test(<!ILLEGAL_CONST_EXPRESSION!>'a)<!>
   <!UNRESOLVED_REFERENCE!>test<!>(<!ILLEGAL_CONST_EXPRESSION!>'<!>
   <!UNRESOLVED_REFERENCE!>test<!>(0<!ILLEGAL_CONST_EXPRESSION!><!SYNTAX!><!>'<!>
   <!UNRESOLVED_REFERENCE!>test<!>('\n')
   test('\\')
-  test(<!ILLEGAL_CONST_EXPRESSION!>''<!><!ILLEGAL_CONST_EXPRESSION!><!SYNTAX!><!>''<!>)
+  test(<!ILLEGAL_CONST_EXPRESSION!>''<!><!ILLEGAL_CONST_EXPRESSION, TOO_MANY_ARGUMENTS!><!SYNTAX!><!>''<!>)
   test('\'')
   test('\"')
 }

compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.fir.kt

@@ -1,10 +1,10 @@
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>Double<!>()
+    Double(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>Float<!>()
+    Float(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>Long<!>()
+    Long(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>Int<!>()
+    Int(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>Short<!>()
+    Short(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>Byte<!>()
+    Byte(<!NO_VALUE_FOR_PARAMETER!>)<!>
     <!HIDDEN!>Char<!>()
-    <!INAPPLICABLE_CANDIDATE!>Boolean<!>()
+    Boolean(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt

@@ -28,8 +28,8 @@ fun <T> fooT2() : (t : T) -> T {
 
 fun main(args : Array<String>) {
     args.foo()()
-    <!INAPPLICABLE_CANDIDATE!>args.foo1()<!>()
+    args.foo1(<!NO_VALUE_FOR_PARAMETER!>)<!>()
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()<!>()
+    <!UNRESOLVED_REFERENCE!>a<!>.foo1(<!NO_VALUE_FOR_PARAMETER!>)<!>()
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     args.foo1()(1)
@@ -38,7 +38,7 @@ fun main(args : Array<String>) {
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     foo2()({})
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(){}
+    foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
     (foo2()){}
     <!INAPPLICABLE_CANDIDATE!>(foo2())<!>{x -> }
     <!INAPPLICABLE_CANDIDATE!>foo2()<!>({x -> })
@@ -76,8 +76,8 @@ fun main1() {
 }
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}<!>();
+    {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
-    <!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)<!>()
+    (fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
     "sd".(<!UNRESOLVED_REFERENCE!>fun Int.() = 1<!>)()
     val i : Int? = null
     i.(<!UNRESOLVED_REFERENCE!>fun Int.() = 1<!>)();

compiler/testData/diagnostics/tests/Nullability.fir.kt

@@ -44,7 +44,7 @@ fun test() {
 
   if (out == null || out.println(0) == Unit) {
     out?.println(1)
-    out.<!INAPPLICABLE_CANDIDATE!>println<!>(1)
+    out.println(<!TOO_MANY_ARGUMENTS!>1<!>)
   }
   else {
     out.println(2)
@@ -66,11 +66,11 @@ fun test() {
 
   if (1 == 2 || out != null && out.println(1) == Unit) {
     out?.println(2);
-    out.<!INAPPLICABLE_CANDIDATE!>println<!>(2);
+    out.println(<!TOO_MANY_ARGUMENTS!>2<!>);
   }
   else {
     out?.println(3)
-    out.<!INAPPLICABLE_CANDIDATE!>println<!>(3)
+    out.println(<!TOO_MANY_ARGUMENTS!>3<!>)
   }
 
   out?.println()
@@ -103,7 +103,7 @@ fun test() {
 
   if (out == null || out.println(0) == Unit) {
     out?.println(1)
-    out.<!INAPPLICABLE_CANDIDATE!>println<!>(1)
+    out.println(<!TOO_MANY_ARGUMENTS!>1<!>)
   }
   else {
     out.println(2)
@@ -127,11 +127,11 @@ fun test() {
 
   if (1 == 2 || out != null && out.println(1) == Unit) {
     out?.println(2);
-    out.<!INAPPLICABLE_CANDIDATE!>println<!>(2);
+    out.println(<!TOO_MANY_ARGUMENTS!>2<!>);
   }
   else {
     out?.println(3)
-    out.<!INAPPLICABLE_CANDIDATE!>println<!>(3)
+    out.println(<!TOO_MANY_ARGUMENTS!>3<!>)
   }
 
   if (1 > 2) {

compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.fir.kt

@@ -3,4 +3,4 @@ import java.util.ArrayList
 
 <!NOT_AN_ANNOTATION_CLASS!>@ArrayList<Int>(1, 1)<!> fun b() {}
 @<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
-<!INAPPLICABLE_CANDIDATE!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
+@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>) fun a() {}

compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt

@@ -1,10 +1,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-class TopLevelClass<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
+class TopLevelClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
-    class InnerClass<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
+    class InnerClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
         fun test() {
-            class InFun<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T>
+            class InFun<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T>
         }
     }
 }

compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt

@@ -1,12 +1,12 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> topFun() = 12
+fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> topFun() = 12
 
 class SomeClass {
-    fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> method() = 12
+    fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> method() = 12
 
     fun foo() {
-        fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> innerFun() = 12
+        fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> innerFun() = 12
     }
 }

compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt

@@ -3,10 +3,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-val <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> T.topProp: Int get() = 12
+val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> T.topProp: Int get() = 12
 
 class SomeClass {
-    val <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.field: Int get() = 12
+    val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.field: Int get() = 12
 
     fun foo() {
         val <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> localVal = 12

compiler/testData/diagnostics/tests/annotations/BasicAnnotations.fir.kt

@@ -3,7 +3,7 @@ annotation class my1(val i : Int)
 annotation class my2(val i : Int = 0)
 
 @my fun foo() {}
-<!INAPPLICABLE_CANDIDATE!>@my1<!> fun foo2() {}
+<!NO_VALUE_FOR_PARAMETER!>@my1<!> fun foo2() {}
 @my1(2) fun foo3() {}
 @my2() fun foo4() {}
 @my2 fun foo41() {}

compiler/testData/diagnostics/tests/annotations/ConstructorCall.fir.kt

@@ -16,7 +16,7 @@ fun foo() {
     Ann()
     val a = Ann()
 
-    <!INAPPLICABLE_CANDIDATE!>Ann1<!>()
+    Ann1(<!NO_VALUE_FOR_PARAMETER!>)<!>
     Ann1(1)
     bar(Ann())
     bar(a = Ann())

compiler/testData/diagnostics/tests/annotations/rendering/tooManyArguments.fir.kt

@@ -6,6 +6,6 @@ annotation class Ann(val s: String = "")
 @Ann("s")
 fun foo() {}
 
-val bar = <!INAPPLICABLE_CANDIDATE!>foo<!>(
+val bar = foo(
-    15
+    <!TOO_MANY_ARGUMENTS!>15<!>
-)
+)

compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt

@@ -13,7 +13,7 @@ fun test() {
     checkSubtype<KProperty1<A, Int>>(p)
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty1<A, Int>>(p)
     checkSubtype<Int>(p.get(A()))
-    p.<!INAPPLICABLE_CANDIDATE!>get<!>()
+    p.get(<!NO_VALUE_FOR_PARAMETER!>)<!>
     p.<!UNRESOLVED_REFERENCE!>set<!>(A(), 239)
 
     val q = A::bar

compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt

@@ -10,7 +10,7 @@ fun main() {
     join(1)
     join(1, "2")
     join(1, "2", "3")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(*1, "2")
+    join(<!NON_VARARG_SPREAD!>*<!>1, "2")
     <!INAPPLICABLE_CANDIDATE!>join<!>(1, *"2")
     join(x = 1, a = "2")
     join(x = *1, a = *"2")
@@ -30,7 +30,7 @@ fun main() {
     join(a = a, x = 1)
 
     joinG<String>(1, "2")
-    <!INAPPLICABLE_CANDIDATE!>joinG<!><String>(*1, "2")
+    joinG<String>(<!NON_VARARG_SPREAD!>*<!>1, "2")
     <!INAPPLICABLE_CANDIDATE!>joinG<!><String>(1, *"2")
     joinG<String>(x = 1, a = a)
     joinG<String>(x = 1, a = "2")
@@ -43,7 +43,7 @@ fun main() {
     joinG<String>(a = a, x = 1)
 
     joinG(1, "2")
-    <!INAPPLICABLE_CANDIDATE!>joinG<!>(*1, "2")
+    joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
     <!INAPPLICABLE_CANDIDATE!>joinG<!>(1, *"2")
     joinG(x = 1, a = a)
     joinG(x = 1, a = "2")
@@ -57,7 +57,7 @@ fun main() {
 
     val x1 = joinT(1, "2")
     checkSubtype<String?>(x1)
-    val x2 = <!INAPPLICABLE_CANDIDATE!>joinT<!>(*1, "2")
+    val x2 = joinT(<!NON_VARARG_SPREAD!>*<!>1, "2")
     checkSubtype<String?>(x2)
     val x6 = joinT(1, *a)
     checkSubtype<String?>(x6)

compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.fir.kt

@@ -31,5 +31,5 @@ fun test() {
     D[0] = ""
     D[0] = 2.72
 
-    <!INAPPLICABLE_CANDIDATE!>Z[0]<!> = ""
+    Z[<!TOO_MANY_ARGUMENTS!>0<!>] = <!TOO_MANY_ARGUMENTS!>""<!>
 }

compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.fir.kt

@@ -6,6 +6,6 @@ class A {
     operator fun set(x: String, value: Int) {}
 
     fun d(x: Int) {
-        <!INAPPLICABLE_CANDIDATE!>this["", 1]<!> = 1
+        this["", 1] = <!TOO_MANY_ARGUMENTS!>1<!>
     }
 }

compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt

@@ -9,21 +9,21 @@ fun foo(i: Int, s: String) {}
 
 fun test() {
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>xx<!>)
+    bar(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!> { }
+    bar <!TOO_MANY_ARGUMENTS!>{ }<!>
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("", 1, <!UNRESOLVED_REFERENCE!>xx<!>)
+    foo("", 1, <!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
 
     <!INAPPLICABLE_CANDIDATE!>foo<!>(r = <!UNRESOLVED_REFERENCE!>xx<!>, i = "", s = "")
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(i = 1, i = 1, s = 11)
+    foo(i = 1, <!ARGUMENT_PASSED_TWICE!>i<!> = 1, s = 11)
 
     <!INAPPLICABLE_CANDIDATE!>foo<!>("", s = 2)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(i = "", s = 2, 33)
+    foo(i = "", s = 2, <!TOO_MANY_ARGUMENTS!>33<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("", 1) {}
+    foo("", 1) <!TOO_MANY_ARGUMENTS!>{}<!>
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("", 1) {} {}
+    foo("", 1) <!TOO_MANY_ARGUMENTS!>{}<!> <!TOO_MANY_ARGUMENTS!>{}<!>
 }

compiler/testData/diagnostics/tests/checkArguments/kt1940.fir.kt

@@ -1,9 +0,0 @@
-//KT-1940 Exception while repeating named parameters
-package kt1940
-
-fun foo(i: Int) {}
-
-fun test() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, i = 2) //exception
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(i = 1, i = 2) //exception
-}

compiler/testData/diagnostics/tests/checkArguments/kt1940.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-1940 Exception while repeating named parameters
 package kt1940
 

compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.fir.kt

@@ -34,7 +34,7 @@ fun test6() {}
 
 annotation class AnnArray(val a: Array<String>)
 
-<!INAPPLICABLE_CANDIDATE!>@AnnArray(*["/"])<!>
+@AnnArray(<!NON_VARARG_SPREAD!>*<!>["/"])
 fun testArray() {}
 
 @Ann1([""])

compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.fir.kt

@@ -1,5 +0,0 @@
-fun foo(a: Int, b: Int) = a + b
-
-fun bar(i: Int) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 1, i)
-}

compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun foo(a: Int, b: Int) = a + b
 
 fun bar(i: Int) {

compiler/testData/diagnostics/tests/controlStructures/kt799.fir.kt

@@ -9,7 +9,7 @@ fun test() {
 
     doSmth(if (true) 3 else return)
 
-    <!INAPPLICABLE_CANDIDATE!>doSmth<!>(if (true) 3 else return, 1)
+    doSmth(if (true) 3 else return, <!TOO_MANY_ARGUMENTS!>1<!>)
 }
 
 val a : Nothing = return 1

compiler/testData/diagnostics/tests/declarationChecks/kt1193.fir.kt

@@ -5,9 +5,9 @@ package kt1193
 
 enum class MyEnum(val i: Int) {
     A(12),
-    <!INAPPLICABLE_CANDIDATE!>B<!>  //no error
+    <!NO_VALUE_FOR_PARAMETER!>B<!>  //no error
 }
 
 open class A(x: Int = 1)
 
-val x: MyEnum = MyEnum.A
+val x: MyEnum = MyEnum.A

compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt

@@ -8,4 +8,4 @@ class ValueWrapper()
     fun setValue(v: Int) { backingValue = v }
 }
 
-val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper<!>()
+val foo by <!TOO_MANY_ARGUMENTS, TOO_MANY_ARGUMENTS!>ValueWrapper()<!>

compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt

@@ -3,10 +3,10 @@
 import kotlin.reflect.KProperty
 
 class A {
-  val a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+  val a: Int by Delegate(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
-val aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+val aTopLevel: Int by Delegate(<!NO_VALUE_FOR_PARAMETER!>)<!>
 
 class Delegate {
   fun getValue(t: Any?, p: KProperty<*>, a: Int): Int {

compiler/testData/diagnostics/tests/deprecated/javaDeprecated.fir.kt

@@ -11,6 +11,6 @@ public class A {
 
 // FILE: B.kt
 
-class B(private <!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>@property:Deprecated<!> val foo: String) : A() {
+class B(private @property:Deprecated val foo: String) : A() {
     override fun getFoo(text: String): String = super.getFoo(text + foo)
 }

compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.fir.kt

@@ -5,8 +5,8 @@ enum class TestOk(val x: String = "OK") {
 }
 
 enum class TestErrors(val x: String) {
-    <!INAPPLICABLE_CANDIDATE!>TEST1,<!>
+    <!NO_VALUE_FOR_PARAMETER!>TEST1,<!>
-    TEST2<!INAPPLICABLE_CANDIDATE!><!>(),
+    TEST2<!NO_VALUE_FOR_PARAMETER!><!>(),
     TEST3("Hello")
 }
 

compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt

@@ -20,7 +20,7 @@ class A
 infix operator fun A.plus(a : Any) {
 
   1.foo()
-  true.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+  true.foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
 
   1
 }

compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt

@@ -16,7 +16,7 @@ class C : T {
         super.foo() // OK
         super.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
         super.buzz() // OK, resolved to a member
-        super.<!INAPPLICABLE_CANDIDATE!>buzz1<!>() // Resolved to an extension
+        super.buzz1(<!NO_VALUE_FOR_PARAMETER!>)<!> // Resolved to an extension
         super.<!INAPPLICABLE_CANDIDATE!>buzz1<!>("") // Resolved to a member
     }
-}
+}

compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt

@@ -20,8 +20,8 @@ fun Int.foo() {}
 fun test3(s: String?) {
     "".<!INAPPLICABLE_CANDIDATE!>foo<!>()
     s<!UNSAFE_CALL!>.<!>foo()
-    "".<!INAPPLICABLE_CANDIDATE!>foo<!>(1)
+    "".foo(<!TOO_MANY_ARGUMENTS!>1<!>)
-    s.<!INAPPLICABLE_CANDIDATE!>foo<!>("a")
+    s.foo(<!TOO_MANY_ARGUMENTS!>"a"<!>)
 }
 
 interface A

compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt

@@ -6,6 +6,6 @@ class A(foo: Int.() -> Unit) {
 
 fun test(foo: Int.(String) -> Unit) {
     4.foo("")
-    4.<!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = "")
+    4.foo(p1 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    4.foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p2 = ""<!>)
+    4.foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p2<!> = "")
 }

compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.fir.kt

@@ -2,15 +2,15 @@
 
 fun foo(p: (Int, () -> Int) -> Unit) {
     // Errors except last call
-    <!INAPPLICABLE_CANDIDATE!>p<!> { 1 }
+    <!NO_VALUE_FOR_PARAMETER!>p { 1 }<!>
-    <!INAPPLICABLE_CANDIDATE!>p<!>() { 2 }
+    p(<!NO_VALUE_FOR_PARAMETER!>)<!> { 2 }
     p(3) { 4 }
 }
 
 fun bar(p: (String, Any, () -> String) -> Unit) {
     // Errors except last call
-    <!INAPPLICABLE_CANDIDATE!>p<!> { "" }
+    <!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>p { "" }<!>
-    <!INAPPLICABLE_CANDIDATE!>p<!>() { "x" }
+    p(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!> { "x" }
-    <!INAPPLICABLE_CANDIDATE!>p<!>("y") { "z" }
+    p("y"<!NO_VALUE_FOR_PARAMETER!>)<!> { "z" }
     p("v", Any()) { "w" }
-}
+}

compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt

@@ -7,4 +7,4 @@ object Z {
     infix fun add(b : Foo.() -> Unit) : Z = Z
 }
 
-val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> <!INAPPLICABLE_CANDIDATE!>{ }<!> { }
+val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> { } <!TOO_MANY_ARGUMENTS!>{ }<!>

compiler/testData/diagnostics/tests/generics/Projections.fir.kt

@@ -50,5 +50,5 @@ fun testInOut() {
     (null as Inv<out Int>).outf()
     (null as Inv<*>).outf()
 
-    Inv<Int>().<!INAPPLICABLE_CANDIDATE!>outf<!>(1) // Wrong Arg
+    Inv<Int>().outf(<!TOO_MANY_ARGUMENTS!>1<!>) // Wrong Arg
 }

compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt

@@ -32,8 +32,8 @@ fun test() {
     <!NONE_APPLICABLE!>zero<!>("")
 
     one()
-    <!INAPPLICABLE_CANDIDATE!>one<!>(1)
+    one(<!TOO_MANY_ARGUMENTS!>1<!>)
-    <!INAPPLICABLE_CANDIDATE!>one<!>("")
+    one(<!TOO_MANY_ARGUMENTS!>""<!>)
 
     two()
     two(1)

compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.fir.kt

@@ -6,5 +6,5 @@ fun <T, R> foo(map: Map<T, R>) : R = throw Exception()
 fun <F, G> getMap() : Map<F, G> = throw Exception()
 
 fun bar123() {
-    foo(<!INAPPLICABLE_CANDIDATE!>getMap<!>(
+    foo(<!TOO_MANY_ARGUMENTS!>getMap<!>(
 <!SYNTAX!><!>}

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt

@@ -39,7 +39,7 @@ fun <R> select(vararg x: R) = x[0]
 fun poll0(): Flow<String> {
     return flow {
         val inv = select(::bar, ::foo)
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -123,7 +123,7 @@ fun poll14(flag: Boolean): Flow<String> {
 fun poll15(flag: Boolean): Flow<String> {
     return flow {
         val inv = if (flag) { ::bar5 } else { ::foo5 }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -144,7 +144,7 @@ fun poll17(flag: Boolean): Flow<String> {
 fun poll2(flag: Boolean): Flow<String> {
     return flow {
         val inv = when (flag) { true -> ::bar else -> ::foo }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -193,7 +193,7 @@ fun poll26(flag: Boolean): Flow<String> {
 fun poll3(flag: Boolean): Flow<String> {
     return flow {
         val inv = when (flag) { true -> ::bar false -> ::foo }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -242,7 +242,7 @@ fun poll36(flag: Boolean): Flow<String> {
 fun poll4(): Flow<String> {
     return flow {
         val inv = try { ::bar } finally { ::foo }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -270,7 +270,7 @@ fun poll43(): Flow<String> {
 fun poll44(): Flow<String> {
     return flow {
         val inv = try { ::bar5 } finally { ::foo5 }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -291,7 +291,7 @@ fun poll46(): Flow<String> {
 fun poll5(): Flow<String> {
     return flow {
         val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -319,7 +319,7 @@ fun poll53(): Flow<String> {
 fun poll54(): Flow<String> {
     return flow {
         val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -389,7 +389,7 @@ fun poll66(): Flow<String> {
 fun poll7(): Flow<String> {
     return flow {
         val inv = ::bar!!
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.fir.kt

@@ -72,7 +72,7 @@ fun poll14(flag: Boolean): Flow<String> {
 fun poll15(flag: Boolean): Flow<String> {
     return flow {
         val inv = if (flag) { ::bar5 } else { ::foo5 }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -93,7 +93,7 @@ fun poll17(flag: Boolean): Flow<String> {
 fun poll4(): Flow<String> {
     return flow {
         val inv = try { ::bar } finally { ::foo }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -121,7 +121,7 @@ fun poll43(): Flow<String> {
 fun poll44(): Flow<String> {
     return flow {
         val inv = try { ::bar5 } finally { ::foo5 }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -142,7 +142,7 @@ fun poll46(): Flow<String> {
 fun poll5(): Flow<String> {
     return flow {
         val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -170,7 +170,7 @@ fun poll53(): Flow<String> {
 fun poll54(): Flow<String> {
     return flow {
         val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 }
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.fir.kt

@@ -38,7 +38,7 @@ class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 fun poll7(): Flow<String> {
     return flow {
         val inv = ::bar!!
-        <!INAPPLICABLE_CANDIDATE!>inv<!>()
+        inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 

compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt

@@ -119,8 +119,8 @@ fun main() {
      * K <: (A) -> Unit -> TypeVariable(_RP1) >: A
      * K >: (C) -> TypeVariable(_R) -> TypeVariable(_RP1) <: C
      */
-    val x12 = <!INAPPLICABLE_CANDIDATE!>selectC<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: B -> })
+    val x12 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: B -> }<!NO_VALUE_FOR_PARAMETER!>)<!>
-    val x13 = <!INAPPLICABLE_CANDIDATE!>selectA<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }, id { x: C -> })
+    val x13 = selectA(id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }, id { x: C -> }<!NO_VALUE_FOR_PARAMETER!>)<!>
     val x14 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: A -> }, { x -> x })
     val x15 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, { x: A -> }, id { x -> x })
     /*
@@ -152,7 +152,7 @@ fun main() {
     select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x: String, y: String -> x })
     // Convert to extension lambda is impossible because the lambda parameter types aren't specified explicitly
     select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x, y -> x })
-    select(<!INAPPLICABLE_CANDIDATE!>id<!>(id(fun(x: String, y: String) { }), fun String.(x: String) {}), { x, y -> x })
+    select(id(id(fun(x: String, y: String) { }), <!TOO_MANY_ARGUMENTS!>fun String.(x: String) {}<!>), { x, y -> x })
     val x26: Int.(String) -> Int = fun (x: String) = 10 // it must be error, see KT-38439
     // Receiver must be specified in anonymous function declaration
     val x27: Int.(String) -> Int = id(fun (x: String) = 10)

compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt

@@ -2,6 +2,6 @@ fun test1(i: Int) = { i ->
     i
 }(i)
 
-fun test2() = <!INAPPLICABLE_CANDIDATE!>{ i -> i }<!>()
+fun test2() = { i -> i }(<!NO_VALUE_FOR_PARAMETER!>)<!>
 
-fun test3() = { i -> i }(1)
+fun test3() = { i -> i }(1)

compiler/testData/diagnostics/tests/inference/regressions/kt2057.fir.kt

@@ -8,5 +8,5 @@ fun <T> foo(a : T, b : Collection<T>, c : Int) {
 
 fun <T> arrayListOf(vararg values: T): ArrayList<T> = throw Exception("$values")
 
-val bar = <!INAPPLICABLE_CANDIDATE!>foo<!>("", arrayListOf(), )
+val bar = foo("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>
-val bar2 = <!INAPPLICABLE_CANDIDATE!>foo<!><String>("", arrayListOf(), )
+val bar2 = foo<String>("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>

compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.fir.kt

@@ -30,22 +30,22 @@ fun poll11(flag: Boolean) {
 
 fun poll12(flag: Boolean) {
     val inv = if (flag) { ::bar3 } else { ::foo3 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll13(flag: Boolean) {
     val inv = if (flag) { ::bar2 } else { ::foo3 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll14(flag: Boolean) {
     val inv = if (flag) { ::bar4 } else { ::foo4 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll15(flag: Boolean) {
     val inv = if (flag) { ::bar5 } else { ::foo5 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll16(flag: Boolean) {
@@ -60,7 +60,7 @@ fun poll17(flag: Boolean) {
 
 fun poll2(flag: Boolean) {
     val inv = when (flag) { true -> ::bar else -> ::foo }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll21(flag: Boolean) {
@@ -70,12 +70,12 @@ fun poll21(flag: Boolean) {
 
 fun poll22(flag: Boolean) {
     val inv = when (flag) { true -> ::bar3 else -> ::foo3 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll23(flag: Boolean) {
     val inv = when (flag) { true -> ::bar4 else -> ::foo4 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll24(flag: Boolean) {
@@ -95,7 +95,7 @@ fun poll26(flag: Boolean) {
 
 fun poll3(flag: Boolean) {
     val inv = when (flag) { true -> ::bar false -> ::foo }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll31(flag: Boolean) {
@@ -105,12 +105,12 @@ fun poll31(flag: Boolean) {
 
 fun poll32(flag: Boolean) {
     val inv = when (flag) { true -> ::bar3 false -> ::foo3 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll33(flag: Boolean) {
     val inv = when (flag) { true -> ::bar4 false -> ::foo4 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll34(flag: Boolean) {
@@ -130,7 +130,7 @@ fun poll36(flag: Boolean) {
 
 fun poll4() {
     val inv = try { ::bar } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll41() {
@@ -140,17 +140,17 @@ fun poll41() {
 
 fun poll42() {
     val inv = try { ::bar3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll43() {
     val inv = try { ::bar4 } finally { ::foo4 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll44() {
     val inv = try { ::bar5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll45() {
@@ -165,7 +165,7 @@ fun poll46() {
 
 fun poll5() {
     val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll51() {
@@ -175,17 +175,17 @@ fun poll51() {
 
 fun poll52() {
     val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll53() {
     val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll54() {
     val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll55() {
@@ -235,7 +235,7 @@ fun poll66() {
 
 fun poll7() {
     val inv = ::bar!!
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll71() {
@@ -245,7 +245,7 @@ fun poll71() {
 
 fun poll72() {
     val inv = ::bar3!!
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll73() {
@@ -270,7 +270,7 @@ fun poll76() {
 
 fun poll8() {
     val inv = ::<!UNRESOLVED_REFERENCE!>bar<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll81() {
@@ -280,7 +280,7 @@ fun poll81() {
 
 fun poll82() {
     val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo3<!>)
-    <!INAPPLICABLE_CANDIDATE!>inv<!>()
+    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun poll83() {

compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt

@@ -20,7 +20,7 @@ class Outer {
 }
 
 fun foo() {
-    Outer.<!INAPPLICABLE_CANDIDATE!>Inner<!>()
+    Outer.Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
     Outer.<!INAPPLICABLE_CANDIDATE!>Inner<!>(1)
     Outer.Inner("")
 }

compiler/testData/diagnostics/tests/inner/kt5854.fir.kt

@@ -1,11 +0,0 @@
-//KT-5854 Incorrect 'Nested class should be qualified'
-
-class A {
-    class Nested {
-
-    }
-
-    fun foo() {
-        <!INAPPLICABLE_CANDIDATE!>Nested<!>(1) //two errors here, the first one is wrong
-    }
-}

compiler/testData/diagnostics/tests/inner/kt5854.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-5854 Incorrect 'Nested class should be qualified'
 
 class A {

compiler/testData/diagnostics/tests/inner/kt6026.fir.kt

@@ -4,5 +4,5 @@ val oo = object {
     // Forbidden in KT-13510
     class Nested
 
-    fun f1() = <!INAPPLICABLE_CANDIDATE!>Nested<!>(11)
+    fun f1() = Nested(<!TOO_MANY_ARGUMENTS!>11<!>)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.fir.kt

@@ -9,4 +9,4 @@ public class C {
 
 // FILE: main.kt
 
-fun foo() = <!INAPPLICABLE_CANDIDATE!>C<!>()
+fun foo() = C(<!NO_VALUE_FOR_PARAMETER!>)<!>

compiler/testData/diagnostics/tests/kt435.fir.kt

@@ -3,5 +3,5 @@ fun Any.foo1() : (i : Int) -> Unit {
 }
 
 fun test(a : Any) {
-    <!INAPPLICABLE_CANDIDATE!>a.foo1()<!>()
+    a.foo1(<!NO_VALUE_FOR_PARAMETER!>)<!>()
 }

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(<!NAMED_ARGUMENTS_NOT_ALLOWED!>zzz = 0<!>)
+    Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>zzz<!> = 0)
-    val f = Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>aaa = true<!>)
+    val f = Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>aaa<!> = true)
-    f.f1(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx = ""<!>)
+    f.f1(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx<!> = "")
-    f2(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx = 42<!>)
+    f2(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx<!> = 42)
 }
 
 // MODULE: m2-jvm(m1-common)

compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.fir.kt

@@ -11,8 +11,8 @@ interface D : B, A
 
 fun foo(x : C, y : D){
     x.foo(x = 0)
-    x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
+    x.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
-    y.<!INAPPLICABLE_CANDIDATE!>foo<!>(x = 0)
+    y.foo(x = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
     y.foo(y = 0)
 }
 
@@ -21,7 +21,7 @@ abstract class D1 : A, B
 
 fun bar(x : C1, y : D1){
     x.foo(x = 0)
-    x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
+    x.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
     y.foo(x = 0)
-    y.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
+    y.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
-}
+}

compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.fir.kt

@@ -14,11 +14,11 @@ interface C : A, B { // Warning here, this is correct
 }
 
 fun test(c: C) {
-    c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b1 = 1, b2 = 1.0)
+    c.foo(b1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
-    c.<!INAPPLICABLE_CANDIDATE!>foo<!>(a1 = 1, b2 = 1.0)
+    c.foo(a1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER!>)<!>
     c.foo(a1 = 1, a2 = 1.0)
     c.foo(a1 = 1, a2 = 1.0)
-    c.<!INAPPLICABLE_CANDIDATE!>bar<!>(a1 = 1, a2 = 1.0, b3= "")
+    c.bar(a1 = 1, a2 = 1.0, b3= ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    c.<!INAPPLICABLE_CANDIDATE!>baz<!>(a1 = 1, b2 = 1.0, a3 = "", b4 = 2, a5 = "")
+    c.baz(a1 = 1, b2 = 1.0, a3 = "", b4 = 2, a5 = ""<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
-    c.<!INAPPLICABLE_CANDIDATE!>baz<!>(a1 = 1, a2 = 1.0, a3 = "", b4 = 2, a5 = "")
+    c.baz(a1 = 1, a2 = 1.0, a3 = "", b4 = 2, a5 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-}
+}

compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.fir.kt

@@ -11,5 +11,5 @@ interface C : A<Int>, B { // Warning here, this is correct
 
 fun test(c: C) {
     c.foo(a = 1)
-    c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b = 1)
+    c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
-}
+}

compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.fir.kt

@@ -11,5 +11,5 @@ interface C : A, B { // Warning here, this is correct
 
 fun test(c: C) {
     c.foo(a = 1)
-    c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b = 1)
+    c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
-}
+}

compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.fir.kt

@@ -11,5 +11,5 @@ interface C<U> : A<U>, B<U> { // Warning here, this is correct
 
 fun test(c: C<Int>) {
     c.foo(a = 1)
-    c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b = 1)
+    c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
-}
+}

compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt

@@ -1,9 +0,0 @@
-// FILE: A.java
-
-public class A {
-    public A(int x, String y) {}
-}
-
-// FILE: 1.kt
-
-val test = A(<!NAMED_ARGUMENTS_NOT_ALLOWED!>x = 1<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>y = "2"<!>)

compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 
 public class A {

compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt

@@ -8,11 +8,11 @@ public class JavaSuperClass {
 
 // FILE: 1.kt
 
-fun directInvocation() = JavaSuperClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName = 1<!>)
+fun directInvocation() = JavaSuperClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName<!> = 1)
 
 open class KotlinSubClass : JavaSuperClass()
 
-fun viaFakeOverride() = KotlinSubClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName = 2<!>)
+fun viaFakeOverride() = KotlinSubClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName<!> = 2)
 
 class KotlinSubSubClass : KotlinSubClass() {
     override fun foo(kotlinName: Int) {}
@@ -21,7 +21,7 @@ class KotlinSubSubClass : KotlinSubClass() {
 fun viaRealOverride() = KotlinSubSubClass().foo(kotlinName = 3)
 
 
-fun unresolvedParameter() = JavaSuperClass().<!INAPPLICABLE_CANDIDATE!>foo<!>(nonexistentName = 4)
+fun unresolvedParameter() = JavaSuperClass(<!NO_VALUE_FOR_PARAMETER!>)<!>.foo(nonexistentName = 4)
 
 
-fun multipleParameters() = JavaSuperClass().multipleParameters(<!NAMED_ARGUMENTS_NOT_ALLOWED!>first = 1<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>second = 2L<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>third = "3"<!>)
+fun multipleParameters() = JavaSuperClass().multipleParameters(<!NAMED_ARGUMENTS_NOT_ALLOWED!>first<!> = 1, <!NAMED_ARGUMENTS_NOT_ALLOWED!>second<!> = 2L, <!NAMED_ARGUMENTS_NOT_ALLOWED!>third<!> = "3")

compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt

@@ -1,17 +0,0 @@
-// !WITH_NEW_INFERENCE
-// FILE: test/J.java
-
-package test;
-
-public class J {
-    public J(String s, Runnable r, Boolean z) {
-    }
-}
-
-// FILE: usage.kt
-
-package test
-
-fun test() {
-    J("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r = { }<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z = false<!>)
-}

compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // FILE: test/J.java
 

compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt

@@ -1,17 +0,0 @@
-// !WITH_NEW_INFERENCE
-// FILE: test/J.java
-
-package test;
-
-public class J {
-    public static void foo(String s, Runnable r, Boolean z) {
-    }
-}
-
-// FILE: usage.kt
-
-package test
-
-fun test() {
-    J.foo("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r = { }<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z = false<!>)
-}

compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // FILE: test/J.java
 

compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/disabledFeature.fir.kt

@@ -15,6 +15,6 @@ fun main() {
 
     foo(p1 = 1, p2 = "2", 3.0)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
+    foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+    foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.fir.kt

@@ -15,6 +15,6 @@ fun main() {
 
     foo(p1 = 1, p2 = "2", 3.0)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
+    foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+    foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.fir.kt

@@ -15,6 +15,6 @@ fun main() {
 
     foo(p1 = 1, p2 = "2", 3.0)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
+    foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+    foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/varargs.fir.kt

@@ -28,10 +28,10 @@ fun foo4(
 ) {}
 
 fun main() {
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(1, 2, p2 = "3", 4.0)
+    foo1(1, 2, p2 = "3", 4.0<!NO_VALUE_FOR_PARAMETER!>)<!>
     foo1(p1 = intArrayOf(1, 2), "3", p3 = 4.0)
 
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(p2 = "3", 4.0)
+    foo1(p2 = "3", 4.0<!NO_VALUE_FOR_PARAMETER!>)<!>
 
     foo2(p1 = 1, "2", "3", p3 = 4.0)
     foo2(1, p2 = arrayOf("2", "3"), 4.0)
@@ -40,11 +40,11 @@ fun main() {
     foo3(p1 = 1, "2", 3.0, 4.0)
     foo3(p1 = 1, "2", p3 = doubleArrayOf(3.0, 4.0))
 
-    <!INAPPLICABLE_CANDIDATE!>foo4<!>(p1 = 1, "2", "3", p3 = 4.0, 5)
+    foo4(p1 = 1, "2", "3", p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo4<!>(1, "2", "3", p3 = 4.0, 5)
+    foo4(1, "2", "3", p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo4<!>(1, p3 = 4.0, 5)
+    foo4(1, p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
 
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(1, 2, p3 = 3.0, "4")
+    foo1(1, 2, p3 = 3.0, "4"<!NO_VALUE_FOR_PARAMETER!>)<!>
     foo1(1, 2, p3 = 3.0, p2 = "4")
     foo1(*intArrayOf(1, 2), p3 = 3.0, p2 = "4")
 
@@ -52,6 +52,6 @@ fun main() {
     <!INAPPLICABLE_CANDIDATE!>foo2<!>(1, p3 = 2.0, *arrayOf("3", "4"))
     foo2(1, p3 = 2.0, p2 = arrayOf("3", "4"))
 
-    <!INAPPLICABLE_CANDIDATE!>foo3<!>(1, p3 = doubleArrayOf(2.0, 3.0), "4")
+    foo3(1, p3 = doubleArrayOf(2.0, 3.0), "4"<!NO_VALUE_FOR_PARAMETER!>)<!>
     foo3(1, p3 = doubleArrayOf(2.0, 3.0), p2 = "4")
 }

compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt

@@ -11,17 +11,17 @@ fun test() {
     foo(b = "")
     foo(1, "")
     foo(a = 2)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, "", "")
+    foo(1, "", <!TOO_MANY_ARGUMENTS!>""<!>)
 
     bar(z = "")
-    <!INAPPLICABLE_CANDIDATE!>bar<!>()
+    bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>bar<!>("")
+    bar(""<!NO_VALUE_FOR_PARAMETER!>)<!>
     bar(1, 1, "")
     bar(1, 1, "")
     bar(1, z = "")
     bar(1, z = "", y = 2)
     <!INAPPLICABLE_CANDIDATE!>bar<!>(z = "", 1)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(1, zz = "",
+    bar(1, zz = "",
            <!UNRESOLVED_REFERENCE!>zz<!>.foo
-           )
+           <!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.fir.kt

@@ -18,5 +18,5 @@ fun test1(d: D) {
 }
 
 fun test2(c: C) {
-    c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b1 = 1, b2 = 1.0)
+    c.foo(b1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
-}
+}

compiler/testData/diagnostics/tests/objects/Objects.fir.kt

@@ -4,15 +4,15 @@ package toplevelObjectDeclarations
     open fun foo() : Int = 1
   }
 
-  <!INAPPLICABLE_CANDIDATE!>class T : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}<!>
+  <!NO_VALUE_FOR_PARAMETER!>class T : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}<!>
 
-  <!INAPPLICABLE_CANDIDATE!>object A : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
+  object A : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
     val x : Int = 2
 
     fun test() : Int {
-      return x + foo()
+      return x + foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
-  }<!>
+  }
 
   object B : A {}
 

compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt

@@ -34,11 +34,11 @@ object MismatchingArities2 {
 }
 
 fun testMismatchingArities() {
-    ++<!INAPPLICABLE_CANDIDATE!>MismatchingArities1[0]<!>
+    <!NO_VALUE_FOR_PARAMETER!>++MismatchingArities1[0]<!>
-    <!INAPPLICABLE_CANDIDATE!>MismatchingArities1[0]<!>++
+    <!NO_VALUE_FOR_PARAMETER!>MismatchingArities1[0]++<!>
     MismatchingArities1[0] <!UNRESOLVED_REFERENCE!>+=<!> 1
 
-    ++<!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!>
+    <!NO_VALUE_FOR_PARAMETER!>++MismatchingArities2[0]<!>
-    <!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!>++
+    <!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]++<!>
-    <!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!> <!UNRESOLVED_REFERENCE!>+=<!> 1
+    <!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]<!> <!UNRESOLVED_REFERENCE!>+=<!> 1
 }

compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.fir.kt

@@ -4,24 +4,24 @@ class Function1Impl : (String) -> Unit {
 
 fun test1(f: Function1Impl) {
     f("")
-    <!INAPPLICABLE_CANDIDATE!>f<!>(p0 = "")
+    f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
     f(myParamName = "")
     f.invoke("")
-    f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(p0 = "")
+    f.invoke(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
     f.invoke(myParamName = "")
 }
 
 fun test2(f: (String) -> Unit) {
     f("")
-    <!INAPPLICABLE_CANDIDATE!>f<!>(p0 = "")
+    f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>f<!>(myParamName = "")
+    f(myParamName = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
     f.invoke("")
-    f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(p0 = "")
+    f.invoke(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(myParamName = "")
+    f.invoke(myParamName = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun test3(f: String.(String) -> Unit) {
     "".f("")
-    "".<!INAPPLICABLE_CANDIDATE!>f<!>(p0 = "")
+    "".f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    "".<!INAPPLICABLE_CANDIDATE!>f<!>(zzz = "")
+    "".f(zzz = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/testData/diagnostics/tests/regressions/kt1736.fir.kt

@@ -1,10 +0,0 @@
-//KT-1736 AssertionError in CallResolver
-
-package kt1736
-
-object Obj {
-    fun method() {
-    }
-}
-
-val x = Obj.<!INAPPLICABLE_CANDIDATE!>method<!>{ -> }

compiler/testData/diagnostics/tests/regressions/kt1736.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-1736 AssertionError in CallResolver
 
 package kt1736

compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.fir.kt

@@ -4,7 +4,7 @@ class X<V>(provider: () -> V, trackValue: Boolean) {
 }
 
 class B {
-    val c = <!INAPPLICABLE_CANDIDATE!>X<!><String> {
+    val c = <!NO_VALUE_FOR_PARAMETER!>X<String> {
         "e"
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt

@@ -1,7 +1,7 @@
 fun test1(f: String.() -> Unit) {
-    (<!INAPPLICABLE_CANDIDATE!>f<!>)()
+    (f)(<!NO_VALUE_FOR_PARAMETER!>)<!>
 
-    <!INAPPLICABLE_CANDIDATE!>f<!>()
+    f(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun test2(f: (Int) -> Int) {

compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt

@@ -7,7 +7,7 @@ fun test1() {
 
 fun test2(f: String.(Int) -> Unit) {
     11.(<!INAPPLICABLE_CANDIDATE!>f<!>)(1)
-    11.(<!INAPPLICABLE_CANDIDATE!>f<!>)()
+    11.(f)(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun test3() {

compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt

@@ -8,7 +8,7 @@ class SomeClass
 
 fun test(identifier: SomeClass, fn: String.() -> Unit) {
     <!NONE_APPLICABLE!>identifier<!>()
-    <!INAPPLICABLE_CANDIDATE!>identifier<!>(123)
+    identifier(123<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
+    identifier(1, <!TOO_MANY_ARGUMENTS!>2<!>)
     1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
 }

compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt

@@ -11,10 +11,10 @@ fun test(a: A) {
     <!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)<!>("")
 
     with("") {
-        a.<!INAPPLICABLE_CANDIDATE!>x<!>()
+        a.x(<!NO_VALUE_FOR_PARAMETER!>)<!>
-        <!INAPPLICABLE_CANDIDATE!>(a.x)<!>()
+        (a.x)(<!NO_VALUE_FOR_PARAMETER!>)<!>
         if (a.x != null) {
-            a.<!INAPPLICABLE_CANDIDATE!>x<!>() // todo
+            a.x(<!NO_VALUE_FOR_PARAMETER!>)<!> // todo
             (a.x)()
         }
     }

compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt

@@ -24,8 +24,8 @@ fun test(a: A, b: B) {
     }
 
     with(b) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
-        a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.(foo)(<!NO_VALUE_FOR_PARAMETER!>)<!>
 
         (a.foo)()
 
@@ -66,8 +66,8 @@ fun test(a: A, b: B) {
     }
 
     with(b) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
-        a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.(foo)(<!NO_VALUE_FOR_PARAMETER!>)<!>
 
         (a.foo)()
 

compiler/testData/diagnostics/tests/resolve/invoke/kt9805.fir.kt

@@ -1,17 +0,0 @@
-class A {
-    val foo: B.() -> Unit get() = null!!
-}
-
-class B
-
-fun test(a: A, b: B) {
-    with(b) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // here must be error, because a is not extension receiver
-
-        a.foo(this)
-
-        (a.foo)()
-
-        (a.foo)(this)
-    }
-}

compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
     val foo: B.() -> Unit get() = null!!
 }

compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt

@@ -7,7 +7,7 @@ class SomeClass
 
 fun test(identifier: SomeClass, fn: String.() -> Unit) {
     <!INAPPLICABLE_CANDIDATE!>identifier<!>()
-    <!INAPPLICABLE_CANDIDATE!>identifier<!>(123)
+    identifier(<!TOO_MANY_ARGUMENTS!>123<!>)
-    <!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
+    identifier(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
     1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
 }