[IR] add new testdata after rebase

compiler/testData/ir/irText/classes/cloneable.kt.txt

@@ -0,0 +1,49 @@
+class A : Cloneable {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+}
+
+interface I : Cloneable {
+
+
+
+
+}
+
+class C : I {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+}
+
+class OC : I {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  protected override fun clone(): OC {
+    return TODO("IrConstructorCall")
+  }
+
+
+
+
+}
+

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

@@ -0,0 +1,42 @@
+class Test : J {
+  constructor(j: J) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private val j: J
+    field = j
+    private get
+
+  @NotNull(...)
+  override fun returnNotNull(): @EnhancedNullability String {
+    return #j.returnNotNull()
+  }
+
+  @Nullable(...)
+  override fun returnNullable(): @EnhancedNullability String? {
+    return #j.returnNullable()
+  }
+
+  override fun returnsFlexible(): @FlexibleNullability String? {
+    return #j.returnsFlexible()
+  }
+
+  override fun takeFlexible(x: @FlexibleNullability String?) {
+    #j.takeFlexible(x = x)
+  }
+
+  override fun takeNotNull(x: @EnhancedNullability String) {
+    #j.takeNotNull(x = x)
+  }
+
+  override fun takeNullable(x: @EnhancedNullability String?) {
+    #j.takeNullable(x = x)
+  }
+
+
+
+
+}
+

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

@@ -0,0 +1,58 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+interface IFoo {
+  @Ann
+  abstract val testVal: String
+    abstract get
+
+  @Ann
+  abstract fun testFun() 
+  @Ann
+  abstract val String.testExtVal: String
+    abstract get
+
+  @Ann
+  abstract fun String.testExtFun() 
+
+
+
+}
+
+class DFoo : IFoo {
+  constructor(d: IFoo) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: IFoo = d
+  @Ann
+  override fun String.testExtFun() {
+    #$$delegate_0.testExtFun($receiver = <this>)
+  }
+
+  @Ann
+  override fun testFun() {
+    #$$delegate_0.testFun()
+  }
+
+  override val String.testExtVal: String
+    override get(): String {
+      return #$$delegate_0.<get-testExtVal>($receiver = <this>)
+    }
+
+  override val testVal: String
+    override get(): String {
+      return #$$delegate_0.<get-testVal>()
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.kt.txt

@@ -0,0 +1,115 @@
+inline class IT {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  override fun toString(): String {
+    return "IT(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      other !is IT -> return false
+    }
+    val tmp0_other_with_cast: IT = other as IT
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+
+inline class InlineMutableSet : MutableSet<IT> {
+  constructor(ms: MutableSet<IT>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private val ms: MutableSet<IT>
+    field = ms
+    private get
+
+  override val size: Int
+    override get(): Int {
+      return <this>.<get-ms>().<get-size>()
+    }
+
+  override operator fun contains(element: IT): Boolean {
+    return <this>.<get-ms>().contains(element = element)
+  }
+
+  override fun containsAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().containsAll(elements = elements)
+  }
+
+  override fun isEmpty(): Boolean {
+    return <this>.<get-ms>().isEmpty()
+  }
+
+  override fun add(element: IT): Boolean {
+    return <this>.<get-ms>().add(element = element)
+  }
+
+  override fun addAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().addAll(elements = elements)
+  }
+
+  override fun clear() {
+    <this>.<get-ms>().clear()
+  }
+
+  override operator fun iterator(): MutableIterator<IT> {
+    return <this>.<get-ms>().iterator()
+  }
+
+  override fun remove(element: IT): Boolean {
+    return <this>.<get-ms>().remove(element = element)
+  }
+
+  override fun removeAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().removeAll(elements = elements)
+  }
+
+  override fun retainAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().retainAll(elements = elements)
+  }
+
+  override fun toString(): String {
+    return "InlineMutableSet(" + 
+"ms=" + 
+#ms + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #ms.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      other !is InlineMutableSet -> return false
+    }
+    val tmp0_other_with_cast: InlineMutableSet = other as InlineMutableSet
+    when {
+      EQEQ(arg0 = #ms, arg1 = #ms).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.kt.txt

@@ -0,0 +1,123 @@
+enum class A : Enum<A> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  V1 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<A> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): A /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+fun testVariableAssignment_throws(a: A) {
+  val x: Int
+  { //BLOCK
+    val tmp0_subject: A = a
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = A) -> x = 11
+      true -> noWhenBranchMatchedException()
+    }
+  }
+}
+
+fun testStatement_empty(a: A) {
+  { //BLOCK
+    val tmp0_subject: A = a
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
+    }
+  }
+}
+
+fun testParenthesized_throwsJvm(a: A) {
+  { //BLOCK
+    val tmp0_subject: A = a
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
+    }
+  }
+}
+
+fun testAnnotated_throwsJvm(a: A) {
+  { //BLOCK
+    val tmp0_subject: A = a
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
+    }
+  }
+}
+
+fun testExpression_throws(a: A): Int {
+  return { //BLOCK
+    val tmp0_subject: A = a
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1
+      true -> noWhenBranchMatchedException()
+    }
+  }
+}
+
+fun testIfTheElseStatement_empty(a: A, flag: Boolean) {
+  when {
+    flag -> 0 /*~> Unit */
+    true -> { //BLOCK
+      { //BLOCK
+        val tmp0_subject: A = a
+        when {
+          EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
+        }
+      }
+    }
+  }
+}
+
+fun testIfTheElseParenthesized_throwsJvm(a: A, flag: Boolean) {
+  when {
+    flag -> 0 /*~> Unit */
+    true -> { //BLOCK
+      { //BLOCK
+        val tmp0_subject: A = a
+        when {
+          EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
+        }
+      }
+    }
+  }
+}
+
+fun testIfTheElseAnnotated_throwsJvm(a: A, flag: Boolean) {
+  when {
+    flag -> 0 /*~> Unit */
+    true -> { //BLOCK
+      { //BLOCK
+        val tmp0_subject: A = a
+        when {
+          EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1 /*~> Unit */
+        }
+      }
+    }
+  }
+}
+
+fun testLambdaResultExpression_throws(a: A) {
+    local fun <anonymous>(): Int {
+    return { //BLOCK
+      val tmp0_subject: A = a
+      when {
+        EQEQ(arg0 = tmp0_subject, arg1 = A) -> 1
+        true -> noWhenBranchMatchedException()
+      }
+    }
+  }
+.invoke() /*~> Unit */
+}
+

compiler/testData/ir/irText/expressions/sam/genericSamSmartcast.kt.txt

@@ -0,0 +1,12 @@
+fun f(x: Any): String {
+  when {
+    x is A<*> -> { //BLOCK
+      return x /*as A<T> */.call(block =       local fun <anonymous>(y: Any?): @FlexibleNullability String? {
+        return "OK"
+      }
+ /*-> @FlexibleNullability I<@FlexibleNullability T?>? */) /*!! String */
+    }
+  }
+  return "Fail"
+}
+

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

@@ -0,0 +1,40 @@
+class MyMap<K : Any, V : Any> : AbstractMutableMap<K, V> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun put(key: K, value: V): V? {
+    return null
+  }
+
+  override val entries: MutableSet<MutableEntry<K, V>>
+    override get(): MutableSet<MutableEntry<K, V>> {
+      return mutableSetOf<MutableEntry<K, V>>()
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+

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

@@ -0,0 +1,38 @@
+class ResolvedCall<C : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class MyCandidate {
+  constructor(resolvedCall: ResolvedCall<*>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val resolvedCall: ResolvedCall<*>
+    field = resolvedCall
+    get
+
+
+
+
+}
+
+private fun <A : Any?> allCandidatesResult(allCandidates: Collection<MyCandidate>): @FlexibleNullability OverloadResolutionResultsImpl<@FlexibleNullability A?>? {
+  return apply<@FlexibleNullability OverloadResolutionResultsImpl<@FlexibleNullability A?>?>($receiver = nameNotFound<@FlexibleNullability A?>(), block =   local fun @FlexibleNullability OverloadResolutionResultsImpl<@FlexibleNullability A?>?.<anonymous>() {
+    <this> /*!! OverloadResolutionResultsImpl<@FlexibleNullability A?> */.setAllCandidates<@FlexibleNullability A?>(allCandidates = map<MyCandidate, ResolvedCall<A>>($receiver = allCandidates, transform =     local fun <anonymous>(it: MyCandidate): ResolvedCall<A> {
+      return it.<get-resolvedCall>() as ResolvedCall<A>
+    }
+))
+  }
+)
+}
+

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

@@ -0,0 +1,39 @@
+annotation class Storage : Annotation {
+  constructor(value: String) /* primary */ 
+  val value: String
+    field = value
+    get
+
+
+
+
+}
+
+annotation class State : Annotation {
+  constructor(name: String, storages: Array<Storage>) /* primary */ 
+  val name: String
+    field = name
+    get
+
+  val storages: Array<Storage>
+    field = storages
+    get
+
+
+
+
+}
+
+@State(...)
+class Test {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+

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

@@ -0,0 +1,77 @@
+interface ComponentContainer {
+
+
+
+}
+
+interface PlatformSpecificExtension<S : PlatformSpecificExtension<S>> {
+
+
+
+}
+
+interface ComponentDescriptor {
+
+
+
+}
+
+abstract class PlatformExtensionsClashResolver<E : PlatformSpecificExtension<E>> {
+  constructor(applicableTo: Class<E>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val applicableTo: Class<E>
+    field = applicableTo
+    get
+
+
+
+
+}
+
+class ClashResolutionDescriptor<E : PlatformSpecificExtension<E>> {
+  constructor(container: ComponentContainer, resolver: PlatformExtensionsClashResolver<E>, clashedComponents: List<ComponentDescriptor>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private val resolver: PlatformExtensionsClashResolver<E>
+    field = resolver
+    private get
+
+  private val clashedComponents: List<ComponentDescriptor>
+    field = clashedComponents
+    private get
+
+
+
+
+}
+
+private val registrationMap: HashMap<Type, Any>
+  field = hashMapOf<Type, Any>()
+  private get
+
+fun resolveClashesIfAny(container: ComponentContainer, clashResolvers: List<PlatformExtensionsClashResolver<*>>) {
+  { //BLOCK
+    val tmp0_iterator: Iterator<PlatformExtensionsClashResolver<*>> = clashResolvers.iterator()
+    while (tmp0_iterator.hasNext()) { //BLOCK
+      val resolver: PlatformExtensionsClashResolver<*> = tmp0_iterator.next()
+      { //BLOCK
+        val clashedComponents: Collection<ComponentDescriptor> = { //BLOCK
+          val tmp1_elvis_lhs: Collection<ComponentDescriptor>? = <get-registrationMap>().get(key = resolver.<get-applicableTo>()) as? Collection<ComponentDescriptor>
+          when {
+            EQEQ(arg0 = tmp1_elvis_lhs, arg1 = null) -> continue
+            true -> tmp1_elvis_lhs
+          }
+        }
+        val substituteDescriptor: ClashResolutionDescriptor<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out Any?>>>>>> = TODO("IrConstructorCall")
+      }
+    }
+  }
+}
+

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

@@ -0,0 +1,97 @@
+interface IrType {
+
+
+
+}
+
+interface TypeRemapper {
+  abstract fun enterScope(irTypeParametersContainer: IrTypeParametersContainer) 
+  abstract fun remapType(type: IrType): IrType 
+  abstract fun leaveScope() 
+
+
+
+}
+
+interface IrTypeParametersContainer : IrDeclaration, IrDeclarationParent {
+  abstract var typeParameters: List<IrTypeParameter>
+    abstract get
+    abstract set
+
+
+
+
+}
+
+interface IrDeclaration {
+
+
+
+}
+
+interface IrTypeParameter : IrDeclaration {
+  abstract val superTypes: MutableList<IrType>
+    abstract get
+
+
+
+
+}
+
+interface IrDeclarationParent {
+
+
+
+}
+
+class DeepCopyIrTreeWithSymbols {
+  constructor(typeRemapper: TypeRemapper) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private val typeRemapper: TypeRemapper
+    field = typeRemapper
+    private get
+
+  private fun copyTypeParameter(declaration: IrTypeParameter): IrTypeParameter {
+    return declaration
+  }
+
+  fun IrTypeParametersContainer.copyTypeParametersFrom(other: IrTypeParametersContainer) {
+    <this>.<set-typeParameters>(<set-?> = map<IrTypeParameter, IrTypeParameter>($receiver = other.<get-typeParameters>(), transform =     local fun <anonymous>(it: IrTypeParameter): IrTypeParameter {
+      return <this>.copyTypeParameter(declaration = it)
+    }
+))
+    withinScope<Unit>($receiver = <this>.<get-typeRemapper>(), irTypeParametersContainer = <this>, fn =     local fun <anonymous>() {
+      { //BLOCK
+        val tmp0_iterator: Iterator<Pair<IrTypeParameter, IrTypeParameter>> = zip<IrTypeParameter, IrTypeParameter>($receiver = <this>.<get-typeParameters>(), other = other.<get-typeParameters>()).iterator()
+        while (tmp0_iterator.hasNext()) { //BLOCK
+          val tmp1_loop_parameter: Pair<IrTypeParameter, IrTypeParameter> = tmp0_iterator.next()
+          val thisTypeParameter: IrTypeParameter = tmp1_loop_parameter.component1()
+          val otherTypeParameter: IrTypeParameter = tmp1_loop_parameter.component2()
+          { //BLOCK
+            mapTo<IrType, IrType, MutableList<IrType>>($receiver = otherTypeParameter.<get-superTypes>(), destination = thisTypeParameter.<get-superTypes>(), transform =             local fun <anonymous>(it: IrType): IrType {
+              return <this>.<get-typeRemapper>().remapType(type = it)
+            }
+) /*~> Unit */
+          }
+        }
+      }
+    }
+)
+  }
+
+
+
+
+}
+
+inline fun <T : Any?> TypeRemapper.withinScope(irTypeParametersContainer: IrTypeParametersContainer, fn: Function0<T>): T {
+  <this>.enterScope(irTypeParametersContainer = irTypeParametersContainer)
+  val result: T = fn.invoke()
+  <this>.leaveScope()
+  return result
+}
+

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

@@ -0,0 +1,62 @@
+class Impl : A, B {
+  constructor(b: B) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: B = b
+  override fun add(element: @FlexibleNullability String?): Boolean {
+    return #$$delegate_0.add(element = element)
+  }
+
+  override fun addAll(elements: Collection<@FlexibleNullability String?>): Boolean {
+    return #$$delegate_0.addAll(elements = elements)
+  }
+
+  override fun clear() {
+    #$$delegate_0.clear()
+  }
+
+  override operator fun contains(element: @FlexibleNullability String?): Boolean {
+    return #$$delegate_0.contains(element = element)
+  }
+
+  override fun containsAll(elements: Collection<@FlexibleNullability String?>): Boolean {
+    return #$$delegate_0.containsAll(elements = elements)
+  }
+
+  override fun isEmpty(): Boolean {
+    return #$$delegate_0.isEmpty()
+  }
+
+  override operator fun iterator(): MutableIterator<@FlexibleNullability String?> {
+    return #$$delegate_0.iterator()
+  }
+
+  override fun remove(element: @FlexibleNullability String?): Boolean {
+    return #$$delegate_0.remove(element = element)
+  }
+
+  override fun removeAll(elements: Collection<@FlexibleNullability String?>): Boolean {
+    return #$$delegate_0.removeAll(elements = elements)
+  }
+
+  override fun retainAll(elements: Collection<@FlexibleNullability String?>): Boolean {
+    return #$$delegate_0.retainAll(elements = elements)
+  }
+
+  override val size: Int
+    override get(): Int {
+      return #$$delegate_0.<get-size>()
+    }
+
+
+
+
+}
+
+fun box(): String {
+  return "OK"
+}
+

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

@@ -0,0 +1,60 @@
+fun box(): String {
+  val obj: <no name provided> = { //BLOCK
+    local class <no name provided> {
+      constructor() /* primary */ {
+        TODO("IrDelegatingConstructorCall")
+                /* InstanceInitializerCall */
+
+      }
+
+      val end: String
+        field = "K"
+        get
+
+      fun foo(): String {
+        return TODO("IrConstructorCall").bar()
+      }
+
+      local inner class Some : Base {
+        constructor(s: String) /* primary */ {
+          TODO("IrDelegatingConstructorCall")
+                    /* InstanceInitializerCall */
+
+        }
+
+        fun bar(): String {
+          return <this>.<get-s>().plus(other = <this>.<get-end>())
+        }
+
+
+
+
+      }
+
+      local open inner class Base {
+        constructor(s: String) /* primary */ {
+          TODO("IrDelegatingConstructorCall")
+                    /* InstanceInitializerCall */
+
+        }
+
+        val s: String
+          field = s
+          get
+
+
+
+
+      }
+
+
+
+
+    }
+
+
+    TODO("IrConstructorCall")
+  }
+  return obj.foo()
+}
+

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

@@ -0,0 +1,159 @@
+data class Some<T : Any?> {
+  constructor(value: T) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val value: T
+    field = value
+    get
+
+  operator fun component1(): T {
+    return #value
+  }
+
+  fun copy(value: T = #value): Some<T> {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Some(" + 
+"value=" + 
+#value + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #value, arg1 = null) -> 0
+      true -> #value.hashCode()
+    }
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Some<T> -> return false
+    }
+    val tmp0_other_with_cast: Some<T> = other as Some<T>
+    when {
+      EQEQ(arg0 = #value, arg1 = #value).not() -> return false
+    }
+    return true
+  }
+
+}
+
+interface MyList<T : Any?> : List<Some<T>> {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+open class SomeList<T : Any?> : MyList<T>, ArrayList<Some<T>> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+class FinalList : SomeList<String> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+

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

@@ -0,0 +1,5 @@
+fun foo() {
+  val ref1: KProperty0<String> = ::someJavaField
+  val ref2: KProperty0<String> = ::someJavaField
+}
+

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

@@ -0,0 +1,91 @@
+typealias Some = Function1<Any, String?>
+object Factory {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun foo(a: String): String {
+    return "Alpha"
+  }
+
+  fun foo(a: String, f: Function1<Any, String?>): String {
+    return "Omega"
+  }
+
+
+
+
+}
+
+interface Base {
+
+
+
+}
+
+interface Delegate : Base {
+  abstract fun bar() 
+
+
+
+}
+
+interface Derived : Delegate {
+
+
+
+
+}
+
+data class DataClass : Derived, Delegate {
+  constructor(delegate: Delegate) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val delegate: Delegate
+    field = delegate
+    get
+
+  override fun bar() {
+    #delegate.bar()
+  }
+
+  operator fun component1(): Delegate {
+    return #delegate
+  }
+
+  fun copy(delegate: Delegate = #delegate): DataClass {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "DataClass(" + 
+"delegate=" + 
+#delegate + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #delegate.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is DataClass -> return false
+    }
+    val tmp0_other_with_cast: DataClass = other as DataClass
+    when {
+      EQEQ(arg0 = #delegate, arg1 = #delegate).not() -> return false
+    }
+    return true
+  }
+
+}
+

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

@@ -0,0 +1,25 @@
+class Some {
+  constructor(foo: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var foo: Int
+    field = foo
+    get
+    set
+
+  init {
+    when {
+      less(arg0 = <this>.<get-foo>(), arg1 = 0) -> { //BLOCK
+        <this>.<set-foo>(<set-?> = 0)
+      }
+    }
+  }
+
+
+
+
+}
+

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

@@ -0,0 +1,67 @@
+class Candidate {
+  constructor(symbol: AbstractFirBasedSymbol<*>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val symbol: AbstractFirBasedSymbol<*>
+    field = symbol
+    get
+
+
+
+
+}
+
+abstract class AbstractFirBasedSymbol<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  lateinit var fir: E
+    get
+    set
+
+
+
+
+}
+
+interface FirDeclaration {
+
+
+
+}
+
+interface FirSymbolOwner<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
+  abstract val symbol: AbstractFirBasedSymbol<E>
+    abstract get
+
+
+
+
+}
+
+interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F>> : FirSymbolOwner<F>, FirDeclaration {
+  abstract override val symbol: AbstractFirBasedSymbol<F>
+    abstract override get
+
+
+
+
+}
+
+fun foo(candidate: Candidate) {
+  val me: FirSymbolOwner<*> = candidate.<get-symbol>().<get-fir>()
+  when {
+    when {
+      me is FirCallableMemberDeclaration<*> -> EQEQ(arg0 = me /*as FirCallableMemberDeclaration<out FirCallableMemberDeclaration<*>> */.<get-symbol>(), arg1 = null).not()
+      true -> false
+    } -> { //BLOCK
+    }
+  }
+}
+

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

@@ -0,0 +1,40 @@
+private const val BACKSLASH: Char
+  field = '\'
+  private get
+
+private fun Reader.nextChar(): Char? {
+  return { //BLOCK
+    val tmp0_safe_receiver: Int? = takeUnless<Int>($receiver = <this>.read(), predicate =     local fun <anonymous>(it: Int): Boolean {
+      return EQEQ(arg0 = it, arg1 = -1)
+    }
+)
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      true -> tmp0_safe_receiver.toChar()
+    }
+  }
+}
+
+fun Reader.consumeRestOfQuotedSequence(sb: StringBuilder, quote: Char) {
+  var ch: Char? = nextChar($receiver = <this>)
+  while (when {
+    EQEQ(arg0 = ch, arg1 = null).not() -> EQEQ(arg0 = ch, arg1 = quote).not()
+    true -> false
+  }) { //BLOCK
+    when {
+      EQEQ(arg0 = ch, arg1 = <get-BACKSLASH>()) -> { //BLOCK
+        val tmp0_safe_receiver: Char? = nextChar($receiver = <this>)
+        when {
+          EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+          true -> let<Char, @FlexibleNullability StringBuilder?>($receiver = tmp0_safe_receiver, block =           local fun <anonymous>(it: Char): @FlexibleNullability StringBuilder? {
+            return sb.append(p0 = it)
+          }
+)
+        }
+      } /*~> Unit */
+      true -> sb.append(p0 = ch) /*~> Unit */
+    }
+    ch = nextChar($receiver = <this>)
+  }
+}
+

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

@@ -0,0 +1,17 @@
+class Owner {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun <T : Any?> foo(x: T, y: T) {
+    val map: MutableMap<T, T> = mutableMapOf<T, T>()
+    map.putIfAbsent(p0 = x, p1 = y) /*~> Unit */
+  }
+
+
+
+
+}
+

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

@@ -0,0 +1,18 @@
+class V8Array {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+fun box(): String {
+  val array: V8Array = TODO("IrConstructorCall")
+  val list: List<String> = toList(array = array) as List<String>
+  return list.get(index = 0)
+}
+

compiler/testData/ir/irText/types/javaWildcardType.kt.txt

@@ -0,0 +1,56 @@
+interface K {
+  abstract fun kf1(): Collection<out CharSequence> 
+  abstract fun kf2(): Collection<CharSequence> 
+  abstract fun kg1(c: Collection<out CharSequence>) 
+  abstract fun kg2(c: Collection<CharSequence>) 
+
+
+
+}
+
+class C : J, K {
+  constructor(j: J, k: K) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: J = j
+  override fun jf1(): @FlexibleNullability MutableCollection<out @FlexibleNullability CharSequence?>? {
+    return #$$delegate_0.jf1()
+  }
+
+  override fun jf2(): @FlexibleNullability MutableCollection<@FlexibleNullability CharSequence?>? {
+    return #$$delegate_0.jf2()
+  }
+
+  override fun jg1(c: @FlexibleNullability MutableCollection<out @FlexibleNullability CharSequence?>?) {
+    #$$delegate_0.jg1(c = c)
+  }
+
+  override fun jg2(c: @FlexibleNullability MutableCollection<@FlexibleNullability CharSequence?>?) {
+    #$$delegate_0.jg2(c = c)
+  }
+
+  private /*final field*/ val $$delegate_1: K = k
+  override fun kf1(): Collection<out CharSequence> {
+    return #$$delegate_1.kf1()
+  }
+
+  override fun kf2(): Collection<CharSequence> {
+    return #$$delegate_1.kf2()
+  }
+
+  override fun kg1(c: Collection<out CharSequence>) {
+    #$$delegate_1.kg1(c = c)
+  }
+
+  override fun kg2(c: Collection<CharSequence>) {
+    #$$delegate_1.kg2(c = c)
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsT.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useT(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useT<@EnhancedNullability String>(fn =   local fun <anonymous>(): @EnhancedNullability String {
+    return notNullString()
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTAny.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any> useTAny(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useTAny<@EnhancedNullability String>(fn =   local fun <anonymous>(): @EnhancedNullability String {
+    return notNullString()
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTConstrained.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useTConstrained(xs: Array<T>, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testWithNullCheck(xs: Array<String>) {
+  useTConstrained<String>(xs = xs, fn =   local fun <anonymous>(): String {
+    return notNullString() /*!! String */
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTXArray.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useTX(x: T, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testWithNullCheck(xs: Array<String>) {
+  useTX<Serializable>(x = xs, fn =   local fun <anonymous>(): Serializable {
+    return notNullString() /*!! String */
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/nnStringVsTXString.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useTX(x: T, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testWithNullCheck() {
+  useTX<String>(x = "", fn =   local fun <anonymous>(): String {
+    return notNullString() /*!! String */
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsT.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useT(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useT<@FlexibleNullability String?>(fn =   local fun <anonymous>(): @FlexibleNullability String? {
+    return string()
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTAny.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any> useTAny(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useTAny<@FlexibleNullability String?>(fn =   local fun <anonymous>(): @FlexibleNullability String? {
+    return string()
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTConstrained.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useTConstrained(xs: Array<T>, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testWithNullCheck(xs: Array<String>) {
+  useTConstrained<String>(xs = xs, fn =   local fun <anonymous>(): String {
+    return string() /*!! String */
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXArray.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useTX(x: T, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck(xs: Array<String>) {
+  useTX<@FlexibleNullability Serializable?>(x = xs, fn =   local fun <anonymous>(): @FlexibleNullability Serializable? {
+    return string()
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXString.kt.txt

@@ -0,0 +1,11 @@
+fun <T : Any?> useTX(x: T, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useTX<@FlexibleNullability String?>(x = "", fn =   local fun <anonymous>(): @FlexibleNullability String? {
+    return string()
+  }
+) /*~> Unit */
+}
+

compiler/testData/ir/irText/types/rawTypeInSignature.kt.txt

@@ -0,0 +1,93 @@
+class GenericInv<T : Number> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class GenericIn<in T : Number> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class GenericOut<out T : Number> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+fun testReturnsRawGenericInv(j: JRaw): @FlexibleNullability @RawType GenericInv<Number>? {
+  return j.returnsRawGenericInv()
+}
+
+fun testReturnsRawGenericIn(j: JRaw): @FlexibleNullability @RawType GenericIn<Number>? {
+  return j.returnsRawGenericIn()
+}
+
+fun testReturnsRawGenericOut(j: JRaw): @FlexibleNullability @RawType GenericOut<Number>? {
+  return j.returnsRawGenericOut()
+}
+
+class KRaw : JRaw {
+  constructor(j: JRaw) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: JRaw = j
+  override fun returnsRawGenericIn(): @FlexibleNullability @RawType GenericIn<Number>? {
+    return #$$delegate_0.returnsRawGenericIn()
+  }
+
+  override fun returnsRawGenericInv(): @FlexibleNullability @RawType GenericInv<Number>? {
+    return #$$delegate_0.returnsRawGenericInv()
+  }
+
+  override fun returnsRawGenericOut(): @FlexibleNullability @RawType GenericOut<Number>? {
+    return #$$delegate_0.returnsRawGenericOut()
+  }
+
+  override fun returnsRawList(): @FlexibleNullability @RawType MutableList<Any?>? {
+    return #$$delegate_0.returnsRawList()
+  }
+
+  override fun takesRawGenericIn(g: @FlexibleNullability @RawType GenericIn<Number>?) {
+    #$$delegate_0.takesRawGenericIn(g = g)
+  }
+
+  override fun takesRawGenericInv(g: @FlexibleNullability @RawType GenericInv<Number>?) {
+    #$$delegate_0.takesRawGenericInv(g = g)
+  }
+
+  override fun takesRawGenericOut(g: @FlexibleNullability @RawType GenericOut<Number>?) {
+    #$$delegate_0.takesRawGenericOut(g = g)
+  }
+
+  override fun takesRawList(list: @FlexibleNullability @RawType MutableList<Any?>?) {
+    #$$delegate_0.takesRawList(list = list)
+  }
+
+
+
+
+}
+