Replace all usages of inlineFunctionSymbol with inlineFunction

2022-12-15 16:09:19 +01:00
parent 1d30a68285
commit ef78196cbc
14 changed files with 117 additions and 58 deletions
@@ -16,13 +16,11 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrReturnableBlockImpl
+import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
 import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrReturnableBlockSymbolImpl
 import org.jetbrains.kotlin.ir.types.getClass
-import org.jetbrains.kotlin.ir.util.explicitParameters
-import org.jetbrains.kotlin.ir.util.functions
-import org.jetbrains.kotlin.ir.util.isVararg
-import org.jetbrains.kotlin.ir.util.statements
+import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.util.OperatorNameConventions

 sealed class IrInlinable
@@ -127,3 +125,37 @@ fun IrInlinable.inline(target: IrDeclarationParent, arguments: List<IrValueDecla
            }
        }
    }
+
+val IrInlinedFunctionBlock.inlineDeclaration: IrDeclaration
+    get() = when (val element = inlinedElement) {
+        is IrFunction -> element
+        is IrFunctionExpression -> element.function
+        is IrFunctionReference -> element.symbol.owner
+        is IrPropertyReference -> element.symbol.owner
+        else -> throw AssertionError("Not supported ir element for inlining ${element.dump()}")
+    }
+
+private val IrInlinedFunctionBlock.inlineFunction: IrFunction?
+    get() = when (val element = inlinedElement) {
+        is IrFunction -> element
+        is IrFunctionExpression -> element.function
+        is IrFunctionReference -> element.symbol.owner.takeIf { it.isInline }
+        else -> null
+    }
+
+fun IrInlinedFunctionBlock.isFunctionInlining(): Boolean {
+    return this.inlinedElement is IrFunction
+}
+
+fun IrInlinedFunctionBlock.isLambdaInlining(): Boolean {
+    return !isFunctionInlining()
+}
+
+val IrContainerExpression.innerInlinedBlockOrThis: IrContainerExpression
+    get() = (this as? IrReturnableBlock)?.statements?.singleOrNull() as? IrInlinedFunctionBlock ?: this
+
+val IrReturnableBlock.inlineFunction: IrFunction?
+    get() = (this.statements.singleOrNull() as? IrInlinedFunctionBlock)?.inlineFunction
+
+val IrReturnableBlock.sourceFileSymbol: IrFileSymbol?
+    get() = inlineFunction?.fileOrNull?.symbol
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.backend.common.lower

+import org.jetbrains.kotlin.backend.common.ir.innerInlinedBlockOrThis
 import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
@@ -120,20 +121,25 @@ abstract class AbstractValueUsageTransformer(
    }

    override fun visitContainerExpression(expression: IrContainerExpression): IrExpression {
+        if (expression is IrInlinedFunctionBlock) {
+            expression.transformChildrenVoid(this)
+            return expression
+        }
+
        expression.transformChildrenVoid(this)

        if (expression.statements.isEmpty()) {
            return expression
        }

-        val lastIndex = expression.statements.lastIndex
-        expression.statements.forEachIndexed { i, irStatement ->
+        val container = expression.innerInlinedBlockOrThis
+        val lastIndex = container.statements.lastIndex
+        container.statements.forEachIndexed { i, irStatement ->
            if (irStatement is IrExpression) {
-                expression.statements[i] =
-                        if (i == lastIndex)
-                            irStatement.useAsResult(expression)
-                        else
-                            irStatement.useAsStatement()
+                container.statements[i] = when (i) {
+                    lastIndex -> irStatement.useAsResult(expression)
+                    else -> irStatement.useAsStatement()
+                }
            }
        }

@@ -162,7 +162,7 @@ class FunctionInlining(

        val substituteMap = mutableMapOf<IrValueParameter, IrExpression>()

-        fun inline() = inlineFunction(callSite, callee, true)
+        fun inline() = inlineFunction(callSite, callee, inlineFunctionResolver.getFunctionSymbol(callee).owner, true)

        private fun IrElement.copy(): IrElement {
            return copyIrElement.copy(this)
@@ -171,6 +171,7 @@ class FunctionInlining(
        private fun inlineFunction(
            callSite: IrFunctionAccessExpression,
            callee: IrFunction,
+            originalInlinedElement: IrElement,
            performRecursiveInline: Boolean
        ): IrReturnableBlock {
            val copiedCallee = (callee.copy() as IrFunction).apply {
@@ -198,18 +199,27 @@ class FunctionInlining(
            val irBuilder = context.createIrBuilder(irReturnableBlockSymbol, endOffset, endOffset)

            val transformer = ParameterSubstitutor()
-            val newStatements = mutableListOf<IrStatement>()
+            val newStatements = statements.map { it.transform(transformer, data = null) as IrStatement }

-            newStatements.addAll(evaluationStatements)
-            statements.mapTo(newStatements) { it.transform(transformer, data = null) as IrStatement }
+            val inlinedBlock = IrInlinedFunctionBlockImpl(
+                startOffset = callSite.startOffset,
+                endOffset = callSite.endOffset,
+                type = callSite.type,
+                inlineCall = callSite,
+                inlinedElement = originalInlinedElement,
+                origin = null,
+                statements = evaluationStatements + newStatements
+            )

+            // Note: here we wrap `IrInlinedFunctionBlock` inside `IrReturnableBlock` because such way it is easier to
+            // control special composite blocks that are inside `IrInlinedFunctionBlock`
            return IrReturnableBlockImpl(
                startOffset = callSite.startOffset,
                endOffset = callSite.endOffset,
                type = callSite.type,
                symbol = irReturnableBlockSymbol,
                origin = null,
-                statements = newStatements,
+                statements = listOf(inlinedBlock),
                inlineFunctionSymbol = inlineFunctionResolver.getFunctionSymbol(callee)
            ).apply {
                transformChildrenVoid(object : IrElementTransformerVoid() {
@@ -281,9 +291,7 @@ class FunctionInlining(
            fun inlineFunctionExpression(irCall: IrCall, irFunctionExpression: IrFunctionExpression): IrExpression {
                // Inline the lambda. Lambda parameters will be substituted with lambda arguments.
                val newExpression = inlineFunction(
-                    irCall,
-                    irFunctionExpression.function,
-                    false
+                    irCall, irFunctionExpression.function, irFunctionExpression, false
                )
                // Substitute lambda arguments with target function arguments.
                return newExpression.transform(this, null)
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.ir.backend.js.dce

+import org.jetbrains.kotlin.backend.common.ir.inlineFunction
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.backend.js.JsCommonBackendContext
 import org.jetbrains.kotlin.ir.backend.js.utils.hasJsPolyfill
@@ -54,7 +55,7 @@ abstract class UsefulDeclarationProcessor(
            super.visitBlock(expression, data)

            if (expression is IrReturnableBlock) {
-                expression.inlineFunctionSymbol?.owner?.addToUsefulPolyfilledDeclarations()
+                expression.inlineFunction?.addToUsefulPolyfilledDeclarations()
            }
        }

@@ -68,7 +68,7 @@ class JsReturnableBlockTransformer(val context: CommonBackendContext) : IrElemen

        val builder = context.createIrBuilder(expression.symbol)

-        expression.type = context.irBuiltIns.unitType
+        expression.type = unitType
        return builder.irComposite(expression, expression.origin, variable.type) {
            +variable
            +expression
@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.ir.backend.js.lower.cleanup

 import org.jetbrains.kotlin.backend.common.BodyLoweringPass
+import org.jetbrains.kotlin.backend.common.ir.isPure
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.backend.common.ir.isPure
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.types.isNothing
@@ -37,8 +37,8 @@ private class BlockRemover : IrElementVisitorVoid {
    private fun process(container: IrStatementContainer) {
        container.statements.transformFlat { statement ->
            when (statement) {
-                // returnable blocks required for sourcemaps generation, so keep them
-                is IrReturnableBlock -> null
+                // returnable and inlined function blocks required for sourcemaps generation, so keep them
+                is IrReturnableBlock, is IrInlinedFunctionBlock -> null
                is IrStatementContainer -> statement.statements
                else -> null
            }
@@ -5,11 +5,12 @@

 package org.jetbrains.kotlin.ir.backend.js.transformers.irToJs

-import org.jetbrains.kotlin.ir.backend.js.utils.isTheLastReturnStatementIn
-import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
+import org.jetbrains.kotlin.backend.common.ir.inlineFunction
+import org.jetbrains.kotlin.backend.common.ir.innerInlinedBlockOrThis
 import org.jetbrains.kotlin.ir.backend.js.JsLoweredDeclarationOrigin
 import org.jetbrains.kotlin.ir.backend.js.utils.JsGenerationContext
 import org.jetbrains.kotlin.ir.backend.js.utils.emptyScope
+import org.jetbrains.kotlin.ir.backend.js.utils.isTheLastReturnStatementIn
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.IrVariable
@@ -36,11 +37,12 @@ class IrElementToJsStatementTransformer : BaseIrElementToJsNodeTransformer<JsSta
    }

    override fun visitBlock(expression: IrBlock, context: JsGenerationContext): JsStatement {
-        val newContext = (expression as? IrReturnableBlock)?.inlineFunctionSymbol?.let {
-            context.newFile(it.owner.file, context.currentFunction, context.localNames)
+        val newContext = (expression as? IrReturnableBlock)?.inlineFunction?.let {
+            context.newFile(it.file, context.currentFunction, context.localNames)
        } ?: context

-        val statements = expression.statements.map { it.accept(this, newContext) }
+        val container = expression.innerInlinedBlockOrThis.statements
+        val statements = container.map { it.accept(this, newContext) }

        return if (expression is IrReturnableBlock) {
            val label = context.getNameForReturnableBlock(expression)
@@ -57,9 +59,9 @@ class IrElementToJsStatementTransformer : BaseIrElementToJsNodeTransformer<JsSta
    }

    private fun List<JsStatement>.wrapInCommentsInlineFunctionCall(expression: IrReturnableBlock): List<JsStatement> {
-        val inlineFunctionSymbol = expression.inlineFunctionSymbol ?: return this
-        val correspondingProperty = (inlineFunctionSymbol.owner as? IrSimpleFunction)?.correspondingPropertySymbol
-        val owner = correspondingProperty?.owner ?: inlineFunctionSymbol.owner
+        val inlineFunction = expression.inlineFunction ?: return this
+        val correspondingProperty = (inlineFunction as? IrSimpleFunction)?.correspondingPropertySymbol
+        val owner = correspondingProperty?.owner ?: inlineFunction
        val funName = owner.fqNameWhenAvailable ?: owner.name
        return listOf(JsSingleLineComment(" Inline function '$funName' call")) + this
    }
@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
+import org.jetbrains.kotlin.ir.expressions.IrInlinedFunctionBlock
 import org.jetbrains.kotlin.ir.expressions.IrReturn
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
@@ -45,6 +46,10 @@ fun IrDeclaration?.isExportedInterface(context: JsIrBackendContext) =
    this is IrClass && kind.isInterface && isExported(context)

 fun IrReturn.isTheLastReturnStatementIn(target: IrReturnableBlockSymbol): Boolean {
+    val ownerFirstStatement = target.owner.statements.singleOrNull()
+    if (ownerFirstStatement is IrInlinedFunctionBlock) {
+        return ownerFirstStatement.statements.lastOrNull() === this
+    }
    return target.owner.statements.lastOrNull() === this
 }

@@ -8,13 +8,7 @@ package org.jetbrains.kotlin.ir.expressions
 import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl
-import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
 import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.util.fileOrNull
-
-@Suppress("unused") // Used in kotlin-native
-val IrReturnableBlock.sourceFileSymbol: IrFileSymbol?
-    get() = inlineFunctionSymbol?.owner?.fileOrNull?.symbol

 val IrFunctionReference.isWithReflection: Boolean
    get() = reflectionTarget != null