[FIR JS] KT-51740: Alter positioning of NO_VALUE_FOR_PARAMETER

2022-09-23 12:20:09 +03:00
parent 418c530820
commit fcd3e4f4c5
101 changed files with 340 additions and 248 deletions
@@ -5,5 +5,5 @@ class A

 annotation class AnnVarargs(val x: Int, vararg val y: String, val z: Int)

-@AnnVarargs(1, "a", "b", "c", 2<!NO_VALUE_FOR_PARAMETER!>)<!>
+@AnnVarargs(1, "a", "b", "c", <!NO_VALUE_FOR_PARAMETER!>2)<!>
 class B
@@ -8,14 +8,14 @@ fun test() {
    foo(1, 2.0, true)
    foo(1, third = true)

-    foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>foo()<!>
    foo(0, 0.0, false, <!TOO_MANY_ARGUMENTS!>""<!>)

    bar(1, third = true)
    bar(1, 2.0, true)
    bar(1, 2.0, true, "my")

-    bar(1, true<!NO_VALUE_FOR_PARAMETER!>)<!>
+    bar(1, <!NO_VALUE_FOR_PARAMETER!>true)<!>

    baz(1)
    baz(1, "my", "yours")
@@ -15,8 +15,8 @@ fun foo(a: A) {
    a.foo()
    a.foo(1)

-    a.bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    a.bar(""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    a.<!NO_VALUE_FOR_PARAMETER!>bar()<!>
+    a.bar(<!NO_VALUE_FOR_PARAMETER!>"")<!>
    a.bar(y = 1)
    a.bar("", 2)
 }
@@ -20,15 +20,15 @@ fun test() {
    bar(x = 1, f = {})

    // Bad
-    <!NO_VALUE_FOR_PARAMETER!>bar {}<!>
-    bar({}<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>bar<!> {}
+    bar(<!NO_VALUE_FOR_PARAMETER!>{})<!>

    // OK
    baz(other = false, f = {})
    baz({}, false)

    // Bad
-    <!NO_VALUE_FOR_PARAMETER!>baz {}<!>
-    baz(<!NO_VALUE_FOR_PARAMETER!>)<!> {}
-    baz(other = false<!NO_VALUE_FOR_PARAMETER!>)<!> <!TOO_MANY_ARGUMENTS!>{}<!>
+    <!NO_VALUE_FOR_PARAMETER!>baz<!> {}
+    <!NO_VALUE_FOR_PARAMETER!>baz()<!> {}
+    baz(<!NO_VALUE_FOR_PARAMETER!>other = false)<!> <!TOO_MANY_ARGUMENTS!>{}<!>
 }
@@ -1,5 +1,5 @@
 fun foo(x: Int) {}

 fun bar() {
-    foo(<!NAMED_PARAMETER_NOT_FOUND!>y<!> = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>y<!> = 1)<!>
 }
@@ -7,11 +7,11 @@ fun test() {
    foo(1, second = 3.14, third = false, fourth = "!?")
    foo(third = false, second = 2.71, fourth = "?!", first = 0)

-    foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>foo()<!>
    foo(<!ARGUMENT_TYPE_MISMATCH!>0.0<!>, <!ARGUMENT_TYPE_MISMATCH!>false<!>, <!ARGUMENT_TYPE_MISMATCH!>0<!>, "")
    foo(1, 2.0, third = true, "")
-    foo(second = 0.0, first = 0, fourth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(second = 0.0, first = 0, <!NO_VALUE_FOR_PARAMETER!>fourth = "")<!>
    foo(first = <!ARGUMENT_TYPE_MISMATCH!>0.0<!>, second = <!ARGUMENT_TYPE_MISMATCH!>0<!>, third = <!ARGUMENT_TYPE_MISMATCH!>""<!>, fourth = <!ARGUMENT_TYPE_MISMATCH!>false<!>)
    foo(first = 0, second = 0.0, third = false, fourth = "", <!ARGUMENT_PASSED_TWICE!>first<!> = 1)
-    foo(0, 0.0, false, <!NAMED_PARAMETER_NOT_FOUND!>foth<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(0, 0.0, false, <!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>foth<!> = "")<!>
 }
@@ -13,6 +13,6 @@ fun test() {
    bar(1, z = true, y = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION!>arrayOf("my", "yours")<!>)

    bar(0, z = false, y = <!ARGUMENT_TYPE_MISMATCH, ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>""<!>, <!ARGUMENT_PASSED_TWICE!>y<!> = "other")
-    bar(0, "", true<!NO_VALUE_FOR_PARAMETER!>)<!>
+    bar(0, "", <!NO_VALUE_FOR_PARAMETER!>true)<!>
    bar(0, z = false, y = <!ARGUMENT_TYPE_MISMATCH, ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>""<!>, <!ARGUMENT_PASSED_TWICE!>y<!> = "other", <!ARGUMENT_PASSED_TWICE!>y<!> = "yet other")
 }
@@ -2,7 +2,7 @@ open class A
 class B : <!SUPERTYPE_NOT_INITIALIZED!>A<!>

 open class C(x: Int)
-<!NO_VALUE_FOR_PARAMETER!>class D : <!SUPERTYPE_NOT_INITIALIZED!>C<!><!>
+class D : <!NO_VALUE_FOR_PARAMETER, SUPERTYPE_NOT_INITIALIZED!>C<!>
 class E : C(10)
 class F() : C(10)

@@ -17,6 +17,8 @@ import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.*
 import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
+import org.jetbrains.kotlin.psi.KtValueArgument
+import org.jetbrains.kotlin.psi.stubs.elements.KtClassElementType
 import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType
 import org.jetbrains.kotlin.psi.stubs.elements.KtStringTemplateExpressionElementType
 import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
@@ -542,14 +544,31 @@ object LightTreePositioningStrategies {
                }
            }
            val nodeToStart = when (node.tokenType) {
-                in KtTokens.QUALIFIED_ACCESS -> tree.findLastChildByType(node, KtNodeTypes.CALL_EXPRESSION) ?: node
+                in QUALIFIED_ACCESS -> tree.findLastChildByType(node, KtNodeTypes.CALL_EXPRESSION) ?: node
+                KtNodeTypes.CLASS -> tree.findLastChildByType(node, KtNodeTypes.SUPER_TYPE_LIST) ?: node
                else -> node
            }
-            return tree.findDescendantByType(nodeToStart, KtNodeTypes.VALUE_ARGUMENT_LIST)?.let { valueArgumentList ->
-                tree.findLastChildByType(valueArgumentList, KtTokens.RPAR)?.let { rpar ->
-                    markElement(rpar, startOffset, endOffset, tree, node)
+            val argumentList = nodeToStart.takeIf { nodeToStart.tokenType == KtNodeTypes.VALUE_ARGUMENT_LIST }
+                ?: tree.findChildByType(nodeToStart, KtNodeTypes.VALUE_ARGUMENT_LIST)
+            return when {
+                argumentList != null -> {
+                    val rightParenthesis = tree.findLastChildByType(argumentList, RPAR)
+                        ?: return markElement(nodeToStart, startOffset, endOffset, tree, node)
+                    val lastArgument = tree.findLastChildByType(argumentList, KtNodeTypes.VALUE_ARGUMENT)
+                    if (lastArgument != null) {
+                        markRange(lastArgument, rightParenthesis, startOffset, endOffset, tree, node)
+                    } else {
+                        markRange(nodeToStart, rightParenthesis, startOffset, endOffset, tree, node)
+                    }
                }
-            } ?: markElement(nodeToStart, startOffset, endOffset, tree, node)
+
+                nodeToStart.tokenType == KtNodeTypes.CALL_EXPRESSION -> markElement(
+                    tree.findChildByType(nodeToStart, KtNodeTypes.REFERENCE_EXPRESSION) ?: nodeToStart,
+                    startOffset, endOffset, tree, node,
+                )
+
+                else -> markElement(nodeToStart, startOffset, endOffset, tree, node)
+            }
        }
    }

@@ -644,9 +644,28 @@ object PositioningStrategies {
            }
            val qualifiedAccess = when (element) {
                is KtQualifiedExpression -> element.selectorExpression ?: element
+                is KtClassOrObject -> element.getSuperTypeList() ?: element
                else -> element
            }
-            return markElement(qualifiedAccess.findDescendantOfType<KtValueArgumentList>()?.rightParenthesis ?: qualifiedAccess)
+            val argumentList = qualifiedAccess as? KtValueArgumentList
+                ?: qualifiedAccess.getChildOfType()
+            return when {
+                argumentList != null -> {
+                    val rightParenthesis = argumentList.rightParenthesis ?: return markElement(qualifiedAccess)
+                    val lastArgument = argumentList.children.findLast { it is KtValueArgument }
+                    if (lastArgument != null) {
+                        markRange(lastArgument, rightParenthesis)
+                    } else {
+                        markRange(qualifiedAccess, rightParenthesis)
+                    }
+                }
+
+                qualifiedAccess is KtCallExpression -> markElement(
+                    qualifiedAccess.getChildOfType<KtNameReferenceExpression>() ?: qualifiedAccess
+                )
+
+                else -> markElement(qualifiedAccess)
+            }
        }
    }

@@ -1,10 +1,10 @@
 fun test() {
-    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!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>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()<!>
    <!INVISIBLE_REFERENCE!>Char<!>()
-    Boolean(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>Boolean()<!>
 }
@@ -28,8 +28,8 @@ fun <T> fooT2() : (t : T) -> T {

 fun main(args : Array<String>) {
    args.foo()()
-    args.foo1(<!NO_VALUE_FOR_PARAMETER{PSI}!>)<!>(<!NO_VALUE_FOR_PARAMETER{LT}!>)<!>
-    <!UNRESOLVED_REFERENCE!>a<!>.foo1(<!NO_VALUE_FOR_PARAMETER{PSI}!>)<!>(<!NO_VALUE_FOR_PARAMETER{LT}!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>args.foo1()()<!>
+    <!NO_VALUE_FOR_PARAMETER!><!UNRESOLVED_REFERENCE!>a<!>.foo1()()<!>
    <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)

    args.foo1()(1)
@@ -76,8 +76,8 @@ fun main1() {
 }

 fun test() {
-    {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
-    (fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>{x : Int -> 1}()<!>;
+    <!NO_VALUE_FOR_PARAMETER!>(fun Int.() = 1)()<!>
    <!ARGUMENT_TYPE_MISMATCH!>"sd"<!>.(fun Int.() = 1)()
    val i : Int? = null
    <!ARGUMENT_TYPE_MISMATCH!>i<!>.(fun Int.() = 1)();
@@ -28,7 +28,7 @@ fun <T> fooT2() : (t : T) -> T {

 fun main(args : Array<String>) {
    args.foo()()
-    args.foo1()(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    args.foo1()<!NO_VALUE_FOR_PARAMETER!>()<!>
    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()()
    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)

@@ -76,8 +76,8 @@ fun main1() {
 }

 fun test() {
-    {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
-    (fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    {x : Int -> 1}<!NO_VALUE_FOR_PARAMETER!>()<!>;
+    (fun Int.() = 1)<!NO_VALUE_FOR_PARAMETER!>()<!>
    "sd".<!FUNCTION_EXPECTED!>(fun Int.() = 1)<!>()
    val i : Int? = null
    i<!UNSAFE_CALL!>.<!>(fun Int.() = 1)();
@@ -17,7 +17,7 @@ fun foo() {
    <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann()<!>
    val a = <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann()<!>

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

-    <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann1(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
+    <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann1<!NO_VALUE_FOR_PARAMETER!>()<!><!>
    <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann1(1)<!>
    bar(<!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann()<!>)
    bar(a = <!ANNOTATION_CLASS_CONSTRUCTOR_CALL!>Ann()<!>)
@@ -31,7 +31,7 @@ fun (@TypeAnn A).extFun(@Ann a: @TypeAnn A): @TypeAnn A? = null
@Target(AnnotationTarget.TYPE)
 annotation class TypeAnnWithArg(val arg: String)

-fun badArgs(a: (@TypeAnnWithArg(<!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!> Int) -> Unit) {}
+fun badArgs(a: (@TypeAnnWithArg(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = "")<!> Int) -> Unit) {}

 typealias BadArgsInTypeAlias = (<!NO_VALUE_FOR_PARAMETER!>@TypeAnnWithArg<!> Int) -> Unit
 fun badArgsInTypeAlias(a: BadArgsInTypeAlias) {}
@@ -31,7 +31,7 @@ fun (@TypeAnn A).extFun(@Ann a: @TypeAnn A): @TypeAnn A? = null
@Target(AnnotationTarget.TYPE)
 annotation class TypeAnnWithArg(val arg: String)

-fun badArgs(a: (@TypeAnnWithArg(<!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!> Int) -> Unit) {}
+fun badArgs(a: (@TypeAnnWithArg(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = "")<!> Int) -> Unit) {}

 typealias BadArgsInTypeAlias = (@<!NO_VALUE_FOR_PARAMETER!>TypeAnnWithArg<!> Int) -> Unit
 fun badArgsInTypeAlias(a: BadArgsInTypeAlias) {}
@@ -8,6 +8,6 @@ annotation class Ann(
        val b3: Boolean
 )

-@Ann(!true, !false<!NO_VALUE_FOR_PARAMETER!>)<!> class MyClass
+@Ann(!true, <!NO_VALUE_FOR_PARAMETER!>!false)<!> class MyClass

 // EXPECTED: @Ann(b1 = false, b2 = true)
@@ -17,8 +17,8 @@ val <T> @x List<@x T>.f: Int get() = 42
@Target(AnnotationTarget.TYPE)
 annotation class TypeAnnWithArg(val arg: String)

-fun badArgs(a: List<@TypeAnnWithArg(<!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!> Int>) {}
-fun badArgsWithProjection(a: Array<out @TypeAnnWithArg(<!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!> Int>) {}
+fun badArgs(a: List<@TypeAnnWithArg(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = "")<!> Int>) {}
+fun badArgsWithProjection(a: Array<out @TypeAnnWithArg(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = "")<!> Int>) {}

 typealias BadArgsInTypeAlias = List<<!NO_VALUE_FOR_PARAMETER!>@TypeAnnWithArg<!> Int>
 fun badArgsInTypeAlias(a: BadArgsInTypeAlias) {}
@@ -17,8 +17,8 @@ val <T> @x List<@x T>.f: Int get() = 42
@Target(AnnotationTarget.TYPE)
 annotation class TypeAnnWithArg(val arg: String)

-fun badArgs(a: List<@TypeAnnWithArg(<!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!> Int>) {}
-fun badArgsWithProjection(a: Array<out @TypeAnnWithArg(<!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!> Int>) {}
+fun badArgs(a: List<@TypeAnnWithArg(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = "")<!> Int>) {}
+fun badArgsWithProjection(a: Array<out @TypeAnnWithArg(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>unresolved<!> = "")<!> Int>) {}

 typealias BadArgsInTypeAlias = List<@<!NO_VALUE_FOR_PARAMETER!>TypeAnnWithArg<!> Int>
 fun badArgsInTypeAlias(a: BadArgsInTypeAlias) {}
@@ -13,7 +13,7 @@ fun test() {
    checkSubtype<KProperty1<A, Int>>(p)
    checkSubtype<KMutableProperty1<A, Int>>(<!ARGUMENT_TYPE_MISMATCH!>p<!>)
    checkSubtype<Int>(p.get(A()))
-    p.get(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    p.<!NO_VALUE_FOR_PARAMETER!>get()<!>
    p.<!UNRESOLVED_REFERENCE!>set<!>(A(), 239)

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

    val q = A::bar
@@ -1,13 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
-
-fun test(x: () -> Unit, y: () -> Unit) {
-
-}
-
-fun main() {
-    <!NO_VALUE_FOR_PARAMETER!>test {
-        1
-    } <!MANY_LAMBDA_EXPRESSION_ARGUMENTS!>{
-        2
-    }<!><!>
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER

 fun test(x: () -> Unit, y: () -> Unit) {
@@ -1,13 +1,13 @@
 // WITH_STDLIB

 // FILE: test.kt
-val bar2 by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY!>bar2(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
+val bar2 by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY, NO_VALUE_FOR_PARAMETER!>bar2()<!>

 // FILE: lt/neworld/compiler/Foo.kt
 package lt.neworld.compiler

 class Foo {
-    val bar by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY!>bar(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
+    val bar by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY, NO_VALUE_FOR_PARAMETER!>bar()<!>
 }

 // FILE: lt/neworld/compiler/bar/Bar.kt
@@ -24,8 +24,8 @@ class K: J.C() {
        <!DEBUG_INFO_DYNAMIC!>sam<!>(null)
        <!DEBUG_INFO_DYNAMIC!>sam<!>(
            name = null,
-            <!ARGUMENT_PASSED_TWICE!>name<!> = null
-        <!NO_VALUE_FOR_PARAMETER!>)<!>
+            <!NO_VALUE_FOR_PARAMETER!><!ARGUMENT_PASSED_TWICE!>name<!> = null
+        )<!>
    }

    fun test() {
@@ -6,7 +6,7 @@ enum class TestOk(val x: String = "OK") {

 enum class TestErrors(val x: String) {
    <!ENUM_ENTRY_SHOULD_BE_INITIALIZED!>TEST1,<!>
-    TEST2(<!NO_VALUE_FOR_PARAMETER!>)<!>,
+    TEST2<!NO_VALUE_FOR_PARAMETER!>()<!>,
    TEST3("Hello")
 }

@@ -19,7 +19,7 @@ class A
 infix operator fun A.plus(a : Any) {

  1.foo()
-  true.foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+  true.<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>foo()<!>

  1
 }
@@ -19,7 +19,7 @@ class A
 infix operator fun A.plus(a : Any) {

  1.foo()
-  true.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+  true.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!><!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>()<!>

  1
 }
@@ -16,7 +16,7 @@ class C : T {
        super.foo() // OK
        super.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
        super.buzz() // OK, resolved to a member
-        super.buzz1(<!NO_VALUE_FOR_PARAMETER!>)<!> // Resolved to an extension
+        super.<!NO_VALUE_FOR_PARAMETER!>buzz1()<!> // Resolved to an extension
        super.buzz1(<!ARGUMENT_TYPE_MISMATCH!>""<!>) // Resolved to a member
    }
 }
@@ -0,0 +1,34 @@
+// !LANGUAGE: +ContextReceivers
+
+class File(name: String)
+interface InputStream
+
+interface AutoCloseScope {
+    fun defer(closeBlock: () -> Unit)
+    fun close()
+}
+class AutoCloseScopeImpl : AutoCloseScope {
+    override fun defer(closeBlock: () -> Unit) = TODO()
+    override fun close() = TODO()
+}
+
+context(AutoCloseScope)
+fun File.open(): InputStream = TODO()
+
+fun withAutoClose(block: context(AutoCloseScope) () -> Unit) {
+    val scope = AutoCloseScopeImpl() // Not shown here
+    try {
+        with(scope) { <!NO_VALUE_FOR_PARAMETER!>block()<!> }
+    } finally {
+        scope.close()
+    }
+}
+
+fun test() {
+    withAutoClose {
+        val input = File("input.txt").open()
+        val config = File("config.txt").open()
+        // Work
+        // All files are closed at the end
+    }
+}
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !LANGUAGE: +ContextReceivers

 class File(name: String)
@@ -19,7 +18,7 @@ fun File.open(): InputStream = TODO()
 fun withAutoClose(block: context(AutoCloseScope) () -> Unit) {
    val scope = AutoCloseScopeImpl() // Not shown here
    try {
-        with(scope) { block(<!NO_VALUE_FOR_PARAMETER!>)<!> }
+        with(scope) { block<!NO_VALUE_FOR_PARAMETER!>()<!> }
    } finally {
        scope.close()
    }
@@ -6,6 +6,6 @@ class A(foo: Int.() -> Unit) {

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

 fun test(foo: Int.(String) -> Unit) {
    4.foo("")
-    4.foo(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p1<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    4.foo(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p1<!> = "")<!>
    4.foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p2<!> = "")
 }
@@ -2,15 +2,15 @@

 fun foo(p: (Int, () -> Int) -> Unit) {
    // Errors except last call
-    <!NO_VALUE_FOR_PARAMETER!>p { 1 }<!>
-    p(<!NO_VALUE_FOR_PARAMETER!>)<!> { 2 }
+    <!NO_VALUE_FOR_PARAMETER!>p<!> { 1 }
+    <!NO_VALUE_FOR_PARAMETER!>p()<!> { 2 }
    p(3) { 4 }
 }

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

 fun bar(p: (String, Any, () -> String) -> Unit) {
    // Errors except last call
    <!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<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>()<!> { "x" }
+    p(<!NO_VALUE_FOR_PARAMETER!>"y")<!> { "z" }
    p("v", Any()) { "w" }
-}
+}
@@ -119,8 +119,8 @@ fun main() {
     * K <: (A) -> Unit -> TypeVariable(_RP1) >: A
     * K >: (C) -> TypeVariable(_R) -> TypeVariable(_RP1) <: 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 x12 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, <!NO_VALUE_FOR_PARAMETER!>id { x: B -> })<!>
+    val x13 = selectA(id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }, <!NO_VALUE_FOR_PARAMETER!>id { x: C -> })<!>
    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 })
    /*
@@ -119,8 +119,8 @@ fun main() {
     * K <: (A) -> Unit -> TypeVariable(_RP1) >: A
     * K >: (C) -> TypeVariable(_R) -> TypeVariable(_RP1) <: C
     */
-    val x12 = selectC(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }<!>, id <!TYPE_MISMATCH!>{ x: B -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
-    val x13 = selectA(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }<!>, id <!TYPE_MISMATCH!>{ x: C -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    val x12 = selectC(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }<!>, <!NO_VALUE_FOR_PARAMETER!>id <!TYPE_MISMATCH!>{ x: B -> }<!>)<!>
+    val x13 = selectA(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }<!>, <!NO_VALUE_FOR_PARAMETER!>id <!TYPE_MISMATCH!>{ x: C -> }<!>)<!>
    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 })
    /*
@@ -2,6 +2,6 @@ fun test1(i: Int) = { i ->
    i
 }(i)

-fun test2() = { i -> i }(<!NO_VALUE_FOR_PARAMETER!>)<!>
+fun test2() = <!NO_VALUE_FOR_PARAMETER!>{ i -> i }()<!>

 fun test3() = { i -> i }(1)
@@ -2,6 +2,6 @@ fun test1(i: Int) = { <!CANNOT_INFER_PARAMETER_TYPE, NAME_SHADOWING!>i<!> ->
    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>i<!>
 }(i)

-fun test2() = { <!CANNOT_INFER_PARAMETER_TYPE!>i<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>i<!> }(<!NO_VALUE_FOR_PARAMETER!>)<!>
+fun test2() = { <!CANNOT_INFER_PARAMETER_TYPE!>i<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>i<!> }<!NO_VALUE_FOR_PARAMETER!>()<!>

 fun test3() = { <!CANNOT_INFER_PARAMETER_TYPE!>i<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>i<!> }(1)
@@ -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 = foo("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>
-val bar2 = foo<String>("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>
+val bar = foo("", <!NO_VALUE_FOR_PARAMETER!>arrayListOf(), )<!>
+val bar2 = foo<String>("", <!NO_VALUE_FOR_PARAMETER!>arrayListOf(), )<!>
@@ -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 = foo("", arrayListOf()<!UNSUPPORTED_FEATURE!>,<!> <!NO_VALUE_FOR_PARAMETER!>)<!>
-val bar2 = foo<String>("", arrayListOf()<!UNSUPPORTED_FEATURE!>,<!> <!NO_VALUE_FOR_PARAMETER!>)<!>
+val bar = foo("", <!NO_VALUE_FOR_PARAMETER!>arrayListOf()<!UNSUPPORTED_FEATURE!>,<!> )<!>
+val bar2 = foo<String>("", <!NO_VALUE_FOR_PARAMETER!>arrayListOf()<!UNSUPPORTED_FEATURE!>,<!> )<!>
@@ -12,7 +12,7 @@ fun test(f: Runnable.(Int) -> Unit, runnable: Runnable) {

 fun Int.test(f: String.(Int) -> Unit) {
    f("", 0)
-    f(""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f(<!NO_VALUE_FOR_PARAMETER!>"")<!>
    with("") {
        f(0)
        f(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>0.0<!>)
@@ -35,7 +35,7 @@ fun poll11(flag: Boolean) {

 fun poll12(flag: Boolean) {
    val inv = if (flag) { ::<!UNRESOLVED_REFERENCE!>bar3<!> } else { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll13(flag: Boolean) {
@@ -45,12 +45,12 @@ fun poll13(flag: Boolean) {

 fun poll14(flag: Boolean) {
    val inv = if (flag) { ::bar4 } else { ::foo4 }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll15(flag: Boolean) {
    val inv = if (flag) { ::<!UNRESOLVED_REFERENCE!>bar5<!> } else { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll16(flag: Boolean) {
@@ -65,7 +65,7 @@ fun poll17(flag: Boolean) {

 fun poll2(flag: Boolean) {
    val inv = when (flag) { true -> ::<!UNRESOLVED_REFERENCE!>bar<!> else -> ::<!UNRESOLVED_REFERENCE!>foo<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll21(flag: Boolean) {
@@ -75,12 +75,12 @@ fun poll21(flag: Boolean) {

 fun poll22(flag: Boolean) {
    val inv = when (flag) { true -> ::<!UNRESOLVED_REFERENCE!>bar3<!> else -> ::<!UNRESOLVED_REFERENCE!>foo3<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll23(flag: Boolean) {
    val inv = when (flag) { true -> ::bar4 else -> ::foo4 }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll24(flag: Boolean) {
@@ -100,7 +100,7 @@ fun poll26(flag: Boolean) {

 fun poll3(flag: Boolean) {
    val inv = when (flag) { true -> ::<!UNRESOLVED_REFERENCE!>bar<!> false -> ::<!UNRESOLVED_REFERENCE!>foo<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll31(flag: Boolean) {
@@ -110,12 +110,12 @@ fun poll31(flag: Boolean) {

 fun poll32(flag: Boolean) {
    val inv = when (flag) { true -> ::<!UNRESOLVED_REFERENCE!>bar3<!> false -> ::<!UNRESOLVED_REFERENCE!>foo3<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll33(flag: Boolean) {
    val inv = when (flag) { true -> ::bar4 false -> ::foo4 }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll34(flag: Boolean) {
@@ -135,7 +135,7 @@ fun poll36(flag: Boolean) {

 fun poll4() {
    val inv = try { ::<!UNRESOLVED_REFERENCE!>bar<!> } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll41() {
@@ -145,17 +145,17 @@ fun poll41() {

 fun poll42() {
    val inv = try { ::<!UNRESOLVED_REFERENCE!>bar3<!> } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll43() {
    val inv = try { ::bar4 } finally { ::foo4 }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll44() {
    val inv = try { ::<!UNRESOLVED_REFERENCE!>bar5<!> } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll45() {
@@ -170,7 +170,7 @@ fun poll46() {

 fun poll5() {
    val inv = try { ::<!UNRESOLVED_REFERENCE!>bar<!> } catch (e: Exception) { ::<!UNRESOLVED_REFERENCE!>foo<!> } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll51() {
@@ -180,17 +180,17 @@ fun poll51() {

 fun poll52() {
    val inv = try { ::<!UNRESOLVED_REFERENCE!>bar3<!> } catch (e: Exception) { ::<!UNRESOLVED_REFERENCE!>foo3<!> } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll53() {
    val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll54() {
    val inv = try { ::<!UNRESOLVED_REFERENCE!>bar5<!> } catch (e: Exception) { ::<!UNRESOLVED_REFERENCE!>foo5<!> } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll55() {
@@ -240,7 +240,7 @@ fun poll66() {

 fun poll7() {
    val inv = ::<!UNRESOLVED_REFERENCE!>bar<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll71() {
@@ -250,7 +250,7 @@ fun poll71() {

 fun poll72() {
    val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll73() {
@@ -275,7 +275,7 @@ fun poll76() {

 fun poll8() {
    val inv = ::<!UNRESOLVED_REFERENCE!>bar<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll81() {
@@ -285,7 +285,7 @@ fun poll81() {

 fun poll82() {
    val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo3<!>)
-    inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }

 fun poll83() {
@@ -12,7 +12,7 @@ class Outer {

        fun baz() {
            // Diagnostic here could be better (why can't I call the constructor above?)
-            Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
+            <!NO_VALUE_FOR_PARAMETER!>Inner()<!>
            Inner(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
            Inner("")
        }
@@ -20,7 +20,7 @@ class Outer {
 }

 fun foo() {
-    Outer.Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Outer.<!NO_VALUE_FOR_PARAMETER!>Inner()<!>
    Outer.Inner(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    Outer.Inner("")
 }
@@ -31,7 +31,7 @@ import abc.Outer.Inner
 import abc.Outer.Companion.Inner

 fun bar() {
-    Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>Inner()<!>
    Inner(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    Inner("")

@@ -12,7 +12,7 @@ class Outer {

        fun baz() {
            // Diagnostic here could be better (why can't I call the constructor above?)
-            Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
+            Inner<!NO_VALUE_FOR_PARAMETER!>()<!>
            Inner(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
            Inner("")
        }
@@ -20,7 +20,7 @@ class Outer {
 }

 fun foo() {
-    Outer.Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Outer.Inner<!NO_VALUE_FOR_PARAMETER!>()<!>
    Outer.Inner(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
    Outer.Inner("")
 }
@@ -31,7 +31,7 @@ import abc.Outer.Inner
 import abc.Outer.Companion.Inner

 fun bar() {
-    Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Inner<!NO_VALUE_FOR_PARAMETER!>()<!>
    Inner(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
    Inner("")

@@ -0,0 +1,11 @@
+// FILE: C.java
+
+// See KT-10410
+public class C {
+    public <T extends T> C(T t) {
+    }
+}
+
+// FILE: main.kt
+
+fun foo() = <!NO_VALUE_FOR_PARAMETER!>C()<!>
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: C.java

 // See KT-10410
@@ -9,4 +8,4 @@ public class C {

 // FILE: main.kt

-fun foo() = C(<!NO_VALUE_FOR_PARAMETER!>)<!>
+fun foo() = C<!NO_VALUE_FOR_PARAMETER!>()<!>
@@ -4,5 +4,5 @@ fun Any.foo1() : (i : Int) -> Unit {
 }

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

 fun test(a : Any) {
-    a.foo1()(<!NO_VALUE_FOR_PARAMETER("i")!>)<!>
+    a.foo1()<!NO_VALUE_FOR_PARAMETER!>()<!>
 }
@@ -21,7 +21,7 @@ class KotlinSubSubClass : KotlinSubClass() {
 fun viaRealOverride() = KotlinSubSubClass().foo(kotlinName = 3)


-fun unresolvedParameter() = JavaSuperClass().foo(<!NAMED_PARAMETER_NOT_FOUND!>nonexistentName<!> = 4<!NO_VALUE_FOR_PARAMETER!>)<!>
+fun unresolvedParameter() = JavaSuperClass().foo(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>nonexistentName<!> = 4)<!>


 fun multipleParameters() = JavaSuperClass().multipleParameters(<!NAMED_ARGUMENTS_NOT_ALLOWED!>first<!> = 1, <!NAMED_ARGUMENTS_NOT_ALLOWED!>second<!> = 2L, <!NAMED_ARGUMENTS_NOT_ALLOWED!>third<!> = "3")
@@ -21,7 +21,7 @@ class KotlinSubSubClass : KotlinSubClass() {
 fun viaRealOverride() = KotlinSubSubClass().foo(kotlinName = 3)


-fun unresolvedParameter() = JavaSuperClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>nonexistentName<!> = 4<!NO_VALUE_FOR_PARAMETER!>)<!>
+fun unresolvedParameter() = JavaSuperClass().foo(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>nonexistentName<!> = 4)<!>


 fun multipleParameters() = JavaSuperClass().multipleParameters(<!NAMED_ARGUMENTS_NOT_ALLOWED!>first<!> = 1, <!NAMED_ARGUMENTS_NOT_ALLOWED!>second<!> = 2L, <!NAMED_ARGUMENTS_NOT_ALLOWED!>third<!> = "3")
@@ -15,6 +15,6 @@ fun main() {

    foo(p1 = 1, p2 = "2", 3.0)

-    foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(1, p3 = 2.0, <!NO_VALUE_FOR_PARAMETER!>"")<!>
+    foo(1, p3 = 2.0, <!NO_VALUE_FOR_PARAMETER!>3.0)<!>
 }
@@ -9,12 +9,12 @@ fun foo(
 ) {}

 fun main() {
-    foo(p1 = 1, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>"2"<!>, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!><!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
-    foo(1, p2 = "2", <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(p1 = 1, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>"2"<!>, <!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!>)<!>
+    foo(1, p2 = "2", <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!>)<!>
    foo(1, "2", p3 = 3.0)

-    foo(p1 = 1, p2 = "2", <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(p1 = 1, p2 = "2", <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!>)<!>

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

    foo(p1 = 1, p2 = "2", 3.0)

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

    foo(p1 = 1, p2 = "2", 3.0)

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

    foo(p1 = 1, p2 = "2", 3.0)

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

    foo(p1 = 1, p2 = "2", 3.0)

-    foo(1, p3 = 2.0, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>""<!><!NO_VALUE_FOR_PARAMETER!>)<!>
-    foo(1, p3 = 2.0, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo(1, p3 = 2.0, <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>""<!>)<!>
+    foo(1, p3 = 2.0, <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>3.0<!>)<!>
 }
@@ -28,10 +28,10 @@ fun foo4(
 ) {}

 fun main() {
-    foo1(1, 2, p2 = "3", 4.0<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo1(1, 2, p2 = "3", <!NO_VALUE_FOR_PARAMETER!>4.0)<!>
    foo1(p1 = intArrayOf(1, 2), "3", p3 = 4.0)

-    foo1(p2 = "3", 4.0<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo1(p2 = "3", <!NO_VALUE_FOR_PARAMETER!>4.0)<!>

    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))

-    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!>)<!>
+    foo4(p1 = 1, "2", "3", p3 = 4.0, <!NO_VALUE_FOR_PARAMETER!>5)<!>
+    foo4(1, "2", "3", p3 = 4.0, <!NO_VALUE_FOR_PARAMETER!>5)<!>
+    foo4(1, p3 = 4.0, <!NO_VALUE_FOR_PARAMETER!>5)<!>

-    foo1(1, 2, p3 = 3.0, "4"<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo1(1, 2, p3 = 3.0, <!NO_VALUE_FOR_PARAMETER!>"4")<!>
    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"))

-    foo3(1, p3 = doubleArrayOf(2.0, 3.0), "4"<!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo3(1, p3 = doubleArrayOf(2.0, 3.0), <!NO_VALUE_FOR_PARAMETER!>"4")<!>
    foo3(1, p3 = doubleArrayOf(2.0, 3.0), p2 = "4")
 }
@@ -28,10 +28,10 @@ fun foo4(
 ) {}

 fun main() {
-    foo1(1, 2, p2 = "3", <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>4.0<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo1(1, 2, p2 = "3", <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>4.0<!>)<!>
    foo1(p1 = intArrayOf(1, 2), "3", p3 = 4.0)

-    foo1(p2 = "3", <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>4.0<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo1(p2 = "3", <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>4.0<!>)<!>

    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))

-    foo4(p1 = 1, "2", "3", p3 = 4.0, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>5<!><!NO_VALUE_FOR_PARAMETER!>)<!>
-    foo4(1, "2", "3", p3 = 4.0, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>5<!><!NO_VALUE_FOR_PARAMETER!>)<!>
-    foo4(1, p3 = 4.0, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>5<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo4(p1 = 1, "2", "3", p3 = 4.0, <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>5<!>)<!>
+    foo4(1, "2", "3", p3 = 4.0, <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>5<!>)<!>
+    foo4(1, p3 = 4.0, <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>5<!>)<!>

-    foo1(1, 2, p3 = 3.0, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>"4"<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo1(1, 2, p3 = 3.0, <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>"4"<!>)<!>
    foo1(1, 2, p3 = 3.0, p2 = "4")
    foo1(*intArrayOf(1, 2), p3 = 3.0, p2 = "4")

@@ -52,6 +52,6 @@ fun main() {
    foo2(1, p3 = 2.0, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>*arrayOf("3", "4")<!>)
    foo2(1, p3 = 2.0, p2 = arrayOf("3", "4"))

-    foo3(1, p3 = doubleArrayOf(2.0, 3.0), <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>"4"<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    foo3(1, p3 = doubleArrayOf(2.0, 3.0), <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>"4"<!>)<!>
    foo3(1, p3 = doubleArrayOf(2.0, 3.0), p2 = "4")
 }
@@ -14,14 +14,14 @@ fun test() {
    foo(1, "", <!TOO_MANY_ARGUMENTS!>""<!>)

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

    bar(z = "")
-    bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    bar(<!TYPE_MISMATCH!>""<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    bar<!NO_VALUE_FOR_PARAMETER!>()<!>
+    bar(<!NO_VALUE_FOR_PARAMETER!><!TYPE_MISMATCH!>""<!>)<!>
    bar(1, 1, "")
    bar(1, 1, "")
    bar(1, z = "")
    bar(1, z = "", y = 2)
    bar(z = "", <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!>1<!>)
    bar(1, <!NAMED_PARAMETER_NOT_FOUND!>zz<!> = "",
-           <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!><!UNRESOLVED_REFERENCE!>zz<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!><!>
-           <!NO_VALUE_FOR_PARAMETER!>)<!>
+           <!NO_VALUE_FOR_PARAMETER!><!MIXING_NAMED_AND_POSITIONED_ARGUMENTS!><!UNRESOLVED_REFERENCE!>zz<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!><!>
+           )<!>
 }
@@ -5,13 +5,13 @@ package toplevelObjectDeclarations
    open fun foo() : Int = 1
  }

-  <!NO_VALUE_FOR_PARAMETER!>class T : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}<!>
+  class T : <!NO_VALUE_FOR_PARAMETER, SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}

-  <!NO_VALUE_FOR_PARAMETER{LT}!>object A : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
+  <!NO_VALUE_FOR_PARAMETER{LT}!>object A : <!NO_VALUE_FOR_PARAMETER{PSI}, SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
    val x : Int = 2

    fun test() : Int {
-      return x + foo(<!NO_VALUE_FOR_PARAMETER{PSI}!>)<!>
+      return x + foo()
    }
  }<!>

@@ -4,24 +4,24 @@ class Function1Impl : (String) -> Unit {

 fun test1(f: Function1Impl) {
    f("")
-    f(<!NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
    f(myParamName = "")
    f.invoke("")
-    f.invoke(<!NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f.invoke(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
    f.invoke(myParamName = "")
 }

 fun test2(f: (String) -> Unit) {
    f("")
-    f(<!NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    f(<!NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
+    f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = "")<!>
    f.invoke("")
-    f.invoke(<!NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    f.invoke(<!NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f.invoke(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
+    f.invoke(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = "")<!>
 }

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

 fun test1(f: Function1Impl) {
    f("")
-    f(<!NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
    f(myParamName = "")
    f.invoke("")
-    f.invoke(<!NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f.invoke(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
    f.invoke(myParamName = "")
 }

 fun test2(f: (String) -> Unit) {
    f("")
-    f(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    f(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
+    f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = "")<!>
    f.invoke("")
-    f.invoke(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    f.invoke(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f.invoke(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
+    f.invoke(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>myParamName<!> = "")<!>
 }

 fun test3(f: String.(String) -> Unit) {
    "".f("")
-    "".f(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p0<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    "".f(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>zzz<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    "".f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>p0<!> = "")<!>
+    "".f(<!NO_VALUE_FOR_PARAMETER!><!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>zzz<!> = "")<!>
 }
@@ -15,5 +15,5 @@ fun main() {
    1.set(2, z = 1)
    1[2] += 1

-    1.set(2, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    1.set(2, <!NO_VALUE_FOR_PARAMETER!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)<!>
 }
@@ -24,7 +24,7 @@ public class Manager {

    class Task(val callback: Manager.() -> Unit) : Runnable {
        override public fun run() {
-            callback(<!NO_VALUE_FOR_PARAMETER!>)<!> // Manager is not accessible here, but no error is shown
+            callback<!NO_VALUE_FOR_PARAMETER!>()<!> // Manager is not accessible here, but no error is shown
        }
    }
 }
@@ -4,7 +4,7 @@ class X<V>(provider: () -> V, trackValue: Boolean) {
 }

 class B {
-    val c = <!NO_VALUE_FOR_PARAMETER!>X<String> {
+    val c = <!NO_VALUE_FOR_PARAMETER!>X<!><String> {
        "e"
-    }<!>
+    }
 }
@@ -1,7 +1,7 @@
 fun test1(f: String.() -> Unit) {
-    (f)(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>(f)()<!>

-    f(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>f()<!>
 }

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

-    f(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    f<!NO_VALUE_FOR_PARAMETER!>()<!>
 }

 fun test2(f: (Int) -> Int) {
    1.<!UNRESOLVED_REFERENCE!>f<!>(2)

    2.<!NO_RECEIVER_ALLOWED!>(f)<!>(2)
-}
+}
@@ -6,7 +6,7 @@ fun test1() {

 fun test2(f: String.(Int) -> Unit) {
    <!ARGUMENT_TYPE_MISMATCH!>11<!>.(f)(1)
-    11.(f)(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    11.<!NO_VALUE_FOR_PARAMETER!>(f)()<!>
 }

 fun test3() {
@@ -7,7 +7,7 @@ class SomeClass

 fun test(identifier: SomeClass, fn: String.() -> Unit) {
    <!NONE_APPLICABLE!>identifier<!>()
-    identifier(123<!NO_VALUE_FOR_PARAMETER!>)<!>
+    identifier(<!NO_VALUE_FOR_PARAMETER!>123)<!>
    identifier(1, <!TOO_MANY_ARGUMENTS!>2<!>)
    <!ARGUMENT_TYPE_MISMATCH!>1<!>.fn()
 }
@@ -11,10 +11,10 @@ fun test(a: A) {
    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)<!>("")

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

    with("") {
-        a.<!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        a.<!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!><!NO_VALUE_FOR_PARAMETER!>()<!>
        <!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)<!>()
        if (a.x != null) {
-            a.<!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!>(<!NO_VALUE_FOR_PARAMETER!>)<!> // todo
+            a.<!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!><!NO_VALUE_FOR_PARAMETER!>()<!> // todo
            <!DEBUG_INFO_SMARTCAST!>(a.x)<!>()
        }
    }
@@ -23,8 +23,8 @@ fun test(a: A, b: B) {
    }

    with(b) {
-        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
-        a.(foo)(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        a.<!NO_VALUE_FOR_PARAMETER!>foo()<!>
+        a.<!NO_VALUE_FOR_PARAMETER!>(foo)()<!>

        (a.foo)()

@@ -65,8 +65,8 @@ fun test(a: A, b: B) {
    }

    with(b) {
-        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
-        a.(foo)(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        a.<!NO_VALUE_FOR_PARAMETER!>foo()<!>
+        a.<!NO_VALUE_FOR_PARAMETER!>(foo)()<!>

        (a.foo)()

@@ -23,7 +23,7 @@ fun test(a: A, b: B) {
    }

    with(b) {
-        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        a.foo<!NO_VALUE_FOR_PARAMETER!>()<!>
        a.<!FUNCTION_EXPECTED!>(<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>)<!>()

        (a.foo)()
@@ -65,7 +65,7 @@ fun test(a: A, b: B) {
    }

    with(b) {
-        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        a.foo<!NO_VALUE_FOR_PARAMETER!>()<!>
        a.<!FUNCTION_EXPECTED!>(<!UNRESOLVED_REFERENCE!>foo<!>)<!>()

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

 fun test(a: A, b: B) {
    with(b) {
-        a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!> // here must be error, because a is not extension receiver
+        a.foo<!NO_VALUE_FOR_PARAMETER!>()<!> // here must be error, because a is not extension receiver

        a.foo(this)

@@ -10,6 +10,6 @@ fun test() {

    bar(foo(<!NAMED_PARAMETER_NOT_FOUND!>xx<!> = zzz(11) { j: Int -> j + 7 }))

-    bar(<!NAMED_PARAMETER_NOT_FOUND!>zz<!> = foo(
-      <!NAMED_PARAMETER_NOT_FOUND!>xx<!> = zzz(12) { i: Int -> i + i })<!NO_VALUE_FOR_PARAMETER!>)<!>
+    bar(<!NO_VALUE_FOR_PARAMETER!><!NAMED_PARAMETER_NOT_FOUND!>zz<!> = foo(
+      <!NAMED_PARAMETER_NOT_FOUND!>xx<!> = zzz(12) { i: Int -> i + i }))<!>
 }
@@ -28,7 +28,7 @@ fun testNoArgs() {
 }

 fun testLambdaArg() {
-    oneLambdaArg(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>oneLambdaArg()<!>
    oneLambdaArg {}
    oneLambdaArg()
    {}
@@ -40,7 +40,7 @@ fun testLambdaArg() {
        <!TOO_MANY_ARGUMENTS!>{}<!>
    )
    oneLambdaArg() {}
-    oneLambdaArg(<!NO_VALUE_FOR_PARAMETER!>)<!> // {}
+    <!NO_VALUE_FOR_PARAMETER!>oneLambdaArg()<!> // {}
    oneLambdaArg() /* */ {}
    oneLambdaArg() /*
        block
@@ -95,7 +95,7 @@ fun testTwoLambdas() {
    )

    fun bar(): () -> Unit {
-        twoLambdaArgs(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        <!NO_VALUE_FOR_PARAMETER!>twoLambdaArgs()<!>
        {}
        <!MANY_LAMBDA_EXPRESSION_ARGUMENTS!>{}<!>

@@ -28,7 +28,7 @@ fun testNoArgs() {
 }

 fun testLambdaArg() {
-    oneLambdaArg(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    oneLambdaArg<!NO_VALUE_FOR_PARAMETER!>()<!>
    oneLambdaArg {}
    oneLambdaArg()
    {}
@@ -40,7 +40,7 @@ fun testLambdaArg() {
        <!TOO_MANY_ARGUMENTS!>{}<!>
    )
    oneLambdaArg() {}
-    oneLambdaArg(<!NO_VALUE_FOR_PARAMETER!>)<!> // {}
+    oneLambdaArg<!NO_VALUE_FOR_PARAMETER!>()<!> // {}
    oneLambdaArg() /* */ {}
    oneLambdaArg() /*
        block
@@ -95,7 +95,7 @@ fun testTwoLambdas() {
    )

    fun bar(): () -> Unit {
-        twoLambdaArgs(<!NO_VALUE_FOR_PARAMETER!>)<!>
+        twoLambdaArgs<!NO_VALUE_FOR_PARAMETER!>()<!>
        {}
        <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!>

@@ -7,7 +7,7 @@ open class A protected constructor(x: Int) {
 }

 fun foo() {
-    A(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NO_VALUE_FOR_PARAMETER!>A()<!>
    A(1.0)
 }

@@ -1,4 +1,4 @@
-val (a, b, c) = A(<!NO_VALUE_FOR_PARAMETER!>)<!>
+val (a, b, c) = A<!NO_VALUE_FOR_PARAMETER!>()<!>

 class A(val a: Int) {
    operator fun component1() {}
@@ -3,7 +3,7 @@ open class B0(x: Int)

 class A0 : B0 {
    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!>
-    constructor(x: Int) : super(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    constructor(x: Int) : super<!NO_VALUE_FOR_PARAMETER!>()<!>
 }

 // --------------------------
@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    constructor(x: Int)
+}
+
+val x = <!NO_VALUE_FOR_PARAMETER!>A()<!>
@@ -1,7 +1,6 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class A {
    constructor(x: Int)
 }

-val x = A(<!NO_VALUE_FOR_PARAMETER!>)<!>
+val x = A<!NO_VALUE_FOR_PARAMETER!>()<!>
@@ -13,7 +13,7 @@ open class C2(val x: Int) {
 typealias C2_Alias = C2

 val test1 = C1_Alias()
-val test2 = C2_Alias(<!NO_VALUE_FOR_PARAMETER!>)<!>
+val test2 = <!NO_VALUE_FOR_PARAMETER!>C2_Alias()<!>

 class Test3 : C1_Alias()

@@ -13,8 +13,8 @@ open class C2(val x: Int) {
 typealias C2_Alias = C2

 val test1 = <!UNRESOLVED_REFERENCE!>C1_Alias<!>()
-val test2 = C2_Alias(<!NO_VALUE_FOR_PARAMETER!>)<!>
+val test2 = C2_Alias<!NO_VALUE_FOR_PARAMETER!>()<!>

 class Test3 : <!API_NOT_AVAILABLE, DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>C1_Alias<!>()

-class Test4 : C2_Alias(<!NO_VALUE_FOR_PARAMETER!>)<!>
+class Test4 : C2_Alias<!NO_VALUE_FOR_PARAMETER!>()<!>
@@ -9,14 +9,14 @@ private typealias TA = <!INVISIBLE_REFERENCE!>C<!>
 private val test1: <!INVISIBLE_REFERENCE!>C<!> = <!INVISIBLE_REFERENCE!>C<!>()
 private val test1co: <!INVISIBLE_REFERENCE!>C.Companion<!> = <!INITIALIZER_TYPE_MISMATCH, INVISIBLE_REFERENCE, NO_COMPANION_OBJECT!>C<!>

-private val test2: <!INVISIBLE_REFERENCE!>TA<!> = <!INITIALIZER_TYPE_MISMATCH!>TA(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
+private val test2: <!INVISIBLE_REFERENCE!>TA<!> = <!INITIALIZER_TYPE_MISMATCH, NO_VALUE_FOR_PARAMETER!>TA()<!>
 private val test2co = <!INVISIBLE_REFERENCE!>TA<!>

 // FILE: file2.kt
 private val test1: C = C()
 private val test1co: C.Companion = <!INITIALIZER_TYPE_MISMATCH, NO_COMPANION_OBJECT!>C<!>

-private val test2: TA = <!INITIALIZER_TYPE_MISMATCH!>TA(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
+private val test2: TA = <!INITIALIZER_TYPE_MISMATCH, NO_VALUE_FOR_PARAMETER!>TA()<!>
 private val test2co = TA

 private class <!PACKAGE_OR_CLASSIFIER_REDECLARATION!>C<!>
@@ -1 +1 @@
-val foo = <!INVISIBLE_MEMBER!>UInt<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>
+val foo = <!INVISIBLE_MEMBER!>UInt<!><!NO_VALUE_FOR_PARAMETER!>()<!>
@@ -3,5 +3,5 @@ fun test(d: dynamic) {

    d.foo(1, name = "name")

-    d.foo(1, duplicate = "", <!ARGUMENT_PASSED_TWICE!>duplicate<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    d.foo(1, duplicate = "", <!NO_VALUE_FOR_PARAMETER!><!ARGUMENT_PASSED_TWICE!>duplicate<!> = "")<!>
 }
@@ -4,7 +4,7 @@
 expect class Ok(x: Int, y: String = "")

 fun test() {
-    Ok(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Ok<!NO_VALUE_FOR_PARAMETER!>()<!>
    Ok(42)
    Ok(42, "OK")
 }
@@ -15,7 +15,7 @@ fun test() {
 actual class Ok actual constructor(x: Int, y: String)

 fun testJvm() {
-    Ok(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    Ok<!NO_VALUE_FOR_PARAMETER!>()<!>
    Ok(42)
    Ok(42, "OK")
 }
@@ -16,21 +16,21 @@ expect fun topLevelFunction(x: Int, y: String = "ok")
 expect fun String.topLevelExtensionFunction(x: Int, y: String = "ok")

 fun test() {
-    A().memberFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    A().memberFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    A().memberFunction(42)
    A().memberFunction(42, "ok")

-    topLevelFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    topLevelFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    topLevelFunction(42)
    topLevelFunction(42, "ok")

-    "".topLevelExtensionFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    "".topLevelExtensionFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    "".topLevelExtensionFunction(42)
    "".topLevelExtensionFunction(42, "ok")
 }

 fun A.test() {
-    "".companionExtensionFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    "".companionExtensionFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    "".companionExtensionFunction(42)
    "".companionExtensionFunction(42, "ok")
 }
@@ -53,21 +53,21 @@ actual fun topLevelFunction(x: Int, y: String) = Unit
 actual fun String.topLevelExtensionFunction(x: Int, y: String) = Unit

 fun testJvm() {
-    A().memberFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    A().memberFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    A().memberFunction(42)
    A().memberFunction(42, "ok")

-    topLevelFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    topLevelFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    topLevelFunction(42)
    topLevelFunction(42, "ok")

-    "".topLevelExtensionFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    "".topLevelExtensionFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    "".topLevelExtensionFunction(42)
    "".topLevelExtensionFunction(42, "ok")
 }

 fun A.testJvm() {
-    "".companionExtensionFunction(<!NO_VALUE_FOR_PARAMETER!>)<!>
+    "".companionExtensionFunction<!NO_VALUE_FOR_PARAMETER!>()<!>
    "".companionExtensionFunction(42)
    "".companionExtensionFunction(42, "ok")
 }
@@ -21,4 +21,4 @@ public @interface A {

@A(y = 7) fun test7() {}

-@A("8", "9", "10"<!NO_VALUE_FOR_PARAMETER!>)<!> fun test8() {}
+@A("8", "9", <!NO_VALUE_FOR_PARAMETER!>"10")<!> fun test8() {}
@@ -0,0 +1,3 @@
+// NI_EXPECTED_FILE
+
+fun foo(first: Array<Any?>, second: Array<Any?>) = Pair(first.<!NO_VALUE_FOR_PARAMETER!>toCollection()<!>, second.<!NO_VALUE_FOR_PARAMETER!>toCollection()<!>)
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // NI_EXPECTED_FILE

-fun foo(first: Array<Any?>, second: Array<Any?>) = Pair(first.toCollection(<!NO_VALUE_FOR_PARAMETER!>)<!>, second.toCollection(<!NO_VALUE_FOR_PARAMETER!>)<!>)
+fun foo(first: Array<Any?>, second: Array<Any?>) = Pair(first.toCollection<!NO_VALUE_FOR_PARAMETER!>()<!>, second.toCollection<!NO_VALUE_FOR_PARAMETER!>()<!>)
@@ -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().toArray(<!ARGUMENT_TYPE_MISMATCH, NO_COMPANION_OBJECT!>Array<Int?><!>)

-    val c2: Array<Int?> = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
+    val c2: Array<Int?> = ci.toArray(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>Array<Int?>()<!>)

-    val c3 = Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+    val c3 = <!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>Array<Int?>()<!>

-    val c4 = ci.toArray<Int?>(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
+    val c4 = ci.toArray<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>Array<Int?>()<!>)

-    val c5 = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
+    val c5 = ci.toArray(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>Array<Int?>()<!>)

    checkSubtype<Array<Int?>>(c1)
    checkSubtype<Array<Int?>>(c2)
@@ -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().toArray(<!FUNCTION_CALL_EXPECTED!><!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>Array<!><Int?><!>)

-    val c2: Array<Int?> = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
+    val c2: Array<Int?> = ci.toArray(Array<Int?><!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>()<!>)

-    val c3 = Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+    val c3 = Array<Int?><!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>()<!>

-    val c4 = ci.toArray<Int?>(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
+    val c4 = ci.toArray<Int?>(Array<Int?><!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>()<!>)

-    val c5 = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
+    val c5 = ci.toArray(Array<Int?><!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>()<!>)

    checkSubtype<Array<Int?>>(c1)
    checkSubtype<Array<Int?>>(c2)
@@ -1,4 +1,4 @@
-@JvmName(<!NO_VALUE_FOR_PARAMETER!>)<!>
+<!NO_VALUE_FOR_PARAMETER!>@JvmName()<!>
 fun foo() {}

@JvmName(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
@@ -1,4 +1,4 @@
-<!ILLEGAL_JVM_NAME!>@JvmName(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
+<!ILLEGAL_JVM_NAME!>@JvmName<!NO_VALUE_FOR_PARAMETER!>()<!><!>
 fun foo() {}

 <!ILLEGAL_JVM_NAME!>@JvmName(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>)<!>
--- a/Show More
+++ b/Show More