Introduce warning about implicitly inferred Nothing as a type parameter

^KT-20849 Fixed

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

@@ -743,6 +743,8 @@ public interface Errors {
 
     DiagnosticFactory0<KtExpression> TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT = DiagnosticFactory0.create(ERROR, SPECIAL_CONSTRUCT_TOKEN);
 
+    DiagnosticFactory0<PsiElement> IMPLICIT_NOTHING_AS_TYPE_PARAMETER = DiagnosticFactory0.create(WARNING);
+
     // Reflection
 
     DiagnosticFactory1<KtExpression, CallableMemberDescriptor> EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED = DiagnosticFactory1.create(ERROR);

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

@@ -959,6 +959,7 @@ public class DefaultErrorMessages {
         MAP.put(ILLEGAL_SUSPEND_PROPERTY_ACCESS, "Suspend property ''{0}'' should be accessed only from a coroutine or suspend function", NAME);
         MAP.put(ILLEGAL_RESTRICTED_SUSPENDING_FUNCTION_CALL, "Restricted suspending functions can only invoke member or extension suspending functions on their restricted coroutine scope");
         MAP.put(NON_MODIFIER_FORM_FOR_BUILT_IN_SUSPEND, "''suspend'' function can only be called in a form of modifier of a lambda: suspend { ... }");
+        MAP.put(IMPLICIT_NOTHING_AS_TYPE_PARAMETER, "One of the type variables was implicitly inferred to Nothing. Please, specify type arguments explicitly to hide this warning.");
         MAP.put(RETURN_FOR_BUILT_IN_SUSPEND, "Using implicit label for this lambda is prohibited");
         MAP.put(MODIFIER_FORM_FOR_NON_BUILT_IN_SUSPEND, "Calls having a form of ''suspend {}'' are deprecated because ''suspend'' in the context will have a meaning of a modifier. Add empty argument list to the call: ''suspend() { ... }''");
 

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

@@ -42,7 +42,7 @@ private val DEFAULT_CALL_CHECKERS = listOf(
     ConstructorHeaderCallChecker, ProtectedConstructorCallChecker, ApiVersionCallChecker,
     CoroutineSuspendCallChecker, BuilderFunctionsCallChecker, DslScopeViolationCallChecker, MissingDependencyClassChecker,
     CallableReferenceCompatibilityChecker(), LateinitIntrinsicApplicabilityChecker,
-    UnderscoreUsageChecker, AssigningNamedArgumentToVarargChecker(),
+    UnderscoreUsageChecker, AssigningNamedArgumentToVarargChecker(), ImplicitNothingAsTypeParameterCallChecker,
     PrimitiveNumericComparisonCallChecker, LambdaWithSuspendModifierCallChecker,
     UselessElvisCallChecker(), ResultTypeWithNullableOperatorsChecker(), NullableVarargArgumentCallChecker,
     NamedFunAsExpressionChecker, ContractNotAllowedCallChecker, ReifiedTypeParameterSubstitutionChecker(), TypeOfChecker

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ImplicitNothingAsTypeParameterCallChecker.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. 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.resolve.calls.checkers
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.builtins.isFunctionType
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils
+import org.jetbrains.kotlin.types.typeUtil.isNothing
+
+object ImplicitNothingAsTypeParameterCallChecker : CallChecker {
+    private val SPECIAL_FUNCTION_NAMES = ControlStructureTypingUtils.ResolveConstruct.values().map { it.specialFunctionName }.toSet()
+
+    /*
+     * The warning isn't reported in cases where there are lambda among the function arguments,
+     * the return type of which is a type variable, that was inferred to Nothing.
+     * This corresponds to useful cases in which this report will not be helpful.
+     *
+     * E.g.:
+     *
+     * 1) Return if null:
+     *      x?.let { return }
+     *
+     * 2) Implicit receiver to shorter code writing:
+     *      x.run {
+     *          println(inv())
+     *          return inv()
+     *      }
+     */
+    override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
+        if (resolvedCall.candidateDescriptor.name !in SPECIAL_FUNCTION_NAMES && resolvedCall.call.typeArguments.isEmpty()) {
+            val lambdasFromArgumentsReturnTypes =
+                resolvedCall.candidateDescriptor.valueParameters.filter { it.type.isFunctionType }
+                    .map { it.returnType?.arguments?.last()?.type }.toSet()
+
+            val hasImplicitNothingExceptLambdaReturnTypes = resolvedCall.typeArguments.any { (unsubstitutedType, resultingType) ->
+                resultingType.isNothing() && unsubstitutedType.defaultType !in lambdasFromArgumentsReturnTypes
+            }
+
+            if (hasImplicitNothingExceptLambdaReturnTypes) {
+                context.trace.report(Errors.IMPLICIT_NOTHING_AS_TYPE_PARAMETER.on(reportOn))
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt

@@ -13,13 +13,13 @@ fun doSomething() {}
 
 fun test2() {
     fun f(x: Any?) = x
-    f(null?.let { return })
+    f(null?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>let<!> { return })
 
     // false unreachable here
     doSomething()
 }
 
 fun test3(x: Any?): Boolean =
-    x?.let { 
+    x?.let {
         return true
     } ?: false

compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt

@@ -24,7 +24,7 @@ fun foo(x: MC<out Open>) {
     x.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>mc<Derived>()<!>)
     x.addAllMC(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>mc<Derived>()<!>)
 
-    x.addAll(c())
+    x.addAll(<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>c<!>())
     x.addAll(c<Nothing>())
 
     x.<!OI;MEMBER_PROJECTED_OUT!>addAllInv<!>(<!NI;TYPE_MISMATCH!>mc<Open>()<!>)

compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt

@@ -17,7 +17,7 @@ fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
         <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
     }
     a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
-    a.bar { Out() }
+    a.bar { <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>() }
     a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.<!NI;TYPE_MISMATCH!>id()<!><!> }
 
     a.foo {

compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt

@@ -16,7 +16,7 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
     a.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo1<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Out<CharSequence>()<!>)
     a.foo1<<!UPPER_BOUND_VIOLATED!>Out<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Out()<!>)
 
-    a.foo1(Out())
+    a.foo1(<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>())
     a.foo1(Out<Nothing>())
 
     a.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)

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

@@ -7,6 +7,6 @@ fun foo1() {
     <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT22<!>()
 }
 
-val n : Nothing = null.sure()
+val n : Nothing = null.<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>sure<!>()
 
 fun <T : Any> T?.sure() : T = this!!

compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.kt

@@ -9,8 +9,8 @@ inline fun <reified T> foo2(f: (T) -> Unit): Foo<T> = Foo()
 
 fun test1() {
     val f1: Foo<out Int> = foo1 { it checkType { _<Int>() } }
-    val f2: Foo<in Nothing> = foo1 { it <!UNREACHABLE_CODE!>checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
+    val f2: Foo<in Nothing> = <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>foo1<!> { it <!UNREACHABLE_CODE!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
 
     val f3: Foo<out Int> = foo2 { it checkType { _<Int>() } }
-    val f4: Foo<in Nothing> = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo2<!> { it <!UNREACHABLE_CODE!>checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
+    val f4: Foo<in Nothing> = <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo2<!> { it <!UNREACHABLE_CODE!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
 }

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

@@ -13,5 +13,5 @@ fun test(s: String): String {
     a checkType { _<String>() }
 
     <!UNREACHABLE_CODE!>val b =<!> TestClass { return s }
-    <!UNREACHABLE_CODE!>b checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
+    <!UNREACHABLE_CODE!>b <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
 }

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

@@ -11,5 +11,5 @@ fun test(s: String): String {
     a checkType { _<TestClass>() }
 
     <!UNREACHABLE_CODE!>val b =<!> TestClass { return s }
-    <!UNREACHABLE_CODE!>b checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
+    <!UNREACHABLE_CODE!>b <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
 }

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

@@ -8,7 +8,7 @@ class TestClass {
 
 fun <T> test(value: T, test: TestClass): T {
     <!UNREACHABLE_CODE!>val x =<!> test { return value }
-    <!UNREACHABLE_CODE!>x checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
+    <!UNREACHABLE_CODE!>x <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
 
     <!UNREACHABLE_CODE!>return value<!>
 }

compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt

@@ -10,7 +10,7 @@ public class TestClass {
 fun run() {
     val testClass = TestClass()
     // inferred as `set<Nothing>()`, return type is Nothing!
-    testClass.set("test", null)
+    testClass.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>set<!>("test", null)
 
     // Should not be unreachable
     run()

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/nullAsNothing.kt

@@ -5,5 +5,5 @@ val <!IMPLICIT_NOTHING_PROPERTY_TYPE!>y<!> get() = null!!
 
 fun foo() {
     <!DEBUG_INFO_CONSTANT!>x<!> checkType { _<Nothing?>() }
-    y <!UNREACHABLE_CODE!>checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
+    y <!UNREACHABLE_CODE!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
 }

compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameter.kt

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNCHECKED_CAST
+// SKIP_TXT
+// Issue: KT-20849
+
+fun <T>test_1(x: T): T = null as T
+fun <T>test_2(x: () -> T): T = null as T
+
+fun case_1() {
+    null?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>run<!> { return }
+    null!!.<!UNREACHABLE_CODE!><!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>run<!> { throw Exception() }<!>
+}
+
+fun case_2() {
+    test_1 { null!! }
+    test_2 { null!! }
+}
+
+fun case_3() {
+    test_1 { throw Exception() }
+    test_2 { throw Exception() }
+}
+
+fun case_6() {
+    null!!
+}
+
+fun case_7(x: Boolean?) {
+    <!DEBUG_INFO_IMPLICIT_EXHAUSTIVE!>when (x) {
+        true -> throw Exception()
+        false -> throw Exception()
+        null -> throw Exception()
+    }<!>
+}
+
+fun <T> something(): T = Any() as T
+
+class Context<T>
+
+fun <T> Any.decodeIn(typeFrom: Context<in T>): T = something()
+
+fun <T> Any?.decodeOut(typeFrom: Context<out T>): T {
+    return this?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>decodeIn<!>(typeFrom) ?: <!UNRESOLVED_REFERENCE!>error<!>("")
+}

compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameterNI.kt

@@ -0,0 +1,49 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNCHECKED_CAST
+// !LANGUAGE: +NewInference
+// SKIP_TXT
+// Issue: KT-20849
+
+fun <T>test_1(x: T.() -> T): T = null as T
+fun <T>test_2(x: (T) -> T): T = null as T
+fun <T>test_3(x: T.(T) -> T): T = null as T
+fun <T>test_4(x: T.(T) -> List<T>): T = null as T
+fun <T>test_5(): List<T> = 10 <!CAST_NEVER_SUCCEEDS!>as<!> List<T>
+fun <K, V>test_6(): Map<K, V> = 10 <!CAST_NEVER_SUCCEEDS!>as<!> Map<K, V>
+
+fun case_1() {
+    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_5<!>()
+    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_6<!>()
+    val <!UNUSED_VARIABLE!>x<!> = <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_6<!>()
+}
+
+fun case_2() {
+    test_1 { null!! }
+}
+
+fun case_3() {
+    test_2 { null!! }
+}
+
+fun case_4() {
+    test_3 { null!! }
+}
+
+fun case_5() {
+    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_4<!> { null!! }
+}
+
+fun case_6() {
+    test_1 { throw Exception() }
+}
+
+fun case_7() {
+    test_2 { throw Exception() }
+}
+
+fun case_8() {
+    test_3 { throw Exception() }
+}
+
+fun case_9() {
+    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_4<!> { throw Exception() }
+}

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt

@@ -13,4 +13,4 @@ fun <T> listOf(): List<T> = null!!
 // since it has 'out' type projection in 'in' position.
 val test1 = <!UNRESOLVED_REFERENCE!>BOutIn<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>listOf<!>(), null!!)
 
-val test2 = <!OI;EXPANDED_TYPE_CANNOT_BE_CONSTRUCTED!>BInIn(listOf(), null!!)<!>
+val test2 = <!OI;EXPANDED_TYPE_CANNOT_BE_CONSTRUCTED!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>BInIn<!>(<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>listOf<!>(), null!!)<!>

compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt

@@ -4,12 +4,12 @@ fun test(mc: MutableCollection<out CharSequence>) {
     mc.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>mc<!>)
 
     mc.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>arrayListOf<CharSequence>()<!>)
-    mc.addAll(arrayListOf())
+    mc.addAll(<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>arrayListOf<!>())
 
     mc.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>listOf("")<!>)
     mc.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>listOf<String>("")<!>)
     mc.addAll(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>listOf<CharSequence>("")<!>)
 
-    mc.addAll(emptyList())
+    mc.addAll(<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>emptyList<!>())
     mc.addAll(emptyList<Nothing>())
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction.kt

@@ -3,7 +3,7 @@
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
 
-suspend fun suspendLogAndThrow(exception: Throwable): Nothing = suspendCoroutineUninterceptedOrReturn { c ->
+suspend fun suspendLogAndThrow(exception: Throwable): Nothing = <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>suspendCoroutineUninterceptedOrReturn<!> { c ->
     c.resumeWithException(exception)
     COROUTINE_SUSPENDED
 }

compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt

@@ -6,7 +6,7 @@ inline fun<reified T> foo(block: () -> T): String = block().toString()
 inline fun <reified T: Any> javaClass(): Class<T> = T::class.java
 
 fun box() {
-    val a = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, UNSUPPORTED!>arrayOf<!>(null!!)
+    val a = <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, UNSUPPORTED!>arrayOf<!>(null!!)
     val b = <!UNSUPPORTED!>Array<!><<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Nothing?<!>>(5) { null!! }
     val c = <!OI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!>() { null!! }
     val d = foo<Any> { null!! }

compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-casts-sources/p-4/pos/1.12.kt

@@ -1661,12 +1661,12 @@ fun Nothing.case_63() {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>this<!>.hashCode()
 
         hashCode()
-        apply {
+        <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>apply<!> {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>this<!>
             <!UNREACHABLE_CODE!>hashCode()<!>
             <!UNREACHABLE_CODE!><!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>this<!>.hashCode()<!>
         }
-        also {
+        <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>also<!> {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!>
             <!UNREACHABLE_CODE!><!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>it<!>.hashCode()<!>
         }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/4.kt

@@ -228,11 +228,11 @@ fun case_7(value_1: String?) {
     }
     when {
         value_1.case_7_10() == null -> println(value_1)
-        <!DEBUG_INFO_CONSTANT!>value_1<!>.case_7_10() != null -> println(<!DEBUG_INFO_CONSTANT!>value_1<!>)
+        <!DEBUG_INFO_CONSTANT!>value_1<!>.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>case_7_10<!>() != null -> println(<!DEBUG_INFO_CONSTANT!>value_1<!>)
     }
     when {
         value_1.case_7_11() != null -> println(value_1)
-        <!DEBUG_INFO_CONSTANT!>value_1<!>.case_7_11() == null -> println(<!DEBUG_INFO_CONSTANT!>value_1<!>)
+        <!DEBUG_INFO_CONSTANT!>value_1<!>.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>case_7_11<!>() == null -> println(<!DEBUG_INFO_CONSTANT!>value_1<!>)
     }
 }
 

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/8.kt

@@ -89,7 +89,7 @@ fun case_3(value_1: Int?, value_2: Any?) {
     if (!value_1.case_3(value_1, value_2 is Number?)) {
         println(<!DEBUG_INFO_SMARTCAST!>value_2<!>?.toByte())
         println(<!DEBUG_INFO_SMARTCAST!>value_1<!>.inv())
-    } else if (<!DEBUG_INFO_CONSTANT!>value_1<!>.case_3(<!DEBUG_INFO_CONSTANT!>value_1<!>, value_2 is Number?)) {
+    } else if (<!DEBUG_INFO_CONSTANT!>value_1<!>.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>case_3<!>(<!DEBUG_INFO_CONSTANT!>value_1<!>, value_2 is Number?)) {
         println(<!DEBUG_INFO_CONSTANT!>value_1<!>)
     } else {
         <!UNREACHABLE_CODE!>println(<!><!DEBUG_INFO_SMARTCAST!>value_1<!><!UNREACHABLE_CODE!>.inv())<!>

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -22150,6 +22150,16 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                 runTest("compiler/testData/diagnostics/tests/typeParameters/functionTypeAsUpperBound.kt");
             }
 
+            @TestMetadata("implicitNothingAsTypeParameter.kt")
+            public void testImplicitNothingAsTypeParameter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameter.kt");
+            }
+
+            @TestMetadata("implicitNothingAsTypeParameterNI.kt")
+            public void testImplicitNothingAsTypeParameterNI() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameterNI.kt");
+            }
+
             @TestMetadata("misplacedConstraints.kt")
             public void testMisplacedConstraints() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt");

compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java

@@ -22070,6 +22070,16 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                 runTest("compiler/testData/diagnostics/tests/typeParameters/functionTypeAsUpperBound.kt");
             }
 
+            @TestMetadata("implicitNothingAsTypeParameter.kt")
+            public void testImplicitNothingAsTypeParameter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameter.kt");
+            }
+
+            @TestMetadata("implicitNothingAsTypeParameterNI.kt")
+            public void testImplicitNothingAsTypeParameterNI() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameterNI.kt");
+            }
+
             @TestMetadata("misplacedConstraints.kt")
             public void testMisplacedConstraints() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt");