[IR] Reorder parameters in IrFactory#createClass

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

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,
-        ClassKind.CLASS, DescriptorVisibilities.PRIVATE, Modality.FINAL
+        startOffset = SYNTHETIC_OFFSET,
+        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,
-        IrClassSymbolImpl(),
-        name, kind, visibility, modality,
-        isCompanion, isInner, isData, isExternal, isValue, isExpect, isFun
+        startOffset = startOffset,
+        endOffset = endOffset,
+        origin = origin,
+        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,
-            isCompanion, isInner, isData, isExternal, isValue, isExpect, isFun, source
+            startOffset,
+            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,
-            mapDeclarationOrigin(declaration.origin),
-            symbolRemapper.getDeclaredClass(declaration.symbol),
-            symbolRenamer.getClassName(declaration.symbol),
-            declaration.kind,
-            declaration.visibility,
-            declaration.modality,
+            startOffset = declaration.startOffset,
+            endOffset = declaration.endOffset,
+            origin = mapDeclarationOrigin(declaration.origin),
+            name = symbolRenamer.getClassName(declaration.symbol),
+            visibility = declaration.visibility,
+            symbol = symbolRemapper.getDeclaredClass(declaration.symbol),
+            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,
-    descriptor.isCompanionObject, descriptor.isInner, descriptor.isData, descriptor.isEffectivelyExternal(),
-    descriptor.isValueClass(), descriptor.isExpect, descriptor.isFun, descriptor.source
+    startOffset = startOffset,
+    endOffset = endOffset,
+    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,
-                    it,
-                    deserializeName(proto.name),
-                    flags.kind,
-                    flags.visibility,
-                    effectiveModality,
-                    flags.isCompanion,
-                    flags.isInner,
-                    flags.isData,
-                    flags.isExternal || isEffectivelyExternal,
-                    flags.isValue,
-                    flags.isExpect,
-                    flags.isFun,
+                    startOffset = startOffset,
+                    endOffset = endOffset,
+                    origin = origin,
+                    name = deserializeName(proto.name),
+                    visibility = flags.visibility,
+                    symbol = it,
+                    kind = flags.kind,
+                    modality = effectiveModality,
+                    isExternal = flags.isExternal || isEffectivelyExternal,
+                    isCompanion = flags.isCompanion,
+                    isInner = flags.isInner,
+                    isData = flags.isData,
+                    isValue = flags.isValue,
+                    isExpect = flags.isExpect,
+                    isFun = flags.isFun,
                 )
             }.usingParent {
                 typeParameters = deserializeTypeParameters(proto.typeParameterList, true)