Erased casts supported

compiler/testData/diagnostics/tests/cast/DowncastMap.kt

@@ -0,0 +1,10 @@
+trait Map<K, out V>
+trait MutableMap<K, V>: Map<K, V> {
+  fun set(k: K, v: V)
+}
+
+fun p(p: Map<String, Int>) {
+    if (p is MutableMap<String, Int>) {
+        p[""] = 1
+    }
+}

compiler/testData/diagnostics/tests/cast/IsArray.kt

@@ -0,0 +1 @@
+fun f(a: Array<out Number>) = a is Array<Int>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric.kt

@@ -0,0 +1,5 @@
+open class BaseTwo<A, B>
+open class DerivedWithOne<D>: BaseTwo<D, String>()
+
+// a is BaseTwo<T, U> => if (a is DerivedWithOne<?>) a is DerivedWithOne<T>
+fun <T, U> testing(a: BaseTwo<T, U>) = a is DerivedWithOne<T>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForExactSupertypeCheck.kt

@@ -0,0 +1,5 @@
+open class Base<A>
+class Some: Base<Int>()
+
+// a is Some => a is Base<Int>
+fun f(a: Some) = a is Base<Int>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForOverridenVarianceWithProjection.kt

@@ -0,0 +1,8 @@
+open class A
+open class B: A()
+
+open class Base<out T>
+open class SubBase<T> : Base<T>()
+
+// l is Base<+B> => if (l is SubBase<?>) l is SubBase<+B> => l is SubBase<+A>
+fun ff(l: Base<B>) = l is SubBase<out A>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithContrvariance.kt

@@ -0,0 +1,8 @@
+open class A
+open class B: A()
+
+open class Base<in T>
+class SubBase: Base<A>()
+
+// f is SubBase => f is Base<A> => (Base<Contravariant T>, B <: A) f is Base<B>
+fun test(f: SubBase) = f is Base<B>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithCovariance.kt

@@ -0,0 +1,8 @@
+open class A
+open class B: A()
+
+open class Base<out T>
+class SubBase: Base<B>()
+
+// f is SubBase => (SubBase <: Base<B>) f is Base<B> => (B <: A, Base<Covariant T> => SubBase <: Base<A>) f is Base<A>
+fun test(f: SubBase) = f is Base<A>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithIrrelevantMixin.kt

@@ -0,0 +1,9 @@
+trait A
+trait B: A
+trait D
+
+trait BaseSuper<T>
+trait BaseImpl: BaseSuper<D>
+trait DerivedSuper<out S>: <!INCONSISTENT_TYPE_PARAMETER_VALUES!>BaseSuper<S>, BaseImpl<!>
+
+fun test(t: BaseSuper<B>) = t is DerivedSuper<A>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithTwoSameTypeSubstitutions.kt

@@ -0,0 +1,6 @@
+open class BaseMulti<out A, B>
+class SomeMultiDerived<out D>: BaseMulti<D, Any>()
+
+// t is BaseMulti<+String, String> => if (t is SomeMultiDerived<?>) => t is SomeMultiDerived<+String> =>
+//     => (String <: Any, SomeMultiDerived<Covariant D>) t is SomeMultiDerived<+Any>
+fun someDerived(t: BaseMulti<String, String>) = t is SomeMultiDerived<Any>

compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithoutTypeArguments.kt

@@ -0,0 +1,5 @@
+open class Base<A>
+class Some: Base<Int>()
+
+// No erased types in check
+fun <A> f(a: Base<A>) = a is Some

compiler/testData/diagnostics/tests/cast/IsErasedDisallowForOverridenVariance.kt

@@ -0,0 +1,8 @@
+open class A
+open class B: A()
+
+open class Base<out T>
+open class SubBase<T> : Base<T>()
+
+
+fun ff(l: Base<B>) = l is <!CANNOT_CHECK_FOR_ERASED!>SubBase<A><!>

compiler/testData/diagnostics/tests/cast/IsErasedDisallowForTypeWithConstraints.kt

@@ -0,0 +1,6 @@
+trait A
+trait B: A
+
+trait Base<T>
+
+fun <T> test(a: Base<B>) where T: Base<A> = a is <!CANNOT_CHECK_FOR_ERASED!>T<!>

compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid.kt

@@ -0,0 +1,8 @@
+open class A
+open class B: A()
+open class D
+
+open class Base<out T, out U>
+open class Derived<out S>: Base<S, S>()
+
+fun test(a: Base<D, B>) = a is <!CANNOT_CHECK_FOR_ERASED!>Derived<A><!>

compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid.kt

@@ -0,0 +1,8 @@
+open class A
+open class B: A()
+open class D
+
+open class Base<out T, out U>
+open class Derived<out S>: Base<S, S>()
+
+fun test(a: Base<B, D>) = a is <!CANNOT_CHECK_FOR_ERASED!>Derived<A><!>

compiler/testData/diagnostics/tests/cast/IsErasedNonGeneric.kt

@@ -0,0 +1,3 @@
+trait A
+trait B
+fun testing(a: A) = a as B

compiler/testData/diagnostics/tests/cast/IsErasedNullableTasT.kt

@@ -0,0 +1 @@
+fun <T: Any> testing(a: T?) = a is T

compiler/testData/diagnostics/tests/cast/IsErasedTasT.kt

@@ -0,0 +1 @@
+fun <T> testing(a: T) = a is T

compiler/testData/diagnostics/tests/cast/IsErasedToErrorType.kt

@@ -0,0 +1 @@
+fun testing(a: Any) = a is <!UNRESOLVED_REFERENCE!>UnresolvedType<!><Int>

compiler/testData/diagnostics/tests/cast/IsRecursionSustainable.kt

@@ -0,0 +1,6 @@
+open class RecA<T>: <!CYCLIC_INHERITANCE_HIERARCHY!>RecB<T><!>()
+open class RecB<T>: <!CYCLIC_INHERITANCE_HIERARCHY!>RecA<T><!>()
+open class SelfR<T>: <!CYCLIC_INHERITANCE_HIERARCHY!>SelfR<T><!>()
+
+fun test(f: SelfR<String>) = f is <!CANNOT_CHECK_FOR_ERASED!>RecA<String><!>
+fun test(f: RecB<String>) = f is RecA<String>

compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.kt

@@ -6,7 +6,7 @@ public fun foo(a: Any) {
     a is Map<out Any?, Any?>
     a is Map<*, *>
     a is Map<<!SYNTAX!><!>>
-    a is <!CANNOT_CHECK_FOR_ERASED!>List<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>><!>
+    a is List<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>>
     a is <!NO_TYPE_ARGUMENTS_ON_RHS_OF_IS_EXPRESSION!>List<!>
     a is Int
 

compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.kt

@@ -5,7 +5,7 @@ public fun foo(a: Any, <!UNUSED_PARAMETER!>b<!>: <!WRONG_NUMBER_OF_TYPE_ARGUMENT
         is Map<out Any?, Any?> -> {}
         is Map<*, *> -> {}
         is Map<<!SYNTAX!><!>> -> {}
-        is <!CANNOT_CHECK_FOR_ERASED!>List<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>><!> -> {}
+        is List<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>> -> {}
         is <!NO_TYPE_ARGUMENTS_ON_RHS_OF_IS_EXPRESSION!>List<!> -> {}
         is Int -> {}
         else -> {}