[FIR-TEST] Add new testdata generated after changes in previous commit

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

@@ -0,0 +1,12 @@
+// FILE: A.java
+
+public @interface A {
+    int x();
+
+    String y();
+}
+
+// FILE: 1.kt
+
+@A(x = 1, y = "2")
+fun test() {}

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

@@ -0,0 +1,27 @@
+interface A {
+    fun foo(x : Int)
+}
+
+interface B {
+    fun foo(y : Int)
+}
+
+interface C : A, B
+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)
+    y.foo(y = 0)
+}
+
+abstract class C1 : A, B
+abstract class D1 : A, B
+
+fun bar(x : C1, y : D1){
+    x.foo(x = 0)
+    x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
+    y.foo(x = 0)
+    y.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
+}

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

@@ -0,0 +1,24 @@
+interface A {
+    fun foo(a1: Int, a2: Double)
+    fun bar(a1: Int, a2: Double, a3: String)
+    fun baz(a1: Int, a2: Double, a3: String, a4: Int, a5: String)
+}
+
+interface B {
+    fun foo(b1: Int, b2: Double)
+    fun bar(a1: Int, a2: Double, b3: String)
+    fun baz(a1: Int, b2: Double, a3: String, b4: Int, a5: String)
+}
+
+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(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 = "")
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+interface A<T> {
+    fun foo(a: T)
+}
+
+interface B<E> {
+    fun foo(b: E)
+}
+
+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)
+}

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

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

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

@@ -0,0 +1,27 @@
+// FILE: JavaSuperClass.java
+
+public class JavaSuperClass {
+    public void foo(int javaName) {}
+
+    public void multipleParameters(int first, long second, String third) {}
+}
+
+// FILE: 1.kt
+
+fun directInvocation() = JavaSuperClass().foo(javaName = 1)
+
+open class KotlinSubClass : JavaSuperClass()
+
+fun viaFakeOverride() = KotlinSubClass().foo(javaName = 2)
+
+class KotlinSubSubClass : KotlinSubClass() {
+    override fun foo(kotlinName: Int) {}
+}
+
+fun viaRealOverride() = KotlinSubSubClass().foo(kotlinName = 3)
+
+
+fun unresolvedParameter() = JavaSuperClass().<!INAPPLICABLE_CANDIDATE!>foo<!>(nonexistentName = 4)
+
+
+fun multipleParameters() = JavaSuperClass().multipleParameters(first = 1, second = 2L, third = "3")

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

@@ -0,0 +1,17 @@
+// !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() {
+    <!INAPPLICABLE_CANDIDATE!>J<!>("", r = { }, z = false)
+}

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

@@ -0,0 +1,17 @@
+// !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("", r = { }, z = false)
+}

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

@@ -0,0 +1,28 @@
+// !LANGUAGE: +NewInference +MixedNamedArgumentsInTheirOwnPosition
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+fun foo(
+    p1: Int = 1,
+    p2: String = "",
+    p3: Double = 3.0,
+    p4: Char = '4'
+) {}
+
+fun main() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, "2", 3.0)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p2 = "2", 3.0)
+    foo(1, "2", p3 = 3.0)
+
+    foo(p1 = 1)
+    foo(1, p2 = "2")
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, p2 = "2", 3.0)
+
+    foo()
+    foo(1, p2 = "")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p3 = 4.0, '4')
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+}

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

@@ -0,0 +1,20 @@
+// !LANGUAGE: +NewInference -MixedNamedArgumentsInTheirOwnPosition
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+fun foo(
+    p1: Int,
+    p2: String,
+    p3: Double
+) {}
+
+fun main() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, "2", 3.0)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p2 = "2", 3.0)
+    foo(1, "2", p3 = 3.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, p2 = "2", 3.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+}

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

@@ -0,0 +1,20 @@
+// !LANGUAGE: -NewInference +MixedNamedArgumentsInTheirOwnPosition
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+fun foo(
+    p1: Int,
+    p2: String,
+    p3: Double
+) {}
+
+fun main() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, "2", 3.0)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p2 = "2", 3.0)
+    foo(1, "2", p3 = 3.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, p2 = "2", 3.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+}

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

@@ -0,0 +1,20 @@
+// !LANGUAGE: +NewInference +MixedNamedArgumentsInTheirOwnPosition
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+fun foo(
+    p1: Int,
+    p2: String,
+    p3: Double
+) {}
+
+fun main() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, "2", 3.0)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p2 = "2", 3.0)
+    foo(1, "2", p3 = 3.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = 1, p2 = "2", 3.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
+}

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

@@ -0,0 +1,57 @@
+// !LANGUAGE: +NewInference +MixedNamedArgumentsInTheirOwnPosition
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+fun foo1(
+    vararg p1: Int,
+    p2: String,
+    p3: Double
+) {}
+
+fun foo2(
+    p1: Int,
+    vararg p2: String,
+    p3: Double
+) {}
+
+fun foo3(
+    p1: Int,
+    p2: String,
+    vararg p3: Double
+) {}
+
+fun foo4(
+    p1: Int,
+    vararg p2: String,
+    p3: Double,
+    p4: Int
+) {}
+
+fun main() {
+    <!INAPPLICABLE_CANDIDATE!>foo1<!>(1, 2, p2 = "3", 4.0)
+    <!INAPPLICABLE_CANDIDATE!>foo1<!>(p1 = *intArrayOf(1, 2), "3", p3 = 4.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo1<!>(p2 = "3", 4.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(p1 = 1, "2", "3", p3 = 4.0)
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(1, p2 = *arrayOf("2", "3"), 4.0)
+    foo2(1, p3 = 3.0)
+
+    <!INAPPLICABLE_CANDIDATE!>foo3<!>(p1 = 1, "2", 3.0, 4.0)
+    <!INAPPLICABLE_CANDIDATE!>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)
+
+    <!INAPPLICABLE_CANDIDATE!>foo1<!>(1, 2, p3 = 3.0, "4")
+    foo1(1, 2, p3 = 3.0, p2 = "4")
+    foo1(*intArrayOf(1, 2), p3 = 3.0, p2 = "4")
+
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(1, p3 = 2.0, "4")
+    <!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), p2 = "4")
+}

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

@@ -0,0 +1,27 @@
+fun foo(a : Int = 1, b : String = "abc") {
+}
+
+fun bar(x : Int = 1, y : Int = 1, z : String) {
+}
+
+fun test() {
+    foo()
+    foo(2)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    foo(b = "")
+    foo(1, "")
+    foo(a = 2)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, "", "")
+
+    bar(z = "")
+    <!INAPPLICABLE_CANDIDATE!>bar<!>()
+    <!INAPPLICABLE_CANDIDATE!>bar<!>("")
+    bar(1, 1, "")
+    bar(1, 1, "")
+    bar(1, z = "")
+    bar(1, z = "", y = 2)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(z = "", 1)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(1, zz = "",
+           <!UNRESOLVED_REFERENCE!>zz<!>.<!UNRESOLVED_REFERENCE!>foo<!>
+           )
+}

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

@@ -0,0 +1,14 @@
+interface A {
+    fun foo(a1: Int, a2: Double)
+}
+
+interface B {
+    fun foo(b1: Int, b2: String)
+}
+
+interface C : A, B {}
+
+fun test(d: C) {
+    d.foo(a1 = 1, a2 = 1.0)
+    d.foo(b1 = 1, b2 = "")
+}

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

@@ -0,0 +1,22 @@
+interface A {
+    fun foo(a1: Int, a2: Double)
+}
+
+interface B {
+    fun foo(b1: Int, b2: Double)
+}
+
+interface C : A, B { // Warning here, this is correct, C.foo has no named parameters
+}
+
+interface D : C {
+    override fun foo(d1: Int, d2: Double)
+}
+
+fun test1(d: D) {
+    d.foo(d1 = 1, d2 = 1.0)
+}
+
+fun test2(c: C) {
+    c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b1 = 1, b2 = 1.0)
+}