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

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultEnum.fir.kt

@@ -0,0 +1,67 @@
+// FILE: Signs.java
+// ANDROID_ANNOTATIONS
+
+public enum Signs {
+    HELLO,
+    WORLD;
+
+    public static final Signs X;
+    public static final class NOT_ENTRY_EITHER {}
+}
+
+// FILE: Mixed.java
+public enum Mixed {
+    NOT_ENTRY_EITHER;
+
+    public static final class NOT_ENTRY_EITHER {}
+}
+
+// FILE: B.kt
+enum class B {
+    X,
+    Y;
+}
+
+// FILE: A.java
+import kotlin.annotations.jvm.internal.*;
+
+class A {
+    public Signs a(@DefaultValue("HELLO") Signs arg)  {
+        return arg;
+    }
+
+    public B b(@DefaultValue("Y") B arg) {
+        return arg;
+    }
+
+    public void foooo(@DefaultValue("ok") B arg) {
+    }
+
+    public Signs bar(@DefaultValue("X") Signs arg)  {
+        return arg;
+    }
+
+    public Signs baz(@DefaultValue("NOT_ENTRY_EITHER") Signs arg) {
+        return arg;
+    }
+
+    public Mixed bam(@DefaultValue("NOT_ENTRY_EITHER") Mixed arg) {
+        return arg;
+    }
+
+}
+
+// FILE: test.kt
+fun test(){
+    val a = A()
+    a.a()
+    a.a(Signs.HELLO)
+    a.b()
+    a.b(B.X)
+    a.<!INAPPLICABLE_CANDIDATE!>foooo<!>()
+    a.foooo(B.Y)
+    a.bar()
+    a.<!INAPPLICABLE_CANDIDATE!>baz<!>()
+
+    a.bam()
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultLongLiteral.fir.kt

@@ -0,0 +1,49 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+public class A {
+    public void first(@DefaultValue("0x1F") Long value) {
+    }
+
+    public void second(@DefaultValue("0X1F") Long value) {
+    }
+
+    public void third(@DefaultValue("0b1010") Long value) {
+    }
+
+    public void fourth(@DefaultValue("0B1010") Long value) {
+    }
+}
+
+// FILE: B.java
+import kotlin.annotations.jvm.internal.*;
+
+public class B {
+    public void first(@DefaultValue("0x") Long value) {
+    }
+
+    public void second(@DefaultValue("0xZZ") Long value) {
+    }
+
+    public void third(@DefaultValue("0b") Long value) {
+    }
+
+    public void fourth(@DefaultValue("0B1234") Long value) {
+    }
+}
+
+// FILE: test.kt
+fun main(a: A, b: B) {
+    a.first()
+    a.second()
+    a.third()
+    a.fourth()
+
+    b.<!INAPPLICABLE_CANDIDATE!>first<!>()
+    b.<!INAPPLICABLE_CANDIDATE!>second<!>()
+    b.<!INAPPLICABLE_CANDIDATE!>third<!>()
+    b.<!INAPPLICABLE_CANDIDATE!>fourth<!>()
+}
+

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultNull.fir.kt

@@ -0,0 +1,31 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+public class A {
+    public void foo(@DefaultNull Integer x) {}
+    public void bar(@DefaultNull int x) {}
+}
+
+// FILE: B.java
+import kotlin.annotations.jvm.internal.*;
+
+public class B<T> {
+    public void foo(@DefaultNull T t) { }
+}
+
+// FILE: test.kt
+fun test(a: A, first: B<Int>, second: B<Int?>) {
+    a.foo()
+    a.foo(0)
+
+    a.bar()
+    a.bar(0)
+
+    first.foo()
+    first.foo(5)
+
+    second.foo()
+    second.foo(5)
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultNullAndParameter.fir.kt

@@ -0,0 +1,57 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+public class A {
+    public void foo(@DefaultNull Integer i) {}
+
+    public void bar(@DefaultNull Integer a) {}
+
+    public void bam(@DefaultNull Integer a) {}
+
+    public void baz(@DefaultValue("42") Integer a) {}
+}
+
+// FILE: AInt.java
+import kotlin.annotations.jvm.internal.*;
+
+public interface AInt {
+    public void foo(@DefaultValue("42") Integer i) {}
+    public void bar(@DefaultNull Integer a) {}
+}
+
+// FILE: B.java
+import kotlin.annotations.jvm.internal.*;
+
+public class B extends A {
+    public void foo(Integer i) {}
+
+    public void bar(@DefaultValue("42") Integer a) {}
+
+    public void bam(@DefaultNull @DefaultValue("42") Integer a) {}
+}
+
+// FILE: C.java
+public class C extends A implements AInt {
+}
+
+// FILE: test.kt
+
+fun test(b: B, c: C) {
+    b.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    b.foo(5)
+    b.bar()
+    b.bar(5)
+    b.bam()
+    b.bam(5)
+
+    c.foo()
+    c.foo(5)
+    c.bar()
+    c.bar(5)
+    c.bam()
+    c.bam(5)
+    c.baz()
+    c.baz(42)
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultParameter.fir.kt

@@ -0,0 +1,45 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+class A {
+    public void first(@DefaultValue("hello") String value) {
+    }
+
+    public void second(@DefaultValue("first") String a, @DefaultValue("second") String b) {
+    }
+
+    public void third(@DefaultValue("first") String a, String b) {
+    }
+
+    public void fourth(String first, @DefaultValue("second") String second) {
+    }
+
+    public void wrong(@DefaultValue("hello") Integer i) {
+    }
+}
+
+
+// FILE: test.kt
+fun main() {
+    val a = A()
+
+    a.first()
+    a.first("arg")
+
+    a.second()
+    a.second("arg")
+    a.second("first", "second")
+
+    a.<!INAPPLICABLE_CANDIDATE!>third<!>("OK")
+    a.third("first", "second")
+
+    a.<!INAPPLICABLE_CANDIDATE!>fourth<!>()
+    a.fourth("first")
+    a.fourth("first", "second")
+
+    a.<!INAPPLICABLE_CANDIDATE!>wrong<!>()
+    a.wrong(42)
+}
+

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/emptyParameterName.fir.kt

@@ -0,0 +1,27 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+class A {
+    public void emptyName(@ParameterName("") String first, @ParameterName("ok") int second) {
+    }
+
+    public void missingName(@ParameterName() String first) {
+    }
+
+    public void numberName(@ParameterName(42) String first) {
+    }
+}
+
+// FILE: test.kt
+fun main() {
+    val test = A()
+    test.emptyName("first", 42)
+    test.<!INAPPLICABLE_CANDIDATE!>emptyName<!>("first", ok = 42)
+
+    test.missingName(`first` = "arg")
+    test.missingName("arg")
+
+    test.numberName("first")
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.fir.kt

@@ -0,0 +1,22 @@
+// FILE: BaseClass.java
+import org.jetbrains.annotations.NotNull;
+
+public class BaseClass {
+    public void loadCache(@NotNull Object... args) {}
+}
+
+// FILE: main.kt
+
+class A : BaseClass() {
+    // org.jetbrains.annotations.NotNull has @Target PARAMETER, so it doesn't affect elements type
+    override fun loadCache(vararg args: Any?) {
+        super.loadCache(*args)
+    }
+}
+
+class B : BaseClass() {
+    // org.jetbrains.annotations.NotNull has @Target PARAMETER, so it doesn't affect elements type
+    override fun loadCache(vararg args: Any) {
+        super.loadCache(*args)
+    }
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.fir.kt

@@ -0,0 +1,22 @@
+// FILE: BaseClass.java
+import org.jetbrains.annotations.Nullable;
+
+public class BaseClass {
+    public void loadCache(@Nullable Object... args) {}
+}
+
+// FILE: main.kt
+
+class A : BaseClass() {
+    // org.jetbrains.annotations.Nullable has @Target PARAMETER, so it doesn't affect elements type
+    override fun loadCache(vararg args: Any?) {
+        super.loadCache(*args)
+    }
+}
+
+class B : BaseClass() {
+    // org.jetbrains.annotations.Nullable has @Target PARAMETER, so it doesn't affect elements type
+    override fun loadCache(vararg args: Any) {
+        super.loadCache(*args)
+    }
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/overridesDefaultValue.fir.kt

@@ -0,0 +1,100 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+class A {
+    public void first(@DefaultValue("42") int arg) {
+    }
+}
+
+// FILE: B.java
+class B {
+    public void first(int arg) {
+    }
+}
+
+// FILE: C.java
+import kotlin.annotations.jvm.internal.*;
+
+class C extends A {
+    public void first(@DefaultValue("73") int arg) {
+    }
+}
+
+// FILE: D.java
+import kotlin.internal.*;
+
+class D extends B {
+    public void first(@DefaultValue("37") int arg) {
+    }
+}
+
+// FILE: E.java
+import kotlin.annotations.jvm.internal.*;
+
+class E extends A {
+    public void first(int arg) {
+    }
+}
+
+// FILE: F.kt
+open class F {
+    open fun foo(x: String = "0") {
+    }
+}
+
+// FILE: G.java
+class G extends F {
+    public void foo(String y) {
+    }
+}
+
+// FILE: K.java
+import kotlin.annotations.jvm.internal.*;
+
+public interface K {
+    public void foo(@DefaultValue("1") String x) { }
+}
+
+// FILE: L.java
+import kotlin.annotations.jvm.internal.*;
+
+public interface L {
+    public void foo(@DefaultValue("1") String x) { }
+}
+
+// FILE: M.java
+public class M implements K, L {
+    public void foo(String x) {
+    }
+}
+
+// FILE: main.kt
+fun main() {
+    val a = A()
+    val c = C()
+    val d = D()
+    val e = E()
+
+    val ac: A = C()
+    val bd: B = D()
+
+    a.first()
+    c.first()
+    ac.first()
+
+    d.<!INAPPLICABLE_CANDIDATE!>first<!>()
+    bd.<!INAPPLICABLE_CANDIDATE!>first<!>()
+
+    e.<!INAPPLICABLE_CANDIDATE!>first<!>()
+
+    val g = G()
+    g.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    g.foo("ok")
+
+    val m = M()
+    m.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+
+}
+

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/overridesParameterName.fir.kt

@@ -0,0 +1,98 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+class A {
+    public void call(@ParameterName("foo") String arg) {
+    }
+}
+
+// FILE: B.java
+import kotlin.annotations.jvm.internal.*;
+
+class B extends A {
+    public void call(@ParameterName("bar") String arg) {
+    }
+}
+
+// FILE: C.java
+
+class C extends A {
+    public void call(String arg) {
+    }
+}
+
+// FILE: D.kt
+open class D {
+    open fun call(foo: String) {
+    }
+}
+
+// FILE: E.java
+import kotlin.annotations.jvm.internal.*;
+
+class E extends D {
+    public void call(@ParameterName("baz") String bar) {
+    }
+}
+
+// FILE: F.java
+class F extends D {
+    public void call(String baaam) {
+    }
+}
+
+
+// FILE: G.java
+import kotlin.annotations.jvm.internal.*;
+
+class G {
+    public void foo(String bar, @ParameterName("foo") String baz) {
+    }
+}
+
+// FILE: H.java
+class H extends G {
+    public void foo(String baz, String bam) {
+    }
+}
+
+// FILE: test.kt
+fun main() {
+    val a = A()
+    val b = B()
+    val c = C()
+
+    a.<!INAPPLICABLE_CANDIDATE!>call<!>(foo = "hello")
+    a.call(arg = "hello")
+    a.call("hello")
+
+    b.<!INAPPLICABLE_CANDIDATE!>call<!>(foo = "hello")
+    b.call(arg = "hello")
+    b.<!INAPPLICABLE_CANDIDATE!>call<!>(bar = "hello")
+    b.call("hello")
+
+    c.<!INAPPLICABLE_CANDIDATE!>call<!>(foo = "hello")
+    c.call(arg = "hello")
+    c.call("hello")
+
+    val e = E()
+    val f = F()
+
+    e.<!INAPPLICABLE_CANDIDATE!>call<!>(foo = "hello")
+    e.call(bar = "hello")
+    e.<!INAPPLICABLE_CANDIDATE!>call<!>(baz = "hello")
+    e.call("hello")
+
+    f.<!INAPPLICABLE_CANDIDATE!>call<!>(foo = "hello")
+    f.call(baaam = "hello")
+    f.call("hello")
+
+    val g = G()
+    val h = H()
+    g.<!INAPPLICABLE_CANDIDATE!>foo<!>("ok", foo = "hohoho")
+    g.foo("ok", "hohoho")
+    h.<!INAPPLICABLE_CANDIDATE!>foo<!>("ok", foo = "hohoho")
+    h.foo("ok", "hohoho")
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/reorderedParameterNames.fir.kt

@@ -0,0 +1,17 @@
+
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+import kotlin.annotations.jvm.internal.*;
+
+public class A {
+    public void connect(@ParameterName("host") String host, @ParameterName("port") int port) {
+    }
+}
+
+// FILE: test.kt
+fun main() {
+    val test = A()
+    test.connect("127.0.0.1", 8080)
+    test.connect(host = "127.0.0.1", port = 8080)
+    test.connect(port = 8080, host = "127.0.0.1")
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/sameParameterName.fir.kt

@@ -0,0 +1,17 @@
+
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+import kotlin.annotations.jvm.internal.*;
+
+public class A {
+    public void same(@ParameterName("ok") String first, @ParameterName("ok") String second) {
+    }
+}
+
+// FILE: test.kt
+fun main() {
+    val test = A()
+    test.same("hello", "world")
+    test.<!INAPPLICABLE_CANDIDATE!>same<!>(ok = "hello", ok = <!UNRESOLVED_REFERENCE!>world<!>)
+    test.<!INAPPLICABLE_CANDIDATE!>same<!>("hello", ok = "world")
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/specialCharsParameterName.fir.kt

@@ -0,0 +1,24 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+import kotlin.annotations.jvm.internal.*;
+import kotlin.internal.*;
+
+public class A {
+    public void dollarName(@ParameterName("$") String host) {
+    }
+
+    public void numberName(@ParameterName("42") String field) {
+    }
+}
+
+// FILE: test.kt
+fun main() {
+    val test = A()
+    test.<!INAPPLICABLE_CANDIDATE!>dollarName<!>(`$` = "hello")
+    test.dollarName("hello")
+    test.dollarName(host = "hello")
+
+    test.<!INAPPLICABLE_CANDIDATE!>numberName<!>(`42` = "world")
+    test.numberName("world")
+    test.numberName(field = "world")
+}

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/stableParameterName.fir.kt

@@ -0,0 +1,20 @@
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+import kotlin.annotations.jvm.internal.*;
+
+
+public class A {
+    public void foo(@ParameterName("hello") String world) {}
+}
+
+// FILE: B.kt
+
+class B : A() {
+    override fun foo(hello: String) {}
+}
+
+// FILE: C.kt
+
+class C : A() {
+}
+

compiler/testData/diagnostics/tests/j+k/signatureAnnotations/staticMethodWithDefaultValue.fir.kt

@@ -0,0 +1,17 @@
+// IGNORE_BACKEND: JS, NATIVE
+
+// FILE: A.java
+// ANDROID_ANNOTATIONS
+
+import kotlin.annotations.jvm.internal.*;
+
+class A {
+    public static String withDefault(@DefaultValue("OK") String arg) {
+        return arg;
+    }
+}
+
+// FILE: test.kt
+fun box(): String {
+    return A.withDefault();
+}