[IR] Reorder parameters in IrFactory#createTypeAlias

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

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

@@ -311,10 +311,14 @@ class Fir2IrClassifierStorage(
             declareIrTypeAlias(signature) { symbol ->
                 preCacheTypeParameters(typeAlias, symbol)
                 val irTypeAlias = irFactory.createTypeAlias(
-                    startOffset, endOffset, symbol,
+                    startOffset = startOffset,
-                    typeAlias.name, components.visibilityConverter.convertToDescriptorVisibility(typeAlias.visibility),
+                    endOffset = endOffset,
-                    typeAlias.expandedTypeRef.toIrType(),
+                    origin = IrDeclarationOrigin.DEFINED,
-                    typeAlias.isActual, IrDeclarationOrigin.DEFINED
+                    name = typeAlias.name,
+                    visibility = components.visibilityConverter.convertToDescriptorVisibility(typeAlias.visibility),
+                    symbol = symbol,
+                    isActual = typeAlias.isActual,
+                    expandedType = typeAlias.expandedTypeRef.toIrType(),
                 ).apply {
                     this.parent = parent
                     setTypeParameters(typeAlias)

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

@@ -111,8 +111,14 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator {
         with(getOrFail(BindingContext.TYPE_ALIAS, ktTypeAlias)) {
             context.symbolTable.declareTypeAlias(this) { symbol ->
                 context.irFactory.createTypeAlias(
-                    ktTypeAlias.startOffsetSkippingComments, ktTypeAlias.endOffset, symbol,
+                    startOffset = ktTypeAlias.startOffsetSkippingComments,
-                    name, visibility, expandedType.toIrType(), isActual, IrDeclarationOrigin.DEFINED
+                    endOffset = ktTypeAlias.endOffset,
+                    origin = IrDeclarationOrigin.DEFINED,
+                    name = name,
+                    visibility = visibility,
+                    symbol = symbol,
+                    isActual = isActual,
+                    expandedType = expandedType.toIrType()
                 )
             }.also {
                 generateGlobalTypeParametersDeclarations(it, declaredTypeParameters)

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

@@ -120,7 +120,14 @@ internal class StandaloneDeclarationGenerator(private val context: GeneratorCont
         symbol: IrTypeAliasSymbol
     ): IrTypeAlias = with(descriptor) {
         irFactory.createTypeAlias(
-            startOffset, endOffset, symbol, name, visibility, expandedType.toIrType(), isActual, origin
+            startOffset = startOffset,
+            endOffset = endOffset,
+            origin = origin,
+            name = name,
+            visibility = visibility,
+            symbol = symbol,
+            isActual = isActual,
+            expandedType = expandedType.toIrType()
         ).also {
             generateGlobalTypeParametersDeclarations(it, declaredTypeParameters)
         }

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

@@ -171,12 +171,12 @@ interface IrFactory {
     fun createTypeAlias(
         startOffset: Int,
         endOffset: Int,
-        symbol: IrTypeAliasSymbol,
+        origin: IrDeclarationOrigin,
         name: Name,
         visibility: DescriptorVisibility,
-        expandedType: IrType,
+        symbol: IrTypeAliasSymbol,
         isActual: Boolean,
-        origin: IrDeclarationOrigin,
+        expandedType: IrType,
     ): IrTypeAlias
 
     fun createTypeParameter(

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

@@ -211,12 +211,12 @@ abstract class AbstractIrFactoryImpl : IrFactory {
     override fun createTypeAlias(
         startOffset: Int,
         endOffset: Int,
-        symbol: IrTypeAliasSymbol,
+        origin: IrDeclarationOrigin,
         name: Name,
         visibility: DescriptorVisibility,
-        expandedType: IrType,
+        symbol: IrTypeAliasSymbol,
         isActual: Boolean,
-        origin: IrDeclarationOrigin,
+        expandedType: IrType,
     ): IrTypeAlias =
         IrTypeAliasImpl(startOffset, endOffset, symbol, name, visibility, expandedType, isActual, origin, factory = this)
 

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

@@ -323,22 +323,22 @@ class IrFactoryImplForJsIC(override val stageController: StageController) : Abst
     override fun createTypeAlias(
         startOffset: Int,
         endOffset: Int,
-        symbol: IrTypeAliasSymbol,
+        origin: IrDeclarationOrigin,
         name: Name,
         visibility: DescriptorVisibility,
-        expandedType: IrType,
+        symbol: IrTypeAliasSymbol,
         isActual: Boolean,
-        origin: IrDeclarationOrigin
+        expandedType: IrType
     ): IrTypeAlias {
         return super.createTypeAlias(
             startOffset,
             endOffset,
-            symbol,
+            origin,
             name,
             visibility,
-            expandedType,
+            symbol,
             isActual,
-            origin,
+            expandedType,
         ).register()
     }
 

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

@@ -170,16 +170,16 @@ class LazyIrFactory(
     override fun createTypeAlias(
         startOffset: Int,
         endOffset: Int,
-        symbol: IrTypeAliasSymbol,
+        origin: IrDeclarationOrigin,
         name: Name,
         visibility: DescriptorVisibility,
-        expandedType: IrType,
+        symbol: IrTypeAliasSymbol,
         isActual: Boolean,
-        origin: IrDeclarationOrigin
+        expandedType: IrType
     ): IrTypeAlias = if (symbol.isBound)
         symbol.owner
     else
-        delegate.createTypeAlias(startOffset, endOffset, symbol, name, visibility, expandedType, isActual, origin)
+        delegate.createTypeAlias(startOffset, endOffset, origin, name, visibility, symbol, isActual, expandedType)
 
     override fun createTypeParameter(
         startOffset: Int,

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

@@ -387,13 +387,14 @@ open class DeepCopyIrTreeWithSymbols(
 
     override fun visitTypeAlias(declaration: IrTypeAlias): IrTypeAlias =
         declaration.factory.createTypeAlias(
-            declaration.startOffset, declaration.endOffset,
+            startOffset = declaration.startOffset,
-            symbolRemapper.getDeclaredTypeAlias(declaration.symbol),
+            endOffset = declaration.endOffset,
-            symbolRenamer.getTypeAliasName(declaration.symbol),
+            origin = mapDeclarationOrigin(declaration.origin),
-            declaration.visibility,
+            name = symbolRenamer.getTypeAliasName(declaration.symbol),
-            declaration.expandedType.remapType(),
+            visibility = declaration.visibility,
-            declaration.isActual,
+            symbol = symbolRemapper.getDeclaredTypeAlias(declaration.symbol),
-            mapDeclarationOrigin(declaration.origin)
+            isActual = declaration.isActual,
+            expandedType = declaration.expandedType.remapType(),
         ).apply {
             transformAnnotations(declaration)
             copyTypeParametersFrom(declaration)

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

@@ -148,12 +148,12 @@ internal class MissingDeclarationStubGenerator(private val builtIns: IrBuiltIns)
         return builtIns.irFactory.createTypeAlias(
             startOffset = UNDEFINED_OFFSET,
             endOffset = UNDEFINED_OFFSET,
-            symbol = symbol,
+            origin = PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION,
             name = symbol.guessName(),
             visibility = DescriptorVisibilities.DEFAULT_VISIBILITY,
-            expandedType = builtIns.nothingType,
+            symbol = symbol,
             isActual = true,
-            origin = PartiallyLinkedDeclarationOrigin.MISSING_DECLARATION,
+            expandedType = builtIns.nothingType,
         ).setCommonParent()
     }
 

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

@@ -433,13 +433,14 @@ class IrDeclarationDeserializer(
                 val flags = TypeAliasFlags.decode(fcode)
                 val nameType = BinaryNameAndType.decode(proto.nameType)
                 irFactory.createTypeAlias(
-                    startOffset, endOffset,
+                    startOffset = startOffset,
-                    it,
+                    endOffset = endOffset,
-                    deserializeName(nameType.nameIndex),
+                    origin = origin,
-                    flags.visibility,
+                    name = deserializeName(nameType.nameIndex),
-                    deserializeIrType(nameType.typeIndex),
+                    visibility = flags.visibility,
-                    flags.isActual,
+                    symbol = it,
-                    origin
+                    isActual = flags.isActual,
+                    expandedType = deserializeIrType(nameType.typeIndex),
                 )
             }.usingParent {
                 typeParameters = deserializeTypeParameters(proto.typeParameterList, true)