FIR: Do not add alias for variables with explicit type

compiler/testData/diagnostics/tests/Variance.fir.kt

@@ -11,10 +11,10 @@ fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
     val c2: Consumer<Int> = c1
 
     val p1: Producer<Any> = p
-    val p2: Producer<Int> = p1
+    val p2: Producer<Int> = <!INITIALIZER_TYPE_MISMATCH!>p1<!>
 
     val u1: Usual<Any> = <!INITIALIZER_TYPE_MISMATCH!>u<!>
-    val u2: Usual<Int> = u1
+    val u2: Usual<Int> = <!INITIALIZER_TYPE_MISMATCH!>u1<!>
 }
 
 //Arrays copy example
@@ -37,4 +37,4 @@ fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
     copy2(ints, <!ARGUMENT_TYPE_MISMATCH!>numbers<!>)
     copy3<Int>(ints, numbers)
     copy4(ints, numbers) //ok
-}
+}

compiler/testData/diagnostics/tests/dataFlow/assignment/assignToNewVal.fir.kt

@@ -6,5 +6,5 @@ fun test(a: Any?) {
     b.hashCode()
 
     val c: Any? = a
-    c.hashCode()
-}
+    c<!UNSAFE_CALL!>.<!>hashCode()
+}

compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.fir.kt

@@ -5,7 +5,7 @@ enum class En { A, B, С }
 fun foo() {
     // nullable variable
     val en2: Any? = En.A
-    if (<!USELESS_IS_CHECK!>en2 is En<!>) {
+    if (en2 is En) {
         when (en2) {
             En.A -> {}
             En.B -> {}
@@ -15,7 +15,7 @@ fun foo() {
 
     // not nullable variable
     val en1: Any = En.A
-    if (<!USELESS_IS_CHECK!>en1 is En<!>) {
+    if (en1 is En) {
         when (en1) {
             En.A -> {}
             En.B -> {}

compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.fir.kt

@@ -10,5 +10,5 @@ fun main() {
     val c : ListOfLists<*> = b
     val d : ArrayList<ArrayList<*>> = <!INITIALIZER_TYPE_MISMATCH!>c.x<!>
 
-    c.x checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><ArrayList<out ArrayList<*>>>() }
+    c.x checkType { _<ArrayList<out ArrayList<*>>>() }
 }

compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt

@@ -1,17 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
-
-class A<out T, in E> {
-    fun foo(x: @UnsafeVariance T) {}
-    fun foo(x: @UnsafeVariance T, y: List<@UnsafeVariance T>): @UnsafeVariance E = null!!
-
-    fun bar(): List<@UnsafeVariance E> = null!!
-}
-
-fun foo(x: A<String, Any?>, cs: CharSequence, ls: List<CharSequence>) {
-    val y: A<CharSequence, String> = x
-
-    y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>)
-    val s: String = <!INITIALIZER_TYPE_MISMATCH!>y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>, <!ARGUMENT_TYPE_MISMATCH!>ls<!>)<!>
-
-    val ls2: List<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>y.bar()<!>
-}

compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
 
 class A<out T, in E> {

compiler/testData/diagnostics/tests/protectedWithGenericsInDifferentPackage.fir.kt

@@ -32,10 +32,10 @@ fun test(s: bar.Sub<String>) {
     s.<!INVISIBLE_REFERENCE!>doSomething<!>()
     s.doSomething2()
     val s2: Super<String> = s
-    s2.<!INVISIBLE_REFERENCE!>name<!>
-    s2.<!INVISIBLE_REFERENCE!>name<!> = ""
+    s2.name
+    s2.name = ""
     s2.name2
-    <!INVISIBLE_SETTER!>s2.name2<!> = ""
-    s2.<!INVISIBLE_REFERENCE!>doSomething<!>()
+    s2.name2 = ""
+    s2.doSomething()
     s2.doSomething2()
 }

compiler/testData/diagnostics/tests/smartCasts/level_1_0.fir.kt

@@ -7,7 +7,7 @@ fun foo(arg: Int?) {
     }
     val y: Any? = arg
     if (y != null) {
-        arg.hashCode()
+        arg<!UNSAFE_CALL!>.<!>hashCode()
     }
     val yy: Any?
     yy = arg

compiler/testData/diagnostics/tests/smartCasts/toInvisible.fir.kt

@@ -0,0 +1,44 @@
+// SKIP_TXT
+// FILE: a/A.java
+package a;
+public interface A {
+    B b();
+}
+
+// FILE: a/B.java
+package a;
+public interface B {
+    void bar();
+}
+
+// FILE: a/AImpl.java
+package a;
+
+public class AImpl implements A {
+    @Override
+    public BImpl b() {
+        return new BImpl();
+    }
+}
+
+class BImpl implements B {
+    @Override
+    public void bar() {}
+}
+
+// FILE: main.kt
+import a.A
+import a.AImpl
+
+fun test1(a: A) {
+    if (a is AImpl) {
+        (a as A).b().bar() // OK
+        a.b().<!UNRESOLVED_REFERENCE!>bar<!>()
+    }
+}
+
+fun test2(aImpl: AImpl) {
+    val a: A = aImpl
+    (a <!USELESS_CAST!>as A<!>).b().bar() // OK
+    a.b().bar() // Works at FE1.0, fails at FIR
+}

compiler/testData/diagnostics/tests/smartCasts/toInvisible.kt

@@ -0,0 +1,45 @@
+// SKIP_TXT
+// FILE: a/A.java
+package a;
+public interface A {
+    B b();
+}
+
+// FILE: a/B.java
+package a;
+public interface B {
+    void bar();
+}
+
+// FILE: a/AImpl.java
+package a;
+
+public class AImpl implements A {
+    @Override
+    public BImpl b() {
+        return new BImpl();
+    }
+}
+
+class BImpl implements B {
+    @Override
+    public void bar() {}
+}
+
+// FILE: main.kt
+import a.A
+import a.AImpl
+
+fun test1(a: A) {
+    if (a is AImpl) {
+        (a as A).b().bar() // OK
+        <!INACCESSIBLE_TYPE!><!DEBUG_INFO_SMARTCAST!>a<!>.b()<!>.<!INVISIBLE_MEMBER!>bar<!>()
+    }
+}
+
+fun test2(aImpl: AImpl) {
+    val a: A = aImpl
+    (a <!USELESS_CAST!>as A<!>).b().bar() // OK
+    a.b().bar() // Works at FE1.0, fails at FIR
+}
+

compiler/testData/diagnostics/tests/smartCasts/variables/whileWithBreak.fir.kt

@@ -4,7 +4,7 @@ fun String.next(): String {
 
 fun list(start: String) {
     var e: Any? = start
-    if (<!SENSELESS_COMPARISON!>e==null<!>) return
+    if (e==null) return
     while (e is String) {
         // Smart cast due to the loop condition
         if (e.length == 0)

compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializer.fir.kt

@@ -5,7 +5,7 @@ fun foo(arg: Int?) {
     }
     val y: Any? = arg
     if (y != null) {
-        arg.hashCode()
+        arg<!UNSAFE_CALL!>.<!>hashCode()
     }
     val yy: Any?
     yy = arg