[IR] dumpKotlinLike: update testdata after rebase

compiler/testData/ir/irText/classes/delegatedImplementationOfJavaInterface.fir.kt.txt

@@ -22,10 +22,12 @@ class Test : J {
     <this>.#<$$delegate_0>.takeFlexible(x = x)
   }
 
+  @NotNull
   override fun returnNotNull(): @EnhancedNullability String {
     return <this>.#<$$delegate_0>.returnNotNull()
   }
 
+  @Nullable
   override fun returnNullable(): @FlexibleNullability String? {
     return <this>.#<$$delegate_0>.returnNullable()
   }

compiler/testData/ir/irText/declarations/annotations/annotationsOnDelegatedMembers.fir.kt.txt

@@ -27,19 +27,23 @@ class DFoo : IFoo {
     <this>.#<$$delegate_0> = d
   }
 
+  @Ann
   override fun testFun() {
     <this>.#<$$delegate_0>.testFun()
   }
 
+  @Ann
   override fun String.testExtFun() {
     (<this>.#<$$delegate_0>, <this>).testExtFun()
   }
 
+  @Ann
   override val testVal: String
     override get(): String {
       return <this>.#<$$delegate_0>.<get-testVal>()
     }
 
+  @Ann
   override val String.testExtVal: String
     override get(): String {
       return (<this>.#<$$delegate_0>, <this>).<get-testExtVal>()

compiler/testData/ir/irText/declarations/annotations/inheritingDeprecation.fir.kt.txt

@@ -21,11 +21,13 @@ class Delegated : IFoo {
     <this>.#<$$delegate_0> = foo
   }
 
+  @Deprecated(message = "")
   override val prop: String
     override get(): String {
       return <this>.#<$$delegate_0>.<get-prop>()
     }
 
+  @Deprecated(message = "")
   override val String.extProp: String
     override get(): String {
       return (<this>.#<$$delegate_0>, <this>).<get-extProp>()

compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.kt.txt

@@ -0,0 +1,175 @@
+abstract class Visibility {
+  constructor(name: String, isPublicAPI: Boolean) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val name: String
+    field = name
+    get
+
+  val isPublicAPI: Boolean
+    field = isPublicAPI
+    get
+
+  open val internalDisplayName: String
+    open get(): String {
+      return <this>.<get-name>()
+    }
+
+  open val externalDisplayName: String
+    open get(): String {
+      return <this>.<get-internalDisplayName>()
+    }
+
+  abstract fun mustCheckInImports(): Boolean
+
+}
+
+object Visibilities {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  object Private : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "private", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object PrivateToThis : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "private_to_this", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override val internalDisplayName: String
+      override get(): String {
+        return "private/*private to this*/"
+      }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object Protected : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "protected", isPublicAPI = true)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return false
+    }
+
+  }
+
+  object Internal : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "internal", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object Public : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "public", isPublicAPI = true)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return false
+    }
+
+  }
+
+  object Local : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "local", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object Inherited : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "inherited", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      throw IllegalStateException(p0 = "This method shouldn't be invoked for INHERITED visibility")
+    }
+
+  }
+
+  object InvisibleFake : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "invisible_fake", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+    override val externalDisplayName: String
+      override get(): String {
+        return "invisible (private in a supertype)"
+      }
+
+  }
+
+  object Unknown : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "unknown", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      throw IllegalStateException(p0 = "This method shouldn't be invoked for UNKNOWN visibility")
+    }
+
+  }
+
+  private val ORDERED_VISIBILITIES: Map<Visibility, Int>
+    field = buildMap<Visibility, Int>(builderAction = local fun MutableMap<Visibility, Int>.<anonymous>() {
+      <this>.put(key = PrivateToThis, value = 0) /*~> Unit */
+      <this>.put(key = Private, value = 0) /*~> Unit */
+      <this>.put(key = Internal, value = 1) /*~> Unit */
+      <this>.put(key = Protected, value = 1) /*~> Unit */
+      return <this>.put(key = Public, value = 2) /*~> Unit */
+    }
+)
+    private get
+
+}

compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.kt.txt

@@ -0,0 +1,175 @@
+abstract class Visibility {
+  constructor(name: String, isPublicAPI: Boolean) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val name: String
+    field = name
+    get
+
+  val isPublicAPI: Boolean
+    field = isPublicAPI
+    get
+
+  open val internalDisplayName: String
+    open get(): String {
+      return <this>.<get-name>()
+    }
+
+  open val externalDisplayName: String
+    open get(): String {
+      return <this>.<get-internalDisplayName>()
+    }
+
+  abstract fun mustCheckInImports(): Boolean
+
+}
+
+object Visibilities {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  object Private : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "private", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object PrivateToThis : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "private_to_this", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override val internalDisplayName: String
+      override get(): String {
+        return "private/*private to this*/"
+      }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object Protected : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "protected", isPublicAPI = true)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return false
+    }
+
+  }
+
+  object Internal : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "internal", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object Public : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "public", isPublicAPI = true)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return false
+    }
+
+  }
+
+  object Local : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "local", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+  }
+
+  object Inherited : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "inherited", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      throw IllegalStateException(p0 = "This method shouldn't be invoked for INHERITED visibility")
+    }
+
+  }
+
+  object InvisibleFake : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "invisible_fake", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      return true
+    }
+
+    override val externalDisplayName: String
+      override get(): String {
+        return "invisible (private in a supertype)"
+      }
+
+  }
+
+  object Unknown : Visibility {
+    private constructor() /* primary */ {
+      super/*Visibility*/(name = "unknown", isPublicAPI = false)
+      /* <init>() */
+
+    }
+
+    override fun mustCheckInImports(): Boolean {
+      throw IllegalStateException(p0 = "This method shouldn't be invoked for UNKNOWN visibility")
+    }
+
+  }
+
+  private val ORDERED_VISIBILITIES: Map<Visibility, Int>
+    field = buildMap<Visibility, Int>(builderAction = local fun MutableMap<Visibility, Int>.<anonymous>() {
+      $this$buildMap.put(key = PrivateToThis, value = 0) /*~> Unit */
+      $this$buildMap.put(key = Private, value = 0) /*~> Unit */
+      $this$buildMap.put(key = Internal, value = 1) /*~> Unit */
+      $this$buildMap.put(key = Protected, value = 1) /*~> Unit */
+      $this$buildMap.put(key = Public, value = 2) /*~> Unit */
+    }
+)
+    private get
+
+}

compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt

@@ -3,7 +3,7 @@ fun <R : Any?> scopedFlow(@BuilderInference block: @ExtensionFunctionType @Exten
   return flow<R>(block = local suspend fun FlowCollector<R>.<anonymous>() {
     val collector: FlowCollector<ErrorType> = <this>
     flowScope<Unit>(block = local suspend fun CoroutineScope.<anonymous>() {
-      block.invoke(p1 = <this>, p2 = collector)
+      block.invoke(p1 = <this>, p2 = collector /*as FlowCollector<ErrorType> */)
     }
 )
   }
@@ -12,7 +12,7 @@ fun <R : Any?> scopedFlow(@BuilderInference block: @ExtensionFunctionType @Exten
 
 fun <T : Any?> Flow<T>.onCompletion(action: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction2<FlowCollector<T>, Throwable?, Unit>): Flow<T> {
   return unsafeFlow<T>(block = local suspend fun FlowCollector<T>.<anonymous>() {
-    val safeCollector: SafeCollector<ErrorType> = SafeCollector<ErrorType>(collector = <this>)
+    val safeCollector: SafeCollector<ErrorType> = SafeCollector<T>(collector = <this>)
     safeCollector.invokeSafely<T>(action = action)
   }
 )