Type parameter as result type: more precise expected type definition #KT-5385 Fixed

Tests for KT-5385 KT-10223 KT-7800 KT-7817 + something related
2015-11-27 18:59:02 +03:00
parent 51abb021bc
commit 5729855e4f
24 changed files with 352 additions and 13 deletions
@@ -11,6 +11,6 @@ fun test(bal: Array<Int>) {

    val <!UNUSED_VARIABLE!>e<!>: Unit = run { bar += 4 }

-    val <!UNUSED_VARIABLE!>f<!>: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>run { bar += 4 }<!>
+    val <!UNUSED_VARIABLE!>f<!>: Int = run { <!ASSIGNMENT_TYPE_MISMATCH!>bar += 4<!> }
 }
 fun <T> run(f: () -> T): T = f()
@@ -7,10 +7,10 @@ val a : (Int?) -> Int = l@ {

 fun <R> let(<!UNUSED_PARAMETER!>f<!>: (Int?) -> R): R = null!!

-val b: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>let {
-    if (it != null) return@let it
+val b: Int = let {
+    if (it != null) return@let <!DEBUG_INFO_SMARTCAST!>it<!>
    5
-}<!>
+}

 val c: Int = let {
    if (it != null) <!DEBUG_INFO_SMARTCAST!>it<!> else 5
@@ -13,6 +13,6 @@ fun <T, G> A<T>.foo(x: (T)-> G): G {

 fun main(args: Array<String>) {
    val a = A(1)
-    val t: String = a.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo({p -> p})<!>
+    val t: String = a.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo({p -> <!TYPE_MISMATCH!>p<!>})<!>
    checkSubtype<String>(t)
 }
@@ -0,0 +1,12 @@
+interface Foo
+fun foo(): Foo? = null
+
+fun <T> run(f: () -> T): T = f()
+
+val foo: Foo = run {
+    run {
+        val x = foo()
+        if (x == null) throw Exception()
+        <!DEBUG_INFO_SMARTCAST!>x<!>
+    }
+}
@@ -0,0 +1,11 @@
+package
+
+public val foo: Foo
+public fun foo(): Foo?
+public fun </*0*/ T> run(/*0*/ f: () -> T): T
+
+public interface Foo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -0,0 +1,19 @@
+class Indexed<T>(val x: T, val y: Int)
+
+class Value<out T>(val x: T)
+
+interface WithValue<out T> {
+    fun value(): Value<T>
+}
+
+class Singleton<T>(val x: T) : WithValue<T> {
+    override fun value() = Value(x)
+}
+
+class WithValueIndexed<T>(val f: () -> Value<T>) : WithValue<Indexed<T>> {
+    override fun value() = Value(Indexed(f().x, 0))
+}
+
+fun <T> Singleton<out T>.indexed(): WithValue<Indexed<T>> {
+    return WithValueIndexed { value() }
+}
@@ -0,0 +1,45 @@
+package
+
+public fun </*0*/ T> Singleton<out T>.indexed(): WithValue<Indexed<T>>
+
+public final class Indexed</*0*/ T> {
+    public constructor Indexed</*0*/ T>(/*0*/ x: T, /*1*/ y: kotlin.Int)
+    public final val x: T
+    public final val y: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Singleton</*0*/ T> : WithValue<T> {
+    public constructor Singleton</*0*/ T>(/*0*/ x: T)
+    public final val x: T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ fun value(): Value<T>
+}
+
+public final class Value</*0*/ out T> {
+    public constructor Value</*0*/ out T>(/*0*/ x: T)
+    public final val x: T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface WithValue</*0*/ out T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public abstract fun value(): Value<T>
+}
+
+public final class WithValueIndexed</*0*/ T> : WithValue<Indexed<T>> {
+    public constructor WithValueIndexed</*0*/ T>(/*0*/ f: () -> Value<T>)
+    public final val f: () -> Value<T>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ fun value(): Value<Indexed<T>>
+}
@@ -0,0 +1,25 @@
+interface Foo
+interface Bar : Foo
+
+fun foo(): Foo? = null
+fun bar(): Bar? = null
+
+fun <T : Bar> run(f: () -> T): T = f()
+
+val foo: Foo = run {
+    val x = bar()
+    if (x == null) throw Exception()
+    <!DEBUG_INFO_SMARTCAST!>x<!>
+}
+
+val foofoo: Foo = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>run<!> {
+    val x = foo()
+    if (x == null) throw Exception()
+    <!DEBUG_INFO_SMARTCAST!>x<!>
+}
+
+val bar: Bar = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>run<!> {
+    val x = foo()
+    if (x == null) throw Exception()
+    <!TYPE_MISMATCH!>x<!>
+}
@@ -0,0 +1,20 @@
+package
+
+public val bar: Bar
+public val foo: Foo
+public val foofoo: Foo
+public fun bar(): Bar?
+public fun foo(): Foo?
+public fun </*0*/ T : Bar> run(/*0*/ f: () -> T): T
+
+public interface Bar : Foo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -0,0 +1,10 @@
+fun <T> run(f: () -> T): T = f()
+
+class My<T: Any>(val y: T?) {
+
+    fun get(): T = run {
+        val x = y
+        if (x == null) throw Exception()
+        <!DEBUG_INFO_SMARTCAST!>x<!>
+    }
+}
@@ -0,0 +1,12 @@
+package
+
+public fun </*0*/ T> run(/*0*/ f: () -> T): T
+
+public final class My</*0*/ T : kotlin.Any> {
+    public constructor My</*0*/ T : kotlin.Any>(/*0*/ y: T?)
+    public final val y: T?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun get(): T
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -0,0 +1,22 @@
+// See KT-5385: no smart cast in a literal without given type arguments
+
+interface Foo
+fun foo(): Foo? = null
+
+fun <T> run(f: () -> T): T = f()
+
+val foo: Foo = run {
+    val x = foo()
+    if (x == null) throw Exception()
+    <!DEBUG_INFO_SMARTCAST!>x<!>
+}
+
+// Basic non-lambda case
+
+fun <T> repeat(arg: T): T = arg
+
+fun bar(): Foo {
+    val x = foo()
+    if (x == null) throw Exception()
+    return repeat(<!DEBUG_INFO_SMARTCAST!>x<!>)
+}
@@ -0,0 +1,13 @@
+package
+
+public val foo: Foo
+public fun bar(): Foo
+public fun foo(): Foo?
+public fun </*0*/ T> repeat(/*0*/ arg: T): T
+public fun </*0*/ T> run(/*0*/ f: () -> T): T
+
+public interface Foo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -0,0 +1,15 @@
+// See also KT-7800
+
+fun <T, R> T.let(f: (T) -> R): R = f(this)
+
+fun foo(): Int {
+    val x: Int = 1.let {
+        val value: Int? = null
+        if (value == null) {
+            return@let 1
+        }
+
+        <!DEBUG_INFO_SMARTCAST!>value<!> // smart-cast should be here
+    }
+    return x
+}
@@ -0,0 +1,4 @@
+package
+
+public fun foo(): kotlin.Int
+public fun </*0*/ T, /*1*/ R> T.let(/*0*/ f: (T) -> R): R
@@ -0,0 +1,14 @@
+// See also KT-7817
+
+fun <R> synchronized(<!UNUSED_PARAMETER!>lock<!>: Any, block: () -> R): R = block()
+
+class My {
+    val test: String
+        get() = synchronized(this) {
+            var x: String? = ""
+            if (x == null) {
+                x = "s"
+            }
+            <!DEBUG_INFO_SMARTCAST!>x<!>
+        }
+}
@@ -0,0 +1,11 @@
+package
+
+public fun </*0*/ R> synchronized(/*0*/ lock: kotlin.Any, /*1*/ block: () -> R): R
+
+public final class My {
+    public constructor My()
+    public final val test: kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -0,0 +1,13 @@
+// See KT-10223
+
+inline fun <T> using(input: Any?, f: (Any?) -> T): T = f(input)
+
+val input: Any? = null
+
+// Error:(32, 24) Type inference failed. Expected type mismatch: inferred type is kotlin.Any? but kotlin.String was expected
+val test4: String = using(input) {
+    when (it) {
+        is String -> <!DEBUG_INFO_SMARTCAST!>it<!>
+        else -> throw RuntimeException()
+    }
+}
@@ -0,0 +1,5 @@
+package
+
+public val input: kotlin.Any? = null
+public val test4: kotlin.String
+public inline fun </*0*/ T> using(/*0*/ input: kotlin.Any?, /*1*/ f: (kotlin.Any?) -> T): T