[IR] Reorder parameters in IrFactory#createClass

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

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.fir.containingClassForLocalAttr
-import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
@@ -352,18 +351,18 @@ class Fir2IrClassifierStorage(
         val irClass = regularClass.convertWithOffsets { startOffset, endOffset ->
             declareIrClass(signature) { symbol ->
                 irFactory.createClass(
-                    startOffset,
+                    startOffset = startOffset,
-                    endOffset,
+                    endOffset = endOffset,
-                    regularClass.computeIrOrigin(predefinedOrigin),
+                    origin = regularClass.computeIrOrigin(predefinedOrigin),
-                    symbol,
+                    name = regularClass.name,
-                    regularClass.name,
+                    visibility = components.visibilityConverter.convertToDescriptorVisibility(visibility),
-                    regularClass.classKind,
+                    symbol = symbol,
-                    components.visibilityConverter.convertToDescriptorVisibility(visibility),
+                    kind = regularClass.classKind,
-                    modality,
+                    modality = modality,
+                    isExternal = regularClass.isExternal,
                     isCompanion = regularClass.isCompanion,
                     isInner = regularClass.isInner,
                     isData = regularClass.isData,
-                    isExternal = regularClass.isExternal,
                     isValue = regularClass.isInline,
                     isExpect = regularClass.isExpect,
                     isFun = regularClass.isFun
@@ -391,10 +390,15 @@ class Fir2IrClassifierStorage(
         val modality = Modality.FINAL
         val irAnonymousObject = anonymousObject.convertWithOffsets { startOffset, endOffset ->
             irFactory.createClass(
-                startOffset, endOffset, origin, IrClassSymbolImpl(), name,
+                startOffset = startOffset,
+                endOffset = endOffset,
+                origin = origin,
+                name = name,
+                visibility = components.visibilityConverter.convertToDescriptorVisibility(visibility),
+                symbol = IrClassSymbolImpl(),
                 // NB: for unknown reason, IR uses 'CLASS' kind for simple anonymous objects
-                anonymousObject.classKind.takeIf { it == ClassKind.ENUM_ENTRY } ?: ClassKind.CLASS,
+                kind = anonymousObject.classKind.takeIf { it == ClassKind.ENUM_ENTRY } ?: ClassKind.CLASS,
-                components.visibilityConverter.convertToDescriptorVisibility(visibility), modality
+                modality = modality,
             ).apply {
                 metadata = FirMetadataSource.Class(anonymousObject)
             }
@@ -634,8 +638,14 @@ class Fir2IrClassifierStorage(
 
         return symbolTable.referenceClass(signature, { Fir2IrClassSymbol(signature) }) {
             irFactory.createClass(
-                UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, it, classId.shortClassName,
+                startOffset = UNDEFINED_OFFSET,
-                ClassKind.CLASS, DescriptorVisibilities.DEFAULT_VISIBILITY, Modality.FINAL,
+                endOffset = UNDEFINED_OFFSET,
+                origin = IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB,
+                name = classId.shortClassName,
+                visibility = DescriptorVisibilities.DEFAULT_VISIBILITY,
+                symbol = it,
+                kind = ClassKind.CLASS,
+                modality = Modality.FINAL,
             ).apply {
                 parent = irParent
             }

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

@@ -710,8 +710,21 @@ class IrBuiltInsOverFir(
                         origin = IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB
                         build()
                         irFactory.createClass(
-                            startOffset, endOffset, origin, symbol, name, kind, visibility, modality,
+                            startOffset = startOffset,
-                            isCompanion, isInner, isData, isExternal, isValue, isExpect, isFun
+                            endOffset = endOffset,
+                            origin = origin,
+                            name = name,
+                            visibility = visibility,
+                            symbol = symbol,
+                            kind = kind,
+                            modality = modality,
+                            isExternal = isExternal,
+                            isCompanion = isCompanion,
+                            isInner = isInner,
+                            isData = isData,
+                            isValue = isValue,
+                            isExpect = isExpect,
+                            isFun = isFun,
                         )
                     }.also {
                         it.parent = parent
@@ -776,8 +789,21 @@ class IrBuiltInsOverFir(
                 origin = IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB
                 builderBlock()
                 irFactory.createClass(
-                    startOffset, endOffset, origin, symbol, name, kind, visibility, modality,
+                    startOffset = startOffset,
-                    isCompanion, isInner, isData, isExternal, isValue, isExpect, isFun
+                    endOffset = endOffset,
+                    origin = origin,
+                    name = name,
+                    visibility = visibility,
+                    symbol = symbol,
+                    kind = kind,
+                    modality = modality,
+                    isExternal = isExternal,
+                    isCompanion = isCompanion,
+                    isInner = isInner,
+                    isData = isData,
+                    isValue = isValue,
+                    isExpect = isExpect,
+                    isFun = isFun,
                 )
             }.also {
                 it.parent = this

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

@@ -19,10 +19,6 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.interpreter.state.Complex
-import org.jetbrains.kotlin.ir.interpreter.state.ExceptionState
-import org.jetbrains.kotlin.ir.interpreter.state.Primitive
-import org.jetbrains.kotlin.ir.interpreter.state.State
 import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl
@@ -108,8 +104,14 @@ internal fun createTempFunction(
 
 internal fun createTempClass(name: Name, origin: IrDeclarationOrigin = TEMP_CLASS_FOR_INTERPRETER): IrClass {
     return IrFactoryImpl.createClass(
-        SYNTHETIC_OFFSET, SYNTHETIC_OFFSET, origin, IrClassSymbolImpl(), name,
+        startOffset = SYNTHETIC_OFFSET,
-        ClassKind.CLASS, DescriptorVisibilities.PRIVATE, Modality.FINAL
+        endOffset = SYNTHETIC_OFFSET,
+        origin = origin,
+        name = name,
+        visibility = DescriptorVisibilities.PRIVATE,
+        symbol = IrClassSymbolImpl(),
+        kind = ClassKind.CLASS,
+        modality = Modality.FINAL,
     )
 }
 

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

@@ -433,7 +433,14 @@ class IrDescriptorBasedFunctionFactory(
         val name = functionClassName(isK, isSuspend, n)
         if (symbol.isBound) return symbol.owner
         val klass = irFactory.createClass(
-            offset, offset, classOrigin, symbol, Name.identifier(name), ClassKind.INTERFACE, DescriptorVisibilities.PUBLIC, Modality.ABSTRACT
+            startOffset = offset,
+            endOffset = offset,
+            origin = classOrigin,
+            name = Name.identifier(name),
+            visibility = DescriptorVisibilities.PUBLIC,
+            symbol = symbol,
+            kind = ClassKind.INTERFACE,
+            modality = Modality.ABSTRACT,
         )
 
         val r = klass.createTypeParameters(n, descriptorFactory)

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

@@ -27,10 +27,21 @@ import org.jetbrains.kotlin.types.Variance
 @PublishedApi
 internal fun IrFactory.buildClass(builder: IrClassBuilder): IrClass = with(builder) {
     createClass(
-        startOffset, endOffset, origin,
+        startOffset = startOffset,
-        IrClassSymbolImpl(),
+        endOffset = endOffset,
-        name, kind, visibility, modality,
+        origin = origin,
-        isCompanion, isInner, isData, isExternal, isValue, isExpect, isFun
+        name = name,
+        visibility = visibility,
+        symbol = IrClassSymbolImpl(),
+        kind = kind,
+        modality = modality,
+        isExternal = isExternal,
+        isCompanion = isCompanion,
+        isInner = isInner,
+        isData = isData,
+        isValue = isValue,
+        isExpect = isExpect,
+        isFun = isFun,
     )
 }
 

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

@@ -31,15 +31,15 @@ interface IrFactory {
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrClassSymbol,
         name: Name,
-        kind: ClassKind,
         visibility: DescriptorVisibility,
+        symbol: IrClassSymbol,
+        kind: ClassKind,
         modality: Modality,
+        isExternal: Boolean = false,
         isCompanion: Boolean = false,
         isInner: Boolean = false,
         isData: Boolean = false,
-        isExternal: Boolean = false,
         isValue: Boolean = false,
         isExpect: Boolean = false,
         isFun: Boolean = false,

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

@@ -38,15 +38,15 @@ abstract class AbstractIrFactoryImpl : IrFactory {
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrClassSymbol,
         name: Name,
-        kind: ClassKind,
         visibility: DescriptorVisibility,
+        symbol: IrClassSymbol,
+        kind: ClassKind,
         modality: Modality,
+        isExternal: Boolean,
         isCompanion: Boolean,
         isInner: Boolean,
         isData: Boolean,
-        isExternal: Boolean,
         isValue: Boolean,
         isExpect: Boolean,
         isFun: Boolean,

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

@@ -50,15 +50,15 @@ class IrFactoryImplForJsIC(override val stageController: StageController) : Abst
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrClassSymbol,
         name: Name,
-        kind: ClassKind,
         visibility: DescriptorVisibility,
+        symbol: IrClassSymbol,
+        kind: ClassKind,
         modality: Modality,
+        isExternal: Boolean,
         isCompanion: Boolean,
         isInner: Boolean,
         isData: Boolean,
-        isExternal: Boolean,
         isValue: Boolean,
         isExpect: Boolean,
         isFun: Boolean,
@@ -68,15 +68,15 @@ class IrFactoryImplForJsIC(override val stageController: StageController) : Abst
             startOffset,
             endOffset,
             origin,
-            symbol,
             name,
-            kind,
             visibility,
+            symbol,
+            kind,
             modality,
+            isExternal,
             isCompanion,
             isInner,
             isData,
-            isExternal,
             isValue,
             isExpect,
             isFun,

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

@@ -24,15 +24,15 @@ class LazyIrFactory(
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        symbol: IrClassSymbol,
         name: Name,
-        kind: ClassKind,
         visibility: DescriptorVisibility,
+        symbol: IrClassSymbol,
+        kind: ClassKind,
         modality: Modality,
+        isExternal: Boolean,
         isCompanion: Boolean,
         isInner: Boolean,
         isData: Boolean,
-        isExternal: Boolean,
         isValue: Boolean,
         isExpect: Boolean,
         isFun: Boolean,
@@ -41,8 +41,22 @@ class LazyIrFactory(
         symbol.owner
     else
         delegate.createClass(
-            startOffset, endOffset, origin, symbol, name, kind, visibility, modality,
+            startOffset,
-            isCompanion, isInner, isData, isExternal, isValue, isExpect, isFun, source
+            endOffset,
+            origin,
+            name,
+            visibility,
+            symbol,
+            kind,
+            modality,
+            isExternal,
+            isCompanion,
+            isInner,
+            isData,
+            isValue,
+            isExpect,
+            isFun,
+            source,
         )
 
     override fun createConstructor(

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

@@ -141,20 +141,21 @@ open class DeepCopyIrTreeWithSymbols(
 
     override fun visitClass(declaration: IrClass): IrClass =
         declaration.factory.createClass(
-            declaration.startOffset, declaration.endOffset,
+            startOffset = declaration.startOffset,
-            mapDeclarationOrigin(declaration.origin),
+            endOffset = declaration.endOffset,
-            symbolRemapper.getDeclaredClass(declaration.symbol),
+            origin = mapDeclarationOrigin(declaration.origin),
-            symbolRenamer.getClassName(declaration.symbol),
+            name = symbolRenamer.getClassName(declaration.symbol),
-            declaration.kind,
+            visibility = declaration.visibility,
-            declaration.visibility,
+            symbol = symbolRemapper.getDeclaredClass(declaration.symbol),
-            declaration.modality,
+            kind = declaration.kind,
+            modality = declaration.modality,
+            isExternal = declaration.isExternal,
             isCompanion = declaration.isCompanion,
             isInner = declaration.isInner,
             isData = declaration.isData,
-            isExternal = declaration.isExternal,
             isValue = declaration.isValue,
             isExpect = declaration.isExpect,
-            isFun = declaration.isFun
+            isFun = declaration.isFun,
         ).apply {
             transformAnnotations(declaration)
             copyTypeParametersFrom(declaration)

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

@@ -37,7 +37,20 @@ fun IrFactory.createIrClassFromDescriptor(
         visibility: DescriptorVisibility = descriptor.visibility,
         modality: Modality = descriptor.modality
 ): IrClass = createClass(
-    startOffset, endOffset, origin, symbol, name, descriptor.kind, visibility, modality,
+    startOffset = startOffset,
-    descriptor.isCompanionObject, descriptor.isInner, descriptor.isData, descriptor.isEffectivelyExternal(),
+    endOffset = endOffset,
-    descriptor.isValueClass(), descriptor.isExpect, descriptor.isFun, descriptor.source
+    origin = origin,
+    name = name,
+    visibility = visibility,
+    symbol = symbol,
+    kind = descriptor.kind,
+    modality = modality,
+    isExternal = descriptor.isEffectivelyExternal(),
+    isCompanion = descriptor.isCompanionObject,
+    isInner = descriptor.isInner,
+    isData = descriptor.isData,
+    isValue = descriptor.isValueClass(),
+    isExpect = descriptor.isExpect,
+    isFun = descriptor.isFun,
+    source = descriptor.source,
 )

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

@@ -69,11 +69,11 @@ internal class MissingDeclarationStubGenerator(private val builtIns: IrBuiltIns)
             startOffset = UNDEFINED_OFFSET,
             endOffset = UNDEFINED_OFFSET,
             origin = PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION,
-            symbol = symbol,
             name = symbol.guessName(),
-            kind = ClassKind.CLASS,
             visibility = DescriptorVisibilities.DEFAULT_VISIBILITY,
-            modality = Modality.OPEN
+            symbol = symbol,
+            kind = ClassKind.CLASS,
+            modality = Modality.OPEN,
         ).apply {
             setCommonParent()
             createImplicitParameterDeclarationWithWrappedDescriptor()

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

@@ -357,19 +357,21 @@ class IrDeclarationDeserializer(
             }
             symbolTable.declareClass(signature, { symbol.checkSymbolType(CLASS_SYMBOL) }) {
                 irFactory.createClass(
-                    startOffset, endOffset, origin,
+                    startOffset = startOffset,
-                    it,
+                    endOffset = endOffset,
-                    deserializeName(proto.name),
+                    origin = origin,
-                    flags.kind,
+                    name = deserializeName(proto.name),
-                    flags.visibility,
+                    visibility = flags.visibility,
-                    effectiveModality,
+                    symbol = it,
-                    flags.isCompanion,
+                    kind = flags.kind,
-                    flags.isInner,
+                    modality = effectiveModality,
-                    flags.isData,
+                    isExternal = flags.isExternal || isEffectivelyExternal,
-                    flags.isExternal || isEffectivelyExternal,
+                    isCompanion = flags.isCompanion,
-                    flags.isValue,
+                    isInner = flags.isInner,
-                    flags.isExpect,
+                    isData = flags.isData,
-                    flags.isFun,
+                    isValue = flags.isValue,
+                    isExpect = flags.isExpect,
+                    isFun = flags.isFun,
                 )
             }.usingParent {
                 typeParameters = deserializeTypeParameters(proto.typeParameterList, true)