diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt
index cddf654e3b4..cdc5af79c7e 100644
--- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt
@@ -200,7 +200,8 @@ class KotlinCallCompleter(
 
         val constructor = typeVariable.constructor
         val variableWithConstraints = csBuilder.currentStorage().notFixedTypeVariables[constructor] ?: return false
-        return variableWithConstraints.constraints.all {
+        val constraints = variableWithConstraints.constraints
+        return constraints.isNotEmpty() && constraints.all {
             !trivialConstraintTypeInferenceOracle.isTrivialConstraint(it) && !it.type.isIntegerValueType() &&
                     it.kind.isLower() && csBuilder.isProperType(it.type)
         }
diff --git a/compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt b/compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt
index a7f6ea032ac..776bf38aabd 100644
--- a/compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt
@@ -7,16 +7,16 @@ fun <T> id(x: T): T = x
 fun <T> baz(x: T, y: T): T = TODO()
 
 fun test() {
-    <!NI;UNREACHABLE_CODE!>val x1: (Int) -> Unit = id(<!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)<!NI;UNREACHABLE_CODE!>)<!>
-    <!NI;UNREACHABLE_CODE!>val x2: (Int) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), ::foo)<!>
-    <!NI;UNREACHABLE_CODE!>val x3: (Int) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    <!NI;UNREACHABLE_CODE!>val x4: (String) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    <!NI;UNREACHABLE_CODE!>val x5: (Double) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)))<!>
+    val x1: (Int) -> Unit = id(id(::foo))
+    val x2: (Int) -> Unit = baz(id(::foo), ::foo)
+    val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
+    val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
+    val x5: (Double) -> Unit = baz(id(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>), id(id(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)))
 
 
-    <!NI;UNREACHABLE_CODE!>id<(Int) -> Unit>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    <!NI;UNREACHABLE_CODE!>id(id<(Int) -> Unit>(::foo))<!>
-    <!NI;UNREACHABLE_CODE!>baz<(Int) -> Unit>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    <!NI;UNREACHABLE_CODE!>baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), id(id<(Int) -> Unit>(::foo)))<!>
-    <!NI;UNREACHABLE_CODE!>baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), id<(Int) -> Unit>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
+    id<(Int) -> Unit>(id(id(::foo)))
+    id(id<(Int) -> Unit>(::foo))
+    baz<(Int) -> Unit>(id(::foo), id(id(::foo)))
+    baz(id(::foo), id(id<(Int) -> Unit>(::foo)))
+    baz(id(::foo), id<(Int) -> Unit>(id(::foo)))
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt
index 97f02366f36..660cbbe2082 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt
@@ -34,6 +34,6 @@ val bbb = null ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 val bbbb = ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>) ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 
 fun f(x : Long?): Long {
-    var a = x ?: (<!OI;TYPE_MISMATCH!>fun() {}<!> <!USELESS_ELVIS!>?: <!OI;TYPE_MISMATCH!>fun() {}<!><!>)
-    return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
+    var a = x ?: (<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>fun() {}<!> <!USELESS_ELVIS!>?: <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>fun() {}<!><!>)
+    return <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
 }
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt
index 14fbc01d280..7708127c2a5 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt
@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // See also KT-5198 / KT-10186
 
 inline fun doCall(f: () -> Unit) = f()
@@ -13,7 +14,7 @@ fun doSomething() {}
 
 fun test2() {
     fun f(x: Any?) = x
-    f(null?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>let<!> { return })
+    f(null?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>let<!> { return })
 
     // false unreachable here
     doSomething()
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt
index 66acefa676d..08216a5ae4b 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt
@@ -8,6 +8,6 @@ fun foo(): String {
 }
 fun bar(): String {
     val x = fn() ?: return ""
-    <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>val <!NI;UNUSED_VARIABLE, OI;UNUSED_VARIABLE!>y<!> =<!> x<!UNNECESSARY_SAFE_CALL!>?.<!>let { throw Exception() } <!NI;UNREACHABLE_CODE, NI;USELESS_ELVIS, OI;UNREACHABLE_CODE, OI;USELESS_ELVIS!>?: "unreachable"<!>
-    <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>return y<!>
+    <!OI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>y<!> =<!> x<!UNNECESSARY_SAFE_CALL!>?.<!>let { throw Exception() } <!OI;UNREACHABLE_CODE, OI;USELESS_ELVIS!>?: "unreachable"<!>
+    <!OI;UNREACHABLE_CODE!>return y<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt
index 217749462c2..4499a4f5fe8 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt
@@ -4,7 +4,7 @@ fun bar(x: Int) = x + 1
 fun f1(x: Int?) {
     bar(<!TYPE_MISMATCH!>x<!>)
     if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
-    if (x == null) <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>)<!>
+    if (x == null) <!OI;UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
 }
 
 fun f2(x: Int?) {    
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt
index 7c37eaa8ce6..c0e232104eb 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt
@@ -1,9 +1,10 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 import kotlin.reflect.KProperty
 
 var a: Int by A()
-var a1 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>A()<!>
+var a1 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>A()<!>
 
 var b: Int by B()
 
diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt
index 475d4360ae9..e8290732d73 100644
--- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt
+++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt
@@ -14,5 +14,5 @@ fun <A> main() {
     <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>b<!>: Int = f()<!>
     <!NI;UNREACHABLE_CODE!>f<Int>()<!>
 
-    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>с<!>: A = id(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, OI;TYPE_PARAMETER_AS_REIFIED!>f<!>())<!>
+    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>с<!>: A = id(<!NI;TYPE_PARAMETER_AS_REIFIED, TYPE_PARAMETER_AS_REIFIED!>f<!>())<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt
index c66b34becf2..34e7ffb3f27 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt
@@ -19,13 +19,13 @@ fun c(): Unit = run {
         // Attention!
         // In OI expected type 'Unit' isn't applied here because of implementation quirks (note that OI still applies Unit in case 'e')
         // In NI, it is applied and call is correctly inferred, which is consistent with the previous case
-        <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }
 
 fun d(): Unit = run outer@{
     run inner@{
-        <!NI;UNREACHABLE_CODE!>return@inner<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        <!NI;UNREACHABLE_CODE!>return@inner<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/nonPropagationOfCoercionToUnitInsideNestedLambda.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/nonPropagationOfCoercionToUnitInsideNestedLambda.kt
index 05f01522125..9a06b729ab7 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/nonPropagationOfCoercionToUnitInsideNestedLambda.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/nonPropagationOfCoercionToUnitInsideNestedLambda.kt
@@ -24,7 +24,7 @@ fun foo(): String? {
 
         run {
             if (true) {
-                Obj()
+                <!IMPLICIT_CAST_TO_ANY!>Obj()<!>
             } else
             <!INVALID_IF_AS_EXPRESSION!>if<!> (true) return null // Error, coercion to Unit doesn't propagate inside nested lambdas
         }
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/returnLambdaFromLambda.kt b/compiler/testData/diagnostics/tests/inference/constraints/returnLambdaFromLambda.kt
index ad3b409b6fd..c6880126246 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/returnLambdaFromLambda.kt
+++ b/compiler/testData/diagnostics/tests/inference/constraints/returnLambdaFromLambda.kt
@@ -9,13 +9,13 @@ fun testLambda() {
         { it -> <!DEBUG_INFO_SMARTCAST!>x<!> + it }
     }
 
-    val twoLambda: (Int) -> Int = <!TYPE_MISMATCH!>myRun {
+    val twoLambda: (Int) -> Int = myRun {
         val x: Int = 1
-        <!TYPE_MISMATCH!>run {
+        run {
             val y: Int = 2
             { x + y }
-        }<!>
-    }<!>
+        }
+    }
 
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt
index 763197f2be3..a1b370c3d9f 100644
--- a/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt
+++ b/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt
@@ -7,7 +7,7 @@ fun <V> id(value: V) = value
 
 val asString = foo() as String
 
-val viaId = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
+val viaId = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
 
 val insideId = id(foo() as String)
 
diff --git a/compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt b/compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt
index 981ce628885..27540748926 100644
--- a/compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt
+++ b/compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt
@@ -3,5 +3,5 @@ fun <T, U> T.map(f: (T) -> U) = f(this)
 fun consume(<!UNUSED_PARAMETER!>s<!>: String) {}
 
 fun test() {
-    <!UNREACHABLE_CODE!>consume(<!>1.map(::<!UNRESOLVED_REFERENCE!>foo<!>)<!UNREACHABLE_CODE!>)<!>
+    consume(1.map(::<!UNRESOLVED_REFERENCE!>foo<!>))
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt b/compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt
index f5596d04f2e..83c4cc1047e 100644
--- a/compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt
+++ b/compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt
@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 // FILE: TestClass.java
 import org.jetbrains.annotations.Nullable;
 public class TestClass {
@@ -10,7 +12,7 @@ public class TestClass {
 fun run() {
     val testClass = TestClass()
     // inferred as `set<Nothing>()`, return type is Nothing!
-    testClass.set("test", null)
+    testClass.<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>set<!>("test", null)
 
     // Should not be unreachable
     run()
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
index 89b5caa154a..0b4f9a7dc02 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
@@ -23,8 +23,8 @@ fun main() {
         foo(<!DEBUG_INFO_SMARTCAST!>x<!>)
     } else {
         foo(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
-        <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>foo(<!><!ALWAYS_NULL!>x<!>!!<!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>)<!>
-        <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>foo(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
+        <!OI;UNREACHABLE_CODE!>foo(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
+        <!OI;UNREACHABLE_CODE!>foo(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
     }
 
     foo(<!DEBUG_INFO_SMARTCAST!>x<!>)
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt
index ba32926959c..a1e9a09a30d 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt
@@ -7,18 +7,18 @@ fun <T> nullable(): T? = null
 fun <T> dependOn(x: T) = x
 
 fun test() {
-    <!NI;UNREACHABLE_CODE!>takeNotNull(<!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>notNull<!>()<!NI;UNREACHABLE_CODE!><!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)<!>
-    <!NI;UNREACHABLE_CODE!>takeNotNull(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>()!!)<!>
+    takeNotNull(notNull()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
+    takeNotNull(nullable()!!)
 
-    <!NI;UNREACHABLE_CODE!>var x: String? = null<!>
-    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(x)!!)<!>
-    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x))!!)<!>
-    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x)!!))<!>
-    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x!!)))<!>
+    var x: String? = null
+    takeNotNull(dependOn(x)!!)
+    takeNotNull(dependOn(dependOn(x))!!)
+    takeNotNull(dependOn(dependOn(x)!!))
+    takeNotNull(dependOn(dependOn(x!!)))
 
-    <!NI;UNREACHABLE_CODE!>if (x != null) {
+    if (x != null) {
         takeNotNull(dependOn(x)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         takeNotNull(dependOn(dependOn(x))<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         takeNotNull(dependOn(dependOn(x)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
-    }<!>
+    }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt b/compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt
index d9c9b402054..2f57ac79a41 100644
--- a/compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt
+++ b/compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt
@@ -22,21 +22,21 @@ fun <T> nullable(): T? = null
 fun <T> dependOn(x: T) = x
 
 fun test() {
-    <!UNREACHABLE_CODE!>takeNotNull(<!><!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>notNull<!>() <!UNREACHABLE_CODE!><!USELESS_ELVIS!>?: ""<!>)<!>
-    <!UNREACHABLE_CODE!>takeNotNull(<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>() ?: "")<!>
+    takeNotNull(notNull() ?: "")
+    takeNotNull(nullable() ?: "")
 
-    <!UNREACHABLE_CODE!>val x: String? = null<!>
-    <!UNREACHABLE_CODE!>takeNotNull(dependOn(x) ?: "")<!>
-    <!UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x)) ?: "")<!>
-    <!UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x as String)) <!USELESS_ELVIS!>?: ""<!>)<!>
+    val x: String? = null
+    takeNotNull(dependOn(x) ?: "")
+    takeNotNull(dependOn(dependOn(x)) ?: "")
+    takeNotNull(dependOn(dependOn(x as String)) <!USELESS_ELVIS!>?: ""<!>)
 
-    <!UNREACHABLE_CODE!>if (x != null) {
+    if (x != null) {
         takeNotNull(dependOn(x) <!USELESS_ELVIS!>?: ""<!>)
         takeNotNull(dependOn(dependOn(x)) <!USELESS_ELVIS!>?: ""<!>)
         takeNotNull(dependOn(dependOn(x) as? String) ?: "")
-    }<!>
+    }
 
-    <!UNREACHABLE_CODE!>takeNotNull(bar()!!)<!>
+    takeNotNull(bar()!!)
 }
 
 inline fun <reified T : Any> reifiedNull(): T? = null
diff --git a/compiler/testData/diagnostics/tests/overload/defaultParameters.kt b/compiler/testData/diagnostics/tests/overload/defaultParameters.kt
index da7c407b241..a3ef5a4614c 100644
--- a/compiler/testData/diagnostics/tests/overload/defaultParameters.kt
+++ b/compiler/testData/diagnostics/tests/overload/defaultParameters.kt
@@ -55,5 +55,5 @@ fun test() {
 
     withGenericDefaults("")
 
-    <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!><!OVERLOAD_RESOLUTION_AMBIGUITY!>wrong<!>(<!>null!!<!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>)<!>
+    <!OI;UNREACHABLE_CODE!><!OVERLOAD_RESOLUTION_AMBIGUITY!>wrong<!>(<!>null!!<!OI;UNREACHABLE_CODE!>)<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt
index 4f31958b479..152cf3b0b44 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt
@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // FILE: p/Visitor.java
 
 package p;
@@ -21,5 +22,5 @@ public class Element {
 import p.*
 
 fun test(v: Visitor<Nothing>, e: Element) {
-    e.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>accept<!>(v, null)
+    e.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>accept<!>(v, null)
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/noWarningOnDoubleElvis.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/noWarningOnDoubleElvis.kt
index 9bcde272cec..e9891546877 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/noWarningOnDoubleElvis.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/noWarningOnDoubleElvis.kt
@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 fun test() {
-    take(<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>() ?: <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>() ?: "foo")
+    take(nullable() ?: nullable() ?: "foo")
 }
 
 fun <T> nullable(): T? = TODO()
diff --git a/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt b/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt
index 2860b1eac1f..3aae6947854 100644
--- a/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt
+++ b/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt
@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 fun test(a: Int, b: Boolean) {
-    <!NI;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(<!>a.<!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>b<!>)<!NI;UNREACHABLE_CODE!>)<!>
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(a.<!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>b<!>))
 }
 
 fun <T, R> T.foo(l: (T) -> R): R = TODO()
diff --git a/compiler/testData/diagnostics/tests/regressions/kt353.kt b/compiler/testData/diagnostics/tests/regressions/kt353.kt
index 798ced14f08..3a1fa33a319 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt353.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt353.kt
@@ -18,7 +18,7 @@ fun foo(a: A) {
 
     val <!UNUSED_VARIABLE!>b<!> : () -> Unit = {
         if (true) {
-            a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>gen<!>()  // unit can be inferred
+            a.gen()  // unit can be inferred
         }
         else {
             Unit
diff --git a/compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt b/compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt
index 6d2f361aedc..93a230cabef 100644
--- a/compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt
+++ b/compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt
@@ -18,15 +18,15 @@ fun foo(i: Int, f: (Int)->Int) = f(i)
 fun <T> id(t: T) = t
 
 fun test() {
-    <!UNREACHABLE_CODE!>foo(<!>1, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { x1 ->
-        <!UNREACHABLE_CODE!>foo(<!>2, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x2<!> ->
-            <!UNREACHABLE_CODE!>foo(<!>3, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x3<!> ->
-                <!UNREACHABLE_CODE!>foo(<!>4, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x4<!> ->
-                    <!UNREACHABLE_CODE!>foo(<!>5, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x5<!> ->
-                        x1 <!UNREACHABLE_CODE!>+ x2 + x3 + x4 + x5 + A.iii<!>
-                    }<!UNREACHABLE_CODE!>)<!>
-                }<!UNREACHABLE_CODE!>)<!>
-            }<!UNREACHABLE_CODE!>)<!>
-        }<!UNREACHABLE_CODE!>)<!>
-    }<!UNREACHABLE_CODE!>)<!>
+    foo(1, id { x1 ->
+        foo(2, id { x2 ->
+            foo(3, id { x3 ->
+                foo(4, id { x4 ->
+                    foo(5, id { x5 ->
+                        x1 + x2 + x3 + x4 + x5 + A.iii
+                    })
+                })
+            })
+        })
+    })
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt b/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt
index 67b4400b312..626182c5195 100644
--- a/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt
+++ b/compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt
@@ -22,11 +22,11 @@ fun foo(i: Int, f: (Int) -> Int) = f(i)
 fun <T> id(t: T) = t
 
 fun test() {
-    foo(1, id(fun(x1: Int) =
-          foo(2, id(fun(x2: Int) =
-                foo(3, id(fun(x3: Int) =
-                      foo(4, id(fun(x4: Int) =
-                            foo(5, id(fun(x5: Int) =
+    <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(1, id(fun(x1: Int) =
+          <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(2, id(fun(x2: Int) =
+                <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(3, id(fun(x3: Int) =
+                      <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(4, id(fun(x4: Int) =
+                            <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(5, id(fun(x5: Int) =
                                   x1 + x2 + x3 + x4 + x5 + A.iii
                             ))
                       ))
diff --git a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.kt b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.kt
index a13f12728c2..5792a3f89a0 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.kt
@@ -10,5 +10,5 @@ fun use() {
     // Write is AFTER
     <!DEBUG_INFO_SMARTCAST!>x<!>.hashCode()
     // x is nullable at the second argument
-    <!UNREACHABLE_CODE!>foo(<!><!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>bar<!> { x = null }, <!UNREACHABLE_CODE!>x!!)<!>
+    foo(bar { x = null }, x!!)
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.kt b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.kt
index cc33f16a425..0cbe4c4629b 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.kt
@@ -10,5 +10,5 @@ fun use() {
     // Write to x is AFTER
     <!DEBUG_INFO_SMARTCAST!>x<!>.hashCode()
     // No smart cast should be here!
-    <!UNREACHABLE_CODE!>foo(<!><!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>bar<!> { x = null }, <!UNREACHABLE_CODE!><!SMARTCAST_IMPOSSIBLE!>x<!>.hashCode())<!>
+    foo(bar { x = null }, <!SMARTCAST_IMPOSSIBLE!>x<!>.hashCode())
 }
diff --git a/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameter.kt b/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameter.kt
index b7218ef65ff..9a2f6049ec0 100644
--- a/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameter.kt
+++ b/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameter.kt
@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNCHECKED_CAST
+// !WITH_NEW_INFERENCE
 // SKIP_TXT
 // Issue: KT-20849
 
@@ -11,13 +12,13 @@ fun case_1() {
 }
 
 fun case_2() {
-    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_1<!> { null!! }
-    <!UNREACHABLE_CODE!>test_2 { null!! }<!>
+    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_1<!> { null!! }
+    <!NI;UNREACHABLE_CODE!>test_2 { null!! }<!>
 }
 
 fun case_3() {
-    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_1<!> { throw Exception() }
-    <!UNREACHABLE_CODE!>test_2 { throw Exception() }<!>
+    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_1<!> { throw Exception() }
+    <!NI;UNREACHABLE_CODE!>test_2 { throw Exception() }<!>
 }
 
 fun case_6() {
@@ -39,5 +40,5 @@ 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, IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>decodeIn<!>(typeFrom) ?: <!UNRESOLVED_REFERENCE!>error<!>("")
+    return this?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>decodeIn<!>(typeFrom) ?: <!UNRESOLVED_REFERENCE!>error<!>("")
 }