Partial body resolve tests: more informative test output

idea/testData/resolve/partialBodyResolve/AnonymousObjects.dump

@@ -1,2 +1,24 @@
 Resolve target: value-parameter val p: kotlin.String?
-Skipped statements:
+----------------------------------------------
+open class C(p: Int) {
+    open fun f(){}
+}
+
+fun foo(p: String?) {
+    val o = object : Runnable {
+        override fun run() {
+            if (p == null) return
+            print(p.size)
+        }
+    }
+
+    val c = object : C(p!!.size) {
+        override fun f() {
+            super.f()
+            if (p == null) return
+            print(p.size)
+        }
+    }
+
+    <caret>p?.size
+}

idea/testData/resolve/partialBodyResolve/As.dump

@@ -1,6 +1,21 @@
 Resolve target: value-parameter val p: kotlin.Any smart-cast to kotlin.String
-Skipped statements:
-y(p as? Int)
-z(f() as String)
-p1 as String
-z(p1 as String)
+----------------------------------------------
+fun foo(p: Any, p1: Any?) {
+    x(e.f as String)
+    // STATEMENT DELETED: y(p as? Int)
+    // STATEMENT DELETED: z(f() as String)
+
+    if (a) {
+        print((p as String).size)
+    }
+    else {
+        print((p as String).length)
+    }
+
+    if (y()) {
+        print(<caret>p.size)
+        // STATEMENT DELETED: p1 as String
+    }
+
+    // STATEMENT DELETED: z(p1 as String)
+}

idea/testData/resolve/partialBodyResolve/BangBang.dump

@@ -1,5 +1,20 @@
 Resolve target: value-parameter val p: kotlin.String? smart-cast to kotlin.String
-Skipped statements:
-y(f()!!)
-p1!!
-z(p1!!)
+----------------------------------------------
+fun foo(p: String?, p1: Any?) {
+    x(e.f!!)
+    // STATEMENT DELETED: y(f()!!)
+
+    if (a) {
+        print(p!!.size)
+    }
+    else {
+        print(p!!.length)
+    }
+
+    if (y()) {
+        print(<caret>p.size)
+        // STATEMENT DELETED: p1!!
+    }
+
+    // STATEMENT DELETED: z(p1!!)
+}

idea/testData/resolve/partialBodyResolve/BangBangInIfCondition.dump

@@ -1,3 +1,9 @@
 Resolve target: value-parameter val p: kotlin.Boolean? smart-cast to kotlin.Boolean
-Skipped statements:
-print(p1!!.hashCode())
+----------------------------------------------
+fun foo(p: Boolean?, p1: Any?) {
+    if (p!!) {
+        // STATEMENT DELETED: print(p1!!.hashCode())
+    }
+
+    <caret>p.hashCode()
+}

idea/testData/resolve/partialBodyResolve/DeclarationsBefore.dump

@@ -1,6 +1,20 @@
 Resolve target: val v2: kotlin.Int
-Skipped statements:
-x()
-run { val v2 = 1 println(v2) }
-run { val v2 = 2 println(v2) }
-z()
+----------------------------------------------
+fun foo(p: Int) {
+    // STATEMENT DELETED: x()
+
+    val v1 = p * p
+
+    if (y()) {
+        val v2 = v1 * v1
+        val v3 = v1 * v2
+
+        // STATEMENT DELETED: run { val v2 = 1 println(v2) }
+
+        print(<caret>v2)
+
+        // STATEMENT DELETED: run { val v2 = 2 println(v2) }
+    }
+
+    // STATEMENT DELETED: z()
+}

idea/testData/resolve/partialBodyResolve/DoWhile.dump

@@ -1,2 +1,9 @@
 Resolve target: value-parameter val p: kotlin.Any?
-Skipped statements:
+----------------------------------------------
+fun foo(p: Any?) {
+    do {
+        print(p!!)
+    } while (x())
+
+    <caret>p.hashCode()
+}

idea/testData/resolve/partialBodyResolve/For.dump

@@ -1,3 +1,11 @@
 Resolve target: value-parameter val p: kotlin.Any? smart-cast to kotlin.String
-Skipped statements:
-print(p1!!)
+----------------------------------------------
+fun x(s: String): Collection<String>{}
+
+fun foo(p: Any?, p1: Any?) {
+    for (e in x(p as String)) {
+        // STATEMENT DELETED: print(p1!!)
+    }
+
+    <caret>p.size
+}

idea/testData/resolve/partialBodyResolve/IfBranchesAutoCasts.dump

@@ -1,3 +1,7 @@
 Resolve target: null
-Skipped statements:
-if (x()) { y(p!!) } else { z(p1!!) }
+----------------------------------------------
+fun foo(p: Any?, p1, Any?) {
+    // STATEMENT DELETED: if (x()) { y(p!!) } else { z(p1!!) }
+
+    <caret>xxx
+}

idea/testData/resolve/partialBodyResolve/IfBranchesAutoCasts2.dump

@@ -1,4 +1,14 @@
 Resolve target: value-parameter val p1: kotlin.Any? smart-cast to kotlin.Any
-Skipped statements:
-print(p!!)
-print(p2!!)
+----------------------------------------------
+fun foo(p: Any?, p1: Any?, p2: Any?) {
+    if (x()) {
+        // STATEMENT DELETED: print(p!!)
+        print(p1!!)
+    }
+    else {
+        print(p1 as String)
+        // STATEMENT DELETED: print(p2!!)
+    }
+
+    <caret>p1.hashCode()
+}

idea/testData/resolve/partialBodyResolve/IfBranchesSmartCast.dump

@@ -1,2 +1,11 @@
 Resolve target: value-parameter val o: kotlin.Any? smart-cast to kotlin.Any
-Skipped statements:
+----------------------------------------------
+fun foo(o: Any?, p: Int) {
+    if (p > 0) {
+        if (o == null) return
+    }
+    else {
+        if (o !is String) return
+    }
+    <caret>o.javaClass
+}

idea/testData/resolve/partialBodyResolve/IfEqAutoCast.dump

@@ -1,2 +1,6 @@
 Resolve target: value-parameter val o: kotlin.String? smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+fun foo(o: String?, o1: String) {
+    if (o != o1) return
+    <caret>o.hashCode()
+}

idea/testData/resolve/partialBodyResolve/IfNotIsError.dump

@@ -1,2 +1,8 @@
 Resolve target: value-parameter val p: kotlin.Any smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+fun foo(p: Any) {
+    if (p !is String) {
+        error("Not String")
+    }
+    println(<caret>p.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotIsErrorQualifier.dump

@@ -1,2 +1,8 @@
 Resolve target: value-parameter val p: kotlin.Any smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+fun foo(p: Any) {
+    if (p !is String) {
+        kotlin.error("Not String")
+    }
+    println(<caret>p.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotIsErrorVariable.dump

@@ -1,3 +1,7 @@
 Resolve target: value-parameter val p: kotlin.Any
-Skipped statements:
-if (p !is String) { print(error) }
+----------------------------------------------
+val error = "error"
+fun foo(p: Any) {
+    // STATEMENT DELETED: if (p !is String) { print(error) }
+    println(<caret>p.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotIsMyError.dump

@@ -1,2 +1,10 @@
 Resolve target: value-parameter val p: kotlin.Any smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+fun myError(): Nothing = throw Exception()
+
+fun foo(p: Any) {
+    if (p !is String) {
+        myError()
+    }
+    println(<caret>p.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotIsNothingProp.dump

@@ -1,2 +1,11 @@
 Resolve target: value-parameter val p: kotlin.Any smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+val prop: Nothing
+    get() = throw Exception()
+
+fun foo(p: Any) {
+    if (p !is String) {
+        prop
+    }
+    println(<caret>p.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotIsReturn.dump

@@ -1,3 +1,14 @@
 Resolve target: value-parameter val p: kotlin.Any? smart-cast to kotlin.String
-Skipped statements:
-print("null")
+----------------------------------------------
+fun foo(p: Any?) {
+    if (p !is String) {
+        if (p == null) {
+            // STATEMENT DELETED: print("null")
+            return
+        }
+        else {
+            return
+        }
+    }
+    println(<caret>p.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotIsReturn2.dump

@@ -1,2 +1,8 @@
 Resolve target: val v: kotlin.Any smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+class C(public val v: Any)
+
+fun foo(c: C) {
+    if (c.v !is String) return
+    println(c.<caret>v.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotIsThrow.dump

@@ -1,2 +1,8 @@
 Resolve target: value-parameter val p: kotlin.Any smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+fun foo(p: Any) {
+    if (p !is String) {
+        throw IllegalArgumentException()
+    }
+    println(<caret>p.size)
+}

idea/testData/resolve/partialBodyResolve/IfNotNullElseReturn.dump

@@ -1,3 +1,11 @@
 Resolve target: value-parameter val p: kotlin.Any? smart-cast to kotlin.Any
-Skipped statements:
-print("not null")
+----------------------------------------------
+fun foo(p: Any?) {
+    if (p != null) {
+        // STATEMENT DELETED: print("not null")
+    }
+    else {
+        return
+    }
+    <caret>p.hashCode()
+}

idea/testData/resolve/partialBodyResolve/IfNotNullReturn.dump

@@ -1,3 +0,0 @@
-Resolve target: value-parameter val p: kotlin.Any?
-Skipped statements:
-if (p != null) return

idea/testData/resolve/partialBodyResolve/IfNullBreak.dump

@@ -1,2 +1,11 @@
 Resolve target: val x: kotlin.Any? smart-cast to kotlin.Any
-Skipped statements:
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        if (x == null) break
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null

idea/testData/resolve/partialBodyResolve/IfNullConditionalReturn.dump

@@ -1,3 +1,12 @@
 Resolve target: val x: kotlin.Any?
-Skipped statements:
-if (x == null) { print(1) if (f()) return }
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        // STATEMENT DELETED: if (x == null) { print(1) if (f()) return }
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null
+fun f(): Boolean{}

idea/testData/resolve/partialBodyResolve/IfNullConditionalReturnWithElse.dump

@@ -1,3 +1,12 @@
 Resolve target: val x: kotlin.Any?
-Skipped statements:
-if (x == null) { print(1) if (f()) { return } else { print(2) } }
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        // STATEMENT DELETED: if (x == null) { print(1) if (f()) { return } else { print(2) } }
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null
+fun f(): Boolean{}

idea/testData/resolve/partialBodyResolve/IfNullContinue.dump

@@ -1,2 +1,11 @@
 Resolve target: val x: kotlin.Any? smart-cast to kotlin.Any
-Skipped statements:
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        if (x == null) continue
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null

idea/testData/resolve/partialBodyResolve/IfNullDoWhileWithBreak.dump

@@ -1,3 +1,13 @@
 Resolve target: val x: kotlin.Any?
-Skipped statements:
-if (x == null) { do { if (g()) break } while (f()) }
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        // STATEMENT DELETED: if (x == null) { do { if (g()) break } while (f()) }
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null
+fun f(): Boolean{}
+fun g(): Boolean{}

idea/testData/resolve/partialBodyResolve/IfNullElvisReturn.dump

@@ -1,3 +1,12 @@
 Resolve target: val x: kotlin.Any?
-Skipped statements:
-if (x == null) { print(1) val v = f() ?: return }
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        // STATEMENT DELETED: if (x == null) { print(1) val v = f() ?: return }
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null
+fun f(): String? = null

idea/testData/resolve/partialBodyResolve/IfNullForWithReturn.dump

@@ -1,3 +1,11 @@
 Resolve target: val x: kotlin.Any?
-Skipped statements:
-if (x == null) { for (s in c) { print(s) return } }
+----------------------------------------------
+fun foo(c: Collection<String>) {
+    for (i in 1..10) {
+        val x = take()
+        // STATEMENT DELETED: if (x == null) { for (s in c) { print(s) return } }
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null

idea/testData/resolve/partialBodyResolve/IfNullPrint.dump

@@ -1,3 +1,6 @@
 Resolve target: value-parameter val p: kotlin.Any?
-Skipped statements:
-if (p == null) { print("null") }
+----------------------------------------------
+fun foo(p: Any?) {
+    // STATEMENT DELETED: if (p == null) { print("null") }
+    <caret>p.hashCode()
+}

idea/testData/resolve/partialBodyResolve/IfNullReturn.dump

@@ -1,3 +1,9 @@
 Resolve target: value-parameter val p: kotlin.Any? smart-cast to kotlin.Any
-Skipped statements:
-print("null")
+----------------------------------------------
+fun foo(p: Any?) {
+    if (p == null) {
+        // STATEMENT DELETED: print("null")
+        return
+    }
+    <caret>p.hashCode()
+}

idea/testData/resolve/partialBodyResolve/IfNullWhileTrueWithBreak.dump

@@ -1,3 +1,13 @@
 Resolve target: val x: kotlin.Any?
-Skipped statements:
-if (x == null) { while (true) { if (g()) break } }
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        // STATEMENT DELETED: if (x == null) { while (true) { if (g()) break } }
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null
+fun f(): Boolean{}
+fun g(): Boolean{}

idea/testData/resolve/partialBodyResolve/IfNullWhileWithReturn.dump

@@ -1,3 +1,12 @@
 Resolve target: val x: kotlin.Any?
-Skipped statements:
-if (x == null) { while (f()) { print(1) return } }
+----------------------------------------------
+fun foo() {
+    for (i in 1..10) {
+        val x = take()
+        // STATEMENT DELETED: if (x == null) { while (f()) { print(1) return } }
+        <caret>x.hashCode()
+    }
+}
+
+fun take(): Any? = null
+fun f(): Boolean{}

idea/testData/resolve/partialBodyResolve/IfReturn.dump

@@ -1,3 +1,6 @@
 Resolve target: val kotlin.String.size: kotlin.Int
-Skipped statements:
-if (x()) return
+----------------------------------------------
+fun foo(p: String) {
+    // STATEMENT DELETED: if (x()) return
+    println(p.<caret>size)
+}

idea/testData/resolve/partialBodyResolve/InIfExpressionElse.dump

@@ -1,2 +1,8 @@
 Resolve target: null
-Skipped statements:
+----------------------------------------------
+fun foo(s: String){}
+fun foo(c: Char){}
+
+fun bar(b: Boolean, s: String, c: Char){
+    foo(if (b) "abc" else <caret>xxx)
+}

idea/testData/resolve/partialBodyResolve/Lambda.dump

@@ -1,3 +1,10 @@
 Resolve target: fun f(): kotlin.Unit
-Skipped statements:
-x()
+----------------------------------------------
+class C {
+    fun f(){}
+}
+
+fun foo() {
+    val lambda = {() -> // STATEMENT DELETED: x(); C() }
+    lambda().<caret>f()
+}

idea/testData/resolve/partialBodyResolve/LambdaInCurrentStatement.dump

@@ -1,3 +1,15 @@
 Resolve target: value-parameter val c: kotlin.Collection<kotlin.String>
-Skipped statements:
-println()
+----------------------------------------------
+fun foo(c: Collection<String>): Collection<String> {
+    return <caret>c.filter {
+        val v = it.length
+        val v1 = v * v
+        if (v1 > 10) {
+            true
+        }
+        else {
+            // STATEMENT DELETED: println()
+            it[0] == 'a'
+        }
+    }
+}

idea/testData/resolve/partialBodyResolve/LocalClass.dump

@@ -1,2 +1,13 @@
 Resolve target: value-parameter val p: kotlin.String?
-Skipped statements:
+----------------------------------------------
+fun foo(p: String?) {
+    class LocalClass {
+        fun f(): String? {
+            if (p == null) return null
+            print(p.size)
+            return ""
+        }
+    }
+
+    <caret>p?.size
+}

idea/testData/resolve/partialBodyResolve/LocalFun.dump

@@ -1,5 +1,11 @@
 Resolve target: value-parameter val p: kotlin.String?
-Skipped statements:
-if (p == null) return null
-print(p.size)
-return ""
+----------------------------------------------
+fun foo(p: String?) {
+    fun local(): String? {
+        // STATEMENT DELETED: if (p == null) return null
+        // STATEMENT DELETED: print(p.size)
+        // STATEMENT DELETED: return ""
+    }
+
+    <caret>p?.size
+}

idea/testData/resolve/partialBodyResolve/LocalNothingFun.dump

@@ -1,2 +1,12 @@
 Resolve target: value-parameter val p: kotlin.String? smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+fun foo(p: String?, p1: Any?) {
+    if (p1 == null) return
+
+    fun localError(): Nothing = throw Exception()
+
+    if (p == null) {
+        localError()
+    }
+    <caret>p.size
+}

idea/testData/resolve/partialBodyResolve/ReturnLambda.dump

@@ -1,3 +1,11 @@
 Resolve target: value-parameter val p: kotlin.String? smart-cast to kotlin.String
-Skipped statements:
-println()
+----------------------------------------------
+fun foo(p: String?): () -> String {
+    if (p == null) {
+        return {
+            // STATEMENT DELETED: println()
+            "a"
+        }
+    }
+    <caret>p.size
+}

idea/testData/resolve/partialBodyResolve/Simple.dump

@@ -1,4 +1,9 @@
 Resolve target: value-parameter val p: kotlin.Int
-Skipped statements:
-x()
-z()
+----------------------------------------------
+fun foo(p: Int) {
+    // STATEMENT DELETED: x()
+    if (y()) {
+        print(<caret>p)
+    }
+    // STATEMENT DELETED: z()
+}

idea/testData/resolve/partialBodyResolve/SmartCastPointsResolveRequired1.dump

@@ -1,2 +0,0 @@
-Resolve target: value-parameter val x: kotlin.Any?
-Skipped statements:

idea/testData/resolve/partialBodyResolve/SmartCastPointsResolveRequired2.dump

@@ -1,2 +0,0 @@
-Resolve target: value-parameter val x: kotlin.Any?
-Skipped statements:

idea/testData/resolve/partialBodyResolve/ThisQualifiedAutoCast.dump

@@ -1,2 +1,14 @@
 Resolve target: val s: kotlin.String? smart-cast to kotlin.String
-Skipped statements:
+----------------------------------------------
+class C(val s: String?) {
+    fun foo(p: Boolean) {
+        if (p) {
+            print(s!!)
+        }
+        else {
+            print(this.s!!)
+        }
+
+        <caret>s.size
+    }
+}

idea/testData/resolve/partialBodyResolve/While.dump

@@ -1,3 +1,11 @@
 Resolve target: value-parameter val p: kotlin.Any? smart-cast to kotlin.Any
-Skipped statements:
-print(p1!!)
+----------------------------------------------
+fun x(s: Any): Boolean{}
+
+fun foo(p: Any?, p1: Any?) {
+    while(x(p!!)) {
+        // STATEMENT DELETED: print(p1!!)
+    }
+
+    <caret>p.hashCode()
+}

idea/testData/resolve/partialBodyResolve/WhileTrue.dump

@@ -1,3 +1,12 @@
 Resolve target: value-parameter val p: kotlin.Any?
-Skipped statements:
-if (x()) break
+----------------------------------------------
+fun x(): Boolean{}
+
+fun foo(p: Any?) {
+    while(true) {
+        print(p!!)
+        // STATEMENT DELETED: if (x()) break
+    }
+
+    <caret>p.hashCode()
+}

idea/testData/resolve/partialBodyResolve/WhileTrueCondition.dump

@@ -1,3 +1,11 @@
 Resolve target: value-parameter val p: kotlin.Any?
-Skipped statements:
-while(2 * 2 == 4) { print(p!!) if (x()) break }
+----------------------------------------------
+// this test will fail if control flow analysis will start to produce smart-casts after "while(2 * 2 == 4)"
+
+fun x(): Boolean{}
+
+fun foo(p: Any?) {
+    // STATEMENT DELETED: while(2 * 2 == 4) { print(p!!) if (x()) break }
+
+    <caret>p.hashCode()
+}