[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,9 @@
+// !WITH_NEW_INFERENCE
+package a
+
+fun foo() {
+    val a = <!UNRESOLVED_REFERENCE!>getErrorType<!>()
+    if (a == null) { //no senseless comparison
+
+    }
+}
@@ -0,0 +1,24 @@
+// !DIAGNOSTICS: -DEBUG_INFO_SMARTCAST
+package a
+
+import java.util.Date
+import java.util.Comparator
+
+fun foo() {
+
+    val c: Comparator<Date?> = comparator { date1, date2 ->
+        if (date1 != null && date2 != null) {
+            date1.compareTo(date2) * -11
+        } else {
+            11
+        }
+    }
+}
+
+fun bar(i: Int, a: U) {
+    val r = if (true) i else a
+    val b: Any = r
+}
+
+//from standard library
+public inline fun <T> comparator(fn: (T,T) -> Int): Comparator<T> {}
@@ -0,0 +1,9 @@
+package b
+
+fun main() {
+    var ints : Array<Int?> = arrayOfNulls<Int>(31)
+
+    ints[0] = 4; ints[11] = 5; ints[2] =7
+    for(i in 0..ints.size)
+        ints[i<!SYNTAX!><!>
+}
@@ -0,0 +1,16 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION
+package d
+
+interface A<T>
+
+fun <T> infer(a: A<T>) : T {}
+
+fun test(nothing: Nothing?) {
+    val i = infer(nothing)
+}
+
+fun sum(a : IntArray) : Int {
+<!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (n
+<!SYNTAX!>return<!><!SYNTAX!><!> "?"<!>
+}
@@ -0,0 +1,26 @@
+// !WITH_NEW_INFERENCE
+
+fun test1() {
+    if (<!UNRESOLVED_REFERENCE!>rr<!>) {
+        if (<!UNRESOLVED_REFERENCE!>l<!>) {
+            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>q<!>()
+        }
+        else {
+            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>w<!>()
+        }
+    }
+    else {
+        if (<!UNRESOLVED_REFERENCE!>n<!>) {
+            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>t<!>()
+        }
+        else {
+            <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>u<!>()
+        }
+    }
+}
+
+fun test2(l: List<AA>) {
+    l.<!UNRESOLVED_REFERENCE!>map<!> {
+        <!UNRESOLVED_REFERENCE!>it<!>!!
+    }
+}
@@ -0,0 +1,8 @@
+// !WITH_NEW_INFERENCE
+package bar
+
+fun main() {
+    class Some
+
+    Some[<!SYNTAX!><!>] <!UNRESOLVED_REFERENCE!>names<!> <!UNRESOLVED_REFERENCE!><!SYNTAX!>=<!> ["ads"]<!>
+}
@@ -0,0 +1,17 @@
+package h
+
+class Square() {
+  var size : Double =
+  <!UNRESOLVED_REFERENCE!>set<!>(<!UNRESOLVED_REFERENCE!>value<!>) {
+    <!SYNTAX!>$area<!> <!SYNTAX!>= size * size<!>
+  }
+
+  var area : Double
+  private set
+}
+
+fun main() {
+  val s = Square()
+
+  s.size = 2.0
+}
@@ -0,0 +1,8 @@
+package c
+
+fun demo() {
+    val bar = 51
+    fun map(f : <!SYNTAX!><!SYNTAX!><!>fun<!>
+    val foo = 3;
+    bar <!INAPPLICABLE_CANDIDATE!>+<!> map { foo }
+}
@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun foo(x: Any) {
+    x.<!SYNTAX!><!>
+    val foo = 1
+
+    x.<!SYNTAX!><!>
+    fun bar() = 2
+
+    x.
+    fun String.() = 3
+
+    var a = 24.<!SYNTAX!><!>
+    var b = 42.0
+}
+
+class A {
+    val z = "a".<!SYNTAX!><!>
+    val x = 4
+
+    val y = "b".<!SYNTAX!><!>
+    fun baz() = 5
+
+    val q = "c".
+    fun String.() = 6
+
+    var a = 24.<!SYNTAX!><!>
+    var b = 42.0
+}
@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+fun foo(x: Any?) {
+    x ?:<!SYNTAX!><!>
+    val foo = 1
+
+    x ?:<!SYNTAX!><!>
+    fun bar() = 2
+
+    val res: String.() -> Int = null ?:
+    fun String.() = 3
+}
+
+class A {
+    val z = null ?:<!SYNTAX!><!>
+    val x = 4
+
+    val y = null ?:<!SYNTAX!><!>
+    fun baz() = 5
+
+    val q = null ?:
+    fun String.() = 6
+}
@@ -0,0 +1 @@
+fun foo() =<!SYNTAX!><!>
@@ -0,0 +1 @@
+fun<!SYNTAX, SYNTAX!><!>
@@ -0,0 +1 @@
+class A : (categoryName: <!SYNTAX!><!>)<!SYNTAX!><!> <!SYNTAX!><!>{<!SYNTAX!><!>
@@ -0,0 +1,11 @@
+enum class E {
+    A,
+    B,
+    C
+}
+
+fun foo() {
+    val e = E.<!SYNTAX!><!>
+}
+
+
@@ -0,0 +1,3 @@
+package c
+
+val i =<!SYNTAX!><!>
@@ -0,0 +1,3 @@
+package c
+
+val i : String get() =<!SYNTAX!><!>
@@ -0,0 +1,3 @@
+fun test(a: Any) {
+    when (a)<!SYNTAX!><!>
+}
@@ -0,0 +1 @@
+fun bar()
@@ -0,0 +1,11 @@
+// !WITH_NEW_INFERENCE
+package b
+
+fun <T, R> foo(map: Map<T, R>) : R = throw Exception()
+
+fun <F, G> getMap() : Map<F, G> = throw Exception()
+
+fun bar123() {
+    foo(<!INAPPLICABLE_CANDIDATE!>getMap<!>(
+<!SYNTAX!><!>}
+
@@ -0,0 +1,3 @@
+package typeReferenceError
+
+class Pair<<!SYNTAX!><!>:<!UNRESOLVED_REFERENCE!>(val c: <!SYNTAX!><!SYNTAX!><!>fun<!><!SYNTAX!><!> main<!>()
@@ -0,0 +1,43 @@
+// VAL
+class A(
+        val<!SYNTAX!><!>
+        val x: Int,
+        val
+        private<!SYNTAX!><!> val z: Int,
+        val<!SYNTAX!><!>
+)
+
+val<!SYNTAX!><!>
+fun foo() {}
+
+class B {
+    val<!SYNTAX!><!>
+    fun foo() {}
+
+    fun bar() {
+        val<!SYNTAX!><!>
+        fun foo() {}
+    }
+}
+
+// VAR
+class C(
+        var<!SYNTAX!><!>
+        val x: Int,
+        var
+        private<!SYNTAX!><!> val z: Int,
+        var<!SYNTAX!><!>
+)
+
+var<!SYNTAX!><!>
+fun baz() {}
+
+class D {
+    var<!SYNTAX!><!>
+    fun foo() {}
+
+    fun bar() {
+        var<!SYNTAX!><!>
+        fun foo() {}
+    }
+}
@@ -0,0 +1,15 @@
+abstract class A {
+    private val<!SYNTAX!><!>
+    // private is parsed as val's identifier
+    private fun foo1() {
+    }
+
+    private val<!SYNTAX!><!>
+    protected abstract fun foo2()
+
+    private val<!SYNTAX!><!>
+    fun foo3() {
+    }
+
+    private val private<!SYNTAX!><!> fun foo() {}
+}
@@ -0,0 +1,50 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+
+fun println(x: String) {
+}
+
+fun run(block: () -> Unit) {}
+
+val propertyNameOnTheNextLine = 1
+
+fun foo() {
+    val<!SYNTAX!><!>
+    println("abc")
+
+    val<!SYNTAX!><!>
+    run {
+        println("abc")
+    }
+
+    val<!SYNTAX!><!>
+    if (1 == 1) {
+
+    }
+
+    val<!SYNTAX!><!>
+    (1 + 2)
+
+    // `propertyNameOnTheNextLine` parsed as simple name expression
+    val<!SYNTAX!><!>
+    propertyNameOnTheNextLine
+
+    val<!SYNTAX!><!>
+    // comment
+    propertyNameOnTheNextLine
+
+    val<!SYNTAX!><!> /* comment */
+    propertyNameOnTheNextLine
+
+    // Correct properties
+    val
+    property1 = 1
+
+    val
+    propertyWithBy by <!UNRESOLVED_REFERENCE!>lazy<!> { 1 }
+
+    val
+    propertyWithType: Int
+
+    val
+    (<!UNRESOLVED_REFERENCE!>a<!>, <!UNRESOLVED_REFERENCE!>b<!>) = 1
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION
+
+fun test() {
+    "a"."b"::foo
+    "a"."b"::class
+    "a"."b"."c"::foo
+    "a"."b"."c"::class
+}
@@ -0,0 +1,5 @@
+package l
+
+fun test(a: Int) {
+    if (a <!UNRESOLVED_REFERENCE!>in<!><!SYNTAX!><!> ) {} //a is not unresolved
+}
@@ -0,0 +1,30 @@
+package sum
+
+import java.util.*
+fun sum(a : IntArray) : Int {
+    // Write your solution here
+    <!UNRESOLVED_REFERENCE!>res<!> = 0
+    for (e in a)
+        <!UNRESOLVED_REFERENCE, VARIABLE_EXPECTED!>res<!> +=<!SYNTAX!><!>
+}
+fun main() {
+    test(0)
+    test(1, 1)
+    test(-1, -1, 0)
+    test(6, 1, 2, 3)
+    test(6, 1, 1, 1, 1, 1, 1)
+}
+// HELPER FUNCTIONS
+fun test(expectedSum : Int, vararg data : Int) {
+    val actualSum = sum(data)
+    assertEquals(actualSum, expectedSum, "\ndata = ${Arrays.toString(data)}\n" +
+    "sum(data) = ${actualSum}, but must be $expectedSum ")
+}
+fun <T: Any> assertEquals(actual : T?, expected : T?, message : Any? = null) {
+    if (actual != expected) {
+        if (message == null)
+            throw AssertionError()
+        else
+            throw AssertionError(message)
+    }
+}
@@ -0,0 +1,3 @@
+package a
+
+fun foo(a: Any) = a ==<!SYNTAX!><!>
@@ -0,0 +1,14 @@
+fun test1() {
+    try {
+
+    } catch (<!SYNTAX!><!>)<!SYNTAX!><!>
+}
+
+fun test2() {
+    try { }<!SYNTAX!><!>
+}
+
+fun test3() {
+    try {
+    } catch (<!SYNTAX!><!>{}<!SYNTAX!>)<!> {}
+}
@@ -0,0 +1,8 @@
+//KT-1955 Half a file is red on incomplete code
+
+package b
+
+fun foo() {
+    val a = 1<!SYNTAX!><!>
+
+
@@ -0,0 +1,20 @@
+//KT-2014 Better diagnostic when using property syntax to call a method
+package c
+
+class Foo {
+    fun prop() : Int = 1
+    fun bar(i: Int) : Int = i
+
+    val a : Int = 1
+}
+
+fun x(f : Foo) {
+    f.<!UNRESOLVED_REFERENCE!>prop<!>
+    f.<!UNRESOLVED_REFERENCE!>bar<!>
+
+    f.<!UNRESOLVED_REFERENCE!>a<!>()
+    <!UNRESOLVED_REFERENCE!>c<!>()
+    <!INAPPLICABLE_CANDIDATE!>R<!>()
+}
+
+object R {}
@@ -0,0 +1,5 @@
+//KT-4866 Resolve does not work inside brackets with unresolved reference before
+
+fun test(i: Int, j: Int) {
+    <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>foo<!>[i, j]<!>
+}
@@ -0,0 +1,11 @@
+// !WITH_NEW_INFERENCE
+//EA-35646
+package a
+
+class MyClass1 {
+    public operator fun unaryPlus() {}
+}
+
+fun main(arg: MyClass1) {
+    arg<!UNRESOLVED_REFERENCE!>+<!><!SYNTAX!><!>
+}
@@ -0,0 +1,8 @@
+package b
+
+fun foo() {
+    <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (i in <!UNRESOLVED_REFERENCE!>collection<!>) {
+        {
+         break
+    }
+}<!SYNTAX!><!><!>
@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION
+package d
+
+fun foo(a : IntArray) {
+    if (null == <!UNRESOLVED_REFERENCE!>a<!>()<!SYNTAX!><!>
+<!SYNTAX!><!>}
@@ -0,0 +1,8 @@
+package bar
+
+class S<T> {
+    fun foo() {
+        <!OTHER_ERROR!>T<!>
+        <!OTHER_ERROR!>T<!>.<!UNRESOLVED_REFERENCE!>create<!>()
+    }
+}
@@ -0,0 +1,13 @@
+// !WITH_NEW_INFERENCE
+//!DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun <T> foo(i: Int, t: T) {}
+fun <T> foo(s: String, t: T) {}
+
+fun bar(i: Int) {}
+fun bar(s: String) {}
+
+fun test() {
+    <!AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>rrr<!>, 1)
+    <!AMBIGUITY!>bar<!>(<!UNRESOLVED_REFERENCE!>rrr<!>)
+}
@@ -0,0 +1,4 @@
+fun foo(a: Int) {
+    <!UNRESOLVED_REFERENCE!>!<!><!UNRESOLVED_REFERENCE!>bbb<!>
+    <!UNRESOLVED_REFERENCE!>bbb<!> + a
+}
@@ -0,0 +1,4 @@
+fun foo(s: String) {
+    s.<!SYNTAX!><!>
+    val b = 42
+}
				`@@ -0,0 +1 @@`
				`class A : (categoryName: <!SYNTAX!><!>)<!SYNTAX!><!> <!SYNTAX!><!>{<!SYNTAX!><!>`