[K2] Avoid field inlining during FIR2IR phase

Before const inlining for fields, we actually want to remember a given
field in `InlineConstTracker`. We are doing it already in const
evaluation. So we just need to ignore const inlining in
`CallAndReferenceGenerator` and delegate it to const evaluation.

#KT-60737

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt

@@ -477,19 +477,11 @@ class CallAndReferenceGenerator(
                         }
                     }
 
-                    is IrFieldSymbol -> if (visitor.annotationMode) {
+                    is IrFieldSymbol -> IrGetFieldImpl(
-                        val resolvedSymbol = calleeReference.toResolvedCallableSymbol() ?: error("should have resolvedSymbol")
+                        startOffset, endOffset, symbol, irType,
-                        val returnType = resolvedSymbol.resolvedReturnTypeRef.toIrType()
+                        origin = IrStatementOrigin.GET_PROPERTY.takeIf { calleeReference !is FirDelegateFieldReference },
-                        val firConstExpression = (resolvedSymbol.fir as FirVariable).initializer as? FirConstExpression<*>
-                            ?: error("should be FirConstExpression")
-                        firConstExpression.toIrConst(returnType)
-                    } else {
-                        IrGetFieldImpl(
-                            startOffset, endOffset, symbol, irType,
-                            origin = IrStatementOrigin.GET_PROPERTY.takeIf { calleeReference !is FirDelegateFieldReference },
                             superQualifierSymbol = dispatchReceiver?.superQualifierSymbol()
-                        )
+                    )
-                    }
 
                     is IrValueSymbol -> {
                         val variable = calleeReference.toResolvedVariableSymbol()!!.fir

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/transformer/IrConstTransformer.kt

@@ -27,6 +27,9 @@ import org.jetbrains.kotlin.ir.util.classId
 import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.ir.util.parentAsClass
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
+import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
+import org.jetbrains.kotlin.ir.visitors.acceptVoid
 
 fun IrFile.transformConst(
     interpreter: IrInterpreter,
@@ -146,17 +149,33 @@ internal abstract class IrConstTransformer(
         )
 
         if (result is IrConst<*>) {
-            val field = when (this) {
+            reportInlinedJavaConst(result)
-                is IrGetField -> this.symbol.owner
-                is IrCall -> this.symbol.owner.property?.backingField
-                else -> null
-            }
-
-            if (field != null) inlineConstTracker?.reportOnIr(irFile, field, result)
         }
 
         return if (failAsError) result.reportIfError(this) else result.warningIfError(this)
     }
+
+    private fun IrExpression.reportInlinedJavaConst(result: IrConst<*>) {
+        this.acceptVoid(object : IrElementVisitorVoid {
+            override fun visitElement(element: IrElement) {
+                element.acceptChildrenVoid(this)
+            }
+
+            private fun report(field: IrField) {
+                inlineConstTracker?.reportOnIr(irFile, field, result)
+            }
+
+            override fun visitGetField(expression: IrGetField) {
+                report(expression.symbol.owner)
+                super.visitGetField(expression)
+            }
+
+            override fun visitCall(expression: IrCall) {
+                expression.symbol.owner.property?.backingField?.let { backingField -> report(backingField) }
+                super.visitCall(expression)
+            }
+        })
+    }
 }
 
 fun InlineConstTracker.reportOnIr(irFile: IrFile, field: IrField, value: IrConst<*>) {