Refactor SirPhases to remove dependency on the Kotlin compiler.

SKIE/common/util/src/commonMain/kotlin/co/touchlab/skie/util/directory/SkieBuildDirectory.kt

@@ -5,9 +5,6 @@ import co.touchlab.skie.util.directory.structure.PermanentDirectory
 import co.touchlab.skie.util.directory.structure.RootDirectory
 import co.touchlab.skie.util.directory.structure.TemporaryDirectory
 import java.io.File
-import kotlin.io.path.isDirectory
-import kotlin.io.path.listDirectoryEntries
-import kotlin.io.path.name
 
 class SkieBuildDirectory(
     rootDirectory: File,

SKIE/compiler/kotlin-plugin/src/kgp_1.8.0/kotlin/co/touchlab/skie/entrypoint/ObjectFilesPhaseInterceptor.kt

@@ -19,11 +19,17 @@ internal class ObjectFilesPhaseInterceptor : SameTypePhaseInterceptor<KonanConte
     override fun intercept(context: KonanContext, input: Unit, next: (KonanContext, Unit) -> Unit) {
         val objCExportedInterface = context.objCExport.reflectedBy<ObjCExportReflector>().exportedInterface as ObjCExportedInterface
 
-        EntrypointUtils.launchSirPhases(
-            mainSkieContext = context.config.configuration.mainSkieContext,
+        val mainSkieContext = context.config.configuration.mainSkieContext
+
+        EntrypointUtils.runDescriptorConversionPhases(
+            mainSkieContext = mainSkieContext,
             objCExportedInterfaceProvider = ObjCExportedInterfaceProvider(objCExportedInterface),
         )
 
+        EntrypointUtils.runSirPhases(
+            mainSkieContext = mainSkieContext,
+        )
+
         return next(context, input)
     }
 }

SKIE/compiler/kotlin-plugin/src/kgp_1.8.20..1.9.20/kotlin/co/touchlab/skie/entrypoint/CreateObjCExportCodeSpecPhaseInterceptor.kgp_1.8.20.kt

@@ -26,7 +26,12 @@ internal class CreateObjCExportCodeSpecPhaseInterceptor : PhaseInterceptor<PsiTo
             symbolTable = context.symbolTable!!,
         )
 
-        EntrypointUtils.launchSirPhases(mainSkieContext, ObjCExportedInterfaceProvider(input))
+        EntrypointUtils.runDescriptorConversionPhases(
+            mainSkieContext = mainSkieContext,
+            objCExportedInterfaceProvider = ObjCExportedInterfaceProvider(input),
+        )
+
+        EntrypointUtils.runSirPhases(mainSkieContext)
 
         return next(context, input)
     }

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/compilerinject/compilerplugin/SkieCompilerConfigurationKeys.kt

@@ -1,27 +1,21 @@
 package co.touchlab.skie.compilerinject.compilerplugin
 
+import co.touchlab.skie.context.InitPhaseContext
 import co.touchlab.skie.context.MainSkieContext
-import co.touchlab.skie.phases.InitPhase
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import co.touchlab.skie.util.directory.SkieDirectories as SkieDirectoriesValue
 
 object SkieConfigurationKeys {
 
-    object InitPhaseContext : CompilerConfigurationKey<InitPhase.Context>("InitSkiePhaseContext")
+    object InitPhaseContext : CompilerConfigurationKey<co.touchlab.skie.context.InitPhaseContext>("InitSkiePhaseContext")
 
     object MainContext : CompilerConfigurationKey<MainSkieContext>("MainSkieContext")
 
     object SkieDirectories : CompilerConfigurationKey<SkieDirectoriesValue>("SKIE directories")
-
-    object SwiftCompiler {
-
-        val swiftVersion = CompilerConfigurationKey<String>("Swift version")
-        val additionalFlags = CompilerConfigurationKey<List<String>>("Additional Swift compiler flags")
-    }
 }
 
-var CompilerConfiguration.initPhaseContext: InitPhase.Context
+var CompilerConfiguration.initPhaseContext: InitPhaseContext
     get() = getNotNull(SkieConfigurationKeys.InitPhaseContext)
     set(value) = put(SkieConfigurationKeys.InitPhaseContext, value)
 

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/configuration/SimpleFunctionConfiguration.kt

@@ -1,6 +1,6 @@
 package co.touchlab.skie.configuration
 
-import co.touchlab.skie.phases.SkiePhase
+import co.touchlab.skie.phases.CommonSkieContext
 
 class SimpleFunctionConfiguration(
     parent: FileOrClassConfiguration,
@@ -18,6 +18,6 @@ class SimpleFunctionConfiguration(
     }
 }
 
-context(SkiePhase.Context)
+context(CommonSkieContext)
 val SimpleFunctionConfiguration.isSuspendInteropEnabled: Boolean
     get() = SkieConfigurationFlag.Feature_CoroutinesInterop.isEnabled && this[SuspendInterop.Enabled]

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/configuration/provider/descriptor/DescriptorConfigurationProvider.kt

@@ -9,7 +9,7 @@ import co.touchlab.skie.configuration.SimpleFunctionConfiguration
 import co.touchlab.skie.configuration.ValueParameterConfiguration
 import co.touchlab.skie.configuration.provider.ConfigurationProvider
 import co.touchlab.skie.configuration.provider.IdentifiedConfigurationTarget
-import co.touchlab.skie.phases.SkiePhase
+import co.touchlab.skie.phases.ForegroundPhase
 import org.jetbrains.kotlin.backend.common.serialization.findPackage
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
@@ -138,19 +138,19 @@ class DescriptorConfigurationProvider(
         }
 }
 
-context(SkiePhase.Context)
+context(ForegroundPhase.Context)
 val ClassDescriptor.configuration: ClassConfiguration
     get() = descriptorConfigurationProvider.getConfiguration(this)
 
-context(SkiePhase.Context)
+context(ForegroundPhase.Context)
 val SimpleFunctionDescriptor.configuration: SimpleFunctionConfiguration
     get() = descriptorConfigurationProvider.getConfiguration(this)
 
-context(SkiePhase.Context)
+context(ForegroundPhase.Context)
 val ConstructorDescriptor.configuration: ConstructorConfiguration
     get() = descriptorConfigurationProvider.getConfiguration(this)
 
-context(SkiePhase.Context)
+context(ForegroundPhase.Context)
 val FunctionDescriptor.configuration: FunctionConfiguration
     get() = when (this) {
         is SimpleFunctionDescriptor -> configuration

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/context/ClassExportPhaseContext.kt

@@ -1,14 +1,17 @@
 package co.touchlab.skie.context
 
+import co.touchlab.skie.kir.descriptor.MutableDescriptorProvider
 import co.touchlab.skie.kir.irbuilder.impl.DeclarationBuilderImpl
 import co.touchlab.skie.phases.ClassExportPhase
-import co.touchlab.skie.phases.SkiePhase
+import co.touchlab.skie.phases.ForegroundPhase
 
 class ClassExportPhaseContext(
     mainSkieContext: MainSkieContext,
-) : ClassExportPhase.Context, SkiePhase.Context by mainSkieContext {
+) : ClassExportPhase.Context, ForegroundPhase.Context by mainSkieContext {
 
     override val context: ClassExportPhaseContext = this
 
+    override val descriptorProvider: MutableDescriptorProvider = mainSkieContext.descriptorProvider
+
     override val declarationBuilder: DeclarationBuilderImpl = mainSkieContext.declarationBuilder
 }

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/context/DescriptorConversionPhaseContext.kt

@@ -0,0 +1,50 @@
+package co.touchlab.skie.context
+
+import co.touchlab.skie.kir.KirProvider
+import co.touchlab.skie.kir.builtin.KirBuiltins
+import co.touchlab.skie.kir.descriptor.DescriptorKirProvider
+import co.touchlab.skie.kir.descriptor.ObjCExportedInterfaceProvider
+import co.touchlab.skie.kir.type.translation.KirCustomTypeMappers
+import co.touchlab.skie.kir.type.translation.KirDeclarationTypeTranslator
+import co.touchlab.skie.kir.type.translation.KirTypeTranslator
+import co.touchlab.skie.phases.DescriptorConversionPhase
+import co.touchlab.skie.phases.ForegroundPhase
+import org.jetbrains.kotlin.backend.konan.objcexport.ObjCExportNamer
+
+class DescriptorConversionPhaseContext(
+    mainSkieContext: MainSkieContext,
+    override val objCExportedInterfaceProvider: ObjCExportedInterfaceProvider,
+) : DescriptorConversionPhase.Context, ForegroundPhase.Context by mainSkieContext {
+
+    override val context: DescriptorConversionPhase.Context = this
+
+    override val kirProvider: KirProvider = KirProvider(lazy { descriptorKirProvider }, rootConfiguration).also {
+        mainSkieContext.kirProvider = it
+    }
+
+    override val descriptorKirProvider: DescriptorKirProvider = DescriptorKirProvider(
+        mainModuleDescriptor = mainSkieContext.mainModuleDescriptor,
+        kirProvider = kirProvider,
+        kotlinBuiltIns = kotlinBuiltins,
+        extraDescriptorBuiltins = extraDescriptorBuiltins,
+        namer = namer,
+        descriptorConfigurationProvider = descriptorConfigurationProvider,
+        rootConfiguration = rootConfiguration,
+    ).also {
+        mainSkieContext.descriptorKirProvider = it
+    }
+
+    override val kirBuiltins: KirBuiltins = descriptorKirProvider.kirBuiltins
+
+    private val kirCustomTypeMappers = KirCustomTypeMappers(kirBuiltins, lazy { kirTypeTranslator })
+
+    override val kirTypeTranslator: KirTypeTranslator = KirTypeTranslator(descriptorKirProvider, kirCustomTypeMappers)
+
+    override val kirDeclarationTypeTranslator: KirDeclarationTypeTranslator = KirDeclarationTypeTranslator(
+        kirTypeTranslator = kirTypeTranslator,
+        kirBuiltins = kirBuiltins,
+    )
+
+    override val namer: ObjCExportNamer
+        get() = objCExportedInterfaceProvider.namer
+}

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/context/DescriptorModificationPhaseContext.kt

@@ -2,11 +2,11 @@ package co.touchlab.skie.context
 
 import co.touchlab.skie.kir.irbuilder.impl.DeclarationBuilderImpl
 import co.touchlab.skie.phases.DescriptorModificationPhase
-import co.touchlab.skie.phases.SkiePhase
+import co.touchlab.skie.phases.ForegroundPhase
 
 class DescriptorModificationPhaseContext(
     mainSkieContext: MainSkieContext,
-) : DescriptorModificationPhase.Context, SkiePhase.Context by mainSkieContext {
+) : DescriptorModificationPhase.Context, ForegroundPhase.Context by mainSkieContext {
 
     override val context: DescriptorModificationPhaseContext = this
 

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/context/InitPhaseContext.kt

@@ -6,11 +6,9 @@ import co.touchlab.skie.compilerinject.compilerplugin.SkieConfigurationKeys
 import co.touchlab.skie.configuration.RootConfiguration
 import co.touchlab.skie.configuration.provider.CompilerSkieConfigurationData
 import co.touchlab.skie.configuration.provider.ConfigurationProvider
-import co.touchlab.skie.configuration.provider.descriptor.DescriptorConfigurationProvider
 import co.touchlab.skie.phases.InitPhase
 import co.touchlab.skie.phases.SkiePhaseScheduler
 import co.touchlab.skie.phases.analytics.performance.SkiePerformanceAnalytics
-import co.touchlab.skie.phases.swift.SwiftCompilerConfiguration
 import co.touchlab.skie.plugin.analytics.AnalyticsCollector
 import co.touchlab.skie.util.FrameworkLayout
 import co.touchlab.skie.util.Reporter
@@ -35,26 +33,18 @@ class InitPhaseContext(
         CompilerSkieConfigurationData.deserialize(serializedUserConfiguration)
     }
 
-    private val configurationProvider = ConfigurationProvider(skieConfigurationData)
+    val configurationProvider = ConfigurationProvider(skieConfigurationData)
 
     override val rootConfiguration: RootConfiguration = configurationProvider.rootConfiguration
 
-    override val descriptorConfigurationProvider: DescriptorConfigurationProvider = DescriptorConfigurationProvider(configurationProvider)
-
-    override val swiftCompilerConfiguration: SwiftCompilerConfiguration = SwiftCompilerConfiguration(
-        sourceFilesDirectory = skieDirectories.buildDirectory.swift.directory,
-        swiftVersion = compilerConfiguration.get(SkieConfigurationKeys.SwiftCompiler.swiftVersion, "5"),
-        additionalFlags = compilerConfiguration.getList(SkieConfigurationKeys.SwiftCompiler.additionalFlags),
-    )
-
     override val analyticsCollector: AnalyticsCollector = AnalyticsCollector(
         skieBuildDirectory = skieDirectories.buildDirectory,
         skieConfiguration = skieConfigurationData,
     )
 
     override val skiePerformanceAnalyticsProducer: SkiePerformanceAnalytics.Producer = SkiePerformanceAnalytics.Producer(rootConfiguration)
 
-    override val reporter: Reporter = Reporter(compilerConfiguration)
+    override val reporter: Reporter = Reporter()
 
     override val framework: FrameworkLayout = run {
         val frameworkPath = compilerConfiguration.getNotNull(KonanConfigKeys.OUTPUT)

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/context/KotlinIrPhaseContext.kt

@@ -4,8 +4,8 @@ package co.touchlab.skie.context
 
 import co.touchlab.skie.kir.irbuilder.impl.DeclarationBuilderImpl
 import co.touchlab.skie.kir.util.SkieSymbolTable
+import co.touchlab.skie.phases.ForegroundPhase
 import co.touchlab.skie.phases.KotlinIrPhase
-import co.touchlab.skie.phases.SkiePhase
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContextImpl
 import org.jetbrains.kotlin.backend.konan.serialization.KonanIrLinker
@@ -16,7 +16,7 @@ class KotlinIrPhaseContext(
     mainSkieContext: MainSkieContext,
     override val moduleFragment: IrModuleFragment,
     override val pluginContext: IrPluginContext,
-) : KotlinIrPhase.Context, SkiePhase.Context by mainSkieContext {
+) : KotlinIrPhase.Context, ForegroundPhase.Context by mainSkieContext {
 
     override val context: KotlinIrPhaseContext = this
 

SKIE/compiler/kotlin-plugin/src/kgp_common/kotlin/co/touchlab/skie/context/LinkPhaseContext.kt

@@ -1,16 +1,19 @@
 package co.touchlab.skie.context
 
+import co.touchlab.skie.kir.descriptor.DescriptorKirProvider
+import co.touchlab.skie.phases.ForegroundPhase
 import co.touchlab.skie.phases.LinkPhase
-import co.touchlab.skie.phases.SkiePhase
 import java.nio.file.Path
 
 class LinkPhaseContext(
     private val mainSkieContext: MainSkieContext,
     private val link: (additionalObjectFiles: List<Path>) -> Unit,
-) : LinkPhase.Context, SkiePhase.Context by mainSkieContext {
+) : LinkPhase.Context, ForegroundPhase.Context by mainSkieContext {
 
     override val context: LinkPhase.Context = this
 
+    override val descriptorKirProvider: DescriptorKirProvider = mainSkieContext.descriptorKirProvider
+
     override fun link(additionalObjectFiles: List<Path>) {
         link.invoke(additionalObjectFiles)
     }