[FE 1.0] Report warnings or errors for upper bounded type variables by an empty intersection type

2022-02-11 11:49:59 +03:00
parent 9474406375
commit 65213e9a42
25 changed files with 233 additions and 12 deletions
@@ -897,6 +897,8 @@ public interface Errors {

    DiagnosticFactoryForDeprecation1<PsiElement, TypeParameterDescriptor> TYPE_INFERENCE_ONLY_INPUT_TYPES =
            DiagnosticFactoryForDeprecation1.create(LanguageFeature.StrictOnlyInputTypesChecks);
+    DiagnosticFactoryForDeprecation2<PsiElement, String, Collection<KotlinType>> INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION =
+            DiagnosticFactoryForDeprecation2.create(LanguageFeature.ForbidInferringTypeVariablesIntoEmptyIntersection);
    DiagnosticFactory1<PsiElement, InferenceErrorData> TYPE_INFERENCE_UPPER_BOUND_VIOLATED = DiagnosticFactory1.create(ERROR);
    DiagnosticFactory2<KtElement, KotlinType, KotlinType> TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH = DiagnosticFactory2.create(ERROR);
    DiagnosticFactory0<PsiElement> TYPE_INFERENCE_CANDIDATE_WITH_SAM_AND_VARARG = DiagnosticFactory0.create(WARNING);
@@ -964,6 +964,7 @@ public class DefaultErrorMessages {
        MAP.put(TYPE_INFERENCE_INCORPORATION_ERROR, "Type inference failed. Please try to specify type arguments explicitly.");
        MAP.put(TYPE_INFERENCE_ONLY_INPUT_TYPES, "Type inference failed. The value of the type parameter {0} should be mentioned in input types " +
                                                 "(argument types, receiver type or expected type). Try to specify it explicitly.", NAME);
+        MAP.put(INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION, "Type argument for a type parameter {0} can''t be inferred because it''s upper bounded by incompatible types: {1}", TO_STRING, RENDER_COLLECTION_OF_TYPES);
        MAP.put(TYPE_INFERENCE_UPPER_BOUND_VIOLATED, "{0}", TYPE_INFERENCE_UPPER_BOUND_VIOLATED_RENDERER);
        MAP.put(TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, "Type inference failed. Expected type mismatch: inferred type is {1} but {0} was expected", RENDER_TYPE, RENDER_TYPE);
        MAP.put(TYPE_INFERENCE_CANDIDATE_WITH_SAM_AND_VARARG, "Please use spread operator to pass an array as vararg. It will be an error in 1.5.");
@@ -601,6 +601,21 @@ class DiagnosticReporterByTrackingStrategy(
                    )
                }
            }
+
+            InferredEmptyIntersectionError::class.java, InferredEmptyIntersectionWarning::class.java -> {
+                val typeVariable = (error as InferredEmptyIntersection).typeVariable
+                psiKotlinCall.psiCall.calleeExpression?.let {
+                    val typeVariableText = (typeVariable as? TypeVariableFromCallableDescriptor)?.originalTypeParameter?.name?.asString()
+                        ?: typeVariable.toString()
+                    trace.reportDiagnosticOnce(
+                        @Suppress("UNCHECKED_CAST")
+                        INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION.on(
+                            context.languageVersionSettings, it, typeVariableText,
+                            error.incompatibleTypes as Collection<KotlinType>
+                        )
+                    )
+                }
+            }
        }
    }

@@ -47,7 +47,7 @@ fun test(i: Inv<Nothing>, iUnit: Inv<Unit>) {

    if (iUnit is <!INCOMPATIBLE_TYPES!>String<!>) {
        launch {
-            run(A.flexible(iUnit)) { 42 }
+            run(A.<!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>flexible<!>(iUnit)) { 42 }
        }
    }
 }
@@ -0,0 +1,12 @@
+/selectFromCovariantAndContravariantTypes.kt:12:22: warning: parameter 'y' is never used
+fun <K> select(x: K, y: K): K = x
+                     ^
+/selectFromCovariantAndContravariantTypes.kt:13:19: warning: parameter 'x' is never used
+fun <V> genericIn(x: In<V>) {}
+                  ^
+/selectFromCovariantAndContravariantTypes.kt:14:20: warning: parameter 'x' is never used
+fun <V> genericOut(x: Out<V>) {}
+                   ^
+/selectFromCovariantAndContravariantTypes.kt:17:5: warning: type argument for a type parameter V can't be inferred because it's upper bounded by incompatible types: A, B. This will become an error in Kotlin 1.8
+    genericIn(select(a, b))
+    ^
@@ -1,4 +1,4 @@
-// FIR_IDENTICAL
+// RENDER_DIAGNOSTICS_FULL_TEXT
 // !LANGUAGE: +NewInference
 // !DIAGNOSTICS: -UNUSED_PARAMETER

@@ -13,7 +13,7 @@ fun <V> genericIn(x: In<V>) {}
 fun <V> genericOut(x: Out<V>) {}

 fun test1(a: In<A>, b: In<B>) {
-    genericIn(select(a, b))
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>genericIn<!>(select(a, b))
 }

 fun test2(a: Out<A>, b: Out<B>) {
@@ -20,7 +20,7 @@ object OnlyOne {
    fun <T : Comparable<T>, S : T> greater(x: Bar<in S>, t: T) {}

    fun test(b: Bar<Long>) {
-        <!DEBUG_INFO_CALL("fqName: OnlyOne.greater; typeCall: function")!>greater(b, b)<!>
+        <!DEBUG_INFO_CALL("fqName: OnlyOne.greater; typeCall: function")!><!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>greater<!>(b, b)<!>
    }
 }

@@ -164,10 +164,10 @@ fun main() {
    select({ x, y -> x.inv() + y.toByte() }, id { x: Int, y -> y.toByte() }, id { x, y: Number -> x.inv() })

    // Inferring lambda parameter types by other specified lambda parameters; expected type is a functional type with type variables in parameter types
-    takeLambdas({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { x: Int -> }, { x: Nothing -> x })
-    takeLambdas({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { } as (Int) -> Unit, { x: Nothing -> x })
-    takeLambdas({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { } as (Nothing) -> Unit, { x: Int -> x })
-    takeLambdas({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { } as (Int) -> Unit, { } as (Nothing) -> Unit)
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>takeLambdas<!>({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { x: Int -> }, { x: Nothing -> x })
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>takeLambdas<!>({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { } as (Int) -> Unit, { x: Nothing -> x })
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>takeLambdas<!>({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { } as (Nothing) -> Unit, { x: Int -> x })
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>takeLambdas<!>({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!> }, { } as (Int) -> Unit, { } as (Nothing) -> Unit)

    // Inferring lambda parameter types by other specified lambda parameters; expected type is a functional type with type variables in parameter types; dependent type parameters
    takeLambdasWithDirectlyDependentTypeParameters({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>it<!> }, { <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>it<!> }, { x: Int -> x })
@@ -0,0 +1,6 @@
+/kt45461.kt:6:25: warning: parameter 'foo' is never used
+    fun <S : T> takeFoo(foo: Foo<in S>) {}
+                        ^
+/kt45461.kt:11:19: warning: type argument for a type parameter S can't be inferred because it's upper bounded by incompatible types: String, Int. This will become an error in Kotlin 1.8
+    Bar<String>().takeFoo(foo) // error in 1.3.72, no error in 1.4.31
+                  ^
@@ -0,0 +1,11 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+class Foo<T>
+
+class Bar<T> {
+    fun <S : T> takeFoo(foo: Foo<in S>) {}
+}
+
+fun main() {
+    val foo = Foo<Int>()
+    Bar<String>().<!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>takeFoo<!>(foo) // error in 1.3.72, no error in 1.4.31
+}
@@ -0,0 +1,18 @@
+package
+
+public fun main(): kotlin.Unit
+
+public final class Bar</*0*/ T> {
+    public constructor Bar</*0*/ 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 final fun </*0*/ S : T> takeFoo(/*0*/ foo: Foo<in S>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Foo</*0*/ T> {
+    public constructor Foo</*0*/ 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
+}
@@ -0,0 +1,15 @@
+/kt48765.kt:5:44: warning: parameter 'x1' is never used
+    fun <T1: Number, T2: A<Float, T1>> foo(x1: T2, x2: T1) {}
+                                           ^
+/kt48765.kt:5:52: warning: parameter 'x2' is never used
+    fun <T1: Number, T2: A<Float, T1>> foo(x1: T2, x2: T1) {}
+                                                   ^
+/kt48765.kt:9:13: warning: type argument for a type parameter T can't be inferred because it's upper bounded by incompatible types: String, Number. This will become an error in Kotlin 1.8
+        B().foo(x, foo())
+            ^
+/kt48765.kt:13:9: warning: 'String' is a final type, and thus a value of the type parameter is predetermined
+fun <T: String> foo(): T  {
+        ^
+/kt48765.kt:14:15: warning: unchecked cast: String to T
+    return "" as T // this cast is safe because String is final.
+              ^
@@ -0,0 +1,17 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+open class A<T1, T2> {}
+class B {
+    fun <T1: Number, T2: A<Float, T1>> foo(x1: T2, x2: T1) {}
+}
+class C<T: D, T2>(val x: T, val y: T2) {
+    fun test() {
+        B().<!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>foo<!>(x, foo())
+    }
+}
+open class D: A<Float, Number>()
+fun <T: <!FINAL_UPPER_BOUND!>String<!>> foo(): T  {
+    return "" <!UNCHECKED_CAST!>as T<!> // this cast is safe because String is final.
+}
+fun main() {
+    C(D(), 10.5).test()
+}
@@ -0,0 +1,36 @@
+package
+
+public fun </*0*/ T : kotlin.String> foo(): T
+public fun main(): kotlin.Unit
+
+public open class A</*0*/ T1, /*1*/ T2> {
+    public constructor A</*0*/ T1, /*1*/ T2>()
+    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 B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun </*0*/ T1 : kotlin.Number, /*1*/ T2 : A<kotlin.Float, T1>> foo(/*0*/ x1: T2, /*1*/ x2: T1): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C</*0*/ T : D, /*1*/ T2> {
+    public constructor C</*0*/ T : D, /*1*/ T2>(/*0*/ x: T, /*1*/ y: T2)
+    public final val x: T
+    public final val y: T2
+    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 final fun test(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class D : A<kotlin.Float, kotlin.Number> {
+    public constructor D()
+    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,7 @@
+/kt48935.kt:7:35: warning: parameter 'func' is never used
+fun <T, V> exampleGenericFunction(func: V) where T: Base, V: (T) -> Unit {
+                                  ^
+/kt48935.kt:13:5: warning: type argument for a type parameter T can't be inferred because it's upper bounded by incompatible types: Base, DoesNotImplementBase. This will become an error in Kotlin 1.8
+    exampleGenericFunction(func) // expected this to be a compilation error as the T: Base constraint should not be satisfied
+    ^
+
@@ -0,0 +1,13 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+interface Base
+
+class DoesNotImplementBase
+
+fun <T, V> exampleGenericFunction(func: V) where T: Base, V: (T) -> Unit {
+
+}
+
+fun main() {
+    val func: (DoesNotImplementBase) -> Unit = { }
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>exampleGenericFunction<!>(func) // expected this to be a compilation error as the T: Base constraint should not be satisfied
+}
@@ -0,0 +1,17 @@
+package
+
+public fun </*0*/ T : Base, /*1*/ V : (T) -> kotlin.Unit> exampleGenericFunction(/*0*/ func: V): kotlin.Unit
+public fun main(): kotlin.Unit
+
+public interface Base {
+    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 DoesNotImplementBase {
+    public constructor DoesNotImplementBase()
+    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,4 @@
+/kt49661.kt:11:5: warning: type argument for a type parameter T can't be inferred because it's upper bounded by incompatible types: Foo, Int. This will become an error in Kotlin 1.8
+    f<Int> { g() }
+    ^
+
@@ -0,0 +1,11 @@
+// RENDER_DIAGNOSTICS_FULL_TEXT
+open class Foo
+inline fun <reified T : Foo> g(): T? = null
+
+inline fun <R> f(block: ()->R?): R? {
+    return block()
+}
+
+fun main() {
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>f<!><Int> { g() }
+}
@@ -0,0 +1,12 @@
+package
+
+public inline fun </*0*/ R> f(/*0*/ block: () -> R?): R?
+public inline fun </*0*/ reified T : Foo> g(): T?
+public fun main(): kotlin.Unit
+
+public open class Foo {
+    public constructor 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
+}
@@ -14,7 +14,7 @@ val a1: A = select(
    { a: Int -> myPrint(a + this.length + 2) }
 )

-val a2 = select(
+val a2 = <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>select<!>(
    { a: Int -> myPrint(a + this.length + 1) },
    fun CharSequence.(a: Int) { myPrint(a + this.length + 2) },
    { a: Int -> myPrint(a + this.length + 3) }
@@ -14,7 +14,7 @@ val a1: A = select(
    { a: Int -> myPrint(a + this.length + 2) }
 )

-val a2 = select(
+val a2 = <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>select<!>(
    { a: Int -> myPrint(a + this.<!UNRESOLVED_REFERENCE!>length<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> 1) },
    fun CharSequence.(a: Int) { myPrint(a + this.length + 2) },
    { a: Int -> myPrint(a + this.<!UNRESOLVED_REFERENCE!>length<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> 3) }
@@ -13,7 +13,7 @@ fun testElvis(a: Int?, b: Int?) {
    if (a != null) {
        doInt(b ?: <!DEBUG_INFO_SMARTCAST!>a<!>)
    }
-    doList(getList() ?: emptyListOfA()) //should be an error
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>doList<!>(getList() ?: emptyListOfA()) //should be an error
    doList(getList() ?: strangeList { doInt(it) }) //lambda was not analyzed
 }

@@ -12,7 +12,7 @@ fun <T: A> emptyNullableListOfA(): List<T>? = null
 //-------------------------------

 fun testExclExcl() {
-    doList(emptyNullableListOfA()!!) //should be an error here
+    <!INFERRED_TYPE_VARIABLE_INTO_EMPTY_INTERSECTION_WARNING!>doList<!>(emptyNullableListOfA()!!) //should be an error here
    val l: List<Int> = <!TYPE_MISMATCH!><!TYPE_MISMATCH!>id<!>(<!TYPE_MISMATCH!>emptyNullableListOfA<!>()<!TYPE_MISMATCH!>!!<!>)<!>

    doList(strangeNullableList { doInt(it) }!!) //lambda should be analyzed (at completion phase)
@@ -13840,6 +13840,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                runTest("compiler/testData/diagnostics/tests/inference/kt40396.kt");
            }

+            @Test
+            @TestMetadata("kt45461.kt")
+            public void testKt45461() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/kt45461.kt");
+            }
+
            @Test
            @TestMetadata("kt46515.kt")
            public void testKt46515() throws Exception {
@@ -13852,6 +13858,18 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                runTest("compiler/testData/diagnostics/tests/inference/kt47316.kt");
            }

+            @Test
+            @TestMetadata("kt48765.kt")
+            public void testKt48765() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/kt48765.kt");
+            }
+
+            @Test
+            @TestMetadata("kt48935.kt")
+            public void testKt48935() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/kt48935.kt");
+            }
+
            @Test
            @TestMetadata("kt49658.kt")
            public void testKt49658() throws Exception {
@@ -13864,6 +13882,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                runTest("compiler/testData/diagnostics/tests/inference/kt49658Strict.kt");
            }

+            @Test
+            @TestMetadata("kt49661.kt")
+            public void testKt49661() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inference/kt49661.kt");
+            }
+
            @Test
            @TestMetadata("kt6175.kt")
            public void testKt6175() throws Exception {