diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/phaser/PhaseFactories.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/phaser/PhaseFactories.kt
index c3a6bc3..e01918f 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/phaser/PhaseFactories.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/phaser/PhaseFactories.kt
@@ -19,7 +19,7 @@
 
 annotation class PhaseDescription(
     val name: String,
-    val prerequisite: Array<KClass<out FileLoweringPass>> = [],
+    val prerequisite: Array<KClass<out ModuleLoweringPass>> = [],
 )
 
 fun <Context : LoweringContext> createFilePhases(
diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmIrInliner.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmIrInliner.kt
index c3c3fa7..38dea2a 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmIrInliner.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmIrInliner.kt
@@ -10,6 +10,8 @@
 import org.jetbrains.kotlin.backend.jvm.ir.isInlineFunctionCall
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
+import org.jetbrains.kotlin.ir.inline.AbstractInlineFunctionResolver
 import org.jetbrains.kotlin.ir.inline.FunctionInlining
 import org.jetbrains.kotlin.ir.inline.InlineFunctionResolver
 import org.jetbrains.kotlin.ir.inline.InlineMode
@@ -27,13 +29,13 @@
 ) {
     private val enabled = context.config.enableIrInliner
 
-    override fun lower(irFile: IrFile) {
+    override fun lower(irModule: IrModuleFragment) {
         if (enabled) {
-            super.lower(irFile)
+            super.lower(irModule)
         }
     }
 }
 
-class JvmInlineFunctionResolver(private val context: JvmBackendContext) : InlineFunctionResolver(InlineMode.ALL_INLINE_FUNCTIONS) {
+class JvmInlineFunctionResolver(private val context: JvmBackendContext) : AbstractInlineFunctionResolver(InlineMode.ALL_INLINE_FUNCTIONS) {
     override fun needsInlining(symbol: IrFunctionSymbol): Boolean = symbol.owner.isInlineFunctionCall(context)
 }
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmFunctionInlining.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmFunctionInlining.kt
index 1eb2ae7..ca0bbbb 100644
--- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmFunctionInlining.kt
+++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmFunctionInlining.kt
@@ -21,7 +21,7 @@
             context = context,
             inlineFunctionResolver = WasmInlineFunctionResolver(context, inlineMode),
             produceOuterThisFields = false,
-        ).inline(irModule)
+        ).lower(irModule)
 
         irModule.patchDeclarationParents()
     }
diff --git a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt
index af37b9d..3d18db4 100644
--- a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt
+++ b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/FunctionInlining.kt
@@ -21,7 +21,6 @@
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.originalBeforeInline
 import org.jetbrains.kotlin.ir.symbols.*
-import org.jetbrains.kotlin.ir.symbols.impl.IrReturnableBlockSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.visitors.*
@@ -35,22 +34,108 @@
     private val insertAdditionalImplicitCasts: Boolean = true,
     private val regenerateInlinedAnonymousObjects: Boolean = false,
     private val produceOuterThisFields: Boolean = true,
-) : IrElementTransformerVoidWithContext(), BodyLoweringPass {
+) : ModuleLoweringPass, FileLoweringPass {
+    class WrapperResolver(
+        val cached: Map<IrFunctionSymbol, IrFunction>,
+        val delegate: InlineFunctionResolver,
+    ) : InlineFunctionResolver by delegate {
+        override fun getFunctionDeclaration(symbol: IrFunctionSymbol): IrFunction? {
+            return cached[symbol] ?: delegate.getFunctionDeclaration(symbol)
+        }
+    }
+
+    private fun lower(container: IrElement) {
+        val dependencies = mutableMapOf<IrFunctionSymbol, MutableList<IrFunctionSymbol>>()
+        container.acceptChildrenVoid(object : IrVisitorVoid() {
+            val insideInlineFunction = mutableListOf<IrFunctionSymbol>()
+            override fun visitFunction(declaration: IrFunction) {
+                if (inlineFunctionResolver.needsInlining(declaration.symbol)) {
+                    insideInlineFunction.add(declaration.symbol)
+                    super.visitFunction(declaration)
+                    insideInlineFunction.removeLast()
+                } else {
+                    super.visitFunction(declaration)
+                }
+            }
+
+            override fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
+                super.visitFunctionAccess(expression)
+                val callee = expression.symbol as? IrSimpleFunctionSymbol ?: return
+                if (inlineFunctionResolver.needsInlining(callee)) {
+                    for (callSite in insideInlineFunction) {
+                        dependencies.getOrPut(callSite) { mutableListOf() }.add(callee)
+                    }
+                }
+            }
+        })
+        val cache = mutableMapOf<IrFunctionSymbol, IrFunction>()
+        val inProgress = mutableSetOf<IrFunctionSymbol>()
+        val resolver = WrapperResolver(cache, inlineFunctionResolver)
+        val inlineTransformer = FunctionInliningTransformer(
+            context,
+            resolver,
+            insertAdditionalImplicitCasts,
+            regenerateInlinedAnonymousObjects,
+            produceOuterThisFields,
+        )
+
+        val inliningOrder = mutableListOf<IrFunctionSymbol>()
+
+        fun computeOrder(callee: IrFunctionSymbol) {
+            if (cache.containsKey(callee) || callee !in dependencies.keys) return
+            if (!inProgress.add(callee)) {
+                TODO("Report recursive inlining")
+            }
+            for (dep in dependencies[callee] ?: emptyList()) {
+                computeOrder(dep)
+            }
+            inliningOrder.add(callee)
+            inProgress.remove(callee)
+        }
+
+        for (callee in dependencies.keys) {
+            computeOrder(callee)
+        }
+
+        for (callee in inliningOrder) {
+            val result = callee.owner.deepCopyWithSymbols(callee.owner.parent)
+            result.transformChildrenVoid(inlineTransformer)
+            // TODO: run erasure on result
+            cache[callee] = result // visible to future inlines in this loop
+        }
+
+        container.transformChildrenVoid(inlineTransformer)
+    }
+
+    override fun lower(irModule: IrModuleFragment) {
+        lower(irModule as IrElement)
+    }
+
+    override fun lower(irFile: IrFile) {
+        lower(irFile as IrElement)
+    }
+
+    fun lower(irFunction: IrFunction) {
+        lower(irFunction.body as IrElement)
+        for (parameter in irFunction.parameters) {
+            parameter.defaultValue?.let(::lower)
+        }
+    }
+}
+
+class FunctionInliningTransformer(
+    val context: LoweringContext,
+    private val inlineFunctionResolver: InlineFunctionResolver,
+    private val insertAdditionalImplicitCasts: Boolean = true,
+    private val regenerateInlinedAnonymousObjects: Boolean = false,
+    private val produceOuterThisFields: Boolean = true,
+) : IrElementTransformerVoidWithContext() {
     init {
         require(!produceOuterThisFields || context is CommonBackendContext) {
             "The inliner can generate outer fields only with param `context` of type `CommonBackendContext`"
         }
     }
 
-    override fun lower(irBody: IrBody, container: IrDeclaration) {
-        // TODO container: IrSymbolDeclaration
-        withinScope(container) {
-            irBody.accept(this, null)
-        }
-
-        irBody.patchDeclarationParents(container as? IrDeclarationParent ?: container.parent)
-    }
-
     override fun visitDeclaration(declaration: IrDeclarationBase): IrStatement {
         return when (declaration) {
             is IrFunction, is IrClass, is IrProperty -> context.irFactory.stageController.restrictTo(declaration) {
@@ -60,8 +145,6 @@
         }
     }
 
-    fun inline(irModule: IrModuleFragment) = irModule.accept(this, data = null)
-
     override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
         expression.transformChildrenVoid(this)
 
@@ -82,16 +165,6 @@
             return expression
         }
 
-        withinScope(actualCallee) {
-            actualCallee.body?.transformChildrenVoid()
-            actualCallee.parameters.forEachIndexed { index, param ->
-                if (expression.arguments[index] == null) {
-                    // Default values can recursively reference [callee] - transform only needed.
-                    param.defaultValue = param.defaultValue?.transform(this@FunctionInlining, null)
-                }
-            }
-        }
-
         val parent = allScopes.map { it.irElement }.filterIsInstance<IrDeclarationParent>().lastOrNull()
             ?: allScopes.map { it.irElement }.filterIsInstance<IrDeclaration>().lastOrNull()?.parent
 
diff --git a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineFunctionResolver.kt b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineFunctionResolver.kt
index 6a8be92..7bce198 100644
--- a/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineFunctionResolver.kt
+++ b/compiler/ir/ir.inline/src/org/jetbrains/kotlin/ir/inline/InlineFunctionResolver.kt
@@ -54,18 +54,27 @@
     ALL_FUNCTIONS,
 }
 
-abstract class InlineFunctionResolver(val inlineMode: InlineMode) {
-    open val callInlinerStrategy: CallInlinerStrategy
+interface InlineFunctionResolver {
+    val inlineMode: InlineMode
+    val callInlinerStrategy: CallInlinerStrategy
+    val allowExternalInlining: Boolean
+    fun needsInlining(symbol: IrFunctionSymbol): Boolean
+    fun needsInlining(expression: IrFunctionAccessExpression): Boolean
+    fun getFunctionDeclaration(symbol: IrFunctionSymbol): IrFunction?
+}
+
+abstract class AbstractInlineFunctionResolver(override val inlineMode: InlineMode) : InlineFunctionResolver {
+    override val callInlinerStrategy: CallInlinerStrategy
         get() = CallInlinerStrategy.DEFAULT
-    open val allowExternalInlining: Boolean
+    override val allowExternalInlining: Boolean
         get() = false
 
-    open fun needsInlining(symbol: IrFunctionSymbol) =
+    override fun needsInlining(symbol: IrFunctionSymbol) =
         symbol.isBound && symbol.owner.isInline && (allowExternalInlining || !symbol.owner.isExternal)
 
-    open fun needsInlining(expression: IrFunctionAccessExpression) = needsInlining(expression.symbol)
+    override fun needsInlining(expression: IrFunctionAccessExpression) = needsInlining(expression.symbol)
 
-    open fun getFunctionDeclaration(symbol: IrFunctionSymbol): IrFunction? {
+    override fun getFunctionDeclaration(symbol: IrFunctionSymbol): IrFunction? {
         if (shouldExcludeFunctionFromInlining(symbol)) return null
 
         val owner = symbol.owner
@@ -80,7 +89,7 @@
 abstract class InlineFunctionResolverReplacingCoroutineIntrinsics<Ctx : LoweringContext>(
     protected val context: Ctx,
     inlineMode: InlineMode,
-) : InlineFunctionResolver(inlineMode) {
+) : AbstractInlineFunctionResolver(inlineMode) {
     final override val allowExternalInlining: Boolean
         get() = context.allowExternalInlining
 
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/NativeLoweringPhases.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/NativeLoweringPhases.kt
index 0f59c41..633bc52 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/NativeLoweringPhases.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/NativeLoweringPhases.kt
@@ -363,11 +363,11 @@
 /**
  * The second phase of inlining (inline all functions).
  */
-internal val inlineAllFunctionsPhase = createFileLoweringPhase(
-        lowering = { context: Context ->
-            NativeIrInliner(context, inlineMode = InlineMode.ALL_INLINE_FUNCTIONS)
-        },
+internal val inlineAllFunctionsPhase = createSimpleNamedCompilerPhase<NativeGenerationState, IrModuleFragment>(
         name = "InlineAllFunctions",
+        op = { context: NativeGenerationState, module ->
+            NativeIrInliner(context.context, inlineMode = InlineMode.ALL_INLINE_FUNCTIONS).lower(module)
+        }
 )
 
 private val interopPhase = createFileLoweringPhase(
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/TopLevelPhases.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/TopLevelPhases.kt
index 434066c..a70d854 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/TopLevelPhases.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/TopLevelPhases.kt
@@ -160,7 +160,7 @@
                 // invariant, we would like to put a synchronization point immediately before "InlineAllFunctions".
                 fragmentWithState.forEach { (fragment, state) -> state.runSpecifiedLowerings(fragment, getLoweringsUpToAndIncludingSyntheticAccessors()) }
                 fragmentWithState.forEach { (fragment, state) -> state.runSpecifiedLowerings(fragment, validateIrAfterInliningOnlyPrivateFunctions) }
-                fragmentWithState.forEach { (fragment, state) -> state.runSpecifiedLowerings(fragment, listOf(inlineAllFunctionsPhase)) }
+                fragmentWithState.forEach { (fragment, state) -> state.runSpecifiedLowerings(fragment, inlineAllFunctionsPhase) }
                 if (context.config.configuration[KlibConfigurationKeys.SYNTHETIC_ACCESSORS_DUMP_DIR] != null) {
                     fragmentWithState.forEach { (fragment, state) -> state.runSpecifiedLowerings(fragment, dumpSyntheticAccessorsPhase) }
                 }
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeInlineFunctionResolver.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeInlineFunctionResolver.kt
index 9e066a4..27ff0dca 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeInlineFunctionResolver.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeInlineFunctionResolver.kt
@@ -61,7 +61,7 @@
 
         ArrayConstructorLowering(context).lower(body, function)
 
-        NativeIrInliner(context, inlineMode = InlineMode.PRIVATE_INLINE_FUNCTIONS).lower(body, function)
+        NativeIrInliner(context, inlineMode = InlineMode.PRIVATE_INLINE_FUNCTIONS).lower(function)
         OuterThisInInlineFunctionsSpecialAccessorLowering(context).lowerWithoutAddingAccessorsToParents(function)
         SyntheticAccessorLowering(context).lowerWithoutAddingAccessorsToParents(function)
     }
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/PreCodegenInliner.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/PreCodegenInliner.kt
index f6030e2..96b639a 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/PreCodegenInliner.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/PreCodegenInliner.kt
@@ -20,12 +20,15 @@
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
 import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint
+import org.jetbrains.kotlin.ir.inline.AbstractInlineFunctionResolver
 import org.jetbrains.kotlin.ir.inline.FunctionInlining
+import org.jetbrains.kotlin.ir.inline.FunctionInliningTransformer
 import org.jetbrains.kotlin.ir.inline.InlineFunctionResolver
 import org.jetbrains.kotlin.ir.inline.InlineMode
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.types.classOrNull
 import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
 import org.jetbrains.kotlin.library.metadata.isCInteropLibrary
 import kotlin.collections.*
 
@@ -146,9 +149,9 @@
                     }
 
                     if (functionsToInline.isNotEmpty()) {
-                        val inliner = FunctionInlining(
+                        val inliner = FunctionInliningTransformer(
                                 context,
-                                inlineFunctionResolver = object : InlineFunctionResolver(inlineMode = InlineMode.ALL_FUNCTIONS) {
+                                inlineFunctionResolver = object : AbstractInlineFunctionResolver(inlineMode = InlineMode.ALL_FUNCTIONS) {
                                     override fun shouldExcludeFunctionFromInlining(symbol: IrFunctionSymbol) =
                                             symbol.owner !in functionsToInline
 
@@ -157,7 +160,7 @@
                                     }
                                 },
                         )
-                        inliner.lower(irBody, irFunction)
+                        irFunction.transform(inliner, null)
 
                         // KT-72336: This is not entirely correct since coroutinesLivenessAnalysisPhase could be turned off.
                         LivenessAnalysis.run(irBody) { it is IrSuspensionPoint }