[IR] add new testdata after rebase

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)
+}
+