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

2019-12-11 16:16:22 +03:00
parent e9c02a1cca
commit 2536fa0cd5
4578 changed files with 104067 additions and 1 deletions
@@ -0,0 +1,6 @@
+fun foo(vararg t : String) = ""
+fun foo(vararg t : Int) = ""
+
+fun test() {
+    foo()
+}
@@ -0,0 +1,9 @@
+fun main(d : D) {
+    d.from("")
+    d.from(1)
+}
+
+class D {
+    fun from(vararg a : Any){}
+    fun from(vararg a : String){}
+}
@@ -0,0 +1,19 @@
+// FILE: kotlin.kt
+fun main(j : C, s : Array<String?>) {
+    j.from()
+    j.from("")
+    j.from("", "")
+    j.<!AMBIGUITY!>from<!>("", "", "")
+
+    j.<!AMBIGUITY!>from<!>("", *s) // This should not be an ambiguity, see KT-1842
+    j.from(*s)
+}
+
+// FILE: C.java
+public class C {
+    void from() {}
+    void from(String s) {}
+    void from(String s, String s1) {}
+    void from(String... s) {}
+    void from(String s1, String... s) {}
+}
@@ -0,0 +1,10 @@
+fun foo0() : String = "noarg"
+
+fun foo0(vararg t : Int) : String = "vararg"
+
+fun test0() {
+    foo0()
+    foo0(1)
+    val a = IntArray(0)
+    foo0(*a)
+}
@@ -0,0 +1,66 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS:-UNUSED_PARAMETER
+
+// KT-9883 prohibit using spread operator for nullable value
+
+// FILE: A.java
+
+public class A {
+    public void foo(int x, String ... args) {}
+    public static String[] ar;
+}
+
+// FILE: J.java
+
+public class J {
+    public interface Invoke {
+        void invoke(String ...args);
+    }
+
+    public static Invoke staticFun;
+}
+
+// FILE: 1.kt
+val args: Array<String>? = null
+
+fun bar(x: Int, vararg s: String) {}
+
+fun baz(s: String) {}
+
+fun getArr(): Array<String>? = null
+
+fun f() {
+    A().foo(1, *args)
+    bar(2, *args)
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(*args)
+}
+
+fun g(args: Array<String>?) {
+
+    if (args != null) {
+        A().foo(1, *args)
+    }
+    A().foo(1, *A.ar)
+}
+
+class B {
+    var args: Array<String>? = null
+}
+
+fun h(b: B) {
+    if (b.args != null) {
+        A().foo(1, *b.args)
+    }
+}
+
+fun k() {
+    A().foo(1, *getArr())
+    bar(2, *getArr())
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(*getArr())
+}
+
+fun invokeTest(goodArgs: Array<String>) {
+    J.staticFun(*goodArgs)
+    J.staticFun(*args)
+    J.staticFun(*args ?: null)
+}
@@ -0,0 +1,9 @@
+fun foo1(a : Int) : String = "noarg"
+
+fun foo1(a : Int, vararg t : Int) : String = "vararg"
+
+fun test1() {
+    foo1(1)
+    val a = IntArray(0)
+    foo1(1, *a)
+}
@@ -0,0 +1,26 @@
+// !LANGUAGE: -ProhibitNonConstValuesAsVarargsInAnnotations, -ProhibitAssigningSingleElementsToVarargsInNamedForm
+
+val nonConstArray = longArrayOf(0)
+fun nonConstFun(): LongArray = TODO()
+
+fun nonConstLong(): Long = TODO()
+
+annotation class Anno(vararg val value: Long)
+
+@Anno(value = nonConstArray)
+fun foo1() {}
+
+@Anno(value = nonConstFun())
+fun foo2() {}
+
+@Anno(value = longArrayOf(nonConstLong()))
+fun foo3() {}
+
+@Anno(value = [nonConstLong()])
+fun foo4() {}
+
+@Anno(value = *nonConstArray)
+fun bar1() {}
+
+@Anno(*nonConstArray)
+fun bar2() {}
@@ -0,0 +1,26 @@
+// !LANGUAGE: +ProhibitNonConstValuesAsVarargsInAnnotations, +ProhibitAssigningSingleElementsToVarargsInNamedForm
+
+val nonConstArray = longArrayOf(0)
+fun nonConstFun(): LongArray = TODO()
+
+fun nonConstLong(): Long = TODO()
+
+annotation class Anno(vararg val value: Long)
+
+@Anno(value = nonConstArray)
+fun foo1() {}
+
+@Anno(value = nonConstFun())
+fun foo2() {}
+
+@Anno(value = longArrayOf(nonConstLong()))
+fun foo3() {}
+
+@Anno(value = [nonConstLong()])
+fun foo4() {}
+
+@Anno(value = *nonConstArray)
+fun bar1() {}
+
+@Anno(*nonConstArray)
+fun bar2() {}
@@ -0,0 +1,46 @@
+// !WITH_NEW_INFERENCE
+// !LANGUAGE: +ArrayLiteralsInAnnotations, +AssigningArraysToVarargsInNamedFormInAnnotations
+
+// FILE: JavaAnn.java
+
+@interface JavaAnn {
+    String[] value() default {};
+    String[] path() default {};
+}
+
+// FILE: test.kt
+
+annotation class Ann(vararg val s: String)
+
+@Ann(s = arrayOf())
+fun test1() {}
+
+@Ann(s = intArrayOf())
+fun test2() {}
+
+@Ann(s = arrayOf(1))
+fun test3() {}
+
+@Ann("value1", "value2")
+fun test4() {}
+
+@Ann(s = ["value"])
+fun test5() {}
+
+@JavaAnn(value = arrayOf("value"))
+fun jTest1() {}
+
+@JavaAnn(value = ["value"])
+fun jTest2() {}
+
+@JavaAnn(value = ["value"], path = ["path"])
+fun jTest3() {}
+
+
+annotation class IntAnn(vararg val i: Int)
+
+@IntAnn(i = [1, 2])
+fun foo1() {}
+
+@IntAnn(i = intArrayOf(0))
+fun foo2() {}
@@ -0,0 +1,30 @@
+// !LANGUAGE: +ArrayLiteralsInAnnotations, +AssigningArraysToVarargsInNamedFormInAnnotations, +ProhibitAssigningSingleElementsToVarargsInNamedForm
+
+// FILE: JavaAnn.java
+
+@interface JavaAnn {
+    String[] value() default {};
+    String[] path() default {};
+}
+
+// FILE: test.kt
+
+annotation class Ann(vararg val s: String)
+
+@Ann(s = "value")
+fun test1() {}
+
+@Ann(s = *arrayOf("value"))
+fun test2() {}
+
+@Ann(s = *["value"])
+fun test3() {}
+
+@JavaAnn(value = "value")
+fun test4() {}
+
+@JavaAnn("value", path = arrayOf("path"))
+fun test5() {}
+
+@JavaAnn("value", path = ["path"])
+fun test6() {}
@@ -0,0 +1,30 @@
+// !LANGUAGE: +ArrayLiteralsInAnnotations, +AssigningArraysToVarargsInNamedFormInAnnotations, -ProhibitAssigningSingleElementsToVarargsInNamedForm
+
+// FILE: JavaAnn.java
+
+@interface JavaAnn {
+    String[] value() default {};
+    String[] path() default {};
+}
+
+// FILE: test.kt
+
+annotation class Ann(vararg val s: String)
+
+@Ann(s = "value")
+fun test1() {}
+
+@Ann(s = *arrayOf("value"))
+fun test2() {}
+
+@Ann(s = *["value"])
+fun test3() {}
+
+@JavaAnn(value = "value")
+fun test4() {}
+
+@JavaAnn("value", path = arrayOf("path"))
+fun test5() {}
+
+@JavaAnn("value", path = ["path"])
+fun test6() {}
@@ -0,0 +1,60 @@
+// !LANGUAGE: +AssigningArraysToVarargsInNamedFormInAnnotations, +ProhibitAssigningSingleElementsToVarargsInNamedForm
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+fun foo(vararg s: Int) {}
+
+open class Cls(vararg p: Long)
+
+fun test(i: IntArray) {
+    foo(s = 1)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(s = i)
+    foo(s = *i)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(s = intArrayOf(1))
+    foo(s = *intArrayOf(1))
+    foo(1)
+
+    Cls(p = 1)
+
+    class Sub : Cls(p = 1)
+
+    val c = object : Cls(p = 1) {}
+
+    foo(s = *intArrayOf(elements = 1))
+}
+
+
+fun anyFoo(vararg a: Any) {}
+
+fun testAny() {
+    anyFoo(a = "")
+    anyFoo(a = arrayOf(""))
+    anyFoo(a = *arrayOf(""))
+}
+
+fun <T> genFoo(vararg t: T) {}
+
+fun testGen() {
+    genFoo<Int>(t = 1)
+    genFoo<Int?>(t = null)
+    genFoo<Array<Int>>(t = arrayOf())
+    genFoo<Array<Int>>(t = *arrayOf(arrayOf()))
+
+    genFoo(t = "")
+    genFoo(t = arrayOf(""))
+    genFoo(t = *arrayOf(""))
+}
+
+fun manyFoo(vararg v: Int) {}
+fun manyFoo(vararg s: String) {}
+
+fun testMany(a: Any) {
+    manyFoo(v = 1)
+    manyFoo(s = "")
+
+    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(a)
+    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(v = a)
+    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(s = a)
+    manyFoo(v = a as Int)
+    manyFoo(s = a as String)
+}
@@ -0,0 +1,60 @@
+// !LANGUAGE: +AssigningArraysToVarargsInNamedFormInAnnotations, -ProhibitAssigningSingleElementsToVarargsInNamedForm
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+fun foo(vararg s: Int) {}
+
+open class Cls(vararg p: Long)
+
+fun test(i: IntArray) {
+    foo(s = 1)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(s = i)
+    foo(s = *i)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(s = intArrayOf(1))
+    foo(s = *intArrayOf(1))
+    foo(1)
+
+    Cls(p = 1)
+
+    class Sub : Cls(p = 1)
+
+    val c = object : Cls(p = 1) {}
+
+    foo(s = *intArrayOf(elements = 1))
+}
+
+
+fun anyFoo(vararg a: Any) {}
+
+fun testAny() {
+    anyFoo(a = "")
+    anyFoo(a = arrayOf(""))
+    anyFoo(a = *arrayOf(""))
+}
+
+fun <T> genFoo(vararg t: T) {}
+
+fun testGen() {
+    genFoo<Int>(t = 1)
+    genFoo<Int?>(t = null)
+    genFoo<Array<Int>>(t = arrayOf())
+    genFoo<Array<Int>>(t = *arrayOf(arrayOf()))
+
+    genFoo(t = "")
+    genFoo(t = arrayOf(""))
+    genFoo(t = *arrayOf(""))
+}
+
+fun manyFoo(vararg v: Int) {}
+fun manyFoo(vararg s: String) {}
+
+fun testMany(a: Any) {
+    manyFoo(v = 1)
+    manyFoo(s = "")
+
+    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(a)
+    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(v = a)
+    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(s = a)
+    manyFoo(v = a as Int)
+    manyFoo(s = a as String)
+}
@@ -0,0 +1,13 @@
+// FILE: kotlin.kt
+fun foo() {
+  JavaClass()
+  JavaClass("")
+}
+
+// FILE: JavaClass.java
+
+public class JavaClass {
+    public JavaClass() {  }
+
+    public JavaClass(String... ss) {  }
+}
@@ -0,0 +1,12 @@
+// FILE: JavaClass.java
+public class JavaClass {
+    void from(String s) {}
+    void from(String... s) {}
+}
+
+// FILE: kotlin.kt
+fun main() {
+    JavaClass().from()
+    JavaClass().from("")
+    JavaClass().from("", "")
+}
@@ -0,0 +1,5 @@
+class A(vararg t : Int) {
+    init {
+        val t1 : IntArray = t
+    }
+}
@@ -0,0 +1,5 @@
+class A(vararg val t : Int) {
+    init {
+        val t1 : IntArray = t
+    }
+}
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun printAll(vararg a : Any) {}
+
+fun main(args: Array<String>) {
+    <!INAPPLICABLE_CANDIDATE!>printAll<!>(*args) // Shouldn't be an error
+}
@@ -0,0 +1,17 @@
+// KT-422 Tune literal typing rules so that varargs overloaded by primitive types work
+
+fun <T> foo(vararg t : T) = t
+fun foo(vararg a: Int) = a
+fun foo(vararg a: Long) = a
+
+fun test() {
+    foo(1, 2, 3) // Error, but should be foo of ints
+}
+
+fun <T> array(vararg elements : T) = elements
+fun array(vararg elements : Int) = elements
+
+fun test1() {
+    array("A", "A")
+    array(1, 1)
+}
@@ -0,0 +1,49 @@
+// !WITH_NEW_INFERENCE
+// !LANGUAGE: +ArrayLiteralsInAnnotations, -AssigningArraysToVarargsInNamedFormInAnnotations
+
+// FILE: JavaAnn.java
+
+@interface JavaAnn {
+    String[] value() default {};
+    String[] path() default {};
+}
+
+// FILE: test.kt
+
+annotation class Ann(vararg val s: String)
+
+@Ann(s = arrayOf())
+fun test1() {}
+
+@Ann(s = intArrayOf())
+fun test2() {}
+
+@Ann(s = arrayOf(1))
+fun test3() {}
+
+@Ann(s = ["value"])
+fun test5() {}
+
+@JavaAnn(value = arrayOf("value"))
+fun jTest1() {}
+
+@JavaAnn(value = ["value"])
+fun jTest2() {}
+
+@JavaAnn(value = ["value"], path = ["path"])
+fun jTest3() {}
+
+annotation class IntAnn(vararg val i: Int)
+
+@IntAnn(i = [1, 2])
+fun foo1() {}
+
+@IntAnn(i = intArrayOf(0))
+fun foo2() {}
+
+fun foo(vararg i: Int) {}
+
+@Ann(s = "value")
+fun dep1() {
+    foo(i = 1)
+}
@@ -0,0 +1,20 @@
+// !LANGUAGE: +ProhibitAssigningSingleElementsToVarargsInNamedForm
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+annotation class Anno1(vararg val s: String)
+annotation class Anno2(vararg val i: Int)
+
+@Anno1(s = "foo")
+@Anno2(i = *intArrayOf(1))
+fun f1() {}
+
+@Anno1(s = ["foo"])
+@Anno2(i = intArrayOf(1))
+fun f2() {}
+
+fun foo(vararg ints: Int) {}
+
+fun test() {
+    foo(ints = 1)
+    foo(ints = *intArrayOf(1))
+}
@@ -0,0 +1,6 @@
+class My {
+    var x: String = ""
+        set(vararg value) {
+            x = value
+        }
+}
@@ -0,0 +1,5 @@
+package test
+
+class CompositeIterator<T>(vararg iterators: java.util.Iterator<T>){
+    val iteratorsIter = iterators.iterator()
+}
@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun testVarargOfNothing(vararg v: Nothing) {}
+
+fun testVarargOfNNothing(vararg v: Nothing?) {}
+
+fun <T : Nothing?> testVarargOfT(vararg v: T) {}
+
+fun outer() {
+    fun testVarargOfNothing(vararg v: Nothing) {}
+
+    fun testVarargOfNNothing(vararg v: Nothing?) {}
+
+    fun <T : Nothing?> testVarargOfT(vararg v: T) {}
+}
@@ -0,0 +1,29 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun stringVararg(vararg args: String) {}
+fun intVararg(vararg args: Int) {}
+fun numberVararg(vararg args: Number) {}
+
+fun useStrings(fn: (String, String, String) -> Unit) = fn("foo", "bar", "boo")
+fun useStringArray(fn: (Array<String>) -> Unit) = fn(arrayOf("foo", "bar", "boo"))
+
+fun useIntArray(fn: (Array<Int>) -> Unit) = fn(arrayOf(1, 2, 3))
+fun usePrimitiveIntArray(fn: (IntArray) -> Unit) = fn(intArrayOf(4, 5, 6))
+
+fun useMixedStringArgs1(fn: (String, Array<String>) -> Unit) = fn("foo", arrayOf("bar", "baz"))
+fun useMixedStringArgs2(fn: (Array<String>, String) -> Unit) = fn(arrayOf("foo", "bar"), "baz")
+fun useMixedStringArgs3(fn: (String, Array<String>, String) -> Unit) = fn("foo", arrayOf("bar", "baz"), "boo")
+fun useTwoStringArrays(fn: (Array<String>, Array<String>) -> Unit) = fn(arrayOf("foo", "bar"), arrayOf("baz", "boo"))
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>useStrings<!>(::stringVararg)
+    useStringArray(::stringVararg)
+    <!INAPPLICABLE_CANDIDATE!>useIntArray<!>(::numberVararg)
+    usePrimitiveIntArray(::intVararg)
+    <!INAPPLICABLE_CANDIDATE!>useIntArray<!>(::intVararg)
+    <!INAPPLICABLE_CANDIDATE!>useMixedStringArgs1<!>(::stringVararg)
+    <!INAPPLICABLE_CANDIDATE!>useMixedStringArgs2<!>(::stringVararg)
+    <!INAPPLICABLE_CANDIDATE!>useMixedStringArgs3<!>(::stringVararg)
+    <!INAPPLICABLE_CANDIDATE!>useTwoStringArrays<!>(::stringVararg)
+}
@@ -0,0 +1,13 @@
+fun f(vararg t : Int, f : ()->Unit) {
+}
+
+fun test() {
+    f {}
+    f() {}
+    f(1) {
+
+    }
+    f(1, 2) {
+
+    }
+}
@@ -0,0 +1,13 @@
+// !CHECK_TYPE
+
+fun test(vararg a: String) {
+    a checkType { <!UNRESOLVED_REFERENCE!>_<!><Array<out String>>() }
+
+    foo(a) checkType { <!UNRESOLVED_REFERENCE!>_<!><Array<out String>>() }
+}
+
+fun <T> test1(vararg t: T) {
+    t checkType { <!UNRESOLVED_REFERENCE!>_<!><Array<out T>>() }
+}
+
+fun <T> foo(a: Array<T>): Array<T> = a
@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun bar(vararg a: String) {}
+
+fun test2(a: Array<String>, b: Array<out String>) {
+    bar(*a)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(*b)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>("", *a, *b, "")
+}
@@ -0,0 +1,10 @@
+// !CHECK_TYPE
+
+fun <T: Any> foo(vararg ts: T): T? = null
+
+class Pair<A>(a: A)
+
+fun test() {
+    val v = foo(Pair(1))
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(v) // check that it is not error type
+}