[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,11 @@
+// FILE: f1.kt
+package test
+
+class A
+class F1
+
+// FILE: f2.kt
+package test
+
+class A
+class F2
@@ -0,0 +1,4 @@
+package foo
+
+val Int.foo: Int get() = 2
+val Int.foo: Int get() = 3
@@ -0,0 +1,7 @@
+fun test0(f: (String, String) -> Unit) {
+    f("", "")
+}
+
+fun test1(f: (a: Int, a: Int) -> Unit) {
+    f(1, 1)
+}
@@ -0,0 +1,3 @@
+enum class A {
+    name
+}
@@ -0,0 +1,10 @@
+// FILE: test1.kt
+class A
+class B(val x: Int) {
+    constructor(x: Int, y: Int): this(x + y)
+}
+
+// FILE: test2.kt
+fun A() {}
+fun B(x: Int) = x
+fun B(x: Int, y: Int) = x + y
@@ -0,0 +1,7 @@
+// FILE: f.kt
+package a
+class b {}
+// FILE: f.kt
+package a.b
+// FILE: f.kt
+package a.b
@@ -0,0 +1,12 @@
+package kt2247
+
+class B {
+    companion object {
+        class Y {
+        }
+    }
+
+    class Y {
+    }
+
+}
@@ -0,0 +1,11 @@
+enum class E {
+    FIRST,
+
+    SECOND;
+
+    companion object {
+        class FIRST
+
+        val SECOND = this
+    }
+}
@@ -0,0 +1,9 @@
+class A() {
+    val a: Int = 1
+    fun a(): Int = 2
+}
+
+class B() {
+    fun b(): Int = 2
+    val b: Int = 1
+}
@@ -0,0 +1,13 @@
+public class A() {
+    public val FOO: String = "test"
+
+    public class FOO() { }
+}
+
+public class B() {
+   companion object {
+      public val FOO: String = "test"
+      
+      public class FOO() { }
+   }
+}
@@ -0,0 +1,6 @@
+class A {
+    companion object B {
+        class G
+        val G = 1
+    }
+}
@@ -0,0 +1,9 @@
+// FILE: a.kt
+val a : Int = 1
+fun f() {
+}
+
+// FILE: b.kt
+val a : Int = 1
+fun f() {
+}
@@ -0,0 +1,4 @@
+// KT-9733 No error shown for 2 "main" functions in the same file
+
+fun main(args: Array<String>) {}
+fun main(args: Array<String>) {}
@@ -0,0 +1,5 @@
+// FILE: a.kt
+fun main() {}
+
+// FILE: b.kt
+fun main() {}
@@ -0,0 +1,5 @@
+// FILE: a.kt
+fun main() {}
+
+// FILE: b.kt
+fun main() {}
@@ -0,0 +1,7 @@
+// FILE: a.kt
+fun main() {}
+
+suspend fun main(args: Array<String>) {}
+
+// FILE: b.kt
+fun main() {}
@@ -0,0 +1,7 @@
+// !LANGUAGE: -ExtendedMainConvention
+
+// FILE: a.kt
+fun main() {}
+
+// FILE: b.kt
+fun main() {}
@@ -0,0 +1,5 @@
+// FILE: a.kt
+suspend fun main() {}
+
+// FILE: b.kt
+suspend fun main() {}
@@ -0,0 +1,7 @@
+// !LANGUAGE: -ExtendedMainConvention
+
+// FILE: a.kt
+suspend fun main(args: Array<String>) {}
+
+// FILE: b.kt
+suspend fun main(args: Array<String>) {}
@@ -0,0 +1,15 @@
+// FILE: f.kt
+package redeclarations
+  object A {
+    val x : Int = 0
+
+    val A = 1
+  }
+
+  class A {}
+
+  val A = 1
+
+// FILE: f.kt
+  package redeclarations.A
+    class A {}
@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -DUPLICATE_CLASS_NAMES
+// KT-3525
+object B {
+    class C
+    class C
+
+    val a : Int = 1
+    val a : Int = 1
+}
@@ -0,0 +1,6 @@
+fun <T, T> Pair() {}
+
+class P<T, T> {}
+
+val <T, T> T.foo : Int
+    get() = 1
@@ -0,0 +1,49 @@
+// FILE: a.kt
+package a
+
+interface A
+interface B : A
+
+private fun validFun() {}
+private val validVal = 1
+
+private fun invalidFun0() {}
+private val invalidProp0 = 1
+
+// NB invalidFun0 and invalidProp0 are conflicting overloads, since the following is an ambiguity:
+fun useInvalidFun0() = invalidFun0()
+fun useInvalidProp0() = invalidProp0
+
+private fun invalidFun1() {}
+private fun invalidFun1() {}
+
+private fun invalidFun2() {}
+public fun invalidFun2() {}
+
+public fun invalidFun3() {}
+
+private fun invalidFun4() {}
+public fun invalidFun4() {}
+
+public fun validFun2(a: A) = a
+public fun validFun2(b: B) = b
+
+// FILE: b.kt
+package a
+
+private fun validFun() {}
+private val validVal = 1
+
+private fun invalidFun0() {}
+
+private val invalidProp0 = 1
+
+internal fun invalidFun3() {}
+internal fun invalidFun4() {}
+
+// FILE: c.kt
+package a
+
+public fun invalidFun0() {}
+
+public val invalidProp0 = 1
@@ -0,0 +1,21 @@
+fun Foo() = 42
+
+object Foo {
+    fun Bar() = 239
+
+    object Bar
+}
+
+
+
+fun En() = 239
+
+enum class En {
+    ENTRY,
+
+    SUBCLASS { };
+
+    fun ENTRY() = 42
+
+    fun SUBCLASS() = <!AMBIGUITY!>ENTRY<!>()
+}
@@ -0,0 +1,13 @@
+val Test1 = null
+class Test1
+
+val Test2 = null
+interface Test2
+
+val Test3 = null
+object Test3
+
+val Test4 = null
+class Test4
+interface Test4
+object Test4
@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
+class C(val x: Int)
+
+typealias CC = C
+
+fun CC(x: Int) = x
+
+class Outer {
+    class C(val x: Int)
+
+    typealias CC = C
+
+    fun CC(x: Int) = x
+}
@@ -0,0 +1,18 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
+// FILE: file1.kt
+class SomeClass
+
+typealias SomeClass = Any
+typealias SomeClass = Any
+typealias SomeClass = Any
+
+class Outer {
+    class Nested
+
+    typealias Nested = Any
+    typealias Nested = Any
+    typealias Nested = Any
+}
+
+// FILE: file2.kt
+typealias SomeClass = Any
@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY
+// FILE: file1.kt
+typealias Test = String
+
+val Test = 42
+
+class Outer {
+    typealias Test = String
+
+    val Test = 42
+}
+
+typealias Test2 = String
+
+// FILE: file2.kt
+val Test2 = 42
@@ -0,0 +1,6 @@
+interface Test1<T, T>
+interface Test2<X, Y, X>
+
+class Outer<T> {
+    interface TestNested<T>
+}
@@ -0,0 +1,27 @@
+//KT-2418 Front-end allows enum constants with same name
+
+package kt2418
+
+enum class A {
+    FOO,
+    FOO
+}
+
+enum class B {
+    FOO;
+    
+    fun FOO() {}
+}
+
+enum class C {
+    FOO;
+    
+    val FOO = 1
+}
+
+enum class D {
+    FOO;
+    
+    class FOO {}
+}
+
@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -DUPLICATE_CLASS_NAMES
+//KT-2438 Prohibit inner classes with the same name
+
+package kt2438
+
+class B {
+    class C
+    class C
+}
+
+
+
+class A {
+    class B
+    
+    companion object {
+        class B
+        class B
+    }
+    
+    class B
+}
@@ -0,0 +1,37 @@
+val a : Int = 1
+val a : Int = 1
+val a : Int = 1
+
+val b : Int = 1
+val b : Int = 1
+val b : Int = 1
+val b : Int = 1
+
+fun foo() {} // and here too
+fun foo() {} // and here
+fun foo() {} // and here
+fun foo() {} // and here
+
+fun bar() {} // and here
+fun bar() {} // and here
+fun bar() {} // and here
+
+class A {
+    val a : Int = 1
+    val a : Int = 1
+    val a : Int = 1
+
+    val b : Int = 1
+    val b : Int = 1
+    val b : Int = 1
+    val b : Int = 1
+
+    fun foo() {} // and here too
+    fun foo() {} // and here
+    fun foo() {} // and here
+    fun foo() {} // and here
+
+    fun bar() {} // and here
+    fun bar() {} // and here
+    fun bar() {} // and here
+}
@@ -0,0 +1,31 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Outer {
+    inner class Test1
+    inner class Test2(val x: Int)
+    inner class Test3(val x: Any)
+    inner class Test4<T>(val x: T)
+    inner class Test5(val x: Int) {
+        constructor() : this(0)
+        private constructor(z: String) : this(z.length)
+    }
+
+    class TestNested
+
+    internal class TestInternal
+    protected class TestProtected
+    private class TestPrivate
+}
+
+fun Outer.Test1() {}
+fun Outer.Test2(x: Int) {}
+fun Outer.Test3(x: String) {}
+fun <T> Outer.Test3(x: T) {}
+fun <T : Number> Outer.Test4(x: T) {}
+fun Outer.Test5() {}
+fun Outer.Test5(z: String) {}
+
+fun Outer.TestNested() {}
+fun Outer.TestInternal() {}
+fun Outer.TestProtected() {}
+fun Outer.TestPrivate() {}
@@ -0,0 +1,32 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+interface Test1 {
+    fun test1() {}
+}
+fun Test1.test1() {}
+
+interface Test2 {
+    fun test2(x: String) {}
+}
+fun Test2.test2(x: Any) {}
+
+interface Test3 {
+    fun test3(x: Any) {}
+}
+fun Test3.test3(x: String) {}
+fun <T : Any?> Test3.test3(x: T) {}
+
+interface Test4 {
+    fun <T> test4(x: T) {}
+}
+fun Test4.test4(x: String) {}
+
+interface Test5 {
+    fun <T> test5(x: T) {}
+}
+fun <T : Number> Test5.test5(x: T) {}
+
+interface Test6 {
+    fun <T : List<Any>> test6(x: T) {}
+}
+fun <T : Set<Any>> Test6.test6(x: T) {}
@@ -0,0 +1,18 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+interface WithInvoke {
+    operator fun invoke()
+    operator fun invoke(s: String)
+    operator fun <T> invoke(x: T, y: Int)
+    fun invoke(i: Int)
+}
+
+interface Test1 {
+    val test1: WithInvoke
+}
+
+fun Test1.test1() {}
+fun Test1.test1(s: String) {}
+fun Test1.test1(i: Int) {}
+fun Test1.test1(x: Any, y: Int) {}
+fun <T : Number> Test1.test1(x: T, y: Int) {}
@@ -0,0 +1,5 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+data class DataClass(val x: Int)
+
+fun DataClass.component1() = 42
@@ -0,0 +1,5 @@
+class C {
+    fun Int.foo() {}
+}
+
+fun C.foo() {}
@@ -0,0 +1,7 @@
+interface G<T> {
+    fun foo()
+    val bar: Int
+}
+
+fun G.foo() {}
+val G.bar: Int get() = 42
@@ -0,0 +1,7 @@
+interface Test {
+    fun foo()
+    val bar: Int
+}
+
+fun Test?.foo() {}
+val Test?.bar: Int get() = 42
@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+interface Test1 {
+    val test1: Int
+}
+val Test1.test1: Int get() = 42
+
+interface Test2 {
+    var test2: Int
+}
+val Test2.test2: Int get() = 42
+
+interface Test3 {
+    val test3: Int
+}
+var Test3.test3: Int get() = 42; set(v) {}
+
+interface Test4 {
+    val test4: Int
+}
+var Test4.test4: Int get() = 42; set(v) {}
+
@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+interface IBase {
+    fun foo()
+    val bar: Int
+}
+
+object Impl : IBase {
+    override fun foo() {}
+    override val bar: Int get() = 42
+}
+
+object Test : IBase by Impl
+
+fun Test.foo() {}
+val Test.bar: Int get() = 42
@@ -0,0 +1,47 @@
+class WithPublicInvoke {
+    public operator fun invoke() {}
+}
+
+class WithInternalInvoke {
+    internal operator fun invoke() {}
+}
+
+class WithProtectedInvoke {
+    protected operator fun invoke() {}
+}
+
+class WithPrivateInvoke {
+    private operator fun invoke() {}
+}
+
+class Test {
+    public fun publicFoo() {}
+    internal fun internalFoo() {}
+    protected fun protectedFoo() {}
+    private fun privateFoo() {}
+
+    public val publicVal = 42
+    internal val internalVal = 42
+    protected val protectedVal = 42
+    private val privateVal = 42
+
+    public val withPublicInvoke = WithPublicInvoke()
+    public val withInternalInvoke = WithInternalInvoke()
+    public val withProtectedInvoke = WithProtectedInvoke()
+    public val withPrivateInvoke = WithPrivateInvoke()
+}
+
+private fun Test.publicFoo() {}
+fun Test.internalFoo() {}
+fun Test.protectedFoo() {}
+fun Test.privateFoo() {}
+
+val Test.publicVal: Int get() = 42
+val Test.internalVal: Int get() = 42
+val Test.protectedVal: Int get() = 42
+val Test.privateVal: Int get() = 42
+
+fun Test.withPublicInvoke() {}
+fun Test.wihtInternalInvoke() {}
+fun Test.withProtectedInvoke() {}
+fun Test.withPrivateInvoke() {}
@@ -0,0 +1,7 @@
+interface IFoo {
+    fun foo(i: Int): Int
+    <!INAPPLICABLE_INFIX_MODIFIER!>infix fun bar(i: Int): Int<!>
+}
+
+infix fun IFoo.foo(i: Int) = i
+infix fun IFoo.bar(i: Int) = i
@@ -0,0 +1,7 @@
+interface IFoo {
+    fun foo()
+}
+
+fun outer() {
+    fun IFoo.foo() {}
+}
@@ -0,0 +1,9 @@
+interface IFooBar {
+    fun foo()
+    val bar: Int
+}
+
+class Host {
+    fun IFooBar.foo() {}
+    val IFooBar.bar: Int get() = 42
+}
@@ -0,0 +1,7 @@
+interface Test {
+    fun invoke()
+    operator fun invoke(i: Int): Int
+}
+
+operator fun Test.invoke() {}
+operator fun Test.invoke(i: Int) = i
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+interface Foo
+interface Bar
+
+fun <T> foo(x: T): T where T: Foo, T: Bar {null!!}
+fun foo(x: Foo): Foo {null!!}
+fun foo(x: Bar): Bar {null!!}