Support definitely-not-null generic T!! types in Parsing and FE1.0

^KT-26245 In Progress

compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java

@@ -438,6 +438,11 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli
                 runTest("compiler/testData/loadJava/compiledKotlin/annotations/types/ClassLiteralArgument.kt");
             }
 
+            @TestMetadata("DefinitelyNotNull.kt")
+            public void testDefinitelyNotNull() throws Exception {
+                runTest("compiler/testData/loadJava/compiledKotlin/annotations/types/DefinitelyNotNull.kt");
+            }
+
             @TestMetadata("ReceiverParameter.kt")
             public void testReceiverParameter() throws Exception {
                 runTest("compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.kt");

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java

@@ -9170,6 +9170,46 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti
             }
         }
 
+        @Nested
+        @TestMetadata("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ExplicitDefinitelyNotNull {
+            @Test
+            public void testAllFilesPresentInExplicitDefinitelyNotNull() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+            }
+
+            @Test
+            @TestMetadata("disabledFeature.kt")
+            public void testDisabledFeature() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/disabledFeature.kt");
+            }
+
+            @Test
+            @TestMetadata("notApplicable.kt")
+            public void testNotApplicable() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/notApplicable.kt");
+            }
+
+            @Test
+            @TestMetadata("overrides.kt")
+            public void testOverrides() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/overrides.kt");
+            }
+
+            @Test
+            @TestMetadata("overridesJavaAnnotated.kt")
+            public void testOverridesJavaAnnotated() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/overridesJavaAnnotated.kt");
+            }
+
+            @Test
+            @TestMetadata("simple.kt")
+            public void testSimple() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/simple.kt");
+            }
+        }
+
         @Nested
         @TestMetadata("compiler/testData/diagnostics/tests/exposed")
         @TestDataPath("$PROJECT_ROOT")

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -1637,6 +1637,7 @@ class DeclarationsConverter(
                 TYPE_REFERENCE -> firType = convertType(it)
                 MODIFIER_LIST -> if (!afterLPar || typeModifiers.hasNoAnnotations()) typeModifiers = convertTypeModifierList(it)
                 USER_TYPE -> firType = convertUserType(it)
+                DEFINITELY_NOT_NULL_TYPE -> firType = unwrapDefinitelyNotNullableType(it)
                 NULLABLE_TYPE -> firType = convertNullableType(it)
                 FUNCTION_TYPE -> firType = convertFunctionType(it, isSuspend = typeModifiers.hasSuspend)
                 DYNAMIC_TYPE -> firType = buildDynamicTypeRef {
@@ -1676,6 +1677,7 @@ class DeclarationsConverter(
                     convertUserType(it, true)
                 FUNCTION_TYPE -> firType = convertFunctionType(it, true)
                 NULLABLE_TYPE -> firType = convertNullableType(it)
+                DEFINITELY_NOT_NULL_TYPE -> firType = unwrapDefinitelyNotNullableType(it, nullable = true)
                 DYNAMIC_TYPE -> firType = buildDynamicTypeRef {
                     source = nullableType.toFirSourceElement()
                     isMarkedNullable = true
@@ -1686,6 +1688,26 @@ class DeclarationsConverter(
         return firType
     }
 
+    private fun unwrapDefinitelyNotNullableType(definitelyNotNullType: LighterASTNode, nullable: Boolean = false): FirTypeRef {
+        lateinit var firType: FirTypeRef
+        // TODO: Support proper DefinitelyNotNullableType
+        definitelyNotNullType.forEachChildren {
+            when (it.tokenType) {
+                USER_TYPE -> firType =
+                    convertUserType(it, nullable)
+                FUNCTION_TYPE -> firType = convertFunctionType(it, nullable)
+                NULLABLE_TYPE -> firType = convertNullableType(it)
+                DEFINITELY_NOT_NULL_TYPE -> firType = unwrapDefinitelyNotNullableType(it, nullable)
+                DYNAMIC_TYPE -> firType = buildDynamicTypeRef {
+                    source = definitelyNotNullType.toFirSourceElement()
+                    isMarkedNullable = false
+                }
+            }
+        }
+
+        return firType
+    }
+
     /**
      * @see org.jetbrains.kotlin.parsing.KotlinParsing.parseUserType
      */

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -1330,7 +1330,12 @@ open class RawFirBuilder(
             val isNullable = typeElement is KtNullableType
 
             fun KtTypeElement?.unwrapNullable(): KtTypeElement? =
-                if (this is KtNullableType) this.innerType.unwrapNullable() else this
+                when (this) {
+                    is KtNullableType -> this.innerType.unwrapNullable()
+                    // TODO: Support explicit definitely not null type
+                    is KtDefinitelyNotNullType -> this.innerType.unwrapNullable()
+                    else -> this
+                }
 
             val firTypeBuilder = when (val unwrappedElement = typeElement.unwrapNullable()) {
                 is KtDynamicType -> FirDynamicTypeRefBuilder().apply {

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -156,6 +156,8 @@ public interface Errors {
     DiagnosticFactory0<KtTypeProjection> PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT = DiagnosticFactory0.create(ERROR, VARIANCE_IN_PROJECTION);
     DiagnosticFactory2<KtTypeReference, KotlinType, KotlinType> UPPER_BOUND_VIOLATED = DiagnosticFactory2.create(ERROR);
     DiagnosticFactory0<KtNullableType> REDUNDANT_NULLABLE = DiagnosticFactory0.create(WARNING, NULLABLE_TYPE);
+    DiagnosticFactory0<KtDefinitelyNotNullType> DEFINITELY_NOT_NULLABLE_NOT_APPLICABLE = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtNullableType> NULLABLE_ON_DEFINITELY_NOT_NULLABLE = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory2<KtElement, Integer, DeclarationDescriptor> WRONG_NUMBER_OF_TYPE_ARGUMENTS = DiagnosticFactory2.create(ERROR);
     DiagnosticFactory1<KtElement, ClassDescriptor> OUTER_CLASS_ARGUMENTS_REQUIRED = DiagnosticFactory1.create(ERROR);
     DiagnosticFactory1<KtElement, String> TYPE_ARGUMENTS_NOT_ALLOWED = DiagnosticFactory1.create(ERROR);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -675,6 +675,8 @@ public class DefaultErrorMessages {
         MAP.put(NULLABLE_SUPERTYPE, "A supertype cannot be nullable");
         MAP.put(DYNAMIC_SUPERTYPE, "A supertype cannot be dynamic");
         MAP.put(REDUNDANT_NULLABLE, "Redundant '?'");
+        MAP.put(DEFINITELY_NOT_NULLABLE_NOT_APPLICABLE, "'!!' is only applicable to type parameters with nullable upper bounds");
+        MAP.put(NULLABLE_ON_DEFINITELY_NOT_NULLABLE, "'!!' type cannot be marked as nullable");
         MAP.put(UNSAFE_CALL, "Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type {0}", RENDER_TYPE);
         MAP.put(UNSAFE_IMPLICIT_INVOKE_CALL, "Reference has a nullable type ''{0}'', use explicit ''?.invoke()'' to make a function-like call instead", RENDER_TYPE);
         MAP.put(AMBIGUOUS_LABEL, "Ambiguous label");

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -264,21 +264,61 @@ class TypeResolver(
             }
 
             override fun visitNullableType(nullableType: KtNullableType) {
-                val innerModifierList = nullableType.modifierList
+                val innerType = nullableType.innerType
-                if (innerModifierList != null && outerModifierList != null) {
+
-                    c.trace.report(MODIFIER_LIST_NOT_ALLOWED.on(innerModifierList))
+                val baseType = createTypeFromInner(nullableType, nullableType.modifierList, innerType)
+
+                if (!baseType.isBare && baseType.actualType is DefinitelyNotNullType) {
+                    c.trace.report(NULLABLE_ON_DEFINITELY_NOT_NULLABLE.on(nullableType))
                 }
 
-                val innerAnnotations = composeAnnotations(annotations, resolveTypeAnnotations(c, nullableType))
-
-                val innerType = nullableType.innerType
-                val baseType = resolveTypeElement(c, innerAnnotations, outerModifierList ?: innerModifierList, innerType)
                 if (baseType.isNullable || innerType is KtNullableType || innerType is KtDynamicType) {
                     c.trace.report(REDUNDANT_NULLABLE.on(nullableType))
                 }
                 result = baseType.makeNullable()
             }
 
+            private fun createTypeFromInner(
+                typeElement: KtTypeElement,
+                innerModifierList: KtModifierList?,
+                innerType: KtTypeElement?
+            ): PossiblyBareType {
+                if (innerModifierList != null && outerModifierList != null) {
+                    c.trace.report(MODIFIER_LIST_NOT_ALLOWED.on(innerModifierList))
+                }
+
+                val innerAnnotations = composeAnnotations(annotations, resolveTypeAnnotations(c, typeElement as KtElementImplStub<*>))
+
+                return resolveTypeElement(c, innerAnnotations, outerModifierList ?: innerModifierList, innerType)
+            }
+
+            override fun visitDefinitelyNotNullType(definitelyNotNullType: KtDefinitelyNotNullType) {
+                val baseType =
+                    createTypeFromInner(definitelyNotNullType, definitelyNotNullType.modifierList, definitelyNotNullType.innerType)
+
+                if (!languageVersionSettings.supportsFeature(LanguageFeature.DefinitelyNotNullTypeParameters)) {
+                    result = baseType
+                    c.trace.report(
+                        UNSUPPORTED_FEATURE.on(
+                            definitelyNotNullType,
+                            LanguageFeature.DefinitelyNotNullTypeParameters to languageVersionSettings
+                        )
+                    )
+                    return
+                }
+
+                val definitelyNotNullKotlinType =
+                    if (!baseType.isBare) DefinitelyNotNullType.makeDefinitelyNotNull(baseType.actualType.unwrap()) else null
+
+                if (definitelyNotNullKotlinType == null) {
+                    result = baseType
+                    c.trace.report(DEFINITELY_NOT_NULLABLE_NOT_APPLICABLE.on(definitelyNotNullType))
+                    return
+                }
+
+                result = type(definitelyNotNullKotlinType)
+            }
+
             override fun visitFunctionType(type: KtFunctionType) {
                 val receiverTypeRef = type.receiverTypeReference
                 val receiverType = if (receiverTypeRef == null) null else resolveType(c.noBareTypes(), receiverTypeRef)
@@ -494,8 +534,8 @@ class TypeResolver(
         }
 
         val (collectedArgumentAsTypeProjections, argumentsForOuterClass) =
-                collectArgumentsForClassifierTypeConstructor(c, classDescriptor, qualifierResolutionResult.qualifierParts)
+            collectArgumentsForClassifierTypeConstructor(c, classDescriptor, qualifierResolutionResult.qualifierParts)
-                        ?: return createErrorTypeForTypeConstructor(c, projectionFromAllQualifierParts, typeConstructor)
+                ?: return createErrorTypeForTypeConstructor(c, projectionFromAllQualifierParts, typeConstructor)
 
         assert(collectedArgumentAsTypeProjections.size <= parameters.size) {
             "Collected arguments count should be not greater then parameters count," +
@@ -583,11 +623,11 @@ class TypeResolver(
 
         val typeAliasQualifierPart =
             qualifierResolutionResult.qualifierParts.lastOrNull()
-                    ?: return createErrorTypeForTypeConstructor(c, projectionFromAllQualifierParts, typeConstructor)
+                ?: return createErrorTypeForTypeConstructor(c, projectionFromAllQualifierParts, typeConstructor)
 
         val (argumentElementsFromUserType, argumentsForOuterClass) =
-                collectArgumentsForClassifierTypeConstructor(c, descriptor, qualifierResolutionResult.qualifierParts)
+            collectArgumentsForClassifierTypeConstructor(c, descriptor, qualifierResolutionResult.qualifierParts)
-                        ?: return createErrorTypeForTypeConstructor(c, projectionFromAllQualifierParts, typeConstructor)
+                ?: return createErrorTypeForTypeConstructor(c, projectionFromAllQualifierParts, typeConstructor)
 
         val argumentsFromUserType = resolveTypeProjections(c, typeConstructor, argumentElementsFromUserType)
 
@@ -803,7 +843,7 @@ class TypeResolver(
                 parameters[result.size].original.containingDeclaration as? ClassDescriptor
                 // If next parameter is captured from the enclosing function, default arguments must be used
                 // (see appendDefaultArgumentsForLocalClassifier)
-                        ?: return Pair(result, null)
+                    ?: return Pair(result, null)
 
             val restArguments = c.scope.findImplicitOuterClassArguments(nextParameterOwner)
             val restParameters = parameters.subList(result.size, parameters.size)

compiler/psi/src/org/jetbrains/kotlin/KtNodeTypes.java

@@ -75,6 +75,7 @@ public interface KtNodeTypes {
     IElementType FUNCTION_TYPE            = KtStubElementTypes.FUNCTION_TYPE;
     IElementType FUNCTION_TYPE_RECEIVER   = KtStubElementTypes.FUNCTION_TYPE_RECEIVER;
     IElementType NULLABLE_TYPE            = KtStubElementTypes.NULLABLE_TYPE;
+    IElementType DEFINITELY_NOT_NULL_TYPE = KtStubElementTypes.DEFINITELY_NOT_NULL_TYPE;
     IElementType TYPE_PROJECTION          = KtStubElementTypes.TYPE_PROJECTION;
 
     IElementType PROPERTY_ACCESSOR       = KtStubElementTypes.PROPERTY_ACCESSOR;

compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java

@@ -2220,6 +2220,12 @@ public class KotlinParsing extends AbstractKotlinParsing {
         }
 
         userType.done(USER_TYPE);
+
+        if (at(EXCLEXCL)) {
+            PsiBuilder.Marker definitelyNotNull = userType.precede();
+            advance(); // !!
+            definitelyNotNull.done(DEFINITELY_NOT_NULL_TYPE);
+        }
     }
 
     private boolean atParenthesizedMutableForPlatformTypes(int offset) {

compiler/psi/src/org/jetbrains/kotlin/psi/KtDefinitelyNotNullType.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.psi
+
+import com.intellij.lang.ASTNode
+import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
+
+class KtDefinitelyNotNullType : KtElementImplStub<KotlinPlaceHolderStub<KtDefinitelyNotNullType>>, KtTypeElement {
+    constructor(node: ASTNode) : super(node)
+    constructor(stub: KotlinPlaceHolderStub<KtDefinitelyNotNullType>) : super(stub, KtStubElementTypes.DEFINITELY_NOT_NULL_TYPE)
+
+    override fun getTypeArgumentsAsTypes(): List<KtTypeReference> {
+        return this.innerType?.typeArgumentsAsTypes ?: emptyList()
+    }
+
+    override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
+        return visitor.visitDefinitelyNotNullType(this, data)
+    }
+
+    @get:IfNotParsed
+    val innerType: KtTypeElement?
+        get() = KtStubbedPsiUtil.getStubOrPsiChild(this, KtStubElementTypes.TYPE_ELEMENT_TYPES, KtTypeElement.ARRAY_FACTORY)
+
+    val modifierList: KtModifierList?
+        get() = getStubOrPsiChild(KtStubElementTypes.MODIFIER_LIST)
+
+    val annotationEntries: List<KtAnnotationEntry>
+        get() {
+            return modifierList?.annotationEntries ?: emptyList()
+        }
+}

compiler/psi/src/org/jetbrains/kotlin/psi/KtVisitor.java

@@ -402,6 +402,10 @@ public class KtVisitor<R, D> extends PsiElementVisitor {
         return visitTypeElement(nullableType, data);
     }
 
+    public R visitDefinitelyNotNullType(@NotNull KtDefinitelyNotNullType definitelyNotNullType, D data) {
+        return visitTypeElement(definitelyNotNullType, data);
+    }
+
     public R visitTypeProjection(@NotNull KtTypeProjection typeProjection, D data) {
         return visitKtElement(typeProjection, data);
     }

compiler/psi/src/org/jetbrains/kotlin/psi/KtVisitorVoid.java

@@ -385,6 +385,10 @@ public class KtVisitorVoid extends KtVisitor<Void, Void> {
         super.visitNullableType(nullableType, null);
     }
 
+    public void visitDefinitelyNotNullType(@NotNull KtDefinitelyNotNullType definitelyNotNullType) {
+        super.visitDefinitelyNotNullType(definitelyNotNullType, null);
+    }
+
     public void visitTypeProjection(@NotNull KtTypeProjection typeProjection) {
         super.visitTypeProjection(typeProjection, null);
     }
@@ -972,6 +976,12 @@ public class KtVisitorVoid extends KtVisitor<Void, Void> {
         return null;
     }
 
+    @Override
+    public Void visitDefinitelyNotNullType(@NotNull KtDefinitelyNotNullType definitelyNotNullType, Void data) {
+        visitDefinitelyNotNullType(definitelyNotNullType);
+        return null;
+    }
+
     @Override
     public final Void visitTypeProjection(@NotNull KtTypeProjection typeProjection, Void data) {
         visitTypeProjection(typeProjection);

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementTypes.java

@@ -79,6 +79,9 @@ public interface KtStubElementTypes {
     KtPlaceHolderStubElementType<KtNullableType> NULLABLE_TYPE =
             new KtPlaceHolderStubElementType<>("NULLABLE_TYPE", KtNullableType.class);
 
+    KtPlaceHolderStubElementType<KtDefinitelyNotNullType> DEFINITELY_NOT_NULL_TYPE =
+            new KtPlaceHolderStubElementType<>("DEFINITELY_NOT_NULL_TYPE", KtDefinitelyNotNullType.class);
+
     KtPlaceHolderStubElementType<KtTypeReference> TYPE_REFERENCE =
             new KtPlaceHolderStubElementType<>("TYPE_REFERENCE", KtTypeReference.class);
 
@@ -167,7 +170,7 @@ public interface KtStubElementTypes {
 
     TokenSet SUPER_TYPE_LIST_ENTRIES = TokenSet.create(DELEGATED_SUPER_TYPE_ENTRY, SUPER_TYPE_CALL_ENTRY, SUPER_TYPE_ENTRY);
 
-    TokenSet TYPE_ELEMENT_TYPES = TokenSet.create(USER_TYPE, NULLABLE_TYPE, FUNCTION_TYPE, DYNAMIC_TYPE);
+    TokenSet TYPE_ELEMENT_TYPES = TokenSet.create(USER_TYPE, NULLABLE_TYPE, FUNCTION_TYPE, DYNAMIC_TYPE, DEFINITELY_NOT_NULL_TYPE);
 
     TokenSet INSIDE_DIRECTIVE_EXPRESSIONS = TokenSet.create(REFERENCE_EXPRESSION, DOT_QUALIFIED_EXPRESSION);
 }

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T : Any> foo(x: T!!, y: List<String!!>!!) {}
+
+fun <F> bar1(x: F?<!SYNTAX!><!SYNTAX!><!>!!<!><!SYNTAX!>)<!> <!FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar2(x: F!!?) {}
+fun <F> bar3(x: (F?)<!SYNTAX!><!SYNTAX!><!>!!<!><!SYNTAX!>)<!> <!FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar4(x: (F!!)?) {}
+
+fun <F> bar5(x: F!!<!SYNTAX!><!SYNTAX!><!>!<!><!SYNTAX!>)<!> <!FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar6(x: F!!<!SYNTAX!><!SYNTAX!><!>!<!><!SYNTAX!>)<!> <!FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar7(x: F!!?<!SYNTAX!><!SYNTAX!><!>!!<!><!SYNTAX!>)<!> <!FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>

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

@@ -0,0 +1,12 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T : Any> foo(x: <!DEFINITELY_NOT_NULLABLE_NOT_APPLICABLE!>T!!<!>, y: <!DEFINITELY_NOT_NULLABLE_NOT_APPLICABLE!>List<<!DEFINITELY_NOT_NULLABLE_NOT_APPLICABLE!>String!!<!>>!!<!>) {}
+
+fun <F> bar1(x: F?<!SYNTAX!><!SYNTAX!><!>!!<!><!SYNTAX!>)<!> <!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar2(x: <!NULLABLE_ON_DEFINITELY_NOT_NULLABLE!>F!!?<!>) {}
+fun <F> bar3(x: (F?)<!SYNTAX!><!SYNTAX!><!>!!<!><!SYNTAX!>)<!> <!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar4(x: <!NULLABLE_ON_DEFINITELY_NOT_NULLABLE!>(F!!)?<!>) {}
+
+fun <F> bar5(x: F!!<!SYNTAX!><!SYNTAX!><!>!<!><!SYNTAX!>)<!> <!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar6(x: F!!<!SYNTAX!><!SYNTAX!><!>!<!><!SYNTAX!>)<!> <!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>
+fun <F> bar7(x: <!NULLABLE_ON_DEFINITELY_NOT_NULLABLE!>F!!?<!><!SYNTAX!><!SYNTAX!><!>!!<!><!SYNTAX!>)<!> <!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!><!SYNTAX!><!>{}<!>

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

@@ -0,0 +1,16 @@
+package
+
+public fun <no name provided>(): kotlin.Unit
+public fun <no name provided>(): kotlin.Unit
+public fun <no name provided>(): kotlin.Unit
+public fun <no name provided>(): kotlin.Unit
+public fun <no name provided>(): kotlin.Unit
+public fun </*0*/ F> bar1(/*0*/ x: F?): 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*/ T : kotlin.Any> foo(/*0*/ x: T, /*1*/ y: kotlin.collections.List<kotlin.String>): kotlin.Unit
+

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

@@ -0,0 +1,36 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+interface A<T> {
+    fun foo(x: T): T
+    fun bar(x: T!!): T!!
+}
+
+interface B<T1> : A<T1> {
+    override fun foo(x: T1): T1
+    override fun bar(x: T1!!): T1!!
+}
+
+interface C<T2> : A<T2> {
+    override fun foo(x: T2!!): T2!!
+    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?> {
+    override fun foo(x: String): String
+    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/explicitDefinitelyNotNull/overrides.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+interface A<T> {
+    fun foo(x: T): T
+    fun bar(x: T!!): T!!
+}
+
+interface B<T1> : A<T1> {
+    override fun foo(x: T1): T1
+    override fun bar(x: T1!!): T1!!
+}
+
+interface C<T2> : A<T2> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: T2!!): T2!!
+    <!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/explicitDefinitelyNotNull/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/explicitDefinitelyNotNull/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
+    override fun bar(x: T1!!): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>T1!!<!>
+}
+
+interface C<T2> : A<T2> {
+    override fun foo(x: T2!!): T2!!
+    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?> {
+    override fun foo(x: String): String
+    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/explicitDefinitelyNotNull/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!!): T1!!
+}
+
+interface C<T2> : A<T2> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: T2!!): T2!!
+    <!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/explicitDefinitelyNotNull/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/explicitDefinitelyNotNull/simple.fir.kt

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

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

@@ -0,0 +1,14 @@
+// !LANGUAGE: +DefinitelyNotNullTypeParameters
+
+fun <T> foo(x: T, y: T!!): T!! = 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/explicitDefinitelyNotNull/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/psi/DefinitelyNotNullType.kt

@@ -0,0 +1,5 @@
+
+fun <T> foo1(x: T!!, y: List<T!!>, z: T!!.(T!!) -> T!!): T!! {}
+
+// should be prohibited on type-resolution level
+fun <T> foo2(x: T!!?, y: List<T!!?>, z: T!!?.(T!!?) -> T!!?, w: String!!): T!! {}

compiler/testData/psi/DefinitelyNotNullType.txt

@@ -0,0 +1,210 @@
+KtFile: DefinitelyNotNullType.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
+          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(EXCLEXCL)('!!')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')
+  PsiWhiteSpace('\n\n')
+  FUN
+    PsiComment(EOL_COMMENT)('// should be prohibited on type-resolution level')
+    PsiWhiteSpace('\n')
+    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
+          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(EXCLEXCL)('!!')
+    PsiWhiteSpace(' ')
+    BLOCK
+      PsiElement(LBRACE)('{')
+      PsiElement(RBRACE)('}')

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -9176,6 +9176,46 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
             }
         }
 
+        @Nested
+        @TestMetadata("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull")
+        @TestDataPath("$PROJECT_ROOT")
+        public class ExplicitDefinitelyNotNull {
+            @Test
+            public void testAllFilesPresentInExplicitDefinitelyNotNull() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+            }
+
+            @Test
+            @TestMetadata("disabledFeature.kt")
+            public void testDisabledFeature() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/disabledFeature.kt");
+            }
+
+            @Test
+            @TestMetadata("notApplicable.kt")
+            public void testNotApplicable() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/notApplicable.kt");
+            }
+
+            @Test
+            @TestMetadata("overrides.kt")
+            public void testOverrides() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/overrides.kt");
+            }
+
+            @Test
+            @TestMetadata("overridesJavaAnnotated.kt")
+            public void testOverridesJavaAnnotated() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/overridesJavaAnnotated.kt");
+            }
+
+            @Test
+            @TestMetadata("simple.kt")
+            public void testSimple() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/simple.kt");
+            }
+        }
+
         @Nested
         @TestMetadata("compiler/testData/diagnostics/tests/exposed")
         @TestDataPath("$PROJECT_ROOT")

compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java

@@ -141,6 +141,11 @@ public class ParsingTestGenerated extends AbstractParsingTest {
             runTest("compiler/testData/psi/DefaultKeyword.kt");
         }
 
+        @TestMetadata("DefinitelyNotNullType.kt")
+        public void testDefinitelyNotNullType() throws Exception {
+            runTest("compiler/testData/psi/DefinitelyNotNullType.kt");
+        }
+
         @TestMetadata("destructuringInLambdas.kt")
         public void testDestructuringInLambdas() throws Exception {
             runTest("compiler/testData/psi/destructuringInLambdas.kt");

compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt

@@ -203,7 +203,10 @@ enum class LanguageFeature(
     InlineClasses(sinceVersion = KOTLIN_1_3, defaultState = State.ENABLED_WITH_WARNING, kind = UNSTABLE_FEATURE),
     JvmInlineValueClasses(sinceVersion = KOTLIN_1_5, defaultState = State.ENABLED, kind = OTHER),
     SuspendFunctionsInFunInterfaces(sinceVersion = KOTLIN_1_5, defaultState = State.ENABLED, kind = OTHER),
-    SamWrapperClassesAreSynthetic(sinceVersion = KOTLIN_1_5, defaultState = State.ENABLED, kind = BUG_FIX)
+    SamWrapperClassesAreSynthetic(sinceVersion = KOTLIN_1_5, defaultState = State.ENABLED, kind = BUG_FIX),
+
+    // 1.6
+    DefinitelyNotNullTypeParameters(sinceVersion = KOTLIN_1_6),
     ;
 
     val presentableName: String

core/descriptors/src/org/jetbrains/kotlin/types/SpecialTypes.kt

@@ -97,7 +97,7 @@ class DefinitelyNotNullType private constructor(
     DefinitelyNotNullTypeMarker {
 
     companion object {
-        internal fun makeDefinitelyNotNull(
+        fun makeDefinitelyNotNull(
             type: UnwrappedType,
             useCorrectedNullabilityForTypeParameters: Boolean = false
         ): DefinitelyNotNullType? {