Support new form of definitely non-nullable types: T & Any

^KT-26245 In Progress

compiler/testData/codegen/box/notNullAssertions/definitelyNotNullTypes.kt

@@ -17,7 +17,7 @@ public abstract class JClass<T> {
 
 // FILE: main.kt
 class KDerived<E> : JClass<E>() {
-    override fun foo(e: E!!) {
+    override fun foo(e: E & Any) {
         throw RuntimeException("Should not be called")
     }
 }

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/approximation.fir.kt

@@ -0,0 +1,14 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T> foo(x: T, y: T & Any) = x!!
+
+fun main() {
+    foo<String>("", "").length
+    foo<String>("", null).length
+    foo<String?>(null, "").length
+    foo<String?>(null, null).length
+
+    foo("", "").length
+    foo("", null).length
+    foo(null, "").<!UNRESOLVED_REFERENCE!>length<!>
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/approximation.kt

@@ -0,0 +1,14 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T> foo(x: T, y: T & Any) = x!!
+
+fun main() {
+    foo<String>("", "").length
+    foo<String>("", <!NULL_FOR_NONNULL_TYPE!>null<!>).length
+    foo<String?>(null, "").length
+    foo<String?>(null, <!NULL_FOR_NONNULL_TYPE!>null<!>).length
+
+    foo("", "").length
+    foo("", <!NULL_FOR_NONNULL_TYPE!>null<!>).length
+    foo(null, "").length
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/approximation.txt

@@ -0,0 +1,5 @@
+package
+
+public fun </*0*/ T> foo(/*0*/ x: T, /*1*/ y: T!!): T!!
+public fun main(): kotlin.Unit
+

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/bareTypes.fir.kt

@@ -0,0 +1,7 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun main(x: Collection<String>) {
+    if (x is List<!SYNTAX!><!> <!SYNTAX!><!SYNTAX!><!>& Any)<!> {}
+
+    val w: List & Any = null!!
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/bareTypes.kt

@@ -0,0 +1,7 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun main(x: Collection<String>) {
+    if (x is List<!SYNTAX!><!> <!SYNTAX!><!SYNTAX!><!>& Any)<!> {}
+
+    val w: <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION, WRONG_NUMBER_OF_TYPE_ARGUMENTS!>List<!> & Any = null!!
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/bareTypes.txt

@@ -0,0 +1,3 @@
+package
+
+public fun main(/*0*/ x: kotlin.collections.Collection<kotlin.String>): kotlin.Unit

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/disabledFeature.fir.kt

@@ -0,0 +1,3 @@
+// !LANGUAGE: -DefinitelyNotNullTypeParameters
+
+fun <T> foo(x: T, y: T & Any): List<T & Any>? = null

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/disabledFeature.kt

@@ -0,0 +1,3 @@
+// !LANGUAGE: -DefinitelyNotNullTypeParameters
+
+fun <T> foo(x: T, y: <!UNSUPPORTED_FEATURE!>T & Any<!>): List<<!UNSUPPORTED_FEATURE!>T & Any<!>>? = null

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/disabledFeature.txt

@@ -0,0 +1,3 @@
+package
+
+public fun </*0*/ T> foo(/*0*/ x: T, /*1*/ y: T): kotlin.collections.List<T>?

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/inference.fir.kt

@@ -0,0 +1,33 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T> toDefNotNull(s: T): T & Any = s!!
+
+fun <K> removeQuestionMark(x: K?): K = x!!
+
+fun Any.foo() {}
+
+fun <E> expectNN(e: E & Any) {}
+
+fun <F> main(x: F, y: F, z: F, w: F, m: F) {
+    val y1 = toDefNotNull(x) // K instead of K & Any
+    val y2: F & Any = toDefNotNull(x) // K instead of K & Any
+    val x1 = removeQuestionMark(x) // T or T & Any
+    val x2: F & Any = removeQuestionMark(x) // T or T & Any
+
+    val z1 = x!!
+    val z2: F & Any = y!!
+    val w1 = if (z != null) z else return
+    val w2: F & Any = if (w != null) w else return
+
+    y1.foo()
+    y2.foo()
+    x1.foo()
+    x2.foo()
+    z1.foo()
+    z2.foo()
+    w1.foo()
+    w2.foo()
+
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>expectNN<!>(m)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>expectNN<!>(m!!)
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/inference.kt

@@ -0,0 +1,33 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T> toDefNotNull(s: T): T & Any = s!!
+
+fun <K> removeQuestionMark(x: K?): K = x!!
+
+fun Any.foo() {}
+
+fun <E> expectNN(e: E & Any) {}
+
+fun <F> main(x: F, y: F, z: F, w: F, m: F) {
+    val y1 = toDefNotNull(x) // K instead of K & Any
+    val y2: F & Any = toDefNotNull(x) // K instead of K & Any
+    val x1 = removeQuestionMark(x) // T or T & Any
+    val x2: F & Any = removeQuestionMark(x) // T or T & Any
+
+    val z1 = x!!
+    val z2: F & Any = y!!
+    val w1 = if (z != null) <!DEBUG_INFO_SMARTCAST!>z<!> else return
+    val w2: F & Any = if (w != null) <!DEBUG_INFO_SMARTCAST!>w<!> else return
+
+    y1.foo()
+    y2.foo()
+    x1.foo()
+    x2.foo()
+    z1.foo()
+    z2.foo()
+    w1.foo()
+    w2.foo()
+
+    expectNN(<!TYPE_MISMATCH!>m<!>)
+    expectNN(m!!)
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/inference.txt

@@ -0,0 +1,7 @@
+package
+
+public fun </*0*/ E> expectNN(/*0*/ e: E!!): kotlin.Unit
+public fun </*0*/ F> main(/*0*/ x: F, /*1*/ y: F, /*2*/ z: F, /*3*/ w: F, /*4*/ m: F): kotlin.Unit
+public fun </*0*/ K> removeQuestionMark(/*0*/ x: K?): K
+public fun </*0*/ T> toDefNotNull(/*0*/ s: T): T!!
+public fun kotlin.Any.foo(): kotlin.Unit

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/isAsOperators.kt

@@ -0,0 +1,17 @@
+// FIR_IDENTICAL
+// SKIP_TXT
+// !LANGUAGE: -DefinitelyNotNullTypeParameters
+
+fun Any.bar() {}
+fun Boolean.baz() {}
+
+var x: Int = 0
+
+inline fun <reified T> foo(v: Any?): T {
+    if (x > 0) 1 else v as T <!SYNTAX!>& Any<!>
+    if (x > 1) 2 else v as? T <!SYNTAX!>& Any<!>
+    if (x > 2) 3 else v is T <!SYNTAX!>& Any<!>
+    if (x > 3) 4 else v !is T <!SYNTAX!>& Any<!>
+
+    return v as T <!SYNTAX!>& Any<!>
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/isAsOperatorsEnabled.kt

@@ -0,0 +1,17 @@
+// FIR_IDENTICAL
+// SKIP_TXT
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun Any.bar() {}
+fun Boolean.baz() {}
+
+var x: Int = 0
+
+inline fun <reified T> foo(v: Any?): T {
+    if (x > 0) 1 else v as T <!SYNTAX!>& Any<!>
+    if (x > 1) 2 else v as? T <!SYNTAX!>& Any<!>
+    if (x > 2) 3 else v is T <!SYNTAX!>& Any<!>
+    if (x > 3) 4 else v !is T <!SYNTAX!>& Any<!>
+
+    return v as T <!SYNTAX!>& Any<!>
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/notApplicable.fir.kt

@@ -0,0 +1,18 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T : Any> foo(x: T & Any, y: List<String & Any> & Any) {}
+
+fun <F> bar1(x: F? & Any) {}
+fun <F> bar2(x: F & Any?) {}
+fun <F> bar3(x: (F?) & Any) {}
+fun <F> bar4(x: (F & Any)?) {}
+
+fun <F> bar5(x: F & String) {}
+
+fun <F> bar6(x: F & (F & Any)) {}
+fun <F> bar7(x: (F & Any) & Any) {}
+fun <F> bar8(x: (F & Any).() -> Unit) {}
+fun <F> (F & Any).bar9(x: () -> Unit) {}
+
+fun <F> bar10(x: F & Any & String) {}
+fun <F> bar11(x: Double & Any & String) {}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/notApplicable.kt

@@ -0,0 +1,18 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T : Any> foo(x: <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>T<!> & Any, y: <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>List<<!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>String<!> & Any><!> & Any) {}
+
+fun <F> bar1(x: <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>F?<!> & Any) {}
+fun <F> bar2(x: F & <!INCORRECT_RIGHT_COMPONENT_OF_INTERSECTION!>Any?<!>) {}
+fun <F> bar3(x: <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>(F?)<!> & Any) {}
+fun <F> bar4(x: <!NULLABLE_ON_DEFINITELY_NOT_NULLABLE!>(F & Any)?<!>) {}
+
+fun <F> bar5(x: F & <!INCORRECT_RIGHT_COMPONENT_OF_INTERSECTION!>String<!>) {}
+
+fun <F> bar6(x: F & <!INCORRECT_RIGHT_COMPONENT_OF_INTERSECTION!>(F & Any)<!>) {}
+fun <F> bar7(x: <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>(F & Any)<!> & Any) {}
+fun <F> bar8(x: (F & Any).() -> Unit) {}
+fun <F> (F & Any).bar9(x: () -> Unit) {}
+
+fun <F> bar10(x: F & <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>Any<!> & String) {}
+fun <F> bar11(x: <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>Double<!> & <!INCORRECT_LEFT_COMPONENT_OF_INTERSECTION!>Any<!> & String) {}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/notApplicable.txt

@@ -0,0 +1,15 @@
+package
+
+public fun </*0*/ F> bar1(/*0*/ x: F?): kotlin.Unit
+public fun </*0*/ F> bar10(/*0*/ x: F & Any): kotlin.Unit
+public fun </*0*/ F> bar11(/*0*/ x: kotlin.Double): kotlin.Unit
+public fun </*0*/ F> bar2(/*0*/ x: F): kotlin.Unit
+public fun </*0*/ F> bar3(/*0*/ x: F?): kotlin.Unit
+public fun </*0*/ F> bar4(/*0*/ x: F?): kotlin.Unit
+public fun </*0*/ F> bar5(/*0*/ x: F): kotlin.Unit
+public fun </*0*/ F> bar6(/*0*/ x: F): kotlin.Unit
+public fun </*0*/ F> bar7(/*0*/ x: F!!): kotlin.Unit
+public fun </*0*/ F> bar8(/*0*/ x: F!!.() -> kotlin.Unit): kotlin.Unit
+public fun </*0*/ T : kotlin.Any> foo(/*0*/ x: T, /*1*/ y: kotlin.collections.List<kotlin.String>): kotlin.Unit
+public fun </*0*/ F> F!!.bar9(/*0*/ x: () -> kotlin.Unit): kotlin.Unit
+

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overrides.fir.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+interface A<T> {
+    fun foo(x: T): T
+    fun bar(x: T & Any): T & Any
+}
+
+interface B<T1> : A<T1> {
+    override fun foo(x: T1): T1
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: T1 & Any): T1 & Any
+}
+
+interface C<T2> : A<T2> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: T2 & Any): T2 & Any
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: T2): T2
+}
+
+interface D : A<String?> {
+    override fun foo(x: String?): String?
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: String): String
+}
+
+interface E : A<String> {
+    override fun foo(x: String): String
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: String): String
+}
+
+interface F : A<String?> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: String): String
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: String?): String?
+}
+
+interface G<T3 : Any> : A<T3> {
+    override fun foo(x: T3): T3
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: T3): T3
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overrides.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+interface A<T> {
+    fun foo(x: T): T
+    fun bar(x: T & Any): T & Any
+}
+
+interface B<T1> : A<T1> {
+    override fun foo(x: T1): T1
+    override fun bar(x: T1 & Any): T1 & Any
+}
+
+interface C<T2> : A<T2> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: T2 & Any): T2 & Any
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: T2): T2
+}
+
+interface D : A<String?> {
+    override fun foo(x: String?): String?
+    override fun bar(x: String): String
+}
+
+interface E : A<String> {
+    override fun foo(x: String): String
+    override fun bar(x: String): String
+}
+
+interface F : A<String?> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: String): String
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: String?): String?
+}
+
+interface G<T3 : Any> : A<T3> {
+    override fun foo(x: T3): T3
+    override fun bar(x: T3): T3
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overrides.txt

@@ -0,0 +1,61 @@
+package
+
+public interface A</*0*/ T> {
+    public abstract fun bar(/*0*/ x: T!!): T!!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: T): T
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B</*0*/ T1> : A<T1> {
+    public abstract override /*1*/ fun bar(/*0*/ x: T1!!): T1!!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: T1): T1
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface C</*0*/ T2> : A<T2> {
+    public abstract fun bar(/*0*/ x: T2): T2
+    public abstract override /*1*/ /*fake_override*/ fun bar(/*0*/ x: T2!!): T2!!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ x: T2): T2
+    public abstract fun foo(/*0*/ x: T2!!): T2!!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface D : A<kotlin.String?> {
+    public abstract override /*1*/ fun bar(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: kotlin.String?): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface E : A<kotlin.String> {
+    public abstract override /*1*/ fun bar(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface F : A<kotlin.String?> {
+    public abstract override /*1*/ /*fake_override*/ fun bar(/*0*/ x: kotlin.String): kotlin.String
+    public abstract fun bar(/*0*/ x: kotlin.String?): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: kotlin.String): kotlin.String
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.String?): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface G</*0*/ T3 : kotlin.Any> : A<T3> {
+    public abstract override /*1*/ fun bar(/*0*/ x: T3): T3
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: T3): T3
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overridesJavaAnnotated.fir.kt

@@ -0,0 +1,42 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+
+// FILE: A.java
+import org.jetbrains.annotations.*;
+
+public interface A<T> {
+    public T foo(T x) { return x; }
+    @NotNull
+    public T bar(@NotNull T x) {}
+}
+
+// FILE: main.kt
+
+interface B<T1> : A<T1> {
+    override fun foo(x: T1): T1
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: T1 & Any): T1 & Any
+}
+
+interface C<T2> : A<T2> {
+    override fun foo(x: T2 & Any): T2 & Any
+    override fun bar(x: T2): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>T2<!>
+}
+
+interface D : A<String?> {
+    override fun foo(x: String?): String?
+    override fun bar(x: String): String
+}
+
+interface E : A<String> {
+    override fun foo(x: String): String
+    override fun bar(x: String): String
+}
+
+interface F : A<String?> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: String): String
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: String?): String?
+}
+
+interface G<T3 : Any> : A<T3> {
+    override fun foo(x: T3): T3
+    override fun bar(x: T3): T3
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overridesJavaAnnotated.kt

@@ -0,0 +1,42 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+
+// FILE: A.java
+import org.jetbrains.annotations.*;
+
+public interface A<T> {
+    public T foo(T x) { return x; }
+    @NotNull
+    public T bar(@NotNull T x) {}
+}
+
+// FILE: main.kt
+
+interface B<T1> : A<T1> {
+    override fun foo(x: T1): T1
+    override fun bar(x: T1 & Any): T1 & Any
+}
+
+interface C<T2> : A<T2> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: T2 & Any): T2 & Any
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: T2): T2
+}
+
+interface D : A<String?> {
+    override fun foo(x: String?): String?
+    override fun bar(x: String): String
+}
+
+interface E : A<String> {
+    override fun foo(x: String): String
+    override fun bar(x: String): String
+}
+
+interface F : A<String?> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: String): String
+    <!NOTHING_TO_OVERRIDE!>override<!> fun bar(x: String?): String?
+}
+
+interface G<T3 : Any> : A<T3> {
+    override fun foo(x: T3): T3
+    override fun bar(x: T3): T3
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overridesJavaAnnotated.txt

@@ -0,0 +1,61 @@
+package
+
+public interface A</*0*/ T : kotlin.Any!> {
+    @org.jetbrains.annotations.NotNull public abstract fun bar(/*0*/ @org.jetbrains.annotations.NotNull x: T!!): T!!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: T!): T!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B</*0*/ T1> : A<T1> {
+    public abstract override /*1*/ fun bar(/*0*/ x: T1!!): T1!!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: T1): T1
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface C</*0*/ T2> : A<T2> {
+    public abstract fun bar(/*0*/ x: T2): T2
+    @org.jetbrains.annotations.NotNull public abstract override /*1*/ /*fake_override*/ fun bar(/*0*/ @org.jetbrains.annotations.NotNull x: T2!!): T2!!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ x: T2!): T2!
+    public abstract fun foo(/*0*/ x: T2!!): T2!!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface D : A<kotlin.String?> {
+    public abstract override /*1*/ fun bar(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: kotlin.String?): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface E : A<kotlin.String> {
+    public abstract override /*1*/ fun bar(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface F : A<kotlin.String?> {
+    @org.jetbrains.annotations.NotNull public abstract override /*1*/ /*fake_override*/ fun bar(/*0*/ @org.jetbrains.annotations.NotNull x: kotlin.String): kotlin.String
+    public abstract fun bar(/*0*/ x: kotlin.String?): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: kotlin.String): kotlin.String
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.String?): kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface G</*0*/ T3 : kotlin.Any> : A<T3> {
+    public abstract override /*1*/ fun bar(/*0*/ x: T3): T3
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ fun foo(/*0*/ x: T3): T3
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/simple.fir.kt

@@ -0,0 +1,14 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T> foo(x: T, y: T & Any): T & Any = x ?: y
+
+fun main() {
+    foo<String>("", "").<!UNRESOLVED_REFERENCE!>length<!>
+    foo<String>("", null).<!UNRESOLVED_REFERENCE!>length<!>
+    foo<String?>(null, "").<!UNRESOLVED_REFERENCE!>length<!>
+    foo<String?>(null, null).<!UNRESOLVED_REFERENCE!>length<!>
+
+    foo("", "").<!UNRESOLVED_REFERENCE!>length<!>
+    foo("", null).<!UNRESOLVED_REFERENCE!>length<!>
+    foo(null, "").<!UNRESOLVED_REFERENCE!>length<!>
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/simple.kt

@@ -0,0 +1,14 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T> foo(x: T, y: T & Any): T & Any = x ?: y
+
+fun main() {
+    foo<String>("", "").length
+    foo<String>("", <!NULL_FOR_NONNULL_TYPE!>null<!>).length
+    foo<String?>(null, "").length
+    foo<String?>(null, <!NULL_FOR_NONNULL_TYPE!>null<!>).length
+
+    foo("", "").length
+    foo("", <!NULL_FOR_NONNULL_TYPE!>null<!>).length
+    foo(null, "").length
+}

compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/simple.txt

@@ -0,0 +1,4 @@
+package
+
+public fun </*0*/ T> foo(/*0*/ x: T, /*1*/ y: T!!): T!!
+public fun main(): kotlin.Unit

compiler/testData/loadJava/compiledKotlin/annotations/types/DefinitelyNotNull.kt

@@ -2,4 +2,4 @@
 // COMPILER_ARGUMENTS: -XXLanguage:+DefinitelyNotNullTypeParameters
 package test
 
-fun <T> foo(x: T!!, y: List<T!!>, z: (T!!) -> T!!): T!! = x
+fun <T> foo(x: T & Any, y: List<T & Any>, z: (T & Any) -> T & Any): T & Any = x

compiler/testData/psi/AnnotatedIntersections.kt

@@ -0,0 +1,10 @@
+fun <T> foo1(x: @ann T & Any) {}
+fun <T> foo2(x: List<@ann T & Any>) {}
+fun <T> foo3(x: List<out @ann T & Any>) {}
+fun <T> foo4(x: @ann (T & Any)) {}
+fun <T> foo5(x: @ann T? & Any?) {}
+fun <T> foo6(x: @ann T & Any & Any) {}
+fun <T> foo7(x: @ann T & (Any & Any)) {}
+fun <T> @ann (T & Any).foo8() {}
+fun <T> foo10(x: @ann T & Any.() -> Unit) {}
+fun <T> foo11(x: @ann (T & Any).() -> Unit) {}

compiler/testData/psi/AnnotatedIntersections.txt

@@ -0,0 +1,523 @@
+KtFile: AnnotatedIntersections.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo1')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              PsiElement(AT)('@')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ann')
+          PsiWhiteSpace(' ')
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('Any')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo2')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('List')
+            TYPE_ARGUMENT_LIST
+              PsiElement(LT)('<')
+              TYPE_PROJECTION
+                TYPE_REFERENCE
+                  MODIFIER_LIST
+                    ANNOTATION_ENTRY
+                      PsiElement(AT)('@')
+                      CONSTRUCTOR_CALLEE
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('ann')
+                  PsiWhiteSpace(' ')
+                  INTERSECTION_TYPE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('T')
+                    PsiWhiteSpace(' ')
+                    PsiElement(AND)('&')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Any')
+              PsiElement(GT)('>')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo3')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('List')
+            TYPE_ARGUMENT_LIST
+              PsiElement(LT)('<')
+              TYPE_PROJECTION
+                MODIFIER_LIST
+                  PsiElement(out)('out')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  MODIFIER_LIST
+                    ANNOTATION_ENTRY
+                      PsiElement(AT)('@')
+                      CONSTRUCTOR_CALLEE
+                        TYPE_REFERENCE
+                          USER_TYPE
+                            REFERENCE_EXPRESSION
+                              PsiElement(IDENTIFIER)('ann')
+                  PsiWhiteSpace(' ')
+                  INTERSECTION_TYPE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('T')
+                    PsiWhiteSpace(' ')
+                    PsiElement(AND)('&')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Any')
+              PsiElement(GT)('>')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo4')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              PsiElement(AT)('@')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ann')
+          PsiWhiteSpace(' ')
+          PsiElement(LPAR)('(')
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('Any')
+          PsiElement(RPAR)(')')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo5')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              PsiElement(AT)('@')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ann')
+          PsiWhiteSpace(' ')
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              NULLABLE_TYPE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('T')
+                PsiElement(QUEST)('?')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              NULLABLE_TYPE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Any')
+                PsiElement(QUEST)('?')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo6')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              PsiElement(AT)('@')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ann')
+          PsiWhiteSpace(' ')
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              INTERSECTION_TYPE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+                PsiWhiteSpace(' ')
+                PsiElement(AND)('&')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo7')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              PsiElement(AT)('@')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ann')
+          PsiWhiteSpace(' ')
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              PsiElement(LPAR)('(')
+              INTERSECTION_TYPE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+                PsiWhiteSpace(' ')
+                PsiElement(AND)('&')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+              PsiElement(RPAR)(')')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiErrorElement:Annotations are not allowed in this position
+      ANNOTATION_ENTRY
+        PsiElement(AT)('@')
+        CONSTRUCTOR_CALLEE
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('ann')
+        PsiWhiteSpace(' ')
+        VALUE_ARGUMENT_LIST
+          PsiElement(LPAR)('(')
+          VALUE_ARGUMENT
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('T')
+          PsiWhiteSpace(' ')
+          PsiErrorElement:Expecting ')'
+            PsiElement(AND)('&')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('Any')
+    PsiErrorElement:Expecting '('
+      <empty list>
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(DOT)('.')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('foo8')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo10')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              PsiElement(AT)('@')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ann')
+          PsiWhiteSpace(' ')
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              FUNCTION_TYPE
+                FUNCTION_TYPE_RECEIVER
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('Any')
+                PsiElement(DOT)('.')
+                VALUE_PARAMETER_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+                PsiWhiteSpace(' ')
+                PsiElement(ARROW)('->')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Unit')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo11')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          MODIFIER_LIST
+            ANNOTATION_ENTRY
+              PsiElement(AT)('@')
+              CONSTRUCTOR_CALLEE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('ann')
+          PsiWhiteSpace(' ')
+          FUNCTION_TYPE
+            FUNCTION_TYPE_RECEIVER
+              TYPE_REFERENCE
+                PsiElement(LPAR)('(')
+                INTERSECTION_TYPE
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('T')
+                  PsiWhiteSpace(' ')
+                  PsiElement(AND)('&')
+                  PsiWhiteSpace(' ')
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('Any')
+                PsiElement(RPAR)(')')
+            PsiElement(DOT)('.')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(ARROW)('->')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('Unit')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/psi/DefinitelyNotNullType.txt

@@ -19,77 +19,75 @@ KtFile: DefinitelyNotNullType.kt
         PsiElement(IDENTIFIER)('x')
         PsiElement(COLON)(':')
         PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          DEFINITELY_NOT_NULL_TYPE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('T')
-            PsiElement(EXCLEXCL)('!!')
-      PsiElement(COMMA)(',')
-      PsiWhiteSpace(' ')
-      VALUE_PARAMETER
-        PsiElement(IDENTIFIER)('y')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
         TYPE_REFERENCE
           USER_TYPE
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('List')
-            TYPE_ARGUMENT_LIST
-              PsiElement(LT)('<')
-              TYPE_PROJECTION
-                TYPE_REFERENCE
-                  DEFINITELY_NOT_NULL_TYPE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('T')
-                    PsiElement(EXCLEXCL)('!!')
-              PsiElement(GT)('>')
-      PsiElement(COMMA)(',')
-      PsiWhiteSpace(' ')
-      VALUE_PARAMETER
-        PsiElement(IDENTIFIER)('z')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          FUNCTION_TYPE
-            FUNCTION_TYPE_RECEIVER
-              TYPE_REFERENCE
-                DEFINITELY_NOT_NULL_TYPE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('T')
-                  PsiElement(EXCLEXCL)('!!')
-            PsiElement(DOT)('.')
-            VALUE_PARAMETER_LIST
-              PsiElement(LPAR)('(')
-              VALUE_PARAMETER
-                TYPE_REFERENCE
-                  DEFINITELY_NOT_NULL_TYPE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('T')
-                    PsiElement(EXCLEXCL)('!!')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              DEFINITELY_NOT_NULL_TYPE
-                USER_TYPE
-                  REFERENCE_EXPRESSION
-                    PsiElement(IDENTIFIER)('T')
-                PsiElement(EXCLEXCL)('!!')
-      PsiElement(RPAR)(')')
-    PsiElement(COLON)(':')
-    PsiWhiteSpace(' ')
-    TYPE_REFERENCE
-      DEFINITELY_NOT_NULL_TYPE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('T')
+              PsiElement(IDENTIFIER)('T')
+      PsiErrorElement:Expecting comma or ')'
+        <empty list>
+      PsiErrorElement:Expecting ')'
         PsiElement(EXCLEXCL)('!!')
-    PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COMMA)(',')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('y')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COLON)(':')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('List')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LT)('<')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(GT)('>')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COMMA)(',')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('z')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COLON)(':')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(DOT)('.')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(ARROW)('->')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COLON)(':')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
     BLOCK
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')
@@ -112,99 +110,95 @@ KtFile: DefinitelyNotNullType.kt
         PsiElement(IDENTIFIER)('x')
         PsiElement(COLON)(':')
         PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          NULLABLE_TYPE
-            DEFINITELY_NOT_NULL_TYPE
-              USER_TYPE
-                REFERENCE_EXPRESSION
-                  PsiElement(IDENTIFIER)('T')
-              PsiElement(EXCLEXCL)('!!')
-            PsiElement(QUEST)('?')
-      PsiElement(COMMA)(',')
-      PsiWhiteSpace(' ')
-      VALUE_PARAMETER
-        PsiElement(IDENTIFIER)('y')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
         TYPE_REFERENCE
           USER_TYPE
             REFERENCE_EXPRESSION
-              PsiElement(IDENTIFIER)('List')
-            TYPE_ARGUMENT_LIST
-              PsiElement(LT)('<')
-              TYPE_PROJECTION
-                TYPE_REFERENCE
-                  NULLABLE_TYPE
-                    DEFINITELY_NOT_NULL_TYPE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('T')
-                      PsiElement(EXCLEXCL)('!!')
-                    PsiElement(QUEST)('?')
-              PsiElement(GT)('>')
-      PsiElement(COMMA)(',')
-      PsiWhiteSpace(' ')
-      VALUE_PARAMETER
-        PsiElement(IDENTIFIER)('z')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          FUNCTION_TYPE
-            FUNCTION_TYPE_RECEIVER
-              TYPE_REFERENCE
-                NULLABLE_TYPE
-                  DEFINITELY_NOT_NULL_TYPE
-                    USER_TYPE
-                      REFERENCE_EXPRESSION
-                        PsiElement(IDENTIFIER)('T')
-                    PsiElement(EXCLEXCL)('!!')
-                  PsiElement(QUEST)('?')
-            PsiElement(DOT)('.')
-            VALUE_PARAMETER_LIST
-              PsiElement(LPAR)('(')
-              VALUE_PARAMETER
-                TYPE_REFERENCE
-                  NULLABLE_TYPE
-                    DEFINITELY_NOT_NULL_TYPE
-                      USER_TYPE
-                        REFERENCE_EXPRESSION
-                          PsiElement(IDENTIFIER)('T')
-                      PsiElement(EXCLEXCL)('!!')
-                    PsiElement(QUEST)('?')
-              PsiElement(RPAR)(')')
-            PsiWhiteSpace(' ')
-            PsiElement(ARROW)('->')
-            PsiWhiteSpace(' ')
-            TYPE_REFERENCE
-              NULLABLE_TYPE
-                DEFINITELY_NOT_NULL_TYPE
-                  USER_TYPE
-                    REFERENCE_EXPRESSION
-                      PsiElement(IDENTIFIER)('T')
-                  PsiElement(EXCLEXCL)('!!')
-                PsiElement(QUEST)('?')
-      PsiElement(COMMA)(',')
-      PsiWhiteSpace(' ')
-      VALUE_PARAMETER
-        PsiElement(IDENTIFIER)('w')
-        PsiElement(COLON)(':')
-        PsiWhiteSpace(' ')
-        TYPE_REFERENCE
-          DEFINITELY_NOT_NULL_TYPE
-            USER_TYPE
-              REFERENCE_EXPRESSION
-                PsiElement(IDENTIFIER)('String')
-            PsiElement(EXCLEXCL)('!!')
-      PsiElement(RPAR)(')')
-    PsiElement(COLON)(':')
-    PsiWhiteSpace(' ')
-    TYPE_REFERENCE
-      DEFINITELY_NOT_NULL_TYPE
-        USER_TYPE
-          REFERENCE_EXPRESSION
-            PsiElement(IDENTIFIER)('T')
+              PsiElement(IDENTIFIER)('T')
+      PsiErrorElement:Expecting comma or ')'
+        <empty list>
+      PsiErrorElement:Expecting ')'
         PsiElement(EXCLEXCL)('!!')
-    PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(QUEST)('?')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COMMA)(',')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('y')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COLON)(':')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('List')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LT)('<')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(QUEST)('?')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(GT)('>')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COMMA)(',')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('z')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COLON)(':')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(SAFE_ACCESS)('?.')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(QUEST)('?')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(ARROW)('->')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(QUEST)('?')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COMMA)(',')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('w')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COLON)(':')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('String')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(COLON)(':')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('T')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(EXCLEXCL)('!!')
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
     BLOCK
       PsiElement(LBRACE)('{')
       PsiElement(RBRACE)('}')

compiler/testData/psi/SimpleIntersections.kt

@@ -0,0 +1,11 @@
+fun <T> foo1(x: T & Any) {}
+fun <T> foo2(x: List<T & Any>) {}
+fun <T> foo3(x: List<out T & Any>) {}
+fun <T> foo4(x: (T & Any)) {}
+fun <T> foo5(x: T? & Any?) {}
+fun <T> foo6(x: T & Any & Any) {}
+fun <T> foo7(x: T & (Any & Any)) {}
+fun <T> T & Any.foo8() {}
+fun <T> (T & Any).foo9() {}
+fun <T> foo10(x: T & Any.() -> Unit) {}
+fun <T> foo11(x: (T & Any).() -> Unit) {}

compiler/testData/psi/SimpleIntersections.txt

@@ -0,0 +1,462 @@
+KtFile: SimpleIntersections.kt
+  PACKAGE_DIRECTIVE
+    <empty list>
+  IMPORT_LIST
+    <empty list>
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo1')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('Any')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo2')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('List')
+            TYPE_ARGUMENT_LIST
+              PsiElement(LT)('<')
+              TYPE_PROJECTION
+                TYPE_REFERENCE
+                  INTERSECTION_TYPE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('T')
+                    PsiWhiteSpace(' ')
+                    PsiElement(AND)('&')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Any')
+              PsiElement(GT)('>')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo3')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('List')
+            TYPE_ARGUMENT_LIST
+              PsiElement(LT)('<')
+              TYPE_PROJECTION
+                MODIFIER_LIST
+                  PsiElement(out)('out')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  INTERSECTION_TYPE
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('T')
+                    PsiWhiteSpace(' ')
+                    PsiElement(AND)('&')
+                    PsiWhiteSpace(' ')
+                    TYPE_REFERENCE
+                      USER_TYPE
+                        REFERENCE_EXPRESSION
+                          PsiElement(IDENTIFIER)('Any')
+              PsiElement(GT)('>')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo4')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          PsiElement(LPAR)('(')
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('Any')
+          PsiElement(RPAR)(')')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo5')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              NULLABLE_TYPE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('T')
+                PsiElement(QUEST)('?')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              NULLABLE_TYPE
+                USER_TYPE
+                  REFERENCE_EXPRESSION
+                    PsiElement(IDENTIFIER)('Any')
+                PsiElement(QUEST)('?')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo6')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              INTERSECTION_TYPE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+                PsiWhiteSpace(' ')
+                PsiElement(AND)('&')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo7')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              PsiElement(LPAR)('(')
+              INTERSECTION_TYPE
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+                PsiWhiteSpace(' ')
+                PsiElement(AND)('&')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Any')
+              PsiElement(RPAR)(')')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('T')
+    PsiErrorElement:Expecting '('
+      <empty list>
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(AND)('&')
+  PsiWhiteSpace(' ')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('Any')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(DOT)('.')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(IDENTIFIER)('foo8')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(LPAR)('(')
+  PsiErrorElement:Expecting a top level declaration
+    PsiElement(RPAR)(')')
+  PsiWhiteSpace(' ')
+  FUN
+    PsiErrorElement:Expecting a top level declaration
+      <empty list>
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    TYPE_REFERENCE
+      PsiElement(LPAR)('(')
+      INTERSECTION_TYPE
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('T')
+        PsiWhiteSpace(' ')
+        PsiElement(AND)('&')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          USER_TYPE
+            REFERENCE_EXPRESSION
+              PsiElement(IDENTIFIER)('Any')
+      PsiElement(RPAR)(')')
+    PsiElement(DOT)('.')
+    PsiElement(IDENTIFIER)('foo9')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo10')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          INTERSECTION_TYPE
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('T')
+            PsiWhiteSpace(' ')
+            PsiElement(AND)('&')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              FUNCTION_TYPE
+                FUNCTION_TYPE_RECEIVER
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('Any')
+                PsiElement(DOT)('.')
+                VALUE_PARAMETER_LIST
+                  PsiElement(LPAR)('(')
+                  PsiElement(RPAR)(')')
+                PsiWhiteSpace(' ')
+                PsiElement(ARROW)('->')
+                PsiWhiteSpace(' ')
+                TYPE_REFERENCE
+                  USER_TYPE
+                    REFERENCE_EXPRESSION
+                      PsiElement(IDENTIFIER)('Unit')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n')
+  FUN
+    PsiElement(fun)('fun')
+    PsiWhiteSpace(' ')
+    TYPE_PARAMETER_LIST
+      PsiElement(LT)('<')
+      TYPE_PARAMETER
+        PsiElement(IDENTIFIER)('T')
+      PsiElement(GT)('>')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('foo11')
+    VALUE_PARAMETER_LIST
+      PsiElement(LPAR)('(')
+      VALUE_PARAMETER
+        PsiElement(IDENTIFIER)('x')
+        PsiElement(COLON)(':')
+        PsiWhiteSpace(' ')
+        TYPE_REFERENCE
+          FUNCTION_TYPE
+            FUNCTION_TYPE_RECEIVER
+              TYPE_REFERENCE
+                PsiElement(LPAR)('(')
+                INTERSECTION_TYPE
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('T')
+                  PsiWhiteSpace(' ')
+                  PsiElement(AND)('&')
+                  PsiWhiteSpace(' ')
+                  TYPE_REFERENCE
+                    USER_TYPE
+                      REFERENCE_EXPRESSION
+                        PsiElement(IDENTIFIER)('Any')
+                PsiElement(RPAR)(')')
+            PsiElement(DOT)('.')
+            VALUE_PARAMETER_LIST
+              PsiElement(LPAR)('(')
+              PsiElement(RPAR)(')')
+            PsiWhiteSpace(' ')
+            PsiElement(ARROW)('->')
+            PsiWhiteSpace(' ')
+            TYPE_REFERENCE
+              USER_TYPE
+                REFERENCE_EXPRESSION
+                  PsiElement(IDENTIFIER)('Unit')
+      PsiElement(RPAR)(')')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/testData/versionRequirement/definitelyNotNull.kt

@@ -1,33 +1,33 @@
 package test
 
 interface A<T> {
-    fun foo(x: T!!)
+    fun foo(x: T & Any)
 
-    val w: T!!
+    val w: T & Any
 }
 
-class B<X>(r: X!!)
+class B<X>(r: X & Any)
 
 fun <K> inside() {
     object : A<K> {
-        override fun foo(x: K!!) {
+        override fun foo(x: K & Any) {
         }
 
-        override val w: K!!
+        override val w: K & Any
             get() = TODO("")
     }
 }
 
-fun <F> bar1(x: F!!) {}
+fun <F> bar1(x: F & Any) {}
 fun <F> bar2(x: F) = x!!
 
-val <E> E.nn: E!! get() = this!!
+val <E> E.nn: E & Any get() = this!!
 
 class Outer {
-    abstract class R1<T, F : T!!> : A<T!!>
-    abstract class R2<T, F : T!!> : A<T>
+    abstract class R1<T, F : T & Any> : A<T & Any>
+    abstract class R2<T, F : T & Any> : A<T>
 
     abstract class W<T> : A<T>
 }
 
-typealias Alias<R> = A<R!!>
+typealias Alias<R> = A<R & Any>