[IR] Reorder parameters in IrFactory#createFunction

This is to prepare for IrFactory auto-generation (KT-59308).

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt

@@ -679,12 +679,22 @@ class Fir2IrClassifierStorage(
     }
 
     private val temporaryParent by lazy {
-        irFactory.createFunction(
-            startOffset = UNDEFINED_OFFSET, endOffset = UNDEFINED_OFFSET,
-            IrDeclarationOrigin.DEFINED, IrSimpleFunctionSymbolImpl(),
-            Name.special("<stub>"), DescriptorVisibilities.PRIVATE, Modality.FINAL, irBuiltIns.unitType,
-            isInline = false, isExternal = false, isTailrec = false,
-            isSuspend = false, isOperator = false, isInfix = false, isExpect = false
+        irFactory.createSimpleFunction(
+            startOffset = UNDEFINED_OFFSET,
+            endOffset = UNDEFINED_OFFSET,
+            origin = IrDeclarationOrigin.DEFINED,
+            name = Name.special("<stub>"),
+            visibility = DescriptorVisibilities.PRIVATE,
+            isInline = false,
+            isExpect = false,
+            returnType = irBuiltIns.unitType,
+            modality = Modality.FINAL,
+            symbol = IrSimpleFunctionSymbolImpl(),
+            isTailrec = false,
+            isSuspend = false,
+            isOperator = false,
+            isInfix = false,
+            isExternal = false,
         ).apply {
             parent = IrExternalPackageFragmentImpl(IrExternalPackageFragmentSymbolImpl(), FqName.ROOT)
         }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt

@@ -568,21 +568,22 @@ class Fir2IrDeclarationStorage(
         val created = function.convertWithOffsets { startOffset, endOffset ->
             val result = declareIrSimpleFunction(signature) { symbol ->
                 classifierStorage.preCacheTypeParameters(function, symbol)
-                irFactory.createFunction(
-                    if (updatedOrigin == IrDeclarationOrigin.DELEGATED_MEMBER) SYNTHETIC_OFFSET else startOffset,
-                    if (updatedOrigin == IrDeclarationOrigin.DELEGATED_MEMBER) SYNTHETIC_OFFSET else endOffset,
-                    updatedOrigin, symbol,
-                    name, components.visibilityConverter.convertToDescriptorVisibility(visibility),
-                    simpleFunction?.modality ?: Modality.FINAL,
-                    function.returnTypeRef.toIrType(),
+                irFactory.createSimpleFunction(
+                    startOffset = if (updatedOrigin == IrDeclarationOrigin.DELEGATED_MEMBER) SYNTHETIC_OFFSET else startOffset,
+                    endOffset = if (updatedOrigin == IrDeclarationOrigin.DELEGATED_MEMBER) SYNTHETIC_OFFSET else endOffset,
+                    origin = updatedOrigin,
+                    name = name,
+                    visibility = components.visibilityConverter.convertToDescriptorVisibility(visibility),
                     isInline = simpleFunction?.isInline == true,
-                    isExternal = simpleFunction?.isExternal == true,
+                    isExpect = simpleFunction?.isExpect == true,
+                    returnType = function.returnTypeRef.toIrType(),
+                    modality = simpleFunction?.modality ?: Modality.FINAL,
+                    symbol = symbol,
                     isTailrec = simpleFunction?.isTailRec == true,
                     isSuspend = isSuspend,
-                    isExpect = simpleFunction?.isExpect == true,
-                    isFakeOverride = updatedOrigin == IrDeclarationOrigin.FAKE_OVERRIDE,
                     isOperator = simpleFunction?.isOperator == true,
                     isInfix = simpleFunction?.isInfix == true,
+                    isExternal = simpleFunction?.isExternal == true,
                     containerSource = simpleFunction?.containerSource,
                 ).apply {
                     metadata = FirMetadataSource.Function(function)
@@ -738,16 +739,22 @@ class Fir2IrDeclarationStorage(
             val visibility = propertyAccessor?.visibility?.let {
                 components.visibilityConverter.convertToDescriptorVisibility(it)
             }
-            irFactory.createFunction(
-                startOffset, endOffset, origin, symbol,
-                Name.special("<$prefix-${correspondingProperty.name}>"),
-                visibility ?: (correspondingProperty as IrDeclarationWithVisibility).visibility,
-                (correspondingProperty as? IrOverridableMember)?.modality ?: Modality.FINAL, accessorReturnType,
+            irFactory.createSimpleFunction(
+                startOffset = startOffset,
+                endOffset = endOffset,
+                origin = origin,
+                name = Name.special("<$prefix-${correspondingProperty.name}>"),
+                visibility = visibility ?: (correspondingProperty as IrDeclarationWithVisibility).visibility,
                 isInline = propertyAccessor?.isInline == true,
-                isExternal = propertyAccessor?.isExternal == true,
-                isTailrec = false, isSuspend = false, isOperator = false,
+                isExpect = false,
+                returnType = accessorReturnType,
+                modality = (correspondingProperty as? IrOverridableMember)?.modality ?: Modality.FINAL,
+                symbol = symbol,
+                isTailrec = false,
+                isSuspend = false,
+                isOperator = false,
                 isInfix = false,
-                isExpect = false, isFakeOverride = origin == IrDeclarationOrigin.FAKE_OVERRIDE,
+                isExternal = propertyAccessor?.isExternal == true,
                 containerSource = containerSource,
             ).apply {
                 correspondingPropertySymbol = (correspondingProperty as? IrProperty)?.symbol

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt

@@ -943,12 +943,24 @@ class IrBuiltInsOverFir(
             this.isOperator = isOperator
             this.isInfix = isInfix
             build()
-            irFactory.createFunction(
-                startOffset, endOffset, this.origin,
-                symbol,
-                this.name, visibility, this.modality, this.returnType,
-                isInline, isExternal, isTailrec, isSuspend, this.isOperator, this.isInfix, isExpect, isFakeOverride,
-                containerSource,
+            irFactory.createSimpleFunction(
+                startOffset = startOffset,
+                endOffset = endOffset,
+                origin = this.origin,
+                name = this.name,
+                visibility = visibility,
+                isInline = isInline,
+                isExpect = isExpect,
+                returnType = this.returnType,
+                modality = this.modality,
+                symbol = symbol,
+                isTailrec = isTailrec,
+                isSuspend = isSuspend,
+                isOperator = this.isOperator,
+                isInfix = this.isInfix,
+                isExternal = isExternal,
+                containerSource = containerSource,
+                isFakeOverride = isFakeOverride,
             )
         }.also { fn ->
             valueParameterTypes.forEachIndexed { index, (pName, irType) ->

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

@@ -204,22 +204,22 @@ internal class AdapterGenerator(
         val returnType = type.arguments.last().typeOrNull!!
         val parameterTypes = type.arguments.dropLast(1).map { it.typeOrNull!! }
         val firMemberAdaptee = firAdaptee as FirMemberDeclaration
-        return irFactory.createFunction(
-            startOffset, endOffset,
-            IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE,
-            IrSimpleFunctionSymbolImpl(),
-            adaptee.name,
-            DescriptorVisibilities.LOCAL,
-            Modality.FINAL,
-            returnType,
+        return irFactory.createSimpleFunction(
+            startOffset = startOffset,
+            endOffset = endOffset,
+            origin = IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE,
+            name = adaptee.name,
+            visibility = DescriptorVisibilities.LOCAL,
             isInline = firMemberAdaptee.isInline,
-            isExternal = false,
+            isExpect = false,
+            returnType = returnType,
+            modality = Modality.FINAL,
+            symbol = IrSimpleFunctionSymbolImpl(),
             isTailrec = false,
             isSuspend = firMemberAdaptee.isSuspend || type.isSuspendFunction(),
             isOperator = firMemberAdaptee.isOperator,
             isInfix = firMemberAdaptee.isInfix,
-            isExpect = false,
-            isFakeOverride = false
+            isExternal = false,
         ).also { irAdapterFunction ->
             symbolTable.enterScope(irAdapterFunction)
             irAdapterFunction.dispatchReceiverParameter = null
@@ -649,23 +649,23 @@ internal class AdapterGenerator(
     ): IrSimpleFunction {
         val returnType = type.arguments.last().typeOrNull!!
         val parameterTypes = type.arguments.dropLast(1).map { it.typeOrNull!! }
-        return irFactory.createFunction(
-            startOffset, endOffset,
-            IrDeclarationOrigin.ADAPTER_FOR_SUSPEND_CONVERSION,
-            IrSimpleFunctionSymbolImpl(),
+        return irFactory.createSimpleFunction(
+            startOffset = startOffset,
+            endOffset = endOffset,
+            origin = IrDeclarationOrigin.ADAPTER_FOR_SUSPEND_CONVERSION,
             // TODO: need a better way to avoid name clash
-            Name.identifier("suspendConversion"),
-            DescriptorVisibilities.LOCAL,
-            Modality.FINAL,
-            returnType,
+            name = Name.identifier("suspendConversion"),
+            visibility = DescriptorVisibilities.LOCAL,
             isInline = false,
-            isExternal = false,
+            isExpect = false,
+            returnType = returnType,
+            modality = Modality.FINAL,
+            symbol = IrSimpleFunctionSymbolImpl(),
             isTailrec = false,
             isSuspend = true,
             isOperator = false,
             isInfix = false,
-            isExpect = false,
-            isFakeOverride = false
+            isExternal = false,
         ).also { irAdapterFunction ->
             symbolTable.enterScope(irAdapterFunction)
             irAdapterFunction.extensionReceiverParameter = createAdapterParameter(
@@ -773,22 +773,22 @@ internal class AdapterGenerator(
         val functionParameter = callableSymbol.valueParameterSymbols.singleOrNull()
             ?: throw AssertionError("Single value parameter expected: ${callableSymbol.valueParameterSymbols}")
 
-        return irFactory.createFunction(
-            startOffset, endOffset,
-            IrDeclarationOrigin.ADAPTER_FOR_FUN_INTERFACE_CONSTRUCTOR,
-            IrSimpleFunctionSymbolImpl(),
-            callableSymbol.name,
-            DescriptorVisibilities.LOCAL,
-            Modality.FINAL,
-            irSamType,
+        return irFactory.createSimpleFunction(
+            startOffset = startOffset,
+            endOffset = endOffset,
+            origin = IrDeclarationOrigin.ADAPTER_FOR_FUN_INTERFACE_CONSTRUCTOR,
+            name = callableSymbol.name,
+            visibility = DescriptorVisibilities.LOCAL,
             isInline = false,
-            isExternal = false,
+            isExpect = false,
+            returnType = irSamType,
+            modality = Modality.FINAL,
+            symbol = IrSimpleFunctionSymbolImpl(),
             isTailrec = false,
             isSuspend = false,
             isOperator = false,
             isInfix = false,
-            isExpect = false,
-            isFakeOverride = false
+            isExternal = false,
         ).also { irAdapterFunction ->
             symbolTable.enterScope(irAdapterFunction)
             irAdapterFunction.dispatchReceiverParameter = null

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

@@ -237,10 +237,23 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) : Fir2IrCompon
         ): IrFunction {
             val signature = if (lookupTag.classId.isLocal) null else components.signatureComposer.composeSignature(syntheticCounterpart)
             return components.declarationStorage.declareIrSimpleFunction(signature) { symbol ->
-                components.irFactory.createFunction(
-                    UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, symbol, name, DescriptorVisibilities.PUBLIC, Modality.OPEN, returnType,
-                    isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isOperator = isOperator,
-                    isInfix = false, isExpect = false, isFakeOverride = false,
+                components.irFactory.createSimpleFunction(
+                    startOffset = UNDEFINED_OFFSET,
+                    endOffset = UNDEFINED_OFFSET,
+                    origin = origin,
+                    name = name,
+                    visibility = DescriptorVisibilities.PUBLIC,
+                    isInline = false,
+                    isExpect = false,
+                    returnType = returnType,
+                    modality = Modality.OPEN,
+                    symbol = symbol,
+                    isTailrec = false,
+                    isSuspend = false,
+                    isOperator = isOperator,
+                    isInfix = false,
+                    isExternal = false,
+                    isFakeOverride = false,
                 ).apply {
                     if (otherParameterNeeded) {
                         val irValueParameter = createSyntheticIrParameter(

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/SyntheticAccessorLowering.kt

@@ -88,23 +88,24 @@ class SyntheticAccessorLowering(private val context: CommonBackendContext) : Bod
         private val copier = object : DeepCopyIrTreeWithSymbols(symbolRemapper, typeRemapper) {
             override fun visitSimpleFunction(declaration: IrSimpleFunction): IrSimpleFunction {
                 val newName = Name.identifier("${declaration.name.asString()}\$accessor\$$fileHash")
-                return declaration.factory.createFunction(
-                    declaration.startOffset, declaration.endOffset,
-                    mapDeclarationOrigin(declaration.origin),
-                    symbolRemapper.getDeclaredFunction(declaration.symbol),
-                    newName,
-                    DescriptorVisibilities.INTERNAL,
-                    declaration.modality,
-                    IrUninitializedType,
+                return declaration.factory.createSimpleFunction(
+                    startOffset = declaration.startOffset,
+                    endOffset = declaration.endOffset,
+                    origin = mapDeclarationOrigin(declaration.origin),
+                    name = newName,
+                    visibility = DescriptorVisibilities.INTERNAL,
                     isInline = declaration.isInline,
-                    isExternal = declaration.isExternal,
+                    isExpect = declaration.isExpect,
+                    returnType = IrUninitializedType,
+                    modality = declaration.modality,
+                    symbol = symbolRemapper.getDeclaredFunction(declaration.symbol),
                     isTailrec = declaration.isTailrec,
                     isSuspend = declaration.isSuspend,
                     isOperator = declaration.isOperator,
                     isInfix = declaration.isInfix,
-                    isExpect = declaration.isExpect,
-                    isFakeOverride = declaration.isFakeOverride,
+                    isExternal = declaration.isExternal,
                     containerSource = declaration.containerSource,
+                    isFakeOverride = declaration.isFakeOverride,
                 ).apply {
                     assert(declaration.overriddenSymbols.isEmpty()) { "Top level function overrides nothing" }
                     transformFunctionChildren(declaration)

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrTreeBuildUtils.kt

@@ -96,9 +96,22 @@ internal fun createTempFunction(
     origin: IrDeclarationOrigin = TEMP_FUNCTION_FOR_INTERPRETER,
     visibility: DescriptorVisibility = DescriptorVisibilities.PUBLIC
 ): IrSimpleFunction {
-    return IrFactoryImpl.createFunction(
-        SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, origin, IrSimpleFunctionSymbolImpl(), name, visibility, Modality.FINAL, type,
-        isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isOperator = true, isInfix = false, isExpect = false
+    return IrFactoryImpl.createSimpleFunction(
+        startOffset = SYNTHETIC_OFFSET,
+        endOffset = SYNTHETIC_OFFSET,
+        origin = origin,
+        name = name,
+        visibility = visibility,
+        isInline = false,
+        isExpect = false,
+        returnType = type,
+        modality = Modality.FINAL,
+        symbol = IrSimpleFunctionSymbolImpl(),
+        isTailrec = false,
+        isSuspend = false,
+        isOperator = true,
+        isInfix = false,
+        isExternal = false,
     )
 }
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt

@@ -103,23 +103,22 @@ class IrBuiltInsOverDescriptors(
         }
 
         val symbol = symbolTable.declareSimpleFunctionIfNotExists(operatorDescriptor) {
-            val operator = irFactory.createFunction(
-                UNDEFINED_OFFSET,
-                UNDEFINED_OFFSET,
-                BUILTIN_OPERATOR,
-                it,
-                Name.identifier(name),
-                DescriptorVisibilities.PUBLIC,
-                Modality.FINAL,
-                returnType,
+            val operator = irFactory.createSimpleFunction(
+                startOffset = UNDEFINED_OFFSET,
+                endOffset = UNDEFINED_OFFSET,
+                origin = BUILTIN_OPERATOR,
+                name = Name.identifier(name),
+                visibility = DescriptorVisibilities.PUBLIC,
                 isInline = false,
-                isExternal = false,
+                isExpect = false,
+                returnType = returnType,
+                modality = Modality.FINAL,
+                symbol = it,
                 isTailrec = false,
                 isSuspend = false,
                 isOperator = false,
                 isInfix = false,
-                isExpect = false,
-                isFakeOverride = false
+                isExternal = false,
             )
             operator.parent = operatorsPackageFragment
             operatorsPackageFragment.declarations += operator
@@ -211,13 +210,22 @@ class IrBuiltInsOverDescriptors(
                 buildSimpleType()
             }
 
-            irFactory.createFunction(
-                UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR,
-                operatorSymbol, name,
-                DescriptorVisibilities.PUBLIC, Modality.FINAL,
-                returnIrType,
-                isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isOperator = false, isInfix = false,
-                isExpect = false, isFakeOverride = false
+            irFactory.createSimpleFunction(
+                startOffset = UNDEFINED_OFFSET,
+                endOffset = UNDEFINED_OFFSET,
+                origin = BUILTIN_OPERATOR,
+                name = name,
+                visibility = DescriptorVisibilities.PUBLIC,
+                isInline = false,
+                isExpect = false,
+                returnType = returnIrType,
+                modality = Modality.FINAL,
+                symbol = operatorSymbol,
+                isTailrec = false,
+                isSuspend = false,
+                isOperator = false,
+                isInfix = false,
+                isExternal = false,
             ).also { operator ->
                 operator.parent = operatorsPackageFragment
                 operatorsPackageFragment.declarations += operator

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrDescriptorBasedFunctionFactory.kt

@@ -296,16 +296,22 @@ class IrDescriptorBasedFunctionFactory(
                     buildSimpleType()
                 }
 
-                irFactory.createFunction(
-                    offset, offset, memberOrigin, it, Name.identifier("invoke"), DescriptorVisibilities.PUBLIC, Modality.ABSTRACT,
-                    returnType,
+                irFactory.createSimpleFunction(
+                    startOffset = offset,
+                    endOffset = offset,
+                    origin = memberOrigin,
+                    name = Name.identifier("invoke"),
+                    visibility = DescriptorVisibilities.PUBLIC,
                     isInline = false,
-                    isExternal = false,
+                    isExpect = false,
+                    returnType = returnType,
+                    modality = Modality.ABSTRACT,
+                    symbol = it,
                     isTailrec = false,
                     isSuspend = isSuspend,
                     isOperator = true,
                     isInfix = false,
-                    isExpect = false,
+                    isExternal = false,
                     isFakeOverride = false
                 )
             }
@@ -378,9 +384,23 @@ class IrDescriptorBasedFunctionFactory(
             val returnType = descriptor.returnType?.let { toIrType(it) } ?: error("No return type for $descriptor")
             val newFunction = symbolTable.declareSimpleFunction(descriptor) {
                 descriptor.run {
-                    irFactory.createFunction(
-                        offset, offset, memberOrigin, it, name, visibility, modality, returnType,
-                        isInline, isEffectivelyExternal(), isTailrec, isSuspend, isOperator, isInfix, isExpect, true
+                    irFactory.createSimpleFunction(
+                        startOffset = offset,
+                        endOffset = offset,
+                        origin = memberOrigin,
+                        name = name,
+                        visibility = visibility,
+                        isInline = isInline,
+                        isExpect = isExpect,
+                        returnType = returnType,
+                        modality = modality,
+                        symbol = it,
+                        isTailrec = isTailrec,
+                        isSuspend = isSuspend,
+                        isOperator = isOperator,
+                        isInfix = isInfix,
+                        isExternal = isEffectivelyExternal(),
+                        isFakeOverride = true,
                     )
                 }
             }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt

@@ -427,16 +427,22 @@ private fun StatementGenerator.createFunctionForSuspendConversion(
     val irFunReturnType = funType.arguments.last().type.toIrType()
     val irSuspendFunReturnType = suspendFunType.arguments.last().type.toIrType()
 
-    val irAdapterFun = context.irFactory.createFunction(
-        startOffset, endOffset,
-        IrDeclarationOrigin.ADAPTER_FOR_SUSPEND_CONVERSION,
-        IrSimpleFunctionSymbolImpl(),
-        Name.identifier(scope.inventNameForTemporary("suspendConversion")),
-        DescriptorVisibilities.LOCAL, Modality.FINAL,
-        irSuspendFunReturnType,
-        isInline = false, isExternal = false, isTailrec = false,
+    val irAdapterFun = context.irFactory.createSimpleFunction(
+        startOffset = startOffset,
+        endOffset = endOffset,
+        origin = IrDeclarationOrigin.ADAPTER_FOR_SUSPEND_CONVERSION,
+        name = Name.identifier(scope.inventNameForTemporary("suspendConversion")),
+        visibility = DescriptorVisibilities.LOCAL,
+        isInline = false,
+        isExpect = false,
+        returnType = irSuspendFunReturnType,
+        modality = Modality.FINAL,
+        symbol = IrSimpleFunctionSymbolImpl(),
+        isTailrec = false,
         isSuspend = true,
-        isOperator = false, isInfix = false, isExpect = false, isFakeOverride = false
+        isOperator = false,
+        isInfix = false,
+        isExternal = false,
     )
 
     context.symbolTable.enterScope(irAdapterFun)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt

@@ -166,16 +166,22 @@ internal class ReflectionReferencesGenerator(statementGenerator: StatementGenera
         val functionParameter = descriptor.valueParameters.singleOrNull()
             ?: throw AssertionError("Single value parameter expected: $descriptor")
 
-        return context.irFactory.createFunction(
-            startOffset, endOffset,
-            IrDeclarationOrigin.ADAPTER_FOR_FUN_INTERFACE_CONSTRUCTOR,
-            IrSimpleFunctionSymbolImpl(),
+        return context.irFactory.createSimpleFunction(
+            startOffset = startOffset,
+            endOffset = endOffset,
+            origin = IrDeclarationOrigin.ADAPTER_FOR_FUN_INTERFACE_CONSTRUCTOR,
             name = samClassDescriptor.name,
             visibility = DescriptorVisibilities.LOCAL,
-            modality = Modality.FINAL,
+            isInline = false,
+            isExpect = false,
             returnType = irSamType,
-            isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isOperator = false, isInfix = false,
-            isExpect = false, isFakeOverride = false
+            modality = Modality.FINAL,
+            symbol = IrSimpleFunctionSymbolImpl(),
+            isTailrec = false,
+            isSuspend = false,
+            isOperator = false,
+            isInfix = false,
+            isExternal = false,
         ).also { irAdapterFun ->
             context.symbolTable.withScope(irAdapterFun) {
                 irAdapterFun.metadata = null
@@ -437,22 +443,22 @@ internal class ReflectionReferencesGenerator(statementGenerator: StatementGenera
         val hasSuspendConversion = !adapteeDescriptor.isSuspend &&
                 callableReferenceType.isKSuspendFunctionType
 
-        return context.irFactory.createFunction(
-            startOffset, endOffset,
-            IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE,
-            IrSimpleFunctionSymbolImpl(),
-            adapteeDescriptor.name,
-            DescriptorVisibilities.LOCAL,
-            Modality.FINAL,
-            ktExpectedReturnType.toIrType(),
+        return context.irFactory.createSimpleFunction(
+            startOffset = startOffset,
+            endOffset = endOffset,
+            origin = IrDeclarationOrigin.ADAPTER_FOR_CALLABLE_REFERENCE,
+            name = adapteeDescriptor.name,
+            visibility = DescriptorVisibilities.LOCAL,
             isInline = adapteeDescriptor.isInline, // TODO ?
-            isExternal = false,
+            isExpect = false,
+            returnType = ktExpectedReturnType.toIrType(),
+            modality = Modality.FINAL,
+            symbol = IrSimpleFunctionSymbolImpl(),
             isTailrec = false,
             isSuspend = adapteeDescriptor.isSuspend || hasSuspendConversion,
             isOperator = adapteeDescriptor.isOperator, // TODO ?
             isInfix = adapteeDescriptor.isInfix,
-            isExpect = false,
-            isFakeOverride = false
+            isExternal = false,
         ).also { irAdapterFun ->
             context.symbolTable.withScope(irAdapterFun) {
                 irAdapterFun.metadata = DescriptorMetadataSource.Function(adapteeDescriptor)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StandaloneDeclarationGenerator.kt

@@ -208,9 +208,22 @@ internal class StandaloneDeclarationGenerator(private val context: GeneratorCont
         defaultArgumentFactory: IrFunction.(IrValueParameter) -> IrExpressionBody? = { null }
     ): IrSimpleFunction {
         val irFunction = with(descriptor) {
-            irFactory.createFunction(
-                startOffset, endOffset, origin, symbol, name, visibility, modality, IrUninitializedType,
-                isInline, isEffectivelyExternal(), isTailrec, isSuspend, isOperator, isInfix, isExpect
+            irFactory.createSimpleFunction(
+                startOffset = startOffset,
+                endOffset = endOffset,
+                origin = origin,
+                name = name,
+                visibility = visibility,
+                isInline = isInline,
+                isExpect = isExpect,
+                returnType = IrUninitializedType,
+                modality = modality,
+                symbol = symbol,
+                isTailrec = isTailrec,
+                isSuspend = isSuspend,
+                isOperator = isOperator,
+                isInfix = isInfix,
+                isExternal = isEffectivelyExternal(),
             )
         }
         irFunction.metadata = DescriptorMetadataSource.Function(descriptor)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/declarations/declarationBuilders.kt

@@ -172,12 +172,24 @@ inline fun IrProperty.addBackingField(builder: IrFieldBuilder.() -> Unit = {}):
 
 @PublishedApi
 internal fun IrFactory.buildFunction(builder: IrFunctionBuilder): IrSimpleFunction = with(builder) {
-    createFunction(
-        startOffset, endOffset, origin,
-        IrSimpleFunctionSymbolImpl(),
-        name, visibility, modality, returnType,
-        isInline, isExternal, isTailrec, isSuspend, isOperator, isInfix, isExpect, isFakeOverride,
-        containerSource,
+    createSimpleFunction(
+        startOffset = startOffset,
+        endOffset = endOffset,
+        origin = origin,
+        name = name,
+        visibility = visibility,
+        isInline = isInline,
+        isExpect = isExpect,
+        returnType = returnType,
+        modality = modality,
+        symbol = IrSimpleFunctionSymbolImpl(),
+        isTailrec = isTailrec,
+        isSuspend = isSuspend,
+        isOperator = isOperator,
+        isInfix = isInfix,
+        isExternal = isExternal,
+        containerSource = containerSource,
+        isFakeOverride = isFakeOverride,
     )
 }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFactory.kt

@@ -88,24 +88,24 @@ interface IrFactory {
         isExternal: Boolean,
     ): IrField
 
-    fun createFunction(
+    fun createSimpleFunction(
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrSimpleFunctionSymbol,
         name: Name,
         visibility: DescriptorVisibility,
-        modality: Modality,
-        returnType: IrType,
         isInline: Boolean,
-        isExternal: Boolean,
+        isExpect: Boolean,
+        returnType: IrType,
+        modality: Modality,
+        symbol: IrSimpleFunctionSymbol,
         isTailrec: Boolean,
         isSuspend: Boolean,
         isOperator: Boolean,
         isInfix: Boolean,
-        isExpect: Boolean,
-        isFakeOverride: Boolean = origin == IrDeclarationOrigin.FAKE_OVERRIDE,
+        isExternal: Boolean,
         containerSource: DeserializedContainerSource? = null,
+        isFakeOverride: Boolean = origin == IrDeclarationOrigin.FAKE_OVERRIDE,
     ): IrSimpleFunction
 
     fun createFunctionWithLateBinding(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFactoryImpl.kt

@@ -107,24 +107,24 @@ abstract class AbstractIrFactoryImpl : IrFactory {
     ): IrField =
         IrFieldImpl(startOffset, endOffset, origin, symbol, name, type, visibility, isFinal, isExternal, isStatic, factory = this)
 
-    override fun createFunction(
+    override fun createSimpleFunction(
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrSimpleFunctionSymbol,
         name: Name,
         visibility: DescriptorVisibility,
-        modality: Modality,
-        returnType: IrType,
         isInline: Boolean,
-        isExternal: Boolean,
+        isExpect: Boolean,
+        returnType: IrType,
+        modality: Modality,
+        symbol: IrSimpleFunctionSymbol,
         isTailrec: Boolean,
         isSuspend: Boolean,
         isOperator: Boolean,
         isInfix: Boolean,
-        isExpect: Boolean,
-        isFakeOverride: Boolean,
+        isExternal: Boolean,
         containerSource: DeserializedContainerSource?,
+        isFakeOverride: Boolean,
     ): IrSimpleFunction =
         IrFunctionImpl(
             startOffset, endOffset, origin, symbol, name, visibility, modality, returnType,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFactoryImplForJsIC.kt

@@ -160,43 +160,43 @@ class IrFactoryImplForJsIC(override val stageController: StageController) : Abst
         ).register()
     }
 
-    override fun createFunction(
+    override fun createSimpleFunction(
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrSimpleFunctionSymbol,
         name: Name,
         visibility: DescriptorVisibility,
-        modality: Modality,
-        returnType: IrType,
         isInline: Boolean,
-        isExternal: Boolean,
+        isExpect: Boolean,
+        returnType: IrType,
+        modality: Modality,
+        symbol: IrSimpleFunctionSymbol,
         isTailrec: Boolean,
         isSuspend: Boolean,
         isOperator: Boolean,
         isInfix: Boolean,
-        isExpect: Boolean,
-        isFakeOverride: Boolean,
-        containerSource: DeserializedContainerSource?
+        isExternal: Boolean,
+        containerSource: DeserializedContainerSource?,
+        isFakeOverride: Boolean
     ): IrSimpleFunction {
-        return super.createFunction(
+        return super.createSimpleFunction(
             startOffset,
             endOffset,
             origin,
-            symbol,
             name,
             visibility,
-            modality,
-            returnType,
             isInline,
-            isExternal,
+            isExpect,
+            returnType,
+            modality,
+            symbol,
             isTailrec,
             isSuspend,
             isOperator,
             isInfix,
-            isExpect,
-            isFakeOverride,
+            isExternal,
             containerSource,
+            isFakeOverride,
         ).register()
     }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/LazyIrFactory.kt

@@ -117,30 +117,30 @@ class LazyIrFactory(
     else
         delegate.createField(startOffset, endOffset, origin, name, visibility, symbol, type, isFinal, isStatic, isExternal)
 
-    override fun createFunction(
+    override fun createSimpleFunction(
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrSimpleFunctionSymbol,
         name: Name,
         visibility: DescriptorVisibility,
-        modality: Modality,
-        returnType: IrType,
         isInline: Boolean,
-        isExternal: Boolean,
+        isExpect: Boolean,
+        returnType: IrType,
+        modality: Modality,
+        symbol: IrSimpleFunctionSymbol,
         isTailrec: Boolean,
         isSuspend: Boolean,
         isOperator: Boolean,
         isInfix: Boolean,
-        isExpect: Boolean,
-        isFakeOverride: Boolean,
-        containerSource: DeserializedContainerSource?
+        isExternal: Boolean,
+        containerSource: DeserializedContainerSource?,
+        isFakeOverride: Boolean
     ): IrSimpleFunction = if (symbol.isBound)
         symbol.owner
     else
-        delegate.createFunction(
-            startOffset, endOffset, origin, symbol, name, visibility, modality, returnType,
-            isInline, isExternal, isTailrec, isSuspend, isOperator, isInfix, isExpect, isFakeOverride, containerSource
+        delegate.createSimpleFunction(
+            startOffset, endOffset, origin, name, visibility, isInline, isExpect, returnType,
+            modality, symbol, isTailrec, isSuspend, isOperator, isInfix, isExternal, containerSource, isFakeOverride
         )
 
     override fun createProperty(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt

@@ -171,23 +171,24 @@ open class DeepCopyIrTreeWithSymbols(
         }.copyAttributes(declaration)
 
     override fun visitSimpleFunction(declaration: IrSimpleFunction): IrSimpleFunction =
-        declaration.factory.createFunction(
-            declaration.startOffset, declaration.endOffset,
-            mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredFunction(declaration.symbol),
-            symbolRenamer.getFunctionName(declaration.symbol),
-            declaration.visibility,
-            declaration.modality,
-            declaration.returnType,
+        declaration.factory.createSimpleFunction(
+            startOffset = declaration.startOffset,
+            endOffset = declaration.endOffset,
+            origin = mapDeclarationOrigin(declaration.origin),
+            name = symbolRenamer.getFunctionName(declaration.symbol),
+            visibility = declaration.visibility,
             isInline = declaration.isInline,
-            isExternal = declaration.isExternal,
+            isExpect = declaration.isExpect,
+            returnType = declaration.returnType,
+            modality = declaration.modality,
+            symbol = symbolRemapper.getDeclaredFunction(declaration.symbol),
             isTailrec = declaration.isTailrec,
             isSuspend = declaration.isSuspend,
             isOperator = declaration.isOperator,
             isInfix = declaration.isInfix,
-            isExpect = declaration.isExpect,
-            isFakeOverride = declaration.isFakeOverride,
+            isExternal = declaration.isExternal,
             containerSource = declaration.containerSource,
+            isFakeOverride = declaration.isFakeOverride,
         ).apply {
             overriddenSymbols = declaration.overriddenSymbols.memoryOptimizedMap {
                 symbolRemapper.getReferencedFunction(it) as IrSimpleFunctionSymbol

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt

@@ -1188,23 +1188,24 @@ fun IrFactory.createStaticFunctionWithReceivers(
     typeParametersFromContext: List<IrTypeParameter> = listOf(),
     remapMultiFieldValueClassStructure: (IrFunction, IrFunction, Map<IrValueParameter, IrValueParameter>?) -> Unit
 ): IrSimpleFunction {
-    return createFunction(
-        oldFunction.startOffset, oldFunction.endOffset,
-        origin,
-        IrSimpleFunctionSymbolImpl(),
-        name,
-        visibility,
-        modality,
-        oldFunction.returnType,
+    return createSimpleFunction(
+        startOffset = oldFunction.startOffset,
+        endOffset = oldFunction.endOffset,
+        origin = origin,
+        name = name,
+        visibility = visibility,
         isInline = oldFunction.isInline,
-        isExternal = false,
+        isExpect = oldFunction.isExpect,
+        returnType = oldFunction.returnType,
+        modality = modality,
+        symbol = IrSimpleFunctionSymbolImpl(),
         isTailrec = false,
         isSuspend = oldFunction.isSuspend,
-        isExpect = oldFunction.isExpect,
-        isFakeOverride = isFakeOverride,
         isOperator = oldFunction is IrSimpleFunction && oldFunction.isOperator,
         isInfix = oldFunction is IrSimpleFunction && oldFunction.isInfix,
+        isExternal = false,
         containerSource = oldFunction.containerSource,
+        isFakeOverride = isFakeOverride,
     ).apply {
         parent = irParent
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/overrides.kt

@@ -24,18 +24,22 @@ fun SymbolTable.declareSimpleFunctionWithOverrides(
 ) =
     declareSimpleFunction(descriptor) {
         with(descriptor) {
-            irFactory.createFunction(
-                startOffset, endOffset, origin, it, nameProvider.nameForDeclaration(this),
-                visibility,
-                modality,
-                IrUninitializedType,
-                isInline,
-                isEffectivelyExternal(),
-                isTailrec,
-                isSuspend,
-                isOperator,
-                isInfix,
-                isExpect,
+            irFactory.createSimpleFunction(
+                startOffset = startOffset,
+                endOffset = endOffset,
+                origin = origin,
+                name = nameProvider.nameForDeclaration(this),
+                visibility = visibility,
+                isInline = isInline,
+                isExpect = isExpect,
+                returnType = IrUninitializedType,
+                modality = modality,
+                symbol = it,
+                isTailrec = isTailrec,
+                isSuspend = isSuspend,
+                isOperator = isOperator,
+                isInfix = isInfix,
+                isExternal = isEffectivelyExternal(),
                 isFakeOverride = descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE
             ).also { declaration ->
                 declaration.metadata = DescriptorMetadataSource.Function(this)

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/linkage/partial/MissingDeclarationStubGenerator.kt

@@ -81,22 +81,22 @@ internal class MissingDeclarationStubGenerator(private val builtIns: IrBuiltIns)
     }
 
     private fun generateSimpleFunction(symbol: IrSimpleFunctionSymbol): IrSimpleFunction {
-        return builtIns.irFactory.createFunction(
+        return builtIns.irFactory.createSimpleFunction(
             startOffset = UNDEFINED_OFFSET,
             endOffset = UNDEFINED_OFFSET,
             origin = PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION,
-            symbol = symbol,
             name = symbol.guessName(),
             visibility = DescriptorVisibilities.DEFAULT_VISIBILITY,
-            modality = Modality.FINAL,
-            returnType = builtIns.nothingType,
             isInline = false,
-            isExternal = false,
+            isExpect = false,
+            returnType = builtIns.nothingType,
+            modality = Modality.FINAL,
+            symbol = symbol,
             isTailrec = false,
             isSuspend = false,
             isOperator = false,
             isInfix = false,
-            isExpect = false
+            isExternal = false
         ).setCommonParent()
     }
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt

@@ -599,21 +599,23 @@ class IrDeclarationDeserializer(
             val flags = FunctionFlags.decode(fcode)
             symbolTable.declareSimpleFunction(idSig, { symbol }) {
                 val nameType = BinaryNameAndType.decode(proto.base.nameType)
-                irFactory.createFunction(
-                    startOffset, endOffset, origin,
-                    it,
-                    deserializeName(nameType.nameIndex),
-                    flags.visibility,
-                    flags.modality,
-                    IrUninitializedType,
-                    flags.isInline,
-                    flags.isExternal || isEffectivelyExternal,
-                    flags.isTailrec,
-                    flags.isSuspend,
-                    flags.isOperator,
-                    flags.isInfix,
-                    flags.isExpect,
-                    flags.isFakeOverride
+                irFactory.createSimpleFunction(
+                    startOffset = startOffset,
+                    endOffset = endOffset,
+                    origin = origin,
+                    name = deserializeName(nameType.nameIndex),
+                    visibility = flags.visibility,
+                    isInline = flags.isInline,
+                    isExpect = flags.isExpect,
+                    returnType = IrUninitializedType,
+                    modality = flags.modality,
+                    symbol = it,
+                    isTailrec = flags.isTailrec,
+                    isSuspend = flags.isSuspend,
+                    isOperator = flags.isOperator,
+                    isInfix = flags.isInfix,
+                    isExternal = flags.isExternal || isEffectivelyExternal,
+                    isFakeOverride = flags.isFakeOverride,
                 )
             }.apply {
                 overriddenSymbols = proto.overriddenList.memoryOptimizedMap { deserializeIrSymbolAndRemap(it).checkSymbolType(FUNCTION_SYMBOL) }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/FunctionsWithoutBoundCheckGenerator.kt

@@ -29,22 +29,22 @@ internal class FunctionsWithoutBoundCheckGenerator(val context: KonanBackendCont
     private val symbols = context.ir.symbols
 
     private fun generateFunction(baseFunction: IrSimpleFunction, delegatingToFunction: IrSimpleFunction?, functionName: Name) =
-            context.irFactory.createFunction(
-                    baseFunction.startOffset, baseFunction.endOffset,
-                    IrDeclarationOrigin.GENERATED_SETTER_GETTER,
-                    IrSimpleFunctionSymbolImpl(),
-                    functionName,
-                    DescriptorVisibilities.PUBLIC,
-                    Modality.FINAL,
-                    baseFunction.returnType,
+            context.irFactory.createSimpleFunction(
+                    startOffset = baseFunction.startOffset,
+                    endOffset = baseFunction.endOffset,
+                    origin = IrDeclarationOrigin.GENERATED_SETTER_GETTER,
+                    name = functionName,
+                    visibility = DescriptorVisibilities.PUBLIC,
                     isInline = false,
-                    isExternal = true,
+                    isExpect = false,
+                    returnType = baseFunction.returnType,
+                    modality = Modality.FINAL,
+                    symbol = IrSimpleFunctionSymbolImpl(),
                     isTailrec = false,
                     isSuspend = false,
-                    isExpect = false,
-                    isFakeOverride = false,
                     isOperator = false,
-                    isInfix = false
+                    isInfix = false,
+                    isExternal = true,
             ).also { function ->
                 function.parent = baseFunction.parent
                 function.createDispatchReceiverParameter()