FIR checker: warn unnecessary non-null assertions

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt

@@ -5,35 +5,35 @@ fun main() {
     val a : Int? = null
     val b : Int? = null
     checkSubtype<Int>(a!!)
-    a!! + 2
-    a!!.plus(2)
-    a!!.plus(b!!)
-    2.plus(b!!)
-    2 + b!!
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!> + 2
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.plus(2)
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.plus(b!!)
+    2.plus(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
+    2 + b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
 
     val c = 1
-    c!!
+    c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
 
     val d : Any? = null
 
     if (d != null) {
-        d!!
+        d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
     }
 
     // smart cast isn't needed, but is reported due to KT-4294
     if (d is String) {
-        d!!
+        d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
     }
 
     if (d is String?) {
         if (d != null) {
-            d!!
+            d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
         }
         if (d is String) {
-            d!!
+            d<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
         }
     }
 
-    val f : String = a!!
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(a!!)
+    val f : String = a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.fir.kt

@@ -10,7 +10,7 @@ fun main() {
     x<!UNSAFE_CALL!>.<!>foo(y)
     x!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
     x.foo(y!!)
-    x!!.foo(y!!)
+    x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(y<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
     
     val a: Foo? = null
     val b: Foo? = null
@@ -19,12 +19,12 @@ fun main() {
     a<!UNSAFE_CALL!>.<!>foo(b<!UNSAFE_CALL!>.<!>foo(c))
     a!!.foo(b<!UNSAFE_CALL!>.<!>foo(c))
     a.foo(b!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
-    a!!.foo(b!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
     a.foo(b.foo(c!!))
-    a!!.foo(b.foo(c!!))
-    a.foo(b!!.foo(c!!))
-    a!!.foo(b!!.foo(c!!))
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
+    a.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
     
     val z: Foo? = null
-    z!!.foo(z!!)
+    z!!.foo(z<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.fir.kt

@@ -11,7 +11,7 @@ fun main() {
 
     if (x != null) {
         foo(x)
-        foo(x!!)
+        foo(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         foo(x)
     }
 
@@ -19,7 +19,7 @@ fun main() {
 
     if (x != null) {
         foo(x)
-        foo(x!!)
+        foo(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         foo(x)
     } else {
         <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
@@ -28,12 +28,12 @@ fun main() {
     }
 
     foo(x)
-    foo(x!!)
+    foo(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
     foo(x)
     
     val y: Int? = null
     y!!
-    y!!
+    y<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
     foo(y)
-    foo(y!!)
+    foo(y<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2176.fir.kt

@@ -11,7 +11,7 @@ fun f1(a: String?) {
 }
 
 fun f2(a: String) {
-    a!!
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
     checkSubtype<String>(a)
 }
 

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2212.fir.kt

@@ -4,5 +4,5 @@ package kt2212
 fun main() {
     val x: Int? = 1
     if (x == null) return
-    System.out.println(x.plus(x!!))
+    System.out.println(x.plus(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
 }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.fir.kt

@@ -11,7 +11,7 @@ fun foo() {
 
     bar(if (x != null) x else return, x)
     x + 2
-    bar(x, x!!)
+    bar(x, x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 
     val y: Int? = 0
     val z: Int? = 0

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2234.fir.kt

@@ -11,14 +11,14 @@ class Pair<A, B>(val a: A, val b: B)
 fun main() {
     val d : Long = 1
     val period : Int? = null
-    if (period != null) Pair(d, checkSubtype<Int>(period!!)) else Pair(d, 1)
+    if (period != null) Pair(d, checkSubtype<Int>(period<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)) else Pair(d, 1)
     if (period != null) Pair(d, checkSubtype<Int>(period)) else Pair(d, 1)
 }
 
 fun foo() {
     val x : Int? = 3
     if (x != null)  {
-        val u = checkSubtype<Int>(x!!)
+        val u = checkSubtype<Int>(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         val y = checkSubtype<Int>(x)
         val z : Int = y
     }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2336.fir.kt

@@ -3,7 +3,7 @@ fun main() {
     if (b != null) {
         if (!b) {} // OK
         if (b) {} // Error: Condition must be of type kotlin.Boolean, but is of type kotlin.Boolean?
-        if (b!!) {} // WARN: Unnecessary non-null assertion (!!) on a non-null receiver of type kotlin.Boolean?
+        if (b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>) {} // WARN: Unnecessary non-null assertion (!!) on a non-null receiver of type kotlin.Boolean?
         foo(b) // OK
     }
 }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.fir.kt

@@ -17,8 +17,8 @@ fun test() {
     takeNotNull(dependOn(dependOn(x!!)))
 
     if (x != null) {
-        takeNotNull(dependOn(x)!!)
-        takeNotNull(dependOn(dependOn(x))!!)
-        takeNotNull(dependOn(dependOn(x)!!))
+        takeNotNull(dependOn(x)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
+        takeNotNull(dependOn(dependOn(x))<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
+        takeNotNull(dependOn(dependOn(x)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
     }
-}
+}