Add some test cases after review

compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt

@@ -1,31 +1,48 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER, -BASE_WITH_NULLABLE_UPPER_BOUND
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -BASE_WITH_NULLABLE_UPPER_BOUND, -UNUSED_VARIABLE
 
 class A<F> {
-    fun <E : F> foo1(x: E) {}
-    fun <E : F?> foo2(x: E) {}
+    fun <E : F> foo1(x: E) = x
+    fun <E : F?> foo2(x: E) = x
 
     fun <Z : F, W : Z?> bar(x: F, y: F?, z: Z, w: W) {
         foo1<F>(x)
-        foo1(x)
+
+        val x1 = foo1(x)
+        x1.checkType { _<F>() }
+
         foo2<F>(x)
-        foo2(x)
+
+        val x2 = foo2(x)
+        x2.checkType { _<F>() }
 
         foo1<<!UPPER_BOUND_VIOLATED!>F?<!>>(y)
         <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo1<!>(y)
         foo2<F?>(y)
-        foo2(y)
+
+        val x3 = foo2(y)
+        x3.checkType { _<F?>() }
+
         foo1<F>(<!TYPE_MISMATCH!>y<!>)
         foo2<F>(<!TYPE_MISMATCH!>y<!>)
 
         foo1<Z>(z)
-        foo1(z)
+
+        val x4 = foo1(z)
+        x4.checkType { _<Z>() }
+
         foo2<Z>(z)
-        foo2(z)
+
+        val x5 = foo2(z)
+        x4.checkType { _<Z>() }
 
         foo1<<!UPPER_BOUND_VIOLATED!>W<!>>(w)
         <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo1<!>(w)
         foo2<W>(w)
-        foo2(w)
+
+        val x6 = foo2(w)
+        x6.checkType { _<W>() }
+
         foo1<<!UPPER_BOUND_VIOLATED!>W<!>>(w)
     }
 }