[K/JVM] Fix incorrect optimization of local delegation

RCA: the bug was introduced in 1ecb034 during refactoring of using
new reference nodes.

In case where a local variable is delegated to a property with
an untrivial bound expression, this expression is started to compute
on each access of variable, instead of computing once on variable
initialization.

This commit fixes this behavior back to correct one by storing this
expression to a local variable.

Regression test is added to also cover local delegation case
(tests for regular properties already existed).

^KT-84620 Fixed

(cherry picked from commit d7464e2)

Author: kunyavskiy

analysis/low-level-api-fir/tests-gen/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLBlackBoxTestGenerated.java

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.ir.builders.IrBlockBuilder
 import org.jetbrains.kotlin.ir.builders.IrBuilder
 import org.jetbrains.kotlin.ir.builders.createTmpVariable
 import org.jetbrains.kotlin.ir.builders.declarations.buildField
+import org.jetbrains.kotlin.ir.builders.declarations.buildVariable
 import org.jetbrains.kotlin.ir.builders.irBlock
 import org.jetbrains.kotlin.ir.builders.irExprBody
 import org.jetbrains.kotlin.ir.builders.irGet
@@ -101,8 +102,7 @@ private class PropertyReferenceDelegationTransformer(val context: JvmBackendCont
     fun DeclarationIrBuilder.createGetterBody(
         getter: IrSimpleFunction,
         delegateReference: IrRichPropertyReference,
-        receiver: IrExpression?,
-        backingField: IrField?,
+        receiverProvider: IrBuilder.() -> IrExpression?,
     ): IrBody {
         val constInitializer = delegateReference.constInitializer
         return if (constInitializer != null) {
@@ -112,7 +112,7 @@ private class PropertyReferenceDelegationTransformer(val context: JvmBackendCont
             irExprBody(irBlock {
                 +delegateReference.getterFunction.inline(
                     getter,
-                    createAccessorArgumentsList(getter, delegateReference.getterFunction, isGetter = true, receiver, backingField)
+                    createAccessorArgumentsList(getter, delegateReference.getterFunction, isGetter = true, receiverProvider)
                 )
             })
         }
@@ -121,14 +121,13 @@ private class PropertyReferenceDelegationTransformer(val context: JvmBackendCont
     fun DeclarationIrBuilder.createSetterBody(
         setter: IrSimpleFunction,
         delegateReference: IrRichPropertyReference,
-        receiver: IrExpression?,
-        backingField: IrField?,
+        receiverProvider: IrBuilder.() -> IrExpression?,
     ): IrBody {
         val delegateSetter = delegateReference.setterFunction ?: error("delegate was expected to have a setter")
         return irExprBody(irBlock {
             +delegateSetter.inline(
                 setter,
-                createAccessorArgumentsList(setter, delegateSetter, isGetter = false, receiver, backingField)
+                createAccessorArgumentsList(setter, delegateSetter, isGetter = false, receiverProvider)
             )
         })
     }
@@ -140,10 +139,9 @@ private class PropertyReferenceDelegationTransformer(val context: JvmBackendCont
         accessor: IrSimpleFunction,
         delegateAccessor: IrSimpleFunction,
         isGetter: Boolean,
-        remappedReceiver: IrExpression?,
-        backingField: IrField?,
+        receiverProvider: IrBuilder.() -> IrExpression?,
     ): List<IrValueDeclaration> {
-        val boundReceiverOrNull = createBoundReceiverExpr(accessor, backingField, remappedReceiver)
+        val boundReceiverOrNull = receiverProvider()
         val setterParam = if (isGetter) null else accessor.parameters.lastOrNull() ?: error("setter must have at least one parameter")
         return buildList {
             if (boundReceiverOrNull != null) add(createTmpVariable(boundReceiverOrNull.deepCopyWithSymbols(accessor)))
@@ -184,12 +182,24 @@ private class PropertyReferenceDelegationTransformer(val context: JvmBackendCont
 
         getter?.apply {
             body = with(context.createIrBuilder(symbol, startOffset, endOffset)) {
-                createGetterBody(this@apply, delegate, remapReceiverIfNeeded(this@apply), backingField)
+                createGetterBody(
+                    getter = this@apply,
+                    delegateReference = delegate,
+                    receiverProvider = {
+                        createBoundReceiverExpr(this@apply, backingField, remapReceiverIfNeeded(this@apply))
+                    }
+                )
             }
         }
         setter?.apply {
             body = with(context.createIrBuilder(symbol, startOffset, endOffset)) {
-                createSetterBody(this@apply, delegate, remapReceiverIfNeeded(this@apply), backingField)
+                createSetterBody(
+                    setter = this@apply,
+                    delegateReference = delegate,
+                    receiverProvider = {
+                        createBoundReceiverExpr(this@apply, backingField, remapReceiverIfNeeded(this@apply))
+                    }
+                )
             }
         }
 
@@ -234,18 +244,30 @@ private class PropertyReferenceDelegationTransformer(val context: JvmBackendCont
             !declaration.getter.returnsResultOfStdlibCall ||
             declaration.setter?.returnsResultOfStdlibCall == false
         ) return super.visitLocalDelegatedProperty(declaration)
-        // Variables are cheap, so optimizing them out is not really necessary.
-        val receiver = delegateInitializer.singleBoundValueOrNull?.transform(this@PropertyReferenceDelegationTransformer, null)
-        // TODO: just like in `PropertyReferenceLowering`, probably better to inline the getter/setter rather than
+        val receiver = delegateInitializer.singleBoundValueOrNull?.let { receiver ->
+            with(delegate) {
+                buildVariable(parent, startOffset, endOffset, origin, name, receiver.type)
+            }.apply {
+                initializer = receiver.transform(this@PropertyReferenceDelegationTransformer, null)
+            }
+        }        // TODO: just like in `PropertyReferenceLowering`, probably better to inline the getter/setter rather than
         //       generate them as local functions.
         val getter = declaration.getter.apply {
             with(context.createIrBuilder(symbol, startOffset, endOffset)) {
-                body = createGetterBody(this@apply, delegateInitializer, receiver, backingField = null)
+                body = createGetterBody(
+                    getter = this@apply,
+                    delegateReference = delegateInitializer,
+                    receiverProvider = { receiver?.let { irGet(it) } }
+                )
             }
         }
         val setter = declaration.setter?.apply {
             with(context.createIrBuilder(symbol, startOffset, endOffset)) {
-                body = createSetterBody(this@apply, delegateInitializer, receiver, backingField = null)
+                body = createSetterBody(
+                    setter = this@apply,
+                    delegateReference = delegateInitializer,
+                    receiverProvider = { receiver?.let { irGet(it) } }
+                )
             }
         }
         val statements = listOfNotNull(receiver, getter, setter)

analysis/low-level-api-fir/tests-gen/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLReversedBlackBoxTestGenerated.java

@@ -0,0 +1,24 @@
+// WITH_STDLIB
+
+var created: Int = 0
+
+class A(val x: Int) {
+    init { created += 1 }
+}
+
+class B(var x: Int) {
+    init { created += 1000 }
+}
+
+fun create() = A(1)
+
+fun box(): String {
+    val t1 by A(1)::x
+    var t2 by B(1)::x
+    if (t1 != 1) return "FAIL 1: $t1"
+    if (t2 != 1) return "FAIL 2: $t2"
+    t2 = 3
+    if (t2 != 3) return "FAIL 3: $t2"
+    if (created != 1001) return "FAIL 4: $created != 1001"
+    return "OK"
+}