[FIR] Make default values for value parameters lazy in RawFirBuilder

Sixth step for ^KT-52615

Merge-request: KT-MR-7926
Merged-by: Egor Kulikov <Egor.Kulikov@jetbrains.com>

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt

@@ -75,8 +75,10 @@ private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
         simpleFunction: FirSimpleFunction,
         data: ResolutionMode
     ): FirSimpleFunction {
-        simpleFunction.processCallable {
+        if (FirLazyBodiesCalculator.needCalculatingLazyBodyForFunction(simpleFunction)) {
-            FirLazyBodiesCalculator.calculateLazyBodiesForFunction(it)
+            simpleFunction.processCallable {
+                FirLazyBodiesCalculator.calculateLazyBodiesForFunction(it)
+            }
         }
 
         return super.transformSimpleFunction(simpleFunction, data)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt

@@ -37,9 +37,18 @@ internal object FirLazyBodiesCalculator {
         firFile.transform<FirElement, PersistentList<FirDeclaration>>(FirLazyBodiesCalculatorTransformer, persistentListOf())
     }
 
+    private fun replaceValueParameterDefaultValues(valueParameters: List<FirValueParameter>, newValueParameters: List<FirValueParameter>) {
+        require(valueParameters.size == newValueParameters.size)
+        for ((valueParameter, newValueParameter) in valueParameters.zip(newValueParameters)) {
+            if (newValueParameter.defaultValue != null) {
+                valueParameter.replaceDefaultValue(newValueParameter.defaultValue)
+            }
+        }
+    }
+
     fun calculateLazyBodiesForFunction(designation: FirDeclarationDesignation) {
         val simpleFunction = designation.declaration as FirSimpleFunction
-        if (simpleFunction.body !is FirLazyBlock) return
+        require(needCalculatingLazyBodyForFunction(simpleFunction))
         val newFunction = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind(
             session = simpleFunction.moduleData.session,
             scopeProvider = simpleFunction.moduleData.session.kotlinScopeProvider,
@@ -49,13 +58,14 @@ internal object FirLazyBodiesCalculator {
         simpleFunction.apply {
             replaceBody(newFunction.body)
             replaceContractDescription(newFunction.contractDescription)
+            replaceValueParameterDefaultValues(valueParameters, newFunction.valueParameters)
         }
     }
 
     fun calculateLazyBodyForConstructor(designation: FirDeclarationDesignation) {
         val constructor = designation.declaration as FirConstructor
         require(constructor.psi is KtConstructor<*>)
-        require(constructor.body is FirLazyBlock || constructor.delegatedConstructor is FirLazyDelegatedConstructorCall)
+        require(needCalculatingLazyBodyForConstructor(constructor))
 
         val newConstructor = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind(
             session = constructor.moduleData.session,
@@ -67,6 +77,7 @@ internal object FirLazyBodiesCalculator {
         constructor.apply {
             replaceBody(newConstructor.body)
             replaceDelegatedConstructor(newConstructor.delegatedConstructor)
+            replaceValueParameterDefaultValues(valueParameters, newConstructor.valueParameters)
         }
     }
 
@@ -147,9 +158,15 @@ internal object FirLazyBodiesCalculator {
         }
     }
 
+    fun needCalculatingLazyBodyForConstructor(firConstructor: FirConstructor): Boolean =
+        needCalculatingLazyBodyForFunction(firConstructor) || firConstructor.delegatedConstructor is FirLazyDelegatedConstructorCall
+
+    fun needCalculatingLazyBodyForFunction(firFunction: FirFunction): Boolean =
+        firFunction.body is FirLazyBlock || firFunction.valueParameters.any { it.defaultValue is FirLazyExpression }
+
     fun needCalculatingLazyBodyForProperty(firProperty: FirProperty): Boolean =
-        firProperty.getter?.body is FirLazyBlock
+        firProperty.getter?.let { needCalculatingLazyBodyForFunction(it) } == true
-                || firProperty.setter?.body is FirLazyBlock
+                || firProperty.setter?.let { needCalculatingLazyBodyForFunction(it) } == true
                 || firProperty.initializer is FirLazyExpression
                 || (firProperty.delegate as? FirWrappedDelegateExpression)?.expression is FirLazyExpression
                 || firProperty.getExplicitBackingField()?.initializer is FirLazyExpression
@@ -179,7 +196,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<PersistentLis
         simpleFunction: FirSimpleFunction,
         data: PersistentList<FirDeclaration>
     ): FirSimpleFunction {
-        if (simpleFunction.body is FirLazyBlock) {
+        if (FirLazyBodiesCalculator.needCalculatingLazyBodyForFunction(simpleFunction)) {
             val designation = FirDeclarationDesignation(data, simpleFunction)
             FirLazyBodiesCalculator.calculateLazyBodiesForFunction(designation)
         }
@@ -190,7 +207,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<PersistentLis
         constructor: FirConstructor,
         data: PersistentList<FirDeclaration>
     ): FirConstructor {
-        if (constructor.body is FirLazyBlock || constructor.delegatedConstructor is FirLazyDelegatedConstructorCall) {
+        if (FirLazyBodiesCalculator.needCalculatingLazyBodyForConstructor(constructor)) {
             val designation = FirDeclarationDesignation(data, constructor)
             FirLazyBodiesCalculator.calculateLazyBodyForConstructor(designation)
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaValueParameter.kt

@@ -179,6 +179,10 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
     override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?) {
     }
 
+    override fun replaceDefaultValue(newDefaultValue: FirExpression?) {
+        error("Java value parameter cannot has default value")
+    }
+
     override fun replaceGetter(newGetter: FirPropertyAccessor?) {
     }
 

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -586,10 +586,7 @@ open class RawFirBuilder(
                 this.name = name
                 symbol = FirValueParameterSymbol(name)
                 defaultValue = if (hasDefaultValue()) {
-                    disabledLazyMode {
+                    buildOrLazyExpression(null, { { this@toFirValueParameter.defaultValue }.toFirExpression("Should have default value") })
-                        // TODO build lazy initializers here
-                        { this@toFirValueParameter.defaultValue }.toFirExpression("Should have default value")
-                    }
                 } else null
                 isCrossinline = hasModifier(CROSSINLINE_KEYWORD)
                 isNoinline = hasModifier(NOINLINE_KEYWORD)

compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/enums.lazyBodies.txt

@@ -57,7 +57,7 @@ FILE: enums.kt
 
     }
     public? final? enum class PseudoInsn : R|kotlin/Enum<PseudoInsn>| {
-        private constructor(signature: String = String(()V)): R|PseudoInsn| {
+        private constructor(signature: String = LAZY_EXPRESSION): R|PseudoInsn| {
             LAZY_super<R|kotlin/Enum<PseudoInsn>|>
         }
 

compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions/namedArgument.lazyBodies.txt

@@ -1,3 +1,3 @@
 FILE: namedArgument.kt
-    public? final? fun foo(first: String = String(), second: Boolean = Boolean(true), third: Double = Double(3.1415)): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? fun foo(first: String = LAZY_EXPRESSION, second: Boolean = LAZY_EXPRESSION, third: Double = LAZY_EXPRESSION): R|kotlin/Unit| { LAZY_BLOCK }
     public? final? fun test(): R|kotlin/Unit| { LAZY_BLOCK }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt

@@ -79,6 +79,8 @@ abstract class FirValueParameter : FirVariable(), FirControlFlowGraphOwner {
 
     abstract override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?)
 
+    abstract fun replaceDefaultValue(newDefaultValue: FirExpression?)
+
     abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirValueParameter
 
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirValueParameter

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt

@@ -195,4 +195,8 @@ internal class FirDefaultSetterValueParameter(
     override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?) {
         controlFlowGraphReference = newControlFlowGraphReference
     }
+
+    override fun replaceDefaultValue(newDefaultValue: FirExpression?) {
+        defaultValue = newDefaultValue
+    }
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt

@@ -172,4 +172,8 @@ internal class FirValueParameterImpl(
     override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?) {
         controlFlowGraphReference = newControlFlowGraphReference
     }
+
+    override fun replaceDefaultValue(newDefaultValue: FirExpression?) {
+        defaultValue = newDefaultValue
+    }
 }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -393,7 +393,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         valueParameter.configure {
             +symbol("FirValueParameterSymbol")
-            +field("defaultValue", expression, nullable = true)
+            +field("defaultValue", expression, nullable = true, withReplace = true)
             +field("containingFunctionSymbol", functionSymbolType, "*").apply {
                 withBindThis = false
             }