Understanding Kotlin IR and Compose Compiler Code Generation

The Compose Compiler backend generates necessary code inside composable function signatures or bodies to enable runtime recomposition. This generation is performed by ComposeIrGenerationExtension , which extends IrGenerationExtension and operates on the Kotlin Intermediate Representation (IR) rather than traditional ASM bytecode.

IR (Intermediate Representation) is a shared, platform‑agnostic intermediate code introduced by the Kotlin compiler to allow multiple backends to reuse compilation logic. The IR tree, like the PSI tree, can be inspected via KCP, with IrModuleFragment as the root node whose dump() method prints the entire tree.

fun main() {
    println("Hello, World!")
}

Using a custom IrGenerationExtension , developers can obtain the IrModuleFragment of a source file and dump its structure, revealing nodes such as IrFile , IrFunction , and others that inherit from IrElement . Unlike PsiElement , IrElement carries semantic information (e.g., IrType ) instead of raw whitespace.

IR traversal follows the visitor pattern. The IrElement interface defines accept , acceptChildren , transform , and transformChildren methods. Custom visitors can be created by implementing IrElementVisitor , while transformations are performed via IrElementTransformer , which returns an updated IrElement .

interface IrElement {
    fun
accept(visitor: IrElementVisitor
, data: D): R
    fun
transform(transformer: IrElementTransformer
, data: D): IrElement
    fun
acceptChildren(visitor: IrElementVisitor
, data: D)
    fun
transformChildren(transformer: IrElementTransformer
, data: D)
}

To generate code, a custom IrElementTransformer updates IR nodes using an IrFactory , which creates elements such as IrClass , IrSimpleFunction , and IrProperty . Extension functions on IR elements simplify common tasks, for example adding a value parameter to a function:

inline fun IrFunction.addValueParameter(builder: IrValueParameterBuilder.() -> Unit): IrValueParameter =
    IrValueParameterBuilder().run {
        builder()
        if (index == UNDEFINED_PARAMETER_INDEX) {
            index = valueParameters.size
        }
        factory.buildValueParameter(this, this@addValueParameter @addValueParameter)
            .also { valueParameter ->
                valueParameters = valueParameters + valueParameter
            }
    }

The Compose Compiler uses this mechanism to add the hidden $composer parameter to composable functions, as shown in the ComposerParamTransformer snippet.

val composerParam = fn.addValueParameter {
    name = KtxNameConventions.COMPOSER_PARAMETER
    type = composerType.makeNullable()
    origin = IrDeclarationOrigin.DEFINED
    isAssignable = true
}

Further code generation inserts startRestartGroup and endRestartGroup calls around composable bodies, enabling recomposition tracking. This is performed by the ComposableFunctionBodyTransformer , which builds a recursive lambda using DeclarationIrBuilder and irBlockBody to emit the necessary IR instructions.

val localIrBuilder = DeclarationIrBuilder(context, fn.symbol)
fn.body = localIrBuilder.irBlockBody {
    +irReturn(
        irCall(function.symbol).apply {
            // set arguments, update $composer, etc.
        }
    )
}

The overall IR‑based code generation is orchestrated by ComposeIrGenerationExtension . Its generate method receives the root IrModuleFragment and sequentially applies a series of lower‑level transformers such as ClassStabilityTransformer , ComposerParamTransformer , and ComposableFunctionBodyTransformer . Each transformer progressively lowers high‑level constructs into simpler IR until it can be emitted as target code.

These transformers reside in the androidx.compose.compiler.plugins.kotlin.lower package and collectively implement the compiler‑phase pipeline that turns composable Kotlin code into efficient runtime representations.