diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt
index 5d460f57658..97efb6d29e9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt
+++ b/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
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
index bf5a1904af2..b663afc10d8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
+++ 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<!>()
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "")
+    foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    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")
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt
index 6995c3c4d61..ec2ce34c183 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt
+++ b/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.<!INAPPLICABLE_CANDIDATE!>bar<!>("")
+    a.bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    a.bar(""<!NO_VALUE_FOR_PARAMETER!>)<!>
     a.bar(y = 1)
     a.bar("", 2)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
index efbfd0fe827..60aa8e6fc51 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
@@ -10,8 +10,8 @@ fun test() {
     foo({})
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1) {}
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {}
+    foo(1) <!TOO_MANY_ARGUMENTS!>{}<!>
+    foo(f = {}) <!TOO_MANY_ARGUMENTS!>{}<!>
 
     // OK
     bar(1) {}
@@ -20,15 +20,15 @@ fun test() {
     bar(x = 1, f = {})
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>bar<!> {}
-    <!INAPPLICABLE_CANDIDATE!>bar<!>({})
+    <!NO_VALUE_FOR_PARAMETER!>bar {}<!>
+    bar({}<!NO_VALUE_FOR_PARAMETER!>)<!>
 
     // OK
     baz(other = false, f = {})
     baz({}, false)
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>baz<!> {}
-    <!INAPPLICABLE_CANDIDATE!>baz<!>() {}
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(other = false) {}
+    <!NO_VALUE_FOR_PARAMETER!>baz {}<!>
+    baz(<!NO_VALUE_FOR_PARAMETER!>)<!> {}
+    baz(other = false<!NO_VALUE_FOR_PARAMETER!>)<!> <!TOO_MANY_ARGUMENTS!>{}<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
index 737e67d3b8e..067d60f6a9e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
+++ b/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)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, foth = "")
+    foo(first = 0, second = 0.0, third = false, fourth = "", <!ARGUMENT_PASSED_TWICE!>first<!> = 1)
+    foo(0, 0.0, false, foth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.fir.txt b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.fir.txt
index bc2b28f3876..ecf6da3fde5 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.fir.txt
+++ b/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))
     }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
index f42aee5067d..3bf7a428880 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
+++ b/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")
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(0, "", true)
+    bar(0, z = false, y = "", <!ARGUMENT_PASSED_TWICE!>y<!> = "other")
+    bar(0, "", true<!NO_VALUE_FOR_PARAMETER!>)<!>
+    bar(0, z = false, y = "", <!ARGUMENT_PASSED_TWICE!>y<!> = "other", <!ARGUMENT_PASSED_TWICE!>y<!> = "yet other")
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt
index 9fc2d8a4684..1924d441068 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt
+++ b/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)
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
index b4f776776d1..f31be1e628c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
+++ b/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)
diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
index 104e5d8cda9..58797850a92 100644
--- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
+++ b/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}"
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 c9db0cfffc7..518ed74a24f 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
@@ -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, PsiElement> {
+        val NAMED_ARGUMENTS_NOT_ALLOWED by error<FirSourceElement, KtValueArgument>(PositioningStrategy.NAME_OF_NAMED_ARGUMENT) {
             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") {
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 52ee9965549..6fd2146d19a 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
@@ -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)
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 82c58820b9e..64f401d036d 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
@@ -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)
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
index 05021fbd55e..329f5e64892 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
+++ b/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
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
index 1232989c737..45aa0814db4 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
+++ b/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
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 e6dab4dc717..f8ed9d4f158 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
@@ -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.NamedArgumentNotAllowed
-import org.jetbrains.kotlin.fir.resolve.calls.ResolutionDiagnostic
-import org.jetbrains.kotlin.fir.resolve.calls.VarargArgumentOutsideParentheses
+import org.jetbrains.kotlin.fir.resolve.calls.*
 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)) }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
index e8e6f55f69d..3dbb8d075e7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+++ b/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)
         }
     }
 
diff --git a/compiler/testData/diagnostics/tests/Basic.fir.kt b/compiler/testData/diagnostics/tests/Basic.fir.kt
index 8e482deb189..4aabd12047d 100644
--- a/compiler/testData/diagnostics/tests/Basic.fir.kt
+++ b/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() {}
diff --git a/compiler/testData/diagnostics/tests/CharacterLiterals.fir.kt b/compiler/testData/diagnostics/tests/CharacterLiterals.fir.kt
index 249092de44a..6fc44b50729 100644
--- a/compiler/testData/diagnostics/tests/CharacterLiterals.fir.kt
+++ b/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('\"')
 }
diff --git a/compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.fir.kt b/compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.fir.kt
index 08cdb42e71e..8c720027bc5 100644
--- a/compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.fir.kt
+++ b/compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.fir.kt
@@ -1,10 +1,10 @@
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>Double<!>()
-    <!INAPPLICABLE_CANDIDATE!>Float<!>()
-    <!INAPPLICABLE_CANDIDATE!>Long<!>()
-    <!INAPPLICABLE_CANDIDATE!>Int<!>()
-    <!INAPPLICABLE_CANDIDATE!>Short<!>()
-    <!INAPPLICABLE_CANDIDATE!>Byte<!>()
+    Double(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Float(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Long(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Int(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Short(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Byte(<!NO_VALUE_FOR_PARAMETER!>)<!>
     <!HIDDEN!>Char<!>()
-    <!INAPPLICABLE_CANDIDATE!>Boolean<!>()
+    Boolean(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
diff --git a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
index 38f66e13e72..e1b90e09b4f 100644
--- a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
+++ b/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()<!>()
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()<!>()
+    args.foo1(<!NO_VALUE_FOR_PARAMETER!>)<!>()
+    <!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}<!>();
-    <!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)<!>()
+    {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
+    (fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
     "sd".(<!UNRESOLVED_REFERENCE!>fun Int.() = 1<!>)()
     val i : Int? = null
     i.(<!UNRESOLVED_REFERENCE!>fun Int.() = 1<!>)();
diff --git a/compiler/testData/diagnostics/tests/Nullability.fir.kt b/compiler/testData/diagnostics/tests/Nullability.fir.kt
index a59a6f45cfb..00edb39d0e7 100644
--- a/compiler/testData/diagnostics/tests/Nullability.fir.kt
+++ b/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) {
diff --git a/compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.fir.kt b/compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.fir.kt
index b2509b87409..4882323d7da 100644
--- a/compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.fir.kt
+++ b/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() {}
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt
index 728e16d62e4..07d16e28c0f 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt
+++ b/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 InnerClass<@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 @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>
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt
index edd5a887999..02536a4b56a 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt
+++ b/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
     }
 }
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt
index 01ae94af87d..06ed2a04db2 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.fir.kt b/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.fir.kt
index 3da14fdb2be..ad0b3f65e63 100644
--- a/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.fir.kt
+++ b/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() {}
diff --git a/compiler/testData/diagnostics/tests/annotations/ConstructorCall.fir.kt b/compiler/testData/diagnostics/tests/annotations/ConstructorCall.fir.kt
index 21188f702fe..fa66da3ee58 100644
--- a/compiler/testData/diagnostics/tests/annotations/ConstructorCall.fir.kt
+++ b/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())
diff --git a/compiler/testData/diagnostics/tests/annotations/rendering/tooManyArguments.fir.kt b/compiler/testData/diagnostics/tests/annotations/rendering/tooManyArguments.fir.kt
index b59d761bfba..a826e31f1d8 100644
--- a/compiler/testData/diagnostics/tests/annotations/rendering/tooManyArguments.fir.kt
+++ b/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<!>(
-    15
-)
\ No newline at end of file
+val bar = foo(
+    <!TOO_MANY_ARGUMENTS!>15<!>
+)
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt b/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt
index 09e82f8d23d..8c32de43108 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt
index 3cd78ff7515..49eac651e55 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt
+++ b/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)
diff --git a/compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.fir.kt
index bb6927c297d..68cff469d7c 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.fir.kt
+++ b/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!>""<!>
 }
diff --git a/compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.fir.kt
index 05cb5f29c98..f0c9d7d0646 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.fir.kt
+++ b/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<!>
     }
 }
diff --git a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt
index 66fd955733e..b63a5b4f488 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt
+++ b/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!>{}<!>
 }
diff --git a/compiler/testData/diagnostics/tests/checkArguments/kt1940.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/kt1940.fir.kt
deleted file mode 100644
index fa19aede37b..00000000000
--- a/compiler/testData/diagnostics/tests/checkArguments/kt1940.fir.kt
+++ /dev/null
@@ -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
-}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/checkArguments/kt1940.kt b/compiler/testData/diagnostics/tests/checkArguments/kt1940.kt
index 4daa0628c5b..4024916acfd 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/kt1940.kt
+++ b/compiler/testData/diagnostics/tests/checkArguments/kt1940.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-1940 Exception while repeating named parameters
 package kt1940
 
diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.fir.kt b/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.fir.kt
index 0f5d04f6d1d..a49fcf77409 100644
--- a/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.fir.kt
+++ b/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([""])
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.fir.kt
deleted file mode 100644
index 0e41d12110d..00000000000
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.fir.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-fun foo(a: Int, b: Int) = a + b
-
-fun bar(i: Int) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 1, i)
-}
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt
index 24d0f37bbcd..0d91c988ad3 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt
+++ b/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) {
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt799.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/kt799.fir.kt
index 27b31997a8c..014d78806cc 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt799.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/kt1193.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/kt1193.fir.kt
index 60dc7517f13..e350c4cb39c 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/kt1193.fir.kt
+++ b/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
\ No newline at end of file
+val x: MyEnum = MyEnum.A
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt
index fb962e9965d..596ae0070e3 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt
+++ b/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()<!>
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt
index f9f35f93c16..275e1445199 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt
+++ b/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 {
diff --git a/compiler/testData/diagnostics/tests/deprecated/javaDeprecated.fir.kt b/compiler/testData/diagnostics/tests/deprecated/javaDeprecated.fir.kt
index c1adba9e67c..4206722ba17 100644
--- a/compiler/testData/diagnostics/tests/deprecated/javaDeprecated.fir.kt
+++ b/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)
 }
diff --git a/compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.fir.kt b/compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.fir.kt
index 863bd73eb40..a53bcadd231 100644
--- a/compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.fir.kt
+++ b/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,<!>
-    TEST2<!INAPPLICABLE_CANDIDATE!><!>(),
+    <!NO_VALUE_FOR_PARAMETER!>TEST1,<!>
+    TEST2<!NO_VALUE_FOR_PARAMETER!><!>(),
     TEST3("Hello")
 }
 
diff --git a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt b/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt
index d3f46fa3931..0233c9fc64c 100644
--- a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt
+++ b/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
 }
diff --git a/compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt b/compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt
index 7c839bac648..319b8106ee9 100644
--- a/compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt
+++ b/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
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt b/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt
index cf9e93659a0..abd2550140a 100644
--- a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt
+++ b/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)
-    s.<!INAPPLICABLE_CANDIDATE!>foo<!>("a")
+    "".foo(<!TOO_MANY_ARGUMENTS!>1<!>)
+    s.foo(<!TOO_MANY_ARGUMENTS!>"a"<!>)
 }
 
 interface A
diff --git a/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt b/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt
index 150d7b92c6d..8783f3069f7 100644
--- a/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt
+++ b/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(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p2 = ""<!>)
+    4.foo(p1 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    4.foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p2<!> = "")
 }
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.fir.kt
index 7b5618f7a0b..2d6edf9f350 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.fir.kt
+++ b/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 }
-    <!INAPPLICABLE_CANDIDATE!>p<!>() { 2 }
+    <!NO_VALUE_FOR_PARAMETER!>p { 1 }<!>
+    p(<!NO_VALUE_FOR_PARAMETER!>)<!> { 2 }
     p(3) { 4 }
 }
 
 fun bar(p: (String, Any, () -> String) -> Unit) {
     // Errors except last call
-    <!INAPPLICABLE_CANDIDATE!>p<!> { "" }
-    <!INAPPLICABLE_CANDIDATE!>p<!>() { "x" }
-    <!INAPPLICABLE_CANDIDATE!>p<!>("y") { "z" }
+    <!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>p { "" }<!>
+    p(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!> { "x" }
+    p("y"<!NO_VALUE_FOR_PARAMETER!>)<!> { "z" }
     p("v", Any()) { "w" }
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt
index 64001baabe3..e7b45efa280 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt
+++ b/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!>{ }<!>
diff --git a/compiler/testData/diagnostics/tests/generics/Projections.fir.kt b/compiler/testData/diagnostics/tests/generics/Projections.fir.kt
index 65ab20e0ec9..8ef6bf22fe4 100644
--- a/compiler/testData/diagnostics/tests/generics/Projections.fir.kt
+++ b/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
 }
diff --git a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
index 05e1b395148..3902c5b8ef1 100644
--- a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
+++ b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
@@ -32,8 +32,8 @@ fun test() {
     <!NONE_APPLICABLE!>zero<!>("")
 
     one()
-    <!INAPPLICABLE_CANDIDATE!>one<!>(1)
-    <!INAPPLICABLE_CANDIDATE!>one<!>("")
+    one(<!TOO_MANY_ARGUMENTS!>1<!>)
+    one(<!TOO_MANY_ARGUMENTS!>""<!>)
 
     two()
     two(1)
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.fir.kt
index 7dcf7de4b6f..2094b38ed5a 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.fir.kt
+++ b/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!><!>}
diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt
index c74674862dc..f08d4ca064d 100644
--- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt
+++ b/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!>)<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.fir.kt
index 5b1aac97a4e..795693120f3 100644
--- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.fir.kt
+++ b/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!>)<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.fir.kt
index c53792ca78e..6a28975caa9 100644
--- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.fir.kt
+++ b/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!>)<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt b/compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt
index 86870041ce5..e39c4d21ce3 100644
--- a/compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt
+++ b/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 x13 = <!INAPPLICABLE_CANDIDATE!>selectA<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }, id { x: C -> })
+    val x12 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: B -> }<!NO_VALUE_FOR_PARAMETER!>)<!>
+    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)
diff --git a/compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt b/compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt
index 89d7abf1986..3a895c91a0e 100644
--- a/compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt
+++ b/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)
\ No newline at end of file
+fun test3() = { i -> i }(1)
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2057.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2057.fir.kt
index f9d3fdbe345..c5880c7b3e5 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2057.fir.kt
+++ b/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 bar2 = <!INAPPLICABLE_CANDIDATE!>foo<!><String>("", arrayListOf(), )
\ No newline at end of file
+val bar = foo("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>
+val bar2 = foo<String>("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>
diff --git a/compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.fir.kt b/compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.fir.kt
index 5f065dee813..3b1681ff5d3 100644
--- a/compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.fir.kt
+++ b/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() {
diff --git a/compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt b/compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt
index 303bb5a88dc..05527d81a2a 100644
--- a/compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt
+++ b/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("")
 }
diff --git a/compiler/testData/diagnostics/tests/inner/kt5854.fir.kt b/compiler/testData/diagnostics/tests/inner/kt5854.fir.kt
deleted file mode 100644
index ae458b800a5..00000000000
--- a/compiler/testData/diagnostics/tests/inner/kt5854.fir.kt
+++ /dev/null
@@ -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
-    }
-}
diff --git a/compiler/testData/diagnostics/tests/inner/kt5854.kt b/compiler/testData/diagnostics/tests/inner/kt5854.kt
index a769b4b6ab5..5a7ffd7070c 100644
--- a/compiler/testData/diagnostics/tests/inner/kt5854.kt
+++ b/compiler/testData/diagnostics/tests/inner/kt5854.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-5854 Incorrect 'Nested class should be qualified'
 
 class A {
diff --git a/compiler/testData/diagnostics/tests/inner/kt6026.fir.kt b/compiler/testData/diagnostics/tests/inner/kt6026.fir.kt
index dc1c5a22692..13f0c4837d9 100644
--- a/compiler/testData/diagnostics/tests/inner/kt6026.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.fir.kt
index d6fae89aa4e..eee0e6ef4dd 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.fir.kt
+++ b/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!>)<!>
diff --git a/compiler/testData/diagnostics/tests/kt435.fir.kt b/compiler/testData/diagnostics/tests/kt435.fir.kt
index 5ec15398cd4..5a1ac0a610e 100644
--- a/compiler/testData/diagnostics/tests/kt435.fir.kt
+++ b/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!>)<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt
index 2295c0fe3da..c4145c624e8 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(<!NAMED_ARGUMENTS_NOT_ALLOWED!>zzz = 0<!>)
-    val f = Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>aaa = true<!>)
-    f.f1(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx = ""<!>)
-    f2(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx = 42<!>)
+    Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>zzz<!> = 0)
+    val f = Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>aaa<!> = true)
+    f.f1(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx<!> = "")
+    f2(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx<!> = 42)
 }
 
 // MODULE: m2-jvm(m1-common)
diff --git a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.fir.kt
index 6620127a9ed..1a4e95387fe 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.fir.kt
+++ b/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)
-    y.<!INAPPLICABLE_CANDIDATE!>foo<!>(x = 0)
+    x.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
+    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)
-}
\ No newline at end of file
+    y.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
+}
diff --git a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.fir.kt
index aae1ca6de24..058d2c1c35a 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.fir.kt
+++ b/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.<!INAPPLICABLE_CANDIDATE!>foo<!>(a1 = 1, b2 = 1.0)
+    c.foo(b1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+    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.<!INAPPLICABLE_CANDIDATE!>baz<!>(a1 = 1, b2 = 1.0, a3 = "", b4 = 2, a5 = "")
-    c.<!INAPPLICABLE_CANDIDATE!>baz<!>(a1 = 1, a2 = 1.0, a3 = "", b4 = 2, a5 = "")
-}
\ No newline at end of file
+    c.bar(a1 = 1, a2 = 1.0, b3= ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    c.baz(a1 = 1, b2 = 1.0, a3 = "", b4 = 2, a5 = ""<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+    c.baz(a1 = 1, a2 = 1.0, a3 = "", b4 = 2, a5 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+}
diff --git a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.fir.kt
index 2ba29a9054f..d6d96276071 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.fir.kt
+++ b/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)
-}
\ No newline at end of file
+    c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
+}
diff --git a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.fir.kt
index a585e0831b0..f2d84a634b0 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.fir.kt
+++ b/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)
-}
\ No newline at end of file
+    c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
+}
diff --git a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.fir.kt
index f75dd574cf5..9cd47f23117 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.fir.kt
+++ b/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)
-}
\ No newline at end of file
+    c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
+}
diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt
deleted file mode 100644
index 66c286e2287..00000000000
--- a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt
+++ /dev/null
@@ -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"<!>)
diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt
index a437f29e87e..6a1498c091d 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt
+++ b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 
 public class A {
diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt
index 233a5e4f392..c7d4c996df1 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(<!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")
diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt
deleted file mode 100644
index cbc5d21c433..00000000000
--- a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt
+++ /dev/null
@@ -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<!>)
-}
diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt
index 7ec20ec9c19..28775d449d4 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt
+++ b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // FILE: test/J.java
 
diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt
deleted file mode 100644
index 888e9066a68..00000000000
--- a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt
+++ /dev/null
@@ -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<!>)
-}
diff --git a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt
index 5d9af118432..2ae3fc32ac4 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt
+++ b/compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // FILE: test/J.java
 
diff --git a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/disabledFeature.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/disabledFeature.fir.kt
index 8c24c4ead05..1b0b5918e3a 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/disabledFeature.fir.kt
+++ b/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, "")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+    foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
diff --git a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.fir.kt
index e89f7f5e9a5..856d4c143c0 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.fir.kt
+++ b/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, "")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+    foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
diff --git a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.fir.kt
index fa71be4dd76..0cd7f35115d 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.fir.kt
+++ b/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, "")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+    foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
diff --git a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/varargs.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/varargs.fir.kt
index 87a05f77887..1d9b4c8c58e 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/varargs.fir.kt
+++ b/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)
-    <!INAPPLICABLE_CANDIDATE!>foo4<!>(1, "2", "3", p3 = 4.0, 5)
-    <!INAPPLICABLE_CANDIDATE!>foo4<!>(1, p3 = 4.0, 5)
+    foo4(p1 = 1, "2", "3", p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo4(1, "2", "3", p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
+    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")
 }
diff --git a/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt
index cc03090bca2..2374bab59f7 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt
+++ b/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<!>()
-    <!INAPPLICABLE_CANDIDATE!>bar<!>("")
+    bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    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!>)<!>
 }
diff --git a/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.fir.kt
index 8b8e9d729d5..09ce8b303e7 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.fir.kt
+++ b/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)
-}
\ No newline at end of file
+    c.foo(b1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+}
diff --git a/compiler/testData/diagnostics/tests/objects/Objects.fir.kt b/compiler/testData/diagnostics/tests/objects/Objects.fir.kt
index 1907fec8769..0205ae8790f 100644
--- a/compiler/testData/diagnostics/tests/objects/Objects.fir.kt
+++ b/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 {}
 
diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt
index 5933e9a4041..5b151c50d65 100644
--- a/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt
+++ b/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt
@@ -34,11 +34,11 @@ object MismatchingArities2 {
 }
 
 fun testMismatchingArities() {
-    ++<!INAPPLICABLE_CANDIDATE!>MismatchingArities1[0]<!>
-    <!INAPPLICABLE_CANDIDATE!>MismatchingArities1[0]<!>++
+    <!NO_VALUE_FOR_PARAMETER!>++MismatchingArities1[0]<!>
+    <!NO_VALUE_FOR_PARAMETER!>MismatchingArities1[0]++<!>
     MismatchingArities1[0] <!UNRESOLVED_REFERENCE!>+=<!> 1
 
-    ++<!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!>
-    <!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!>++
-    <!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!> <!UNRESOLVED_REFERENCE!>+=<!> 1
+    <!NO_VALUE_FOR_PARAMETER!>++MismatchingArities2[0]<!>
+    <!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]++<!>
+    <!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]<!> <!UNRESOLVED_REFERENCE!>+=<!> 1
 }
diff --git a/compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.fir.kt b/compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.fir.kt
index 820b4bc9a52..36f23c088f8 100644
--- a/compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.fir.kt
+++ b/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 = "")
-    <!INAPPLICABLE_CANDIDATE!>f<!>(myParamName = "")
+    f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f(myParamName = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
     f.invoke("")
-    f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(p0 = "")
-    f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(myParamName = "")
+    f.invoke(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f.invoke(myParamName = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 fun test3(f: String.(String) -> Unit) {
     "".f("")
-    "".<!INAPPLICABLE_CANDIDATE!>f<!>(p0 = "")
-    "".<!INAPPLICABLE_CANDIDATE!>f<!>(zzz = "")
+    "".f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    "".f(zzz = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
diff --git a/compiler/testData/diagnostics/tests/regressions/kt1736.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt1736.fir.kt
deleted file mode 100644
index d81fdfcd2b1..00000000000
--- a/compiler/testData/diagnostics/tests/regressions/kt1736.fir.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-//KT-1736 AssertionError in CallResolver
-
-package kt1736
-
-object Obj {
-    fun method() {
-    }
-}
-
-val x = Obj.<!INAPPLICABLE_CANDIDATE!>method<!>{ -> }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/regressions/kt1736.kt b/compiler/testData/diagnostics/tests/regressions/kt1736.kt
index e659bdc9a3c..83a0649973e 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt1736.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt1736.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-1736 AssertionError in CallResolver
 
 package kt1736
diff --git a/compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.fir.kt b/compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.fir.kt
index 060b8628bd9..f221efafca1 100644
--- a/compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.fir.kt
+++ b/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"
-    }
+    }<!>
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt
index 68c4faece55..cc7a06dd453 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt
+++ b/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) {
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt
index b92866a8c13..e565821cbee 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt
+++ b/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() {
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt
index 221636473b8..42798dd77f2 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt
+++ b/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)
-    <!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
+    identifier(123<!NO_VALUE_FOR_PARAMETER!>)<!>
+    identifier(1, <!TOO_MANY_ARGUMENTS!>2<!>)
     1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt
index a95ec3b4fd2..822774ec9a7 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt
+++ b/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<!>()
-        <!INAPPLICABLE_CANDIDATE!>(a.x)<!>()
+        a.x(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        (a.x)(<!NO_VALUE_FOR_PARAMETER!>)<!>
         if (a.x != null) {
-            a.<!INAPPLICABLE_CANDIDATE!>x<!>() // todo
+            a.x(<!NO_VALUE_FOR_PARAMETER!>)<!> // todo
             (a.x)()
         }
     }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
index f0c2f5f5486..4541883398a 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
+++ b/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.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        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.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        a.(foo)(<!NO_VALUE_FOR_PARAMETER!>)<!>
 
         (a.foo)()
 
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/kt9805.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/kt9805.fir.kt
deleted file mode 100644
index e4ebeaadaae..00000000000
--- a/compiler/testData/diagnostics/tests/resolve/invoke/kt9805.fir.kt
+++ /dev/null
@@ -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)
-    }
-}
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt b/compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt
index 3190359c25b..9b69d4949ea 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
     val foo: B.() -> Unit get() = null!!
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt
index 9ba5b306186..2632e43b888 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt
+++ b/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)
-    <!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
+    identifier(<!TOO_MANY_ARGUMENTS!>123<!>)
+    identifier(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
     1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.fir.kt b/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.fir.kt
index 7b787bf145c..215bd134df8 100644
--- a/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.fir.kt
@@ -9,6 +9,6 @@ fun test() {
 
     bar(<!INAPPLICABLE_CANDIDATE!>foo<!>(xx = zzz(11) { j: Int -> j + 7 }))
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(zz = <!INAPPLICABLE_CANDIDATE!>foo<!>(
-      xx = zzz(12) { i: Int -> i + i }))
-}
\ No newline at end of file
+    bar(zz = <!INAPPLICABLE_CANDIDATE!>foo<!>(
+      xx = zzz(12) { i: Int -> i + i })<!NO_VALUE_FOR_PARAMETER!>)<!>
+}
diff --git a/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt b/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
index 94f3778182d..27d0a82836a 100644
--- a/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
@@ -8,40 +8,40 @@ fun varargFn(vararg args: Int) {}
 
 fun testNoArgs() {
     noArgs()
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!> {}
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() {}
+    noArgs <!TOO_MANY_ARGUMENTS!>{}<!>
+    noArgs() <!TOO_MANY_ARGUMENTS!>{}<!>
     noArgs() // {}
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() /* */ {}
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() /*
+    noArgs() /* */ <!TOO_MANY_ARGUMENTS!>{}<!>
+    noArgs() /*
         block comment, no new line
-    */ {}
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!>()
+    */ <!TOO_MANY_ARGUMENTS!>{}<!>
+    noArgs()
     /*
         block comment with new line
     */
-    {}
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() // comment
+    <!TOO_MANY_ARGUMENTS!>{}<!>
+    noArgs() // comment
     // comment
-    {}
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() {} {}
-    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() {}
-    {}
+    <!TOO_MANY_ARGUMENTS!>{}<!>
+    noArgs() <!TOO_MANY_ARGUMENTS!>{}<!> <!TOO_MANY_ARGUMENTS!>{}<!>
+    noArgs() <!TOO_MANY_ARGUMENTS!>{}<!>
+    <!TOO_MANY_ARGUMENTS!>{}<!>
 }
 
 fun testLambdaArg() {
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>()
+    oneLambdaArg(<!NO_VALUE_FOR_PARAMETER!>)<!>
     oneLambdaArg {}
     oneLambdaArg()
     {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>()
+    oneLambdaArg()
     {}
-    {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>(
+    <!TOO_MANY_ARGUMENTS!>{}<!>
+    oneLambdaArg(
         {},
-        {}
+        <!TOO_MANY_ARGUMENTS!>{}<!>
     )
     oneLambdaArg() {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() // {}
+    oneLambdaArg(<!NO_VALUE_FOR_PARAMETER!>)<!> // {}
     oneLambdaArg() /* */ {}
     oneLambdaArg() /*
         block
@@ -50,21 +50,21 @@ fun testLambdaArg() {
     oneLambdaArg() // comment
     // comment
     {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}/*
+    oneLambdaArg() {}/*
         block comment, no new line
-    */ {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}/*
+    */ <!TOO_MANY_ARGUMENTS!>{}<!>
+    oneLambdaArg() {}/*
         block comment with new line
     */
-    {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}// comment
+    <!TOO_MANY_ARGUMENTS!>{}<!>
+    oneLambdaArg() {}// comment
     // comment
-    {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {} {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}
-    {}
-    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {} // comment
-    {}
+    <!TOO_MANY_ARGUMENTS!>{}<!>
+    oneLambdaArg() {} <!TOO_MANY_ARGUMENTS!>{}<!>
+    oneLambdaArg() {}
+    <!TOO_MANY_ARGUMENTS!>{}<!>
+    oneLambdaArg() {} // comment
+    <!TOO_MANY_ARGUMENTS!>{}<!>
 }
 
 fun testVararg() {
@@ -101,9 +101,9 @@ fun testTwoLambdas() {
         {}
 
         return if (true) {
-            <!INAPPLICABLE_CANDIDATE!>twoLambdaArgs<!>({})
-            {}
+            twoLambdaArgs({})
             {}
+            <!TOO_MANY_ARGUMENTS!>{}<!>
         } else {
             {}
         }
@@ -112,7 +112,7 @@ fun testTwoLambdas() {
 
 fun f1(): (() -> Unit) -> (() -> Unit) -> Unit {
     return { l1 ->
-        <!INAPPLICABLE_CANDIDATE!>l1<!>()
-        { l2 -> <!UNRESOLVED_REFERENCE!>l2<!>() }
+        l1()
+        <!TOO_MANY_ARGUMENTS!>{ l2 -> <!UNRESOLVED_REFERENCE!>l2<!>() }<!>
     }
 }
diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructors.fir.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructors.fir.kt
index 4793101a9cf..896f4fff6fb 100644
--- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructors.fir.kt
+++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructors.fir.kt
@@ -7,7 +7,7 @@ open class A protected constructor(x: Int) {
 }
 
 fun foo() {
-    <!INAPPLICABLE_CANDIDATE!>A<!>()
+    A(<!NO_VALUE_FOR_PARAMETER!>)<!>
     A(1.0)
 }
 
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.fir.kt
index b36ed84abaf..cbd41fe3e7f 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.fir.kt
@@ -5,7 +5,7 @@ annotation class Ann2(val x: Int)
 class A {
     @Ann1
     constructor()
-    <!INAPPLICABLE_CANDIDATE!>@Ann2<!>
+    <!NO_VALUE_FOR_PARAMETER!>@Ann2<!>
     constructor(x1: Int)
     @Ann2(2)
     constructor(x1: Int, x2: Int)
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.fir.kt
index f8ff7c69fa7..6b195862cf1 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.fir.kt
@@ -3,7 +3,7 @@ open class B0(x: Int)
 
 class A0 : B0 {
     constructor()
-    constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>()
+    constructor(x: Int) : <!NO_VALUE_FOR_PARAMETER!>super<!>()
 }
 
 // --------------------------
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.fir.kt
deleted file mode 100644
index c2b72c83e13..00000000000
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.fir.kt
+++ /dev/null
@@ -1,6 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-class A {
-    constructor(x: Int)
-}
-
-val x = <!INAPPLICABLE_CANDIDATE!>A<!>()
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt
index 89665c8bbbc..b3dadd7c7ef 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A {
     constructor(x: Int)
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.fir.kt
deleted file mode 100644
index 28338060b30..00000000000
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.fir.kt
+++ /dev/null
@@ -1,4 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-class A {
-    constructor(): <!INAPPLICABLE_CANDIDATE!>super<!>(1)
-}
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.kt
index 1e31c5345f7..6fa41193d9a 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A {
     constructor(): super(<!TOO_MANY_ARGUMENTS!>1<!>)
diff --git a/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.fir.kt
index f5fbc030695..5f772e95754 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.fir.kt
@@ -31,7 +31,7 @@ fun test() {
         x.foo().checkType { _<CharSequence?>() }
         x.baz("")
         x.baz(1).checkType { _<Unit>() }
-        x.<!INAPPLICABLE_CANDIDATE!>baz<!>(1, 2)
+        x.baz(1, <!TOO_MANY_ARGUMENTS!>2<!>)
 
         x.<!UNRESOLVED_REFERENCE!>foobar<!>().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     }
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.fir.kt
deleted file mode 100644
index 77c5e172e97..00000000000
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.fir.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-// !WITH_NEW_INFERENCE
-// FILE: KotlinFile.kt
-fun foo(javaClass: JavaClass) {
-    javaClass.doSomething(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p = 1<!>) {
-        bar()
-    }
-}
-
-fun bar(){}
-
-// FILE: JavaClass.java
-public class JavaClass {
-    public void doSomething(int p, Runnable runnable) { runnable.run(); }
-}
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt
index c0f3ecee47e..f91a4e7d6ae 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass) {
diff --git a/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/disabledFeature.fir.kt b/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/disabledFeature.fir.kt
index e5eae937740..2048c53037b 100644
--- a/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/disabledFeature.fir.kt
+++ b/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/disabledFeature.fir.kt
@@ -13,7 +13,7 @@ class MyRec(
 )
 
 fun foo(jr: JRecord) {
-    <!INAPPLICABLE_CANDIDATE!>JRecord<!>(1, "")
+    JRecord(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>""<!>)
 
     jr.<!UNRESOLVED_REFERENCE!>x<!>()
     jr.<!UNRESOLVED_REFERENCE!>y<!>()
diff --git a/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/simpleRecords.fir.kt b/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/simpleRecords.fir.kt
index 58fb8a59523..a6cb2cf77b2 100644
--- a/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/simpleRecords.fir.kt
+++ b/compiler/testData/diagnostics/tests/testsWithJava15/jvmRecord/simpleRecords.fir.kt
@@ -8,7 +8,7 @@ public record MyRecord(int x, CharSequence y) {
 // FILE: main.kt
 
 fun foo(mr: MyRecord) {
-    <!INAPPLICABLE_CANDIDATE!>MyRecord<!>(1, "")
+    MyRecord(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>""<!>)
 
     mr.<!UNRESOLVED_REFERENCE!>x<!>()
     mr.<!UNRESOLVED_REFERENCE!>y<!>()
diff --git a/compiler/testData/diagnostics/tests/typealias/privateInFile.fir.kt b/compiler/testData/diagnostics/tests/typealias/privateInFile.fir.kt
index 740fcab3ee4..9700eb28880 100644
--- a/compiler/testData/diagnostics/tests/typealias/privateInFile.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/privateInFile.fir.kt
@@ -8,14 +8,14 @@ private typealias TA = C
 private val test1: C = <!HIDDEN!>C<!>()
 private val test1co: C.Companion = C
 
-private val test2: TA = <!INAPPLICABLE_CANDIDATE!>TA<!>()
+private val test2: TA = TA(<!NO_VALUE_FOR_PARAMETER!>)<!>
 private val test2co = TA
 
 // FILE: file2.kt
 private val test1: C = C()
 private val test1co: C.Companion = C
 
-private val test2: TA = <!INAPPLICABLE_CANDIDATE!>TA<!>()
+private val test2: TA = TA(<!NO_VALUE_FOR_PARAMETER!>)<!>
 private val test2co = TA
 
 <!REDECLARATION!>private class C<!>
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt
index 7f0db227d54..bb0c017ef31 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt
@@ -16,7 +16,7 @@ typealias WI = ObjectWithInvoke
 typealias CWI = ClassWithCompanionObjectWithInvoke
 
 val test1 = WI()
-val test2 = <!INAPPLICABLE_CANDIDATE!>WI<!>(null)
+val test2 = WI(<!TOO_MANY_ARGUMENTS!>null<!>)
 
 val test3 = CWI()
 val test4 = CWI("")
diff --git a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt
index 037cf7fa0fd..454b4716190 100644
--- a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt
@@ -32,7 +32,7 @@ fun getArr(): Array<String>? = null
 fun f() {
     A().foo(1, *args)
     <!INAPPLICABLE_CANDIDATE!>bar<!>(2, *args)
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(*args)
+    baz(<!NON_VARARG_SPREAD!>*<!>args)
 }
 
 fun g(args: Array<String>?) {
@@ -56,7 +56,7 @@ fun h(b: B) {
 fun k() {
     A().foo(1, *getArr())
     <!INAPPLICABLE_CANDIDATE!>bar<!>(2, *getArr())
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(*getArr())
+    baz(<!NON_VARARG_SPREAD!>*<!>getArr())
 }
 
 fun invokeTest(goodArgs: Array<String>) {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.fir.kt
deleted file mode 100644
index a0bfa860b25..00000000000
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.fir.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-// FILE: A.java
-public @interface A {
-    String[] value();
-    Class<?> x() default Integer.class;
-    int y();
-}
-
-// FILE: b.kt
-@A("1", "2", "3", y = 1) fun test1() {}
-
-@A("4", y = 2) fun test2() {}
-
-@A(*arrayOf("5", "6"), "7", y = 3) fun test3() {}
-
-@A("1", "2", "3", x = String::class, y = 4) fun test4() {}
-
-@A("4", y = 5) fun test5() {}
-
-@A(*arrayOf("5", "6"), "7", x = Any::class, y = 6) fun test6() {}
-
-@A(y = 7) fun test7() {}
-
-<!INAPPLICABLE_CANDIDATE!>@A("8", "9", "10")<!> fun test8() {}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.kt
index 167492f03fd..a7499621980 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 public @interface A {
     String[] value();
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.fir.kt
index f3cd8e7f854..ab8d76fde53 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.fir.kt
@@ -6,6 +6,6 @@ public @interface A {
 }
 
 // FILE: b.kt
-<!INAPPLICABLE_CANDIDATE!>@A(false,
+@A(false,
 1.0,
-false, 1, 2)<!> fun foo1() {}
+false, <!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>) fun foo1() {}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt
index d9965faf092..9a5ad755e6c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt
@@ -36,7 +36,7 @@ fun test() {
 
         severalParams("", 89) checkType { _<Double>() }
         // TODO: should we allow somehow to call with passing continuation explicitly?
-        <!INAPPLICABLE_CANDIDATE!>severalParams<!>("", 89, 6.9) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Unit>() }
+        severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Unit>() }
 
         "".stringReceiver(1)
         Any().anyReceiver(1)
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt
index 056131d68e4..2663d0780de 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt
@@ -37,7 +37,7 @@ fun test() {
         severalParams("", 89) checkType { _<Double>() }
 
         // TODO: should we allow somehow to call with passing continuation explicitly?
-        <!INAPPLICABLE_CANDIDATE!>severalParams<!>("", 89, 6.9) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Unit>() }
-        <!INAPPLICABLE_CANDIDATE!>severalParams<!>("", 89, this as Continuation<Double>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Unit>() }
+        severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Unit>() }
+        severalParams("", 89, <!TOO_MANY_ARGUMENTS!>this as Continuation<Double><!>) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Unit>() }
     }
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.fir.kt
deleted file mode 100644
index 13a8675f6c9..00000000000
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.fir.kt
+++ /dev/null
@@ -1,4 +0,0 @@
-// !WITH_NEW_INFERENCE
-// NI_EXPECTED_FILE
-
-fun foo(first: Array<Any?>, second: Array<Any?>) = Pair(first.<!INAPPLICABLE_CANDIDATE!>toCollection<!>(), second.<!INAPPLICABLE_CANDIDATE!>toCollection<!>())
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt
index 27ada61349a..4649f78fe29 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt
index f42237eb05a..24f7c942f03 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt
@@ -12,13 +12,13 @@ fun <E> List<*>.toArray(ar: Array<E>): Array<E> = ar
 fun testArrays(ci: List<Int?>, cii: List<Int?>?) {
     val c1: Array<Int?> = cii.sure().<!INAPPLICABLE_CANDIDATE!>toArray<!>(Array<Int?>)
 
-    val c2: Array<Int?> = ci.toArray(<!INAPPLICABLE_CANDIDATE!>Array<!><Int?>())
+    val c2: Array<Int?> = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
 
-    val c3 = <!INAPPLICABLE_CANDIDATE!>Array<!><Int?>()
+    val c3 = Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
 
-    val c4 = ci.toArray<Int?>(<!INAPPLICABLE_CANDIDATE!>Array<!><Int?>())
+    val c4 = ci.toArray<Int?>(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
 
-    val c5 = ci.toArray(<!INAPPLICABLE_CANDIDATE!>Array<!><Int?>())
+    val c5 = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
 
     checkSubtype<Array<Int?>>(c1)
     checkSubtype<Array<Int?>>(c2)
diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt
index 36209e35b10..e75585de35b 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt
@@ -1,8 +1,8 @@
-<!INAPPLICABLE_CANDIDATE!>@JvmName()<!>
+@JvmName(<!NO_VALUE_FOR_PARAMETER!>)<!>
 fun foo() {}
 
 <!INAPPLICABLE_CANDIDATE!>@JvmName(42)<!>
 fun bar() {}
 
-<!INAPPLICABLE_CANDIDATE!>@JvmName("a", "b")<!>
+@JvmName("a", <!TOO_MANY_ARGUMENTS!>"b"<!>)
 fun baz() {}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt
index 1190f320a02..2d5dc57c918 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt
@@ -17,7 +17,7 @@ fun case1() {
 }
 
 class B() {
-    val p: String by <!INAPPLICABLE_CANDIDATE!>Delegate<!>() // DELEGATE_SPECIAL_FUNCTION_MISSING expected
+    val p: String by <!TOO_MANY_ARGUMENTS!>Delegate()<!> // DELEGATE_SPECIAL_FUNCTION_MISSING expected
 }
 
 class Delegate {
@@ -42,7 +42,7 @@ fun case2() {
 }
 
 class B() {
-    var p: String by <!INAPPLICABLE_CANDIDATE!>Delegate<!>() // DELEGATE_SPECIAL_FUNCTION_MISSING expected
+    var p: String by <!TOO_MANY_ARGUMENTS!>Delegate()<!> // DELEGATE_SPECIAL_FUNCTION_MISSING expected
 }
 
 class Delegate {
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/13.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/13.fir.kt
index 7e2d5a9980f..f167a08ef89 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/13.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/13.fir.kt
@@ -23,7 +23,7 @@ fun case_2() {
 fun case_3() {
     var x: Class? = Class()
     x!!
-    val y = <!DEBUG_INFO_EXPRESSION_TYPE("Class? & Class")!>x<!>[if (true) {x=null;0} else 0, <!INAPPLICABLE_CANDIDATE!><!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>[0]<!>]
+    val y = <!DEBUG_INFO_EXPRESSION_TYPE("Class? & Class")!>x<!>[if (true) {x=null;0} else 0, <!NO_VALUE_FOR_PARAMETER!><!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>[0]<!>]
     <!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>
     <!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!><!UNSAFE_CALL!>.<!>fun_1()
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/26.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/26.fir.kt
index fbc59bb9911..17a2d9ccf94 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/26.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/26.fir.kt
@@ -41,9 +41,9 @@ fun case_3() {
 fun case_4() {
     var x: Class? = Class()
     x!!
-    val y = <!DEBUG_INFO_EXPRESSION_TYPE("Class? & Class")!>x<!>[if (true) {x=null;0} else 0, <!INAPPLICABLE_CANDIDATE!><!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>[0]<!>]
+    val y = <!DEBUG_INFO_EXPRESSION_TYPE("Class? & Class")!>x<!>[if (true) {x=null;0} else 0, <!NO_VALUE_FOR_PARAMETER!><!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>[0]<!>]
     <!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>
-    <!INAPPLICABLE_CANDIDATE!><!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>[0]<!>.inv()
+    <!NO_VALUE_FOR_PARAMETER!><!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>[0]<!>.inv()
 }
 
 /*
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/36.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/36.fir.kt
index c30f0e3ba32..8f65710a4cc 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/36.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/36.fir.kt
@@ -50,14 +50,14 @@ fun case_4(x: Class?, y: Any) {
 fun case_5(x: Class?, y: String?) {
     x?.prop_12 = y ?: return
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.<!INAPPLICABLE_CANDIDATE!>toUpperCase<!>()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.toUpperCase(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 // TESTCASE NUMBER: 6
 fun case_6(x: Class?, y: String?) {
     x?.prop_9 = y !is String && throw Exception()
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.<!INAPPLICABLE_CANDIDATE!>toUpperCase<!>()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.toUpperCase(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 /*
@@ -68,7 +68,7 @@ fun case_6(x: Class?, y: String?) {
 fun case_7(x: Class?, y: String?) {
     x?.prop_12 = y!!
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.<!INAPPLICABLE_CANDIDATE!>toUpperCase<!>()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.toUpperCase(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 
 /*
@@ -79,5 +79,5 @@ fun case_7(x: Class?, y: String?) {
 fun case_8(x: Class?, y: String?) {
     x?.prop_12 = if (y === null) throw Exception() else ""
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.<!INAPPLICABLE_CANDIDATE!>toUpperCase<!>()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>y<!>.toUpperCase(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/42.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/42.fir.kt
index 7b5dbfaf037..97149066ff2 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/42.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/42.fir.kt
@@ -20,7 +20,7 @@ fun case_1(x: Any) {
 fun case_2(x: Any?) {
     if (x is Int || x is Float?) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>?")!>x<!>.toByte(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -31,7 +31,7 @@ fun case_2(x: Any?) {
 fun case_3(x: Any?) {
     if (x is Int? || x is Float) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>?")!>x<!>.toByte(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -75,7 +75,7 @@ fun <T> case_6(x: T) {
 fun <T> case_7(x: T) {
     if (x is Int? || x is Float?) {
         <!DEBUG_INFO_EXPRESSION_TYPE("T & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>? & T")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("T & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>? & T")!>x<!>.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>? & T")!>x<!>.toByte(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
@@ -86,7 +86,7 @@ fun <T> case_7(x: T) {
 inline fun <reified T> case_8(x: T) {
     if (x is Int? || x is Float?) {
         <!DEBUG_INFO_EXPRESSION_TYPE("T & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>? & T")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("T & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>? & T")!>x<!>.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
+        <!DEBUG_INFO_EXPRESSION_TYPE("T & kotlin.Number? & kotlin.Comparable<kotlin.Int & kotlin.Float>? & T")!>x<!>.toByte(<!NO_VALUE_FOR_PARAMETER!>)<!>
     }
 }
 
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/5.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/5.fir.kt
index 4ebf1b2ea41..be378bedfc5 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/5.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/5.fir.kt
@@ -7,7 +7,7 @@ class Case1<T : Number> {
     inline fun <reified T : CharSequence>case_1(x: Any?) {
         if (x is T) {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & T")!>x<!>
-            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & T")!>x<!>.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
+            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & T")!>x<!>.toByte(<!NO_VALUE_FOR_PARAMETER!>)<!>
         }
     }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/48.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/48.fir.kt
index 350c26fadb8..e07f194c83f 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/48.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/48.fir.kt
@@ -24,9 +24,9 @@ fun case_1(x: Any?, y: Any?) {
 fun case_2(x: Any?, y: Any?) {
     if (x as Int === y) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>(10)
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>x<!>.inv(<!TOO_MANY_ARGUMENTS!>10<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>y<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>y<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>(10)
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>y<!>.inv(<!TOO_MANY_ARGUMENTS!>10<!>)
     }
 }
 
@@ -52,8 +52,8 @@ fun case_3(x: Any?, y: Any?) {
 fun case_4(x: Any?, y: Any?) {
     if (y === x as Int) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>(10)
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>x<!>.inv(<!TOO_MANY_ARGUMENTS!>10<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>y<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>y<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>(10)
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Int")!>y<!>.inv(<!TOO_MANY_ARGUMENTS!>10<!>)
     }
 }
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 e5b5f8d51e2..366496d0f63 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
@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticParamet
 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
@@ -32,6 +33,7 @@ import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtParameter
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.full.createType
@@ -138,6 +140,11 @@ private object FirToKtConversionCreator {
                 "org.jetbrains.kotlin.fir.psi"
             )
         ),
+        FirValueParameter::class to HLFunctionCallConversion(
+            "firSymbolBuilder.buildSymbol({0})",
+            KtSymbol::class.createType(),
+            importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
+        ),
         FirClassLikeSymbol::class to HLFunctionCallConversion(
             "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.fir as FirClass<*>)",
             KtClassLikeSymbol::class.createType(),
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 855cf657b88..b6f2f23c2ae 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
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.diagnostics
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiTypeElement
+import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
@@ -37,6 +38,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
 
 /*
@@ -698,6 +700,32 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.NON_VARARG_SPREAD) { firDiagnostic ->
+        NonVarargSpreadImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.ARGUMENT_PASSED_TWICE) { firDiagnostic ->
+        ArgumentPassedTwiceImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.TOO_MANY_ARGUMENTS) { firDiagnostic ->
+        TooManyArgumentsImpl(
+            firSymbolBuilder.callableBuilder.buildCallableSymbol(firDiagnostic.a as FirCallableDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.NO_VALUE_FOR_PARAMETER) { firDiagnostic ->
+        NoValueForParameterImpl(
+            firSymbolBuilder.buildSymbol(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 9f806e8fc7b..9d7872fb9b1 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
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.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
@@ -43,6 +44,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
 
@@ -498,11 +500,29 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
         override val diagnosticClass get() = VarargOutsideParentheses::class
     }
 
-    abstract class NamedArgumentsNotAllowed : KtFirDiagnostic<PsiElement>() {
+    abstract class NamedArgumentsNotAllowed : KtFirDiagnostic<KtValueArgument>() {
         override val diagnosticClass get() = NamedArgumentsNotAllowed::class
         abstract val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget
     }
 
+    abstract class NonVarargSpread : KtFirDiagnostic<LeafPsiElement>() {
+        override val diagnosticClass get() = NonVarargSpread::class
+    }
+
+    abstract class ArgumentPassedTwice : KtFirDiagnostic<KtValueArgument>() {
+        override val diagnosticClass get() = ArgumentPassedTwice::class
+    }
+
+    abstract class TooManyArguments : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = TooManyArguments::class
+        abstract val function: KtCallableSymbol
+    }
+
+    abstract class NoValueForParameter : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = NoValueForParameter::class
+        abstract val violatedParameter: KtSymbol
+    }
+
     abstract class Ambiguity : KtFirDiagnostic<PsiElement>() {
         override val diagnosticClass get() = Ambiguity::class
         abstract val candidates: List<KtSymbol>
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 ed79f74c14e..b484d46de52 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
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.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
@@ -45,6 +46,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
 
@@ -800,7 +802,37 @@ internal class NamedArgumentsNotAllowedImpl(
     override val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
-) : KtFirDiagnostic.NamedArgumentsNotAllowed(), KtAbstractFirDiagnostic<PsiElement> {
+) : KtFirDiagnostic.NamedArgumentsNotAllowed(), KtAbstractFirDiagnostic<KtValueArgument> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class NonVarargSpreadImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.NonVarargSpread(), KtAbstractFirDiagnostic<LeafPsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class ArgumentPassedTwiceImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.ArgumentPassedTwice(), KtAbstractFirDiagnostic<KtValueArgument> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class TooManyArgumentsImpl(
+    override val function: KtCallableSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.TooManyArguments(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class NoValueForParameterImpl(
+    override val violatedParameter: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.NoValueForParameter(), KtAbstractFirDiagnostic<KtElement> {
     override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }
 
diff --git a/idea/idea-frontend-fir/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.kt b/idea/idea-frontend-fir/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.kt
index 5e1da7ba366..c1bf2f6ba92 100644
--- a/idea/idea-frontend-fir/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.kt
+++ b/idea/idea-frontend-fir/testData/analysisSession/resolveCall/simpleCallWithNonMatchingArgs.kt
@@ -4,4 +4,6 @@ fun x() {
 
 fun foo(){}
 
-// CALL: KtFunctionCall: targetFunction = ERR<Inapplicable candidate(s): /foo, [/foo(): kotlin.Unit]>
\ No newline at end of file
+// CALL: KtFunctionCall: targetFunction = ERR<Too many arguments for org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl@5f1f1786: public final fun /foo(): R|kotlin/Unit| {
+}
+, [/foo(): kotlin.Unit]>
\ No newline at end of file
diff --git a/idea/testData/checker/ExtensionFunctions.fir.kt b/idea/testData/checker/ExtensionFunctions.fir.kt
index 2d2e0481e90..fd4f38b2924 100644
--- a/idea/testData/checker/ExtensionFunctions.fir.kt
+++ b/idea/testData/checker/ExtensionFunctions.fir.kt
@@ -16,7 +16,7 @@ class A
 infix operator fun A.plus(a : Any) {
 
   1.foo()
-  true.<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /foo">foo</error>()
+  true.foo(<error descr="[NO_VALUE_FOR_PARAMETER] No value passed for parameter 'x'"><error descr="[NO_VALUE_FOR_PARAMETER] No value passed for parameter 'y'">)</error></error>
 
   1
 }
diff --git a/idea/testData/checker/Objects.fir.kt b/idea/testData/checker/Objects.fir.kt
index 5c096dd5d4b..8325cc56e26 100644
--- a/idea/testData/checker/Objects.fir.kt
+++ b/idea/testData/checker/Objects.fir.kt
@@ -3,15 +3,15 @@ package toplevelObjectDeclarations
     open fun foo() : Int = 1
   }
 
-  <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): toplevelObjectDeclarations/Foo.Foo">class T : <error descr="[SUPERTYPE_NOT_INITIALIZED] This type has a constructor, and thus must be initialized here">Foo</error> {}</error>
+  <error descr="[NO_VALUE_FOR_PARAMETER] No value passed for parameter 'y'">class T : <error descr="[SUPERTYPE_NOT_INITIALIZED] This type has a constructor, and thus must be initialized here">Foo</error> {}</error>
 
-  <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): toplevelObjectDeclarations/Foo.Foo">object A : <error descr="[SUPERTYPE_NOT_INITIALIZED] This type has a constructor, and thus must be initialized here">Foo</error> {
+  object A : <error descr="[SUPERTYPE_NOT_INITIALIZED] This type has a constructor, and thus must be initialized here">Foo</error> {
     val x : Int = 2
 
     fun test() : Int {
-      return x + foo()
+      return x + foo(<error descr="[NO_VALUE_FOR_PARAMETER] No value passed for parameter 'y'">)</error>
     }
-  }</error>
+  }
 
   object B : A {}
 
diff --git a/idea/testData/checker/regression/DestructuringDeclarationInLambda.fir.kt b/idea/testData/checker/regression/DestructuringDeclarationInLambda.fir.kt
new file mode 100644
index 00000000000..750c4bf50e5
--- /dev/null
+++ b/idea/testData/checker/regression/DestructuringDeclarationInLambda.fir.kt
@@ -0,0 +1,5 @@
+data class XY(val x: Int, val y: Int)
+
+fun convert(xy: XY, f: (XY) -> Int) = f(xy)
+
+fun foo() = <error descr="[NO_VALUE_FOR_PARAMETER] No value passed for parameter 'xy'">convert { (<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: x">x</error><error descr="Unexpected tokens (use ';' to separate expressions on the same line)"><error descr="Expecting ')'">,</error> y)</error> }</error>
diff --git a/idea/testData/checker/regression/DestructuringDeclarationInLambda.kt b/idea/testData/checker/regression/DestructuringDeclarationInLambda.kt
index 4680eeed218..3ee969d8e61 100644
--- a/idea/testData/checker/regression/DestructuringDeclarationInLambda.kt
+++ b/idea/testData/checker/regression/DestructuringDeclarationInLambda.kt
@@ -1,5 +1,3 @@
-// FIR_IDENTICAL
-
 data class XY(val x: Int, val y: Int)
 
 fun convert(xy: XY, f: (XY) -> Int) = f(xy)
diff --git a/idea/testData/checker/rendering/TypeInferenceError.fir.kt b/idea/testData/checker/rendering/TypeInferenceError.fir.kt
index f8e00fefc51..a9504a93565 100644
--- a/idea/testData/checker/rendering/TypeInferenceError.fir.kt
+++ b/idea/testData/checker/rendering/TypeInferenceError.fir.kt
@@ -4,7 +4,7 @@ fun <K, V> testMutableMapEntry(map: MutableMap<K, V>, k1: K, v: V) {
 }
 
 fun foo() {
-    <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /testMutableMapEntry">testMutableMapEntry</error>(hashMap(1 to 'a'), 'b')
+    testMutableMapEntry(hashMap(1 to 'a'), 'b'<error descr="[NO_VALUE_FOR_PARAMETER] No value passed for parameter 'v'">)</error>
 }
 
 //extract from library