rrn/rd/KT-63270-swift-printer

KT-63270: add swift printing capabilities to SIR

Co-authored-by: Artem Olkov <artem.olkov@jetbrains.com>
Co-authored-by: Sergej Jaskiewicz <jaskiewiczs@icloud.com>


Merge-request: KT-MR-13191
Merged-by: Gleb Lukianets <Gleb.Lukianets@jetbrains.com>

native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/SirGenerator.kt

@@ -41,7 +41,7 @@ class SirGenerator : SirFactory {
                 ?.pathSegments()
                 ?.toListString()
                 ?.let { names -> buildForeignFunction {
-                        origin = SirOrigin(path = names)
+                        origin = SirOrigin.KotlinEntity(names)
                         visibility = SirVisibility.PUBLIC
                     }
                 }

native/swift/sir-analysis-api/tests/org/jetbrains/kotlin/sir/analysisapi/AbstractKotlinSirContextTest.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.sir.SirDeclaration
 import org.jetbrains.kotlin.sir.SirForeignFunction
 import org.jetbrains.kotlin.sir.SirModule
+import org.jetbrains.kotlin.sir.SirOrigin
 import org.jetbrains.kotlin.sir.builder.SirModuleBuilder
 import org.jetbrains.kotlin.sir.builder.buildModule
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
@@ -52,6 +53,7 @@ abstract class AbstractKotlinSirContextTestBase : AbstractAnalysisApiBasedTest()
         val module = buildModule {
             val sirFactory = SirGenerator()
             ktFiles.forEach { file ->
+                name = "Test"
                 declarations += sirFactory.build(file)
             }
         }
@@ -60,7 +62,7 @@ abstract class AbstractKotlinSirContextTestBase : AbstractAnalysisApiBasedTest()
             module.declarations
                 .filterIsInstance<SirForeignFunction>()
                 .forEach {
-                    appendLine("${it.origin.path}")
+                    appendLine("${(it.origin as SirOrigin.KotlinEntity).path}")
                 }
         }
 

native/swift/sir-printer/build.gradle.kts

@@ -0,0 +1,25 @@
+plugins {
+    kotlin("jvm")
+}
+
+description = "Printer for SIR"
+
+dependencies {
+    compileOnly(kotlinStdlib())
+
+    api(project(":native:swift:sir"))
+
+    implementation(project(":core:util.runtime"))
+
+    testApi(platform(libs.junit.bom))
+    testRuntimeOnly(libs.junit.jupiter.engine)
+    testImplementation(libs.junit.jupiter.api)
+
+    testImplementation(projectTests(":compiler:tests-common"))
+    testImplementation(projectTests(":compiler:tests-common-new"))
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" { projectDefault() }
+}

native/swift/sir-printer/src/org/jetbrains/sir/printer/SirAsSwiftSourcesPrinter.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.sir.printer
+
+import org.jetbrains.kotlin.sir.*
+import org.jetbrains.kotlin.sir.visitors.SirVisitor
+import org.jetbrains.kotlin.utils.SmartPrinter
+
+private const val DEFAULT_INDENT: String = "    "
+
+class SirAsSwiftSourcesPrinter : SirVisitor<Unit, SmartPrinter>() {
+    fun print(element: SirElement): String = buildString {
+        element.accept(this@SirAsSwiftSourcesPrinter, SmartPrinter(this))
+    }.trim()
+
+    override fun visitModule(module: SirModule, data: SmartPrinter) = with(data) {
+        module.declarations.forEach {
+            it.accept(this@SirAsSwiftSourcesPrinter, this)
+            if (module.declarations.last() != it) {
+                println()
+            }
+        }
+    }
+
+    override fun visitFunction(function: SirFunction, data: SmartPrinter): Unit = with(data) {
+        println(listOfNotNull(
+            function.visibility.takeIf { it != SirVisibility.INTERNAL }?.let { "${it.swift} " },
+            "func ",
+            function.name.swiftIdentifier,
+            function.parameters.takeIf { it.isNotEmpty() }
+                ?.joinToString(prefix = "(\n", postfix = "\n)", separator = ",\n") {
+                    it.swift.prependIndent(DEFAULT_INDENT)
+                } ?: "()",
+            " -> ",
+            function.returnType.swift,
+            " { fatalError() }"
+        ).joinToString(separator = ""))
+    }
+
+    override fun visitForeignFunction(function: SirForeignFunction, data: SmartPrinter) {} // we do not write Foreign nodes
+
+    override fun visitElement(element: SirElement, data: SmartPrinter): Unit = with(data) {
+        println("/* ERROR: unsupported element type: " + element.javaClass.simpleName + " */")
+    }
+}
+
+private val SirVisibility.swift
+    get(): String = when (this) {
+        SirVisibility.PRIVATE -> "private"
+        SirVisibility.FILEPRIVATE -> "fileprivate"
+        SirVisibility.INTERNAL -> "internal"
+        SirVisibility.PUBLIC -> "public"
+        SirVisibility.PACKAGE -> "package"
+    }
+
+private val SirParameter.swift get(): String = (argumentName ?: "_") + (parameterName?.let { " $it" } ?: "") + ": " + type.swift
+
+private val SirType.swift
+    get(): String = when (this) {
+        is SirExistentialType -> "Any"
+        is SirNominalType -> type.swiftFqName
+    }
+
+private val SirNamedDeclaration.swiftFqName: String
+    get() {
+        val parentName = (parent as? SirNamedDeclaration)?.swiftFqName ?: ((parent as? SirNamed)?.name)
+        return parentName?.let { "$it.$name" } ?: name
+    }
+
+private val simpleIdentifierRegex = Regex("[_a-zA-Z][_a-zA-Z0-9]*")
+
+private val String.swiftIdentifier get() = if (simpleIdentifierRegex.matches(this)) this else "`$this`"

native/swift/sir-printer/testData/all_types_argument.golden.swift

@@ -0,0 +1,9 @@
+public func foo(
+    arg1: Swift.Bool,
+    arg2: Swift.Int8,
+    arg3: Swift.Int16,
+    arg4: Swift.Int32,
+    arg5: Swift.Int64,
+    arg6: Swift.Double,
+    arg7: Swift.Float
+) -> Swift.Bool { fatalError() }

native/swift/sir-printer/testData/simple_function.golden.swift

@@ -0,0 +1 @@
+public func foo() -> Swift.Bool { fatalError() }

native/swift/sir-printer/testData/simple_multiple_function.golden.swift

@@ -0,0 +1,3 @@
+public func foo1() -> Swift.Bool { fatalError() }
+
+public func foo2() -> Swift.Bool { fatalError() }

native/swift/sir-printer/testData/single_argument.golden.swift

@@ -0,0 +1,3 @@
+public func foo(
+    arg1: Swift.Int32
+) -> Swift.Bool { fatalError() }

native/swift/sir-printer/testData/two_arguments.golden.swift

@@ -0,0 +1,4 @@
+public func foo(
+    arg1: Swift.Int32,
+    arg2: Swift.Double
+) -> Swift.Bool { fatalError() }

native/swift/sir-printer/tests/org/jetbrains/kotlin/sir/printer/SirAsSwiftSourcesPrinterTests.kt

@@ -0,0 +1,207 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.sir.printer
+
+import org.jetbrains.kotlin.sir.*
+import org.jetbrains.kotlin.sir.builder.buildForeignFunction
+import org.jetbrains.kotlin.sir.builder.buildFunction
+import org.jetbrains.kotlin.sir.builder.buildModule
+import org.jetbrains.kotlin.sir.util.SirSwiftModule
+import org.jetbrains.kotlin.test.services.JUnit5Assertions
+import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.sir.printer.SirAsSwiftSourcesPrinter
+import org.junit.Test
+import java.io.File
+
+fun basicModule(): SirModule = buildModule { name = "Test" }
+
+class SirAsSwiftSourcesPrinterTests {
+    @Test
+    fun `should ignore foreign elements`() {
+        val module = buildModule {
+            name = "Test"
+            declarations.add(foreignFunction())
+        }
+
+        runTest(
+            module,
+            "testData/empty"
+        )
+    }
+
+    @Test
+    fun `should print simple function`() {
+        val module = buildModule {
+            name = "Test"
+            declarations.add(
+                buildFunction {
+                    origin = SirOrigin.Unknown
+                    visibility = SirVisibility.PUBLIC
+                    name = "foo"
+                    returnType = SirNominalType(SirSwiftModule.bool)
+                }
+            )
+        }
+
+        runTest(
+            module,
+            "testData/simple_function"
+        )
+    }
+
+    @Test
+    fun `should print multiple functions`() {
+        val module = buildModule {
+            name = "Test"
+            declarations.add(
+                buildFunction {
+                    origin = SirOrigin.Unknown
+                    visibility = SirVisibility.PUBLIC
+                    name = "foo1"
+                    returnType = SirNominalType(SirSwiftModule.bool)
+                }
+            )
+            declarations.add(
+                buildFunction {
+                    origin = SirOrigin.Unknown
+                    visibility = SirVisibility.PUBLIC
+                    name = "foo2"
+                    returnType = SirNominalType(SirSwiftModule.bool)
+                }
+            )
+        }
+
+        runTest(
+            module,
+            "testData/simple_multiple_function"
+        )
+    }
+
+    @Test
+    fun `should print single argument`() {
+        val module = buildModule {
+            name = "Test"
+            declarations.add(
+                buildFunction {
+                    origin = SirOrigin.Unknown
+                    visibility = SirVisibility.PUBLIC
+                    name = "foo"
+                    parameters.add(
+                        SirParameter(
+                            argumentName = "arg1",
+                            type = SirNominalType(SirSwiftModule.int32)
+                        )
+                    )
+                    returnType = SirNominalType(SirSwiftModule.bool)
+                }
+            )
+        }
+
+        runTest(
+            module,
+            "testData/single_argument"
+        )
+    }
+
+    @Test
+    fun `should print two argument`() {
+        val module = buildModule {
+            name = "Test"
+
+            declarations.add(
+                buildFunction {
+                    origin = SirOrigin.Unknown
+                    visibility = SirVisibility.PUBLIC
+                    name = "foo"
+                    parameters.add(
+                        SirParameter(
+                            argumentName = "arg1",
+                            type = SirNominalType(SirSwiftModule.int32)
+                        )
+                    )
+                    parameters.add(
+                        SirParameter(
+                            argumentName = "arg2",
+                            type = SirNominalType(SirSwiftModule.double)
+                        )
+                    )
+                    returnType = SirNominalType(SirSwiftModule.bool)
+                }
+            )
+        }
+
+        runTest(
+            module,
+            "testData/two_arguments"
+        )
+    }
+
+    @Test
+    fun `should all types as parameter be handled`() {
+        val module = buildModule {
+            name = "Test"
+            declarations.add(foreignFunction())
+
+            declarations.add(
+                buildFunction {
+                    origin = SirOrigin.Unknown
+                    visibility = SirVisibility.PUBLIC
+                    name = "foo"
+                    parameters.addAll(
+                        listOf(
+                            SirParameter(
+                                argumentName = "arg1",
+                                type = SirNominalType(SirSwiftModule.bool)
+                            ),
+                            SirParameter(
+                                argumentName = "arg2",
+                                type = SirNominalType(SirSwiftModule.int8)
+                            ),
+                            SirParameter(
+                                argumentName = "arg3",
+                                type = SirNominalType(SirSwiftModule.int16)
+                            ),
+                            SirParameter(
+                                argumentName = "arg4",
+                                type = SirNominalType(SirSwiftModule.int32)
+                            ),
+                            SirParameter(
+                                argumentName = "arg5",
+                                type = SirNominalType(SirSwiftModule.int64)
+                            ),
+                            SirParameter(
+                                argumentName = "arg6",
+                                type = SirNominalType(SirSwiftModule.double)
+                            ),
+                            SirParameter(
+                                argumentName = "arg7",
+                                type = SirNominalType(SirSwiftModule.float)
+                            ),
+                        )
+                    )
+                    returnType = SirNominalType(SirSwiftModule.bool)
+                }
+            )
+        }
+
+        runTest(
+            module,
+            "testData/all_types_argument"
+        )
+    }
+
+    private fun runTest(module: SirModule, goldenDataFile: String) {
+        val expectedSwiftSrc = File(KtTestUtil.getHomeDirectory()).resolve("$goldenDataFile.golden.swift")
+
+        val actualSwiftSrc = SirAsSwiftSourcesPrinter().print(module)
+        JUnit5Assertions.assertEqualsToFile(expectedSwiftSrc, actualSwiftSrc)
+    }
+
+    private fun foreignFunction(): SirForeignFunction = buildForeignFunction {
+        origin = SirOrigin.Unknown
+        visibility = SirVisibility.PUBLIC
+    }
+}

native/swift/sir/gen/org/jetbrains/kotlin/sir/SirEnum.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.sir.visitors.SirVisitor
 /**
  * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.enum]
  */
-abstract class SirEnum : SirDeclarationContainer(), SirNamedTypeDeclaration {
+abstract class SirEnum : SirDeclarationContainer(), SirNamedDeclaration {
     abstract override val origin: SirOrigin
     abstract override val visibility: SirVisibility
     abstract override var parent: SirDeclarationParent

native/swift/sir/gen/org/jetbrains/kotlin/sir/SirModule.kt

@@ -14,8 +14,9 @@ import org.jetbrains.kotlin.sir.visitors.SirVisitor
 /**
  * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.module]
  */
-abstract class SirModule : SirDeclarationContainer() {
+abstract class SirModule : SirDeclarationContainer(), SirNamed {
     abstract override val declarations: List<SirDeclaration>
+    abstract override val name: String
 
     override fun <R, D> accept(visitor: SirVisitor<R, D>, data: D): R =
         visitor.visitModule(this, data)

native/swift/sir/gen/org/jetbrains/kotlin/sir/SirNamed.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// This file was generated automatically. See native/swift/sir/tree-generator/Readme.md.
+// DO NOT MODIFY IT MANUALLY.
+
+package org.jetbrains.kotlin.sir
+
+/**
+ * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.named]
+ */
+sealed interface SirNamed : SirElement {
+    val name: String
+}

native/swift/sir/gen/org/jetbrains/kotlin/sir/SirNamedDeclaration.kt

@@ -12,18 +12,18 @@ import org.jetbrains.kotlin.sir.visitors.SirTransformer
 import org.jetbrains.kotlin.sir.visitors.SirVisitor
 
 /**
- * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.namedTypeDeclaration]
+ * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.namedDeclaration]
  */
-sealed interface SirNamedTypeDeclaration : SirDeclarationWithName {
+sealed interface SirNamedDeclaration : SirDeclaration, SirNamed {
     override val origin: SirOrigin
     override val visibility: SirVisibility
     override var parent: SirDeclarationParent
     override val name: String
 
     override fun <R, D> accept(visitor: SirVisitor<R, D>, data: D): R =
-        visitor.visitNamedTypeDeclaration(this, data)
+        visitor.visitNamedDeclaration(this, data)
 
     @Suppress("UNCHECKED_CAST")
     override fun <E : SirElement, D> transform(transformer: SirTransformer<D>, data: D): E =
-        transformer.transformNamedTypeDeclaration(this, data) as E
+        transformer.transformNamedDeclaration(this, data) as E
 }

native/swift/sir/gen/org/jetbrains/kotlin/sir/SirStruct.kt

@@ -12,18 +12,19 @@ import org.jetbrains.kotlin.sir.visitors.SirTransformer
 import org.jetbrains.kotlin.sir.visitors.SirVisitor
 
 /**
- * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.declarationWithName]
+ * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.struct]
  */
-sealed interface SirDeclarationWithName : SirDeclaration {
+abstract class SirStruct : SirDeclarationContainer(), SirNamedDeclaration {
-    override val origin: SirOrigin
+    abstract override val origin: SirOrigin
-    override val visibility: SirVisibility
+    abstract override val visibility: SirVisibility
-    override var parent: SirDeclarationParent
+    abstract override var parent: SirDeclarationParent
-    val name: String
+    abstract override val name: String
+    abstract override val declarations: List<SirDeclaration>
 
     override fun <R, D> accept(visitor: SirVisitor<R, D>, data: D): R =
-        visitor.visitDeclarationWithName(this, data)
+        visitor.visitStruct(this, data)
 
     @Suppress("UNCHECKED_CAST")
     override fun <E : SirElement, D> transform(transformer: SirTransformer<D>, data: D): E =
-        transformer.transformDeclarationWithName(this, data) as E
+        transformer.transformStruct(this, data) as E
 }

native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirEnumBuilder.kt

@@ -16,8 +16,8 @@ import org.jetbrains.kotlin.sir.impl.SirEnumImpl
 
 @SirBuilderDsl
 class SirEnumBuilder {
-    lateinit var origin: SirOrigin
+    var origin: SirOrigin = SirOrigin.Unknown
-    lateinit var visibility: SirVisibility
+    var visibility: SirVisibility = SirVisibility.PUBLIC
     lateinit var name: String
     val declarations: MutableList<SirDeclaration> = mutableListOf()
     val cases: MutableList<SirEnumCase> = mutableListOf()

native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirForeignFunctionBuilder.kt

@@ -11,16 +11,16 @@
 package org.jetbrains.kotlin.sir.builder
 
 import kotlin.contracts.*
-import org.jetbrains.kotlin.sir.SirOrigin
 import org.jetbrains.kotlin.sir.SirBuilderDsl
 import org.jetbrains.kotlin.sir.SirForeignFunction
+import org.jetbrains.kotlin.sir.SirOrigin
 import org.jetbrains.kotlin.sir.SirVisibility
 import org.jetbrains.kotlin.sir.impl.SirForeignFunctionImpl
 
 @SirBuilderDsl
 class SirForeignFunctionBuilder {
-    lateinit var origin: SirOrigin
+    var origin: SirOrigin = SirOrigin.Unknown
-    lateinit var visibility: SirVisibility
+    var visibility: SirVisibility = SirVisibility.PUBLIC
 
     fun build(): SirForeignFunction {
         return SirForeignFunctionImpl(
@@ -31,7 +31,7 @@ class SirForeignFunctionBuilder {
 }
 
 @OptIn(ExperimentalContracts::class)
-inline fun buildForeignFunction(init: SirForeignFunctionBuilder.() -> Unit): SirForeignFunction {
+inline fun buildForeignFunction(init: SirForeignFunctionBuilder.() -> Unit = {}): SirForeignFunction {
     contract {
         callsInPlace(init, InvocationKind.EXACTLY_ONCE)
     }

native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirFunctionBuilder.kt

@@ -16,8 +16,8 @@ import org.jetbrains.kotlin.sir.impl.SirFunctionImpl
 
 @SirBuilderDsl
 class SirFunctionBuilder {
-    lateinit var origin: SirOrigin
+    var origin: SirOrigin = SirOrigin.Unknown
-    lateinit var visibility: SirVisibility
+    var visibility: SirVisibility = SirVisibility.PUBLIC
     lateinit var name: String
     val parameters: MutableList<SirParameter> = mutableListOf()
     lateinit var returnType: SirType

native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirModuleBuilder.kt

@@ -19,16 +19,18 @@ import org.jetbrains.kotlin.sir.impl.SirModuleImpl
 @SirBuilderDsl
 class SirModuleBuilder {
     val declarations: MutableList<SirDeclaration> = mutableListOf()
+    lateinit var name: String
 
     fun build(): SirModule {
         return SirModuleImpl(
             declarations,
+            name,
         )
     }
 }
 
 @OptIn(ExperimentalContracts::class)
-inline fun buildModule(init: SirModuleBuilder.() -> Unit = {}): SirModule {
+inline fun buildModule(init: SirModuleBuilder.() -> Unit): SirModule {
     contract {
         callsInPlace(init, InvocationKind.EXACTLY_ONCE)
     }

native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirStructBuilder.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// This file was generated automatically. See native/swift/sir/tree-generator/Readme.md.
+// DO NOT MODIFY IT MANUALLY.
+
+@file:Suppress("DuplicatedCode", "unused")
+
+package org.jetbrains.kotlin.sir.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.sir.*
+import org.jetbrains.kotlin.sir.impl.SirStructImpl
+
+@SirBuilderDsl
+class SirStructBuilder {
+    var origin: SirOrigin = SirOrigin.Unknown
+    var visibility: SirVisibility = SirVisibility.PUBLIC
+    lateinit var name: String
+    val declarations: MutableList<SirDeclaration> = mutableListOf()
+
+    fun build(): SirStruct {
+        return SirStructImpl(
+            origin,
+            visibility,
+            name,
+            declarations,
+        )
+    }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun buildStruct(init: SirStructBuilder.() -> Unit): SirStruct {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
+    return SirStructBuilder().apply(init).build()
+}

native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirForeignFunctionImpl.kt

@@ -8,9 +8,9 @@
 
 package org.jetbrains.kotlin.sir.impl
 
-import org.jetbrains.kotlin.sir.SirOrigin
 import org.jetbrains.kotlin.sir.SirDeclarationParent
 import org.jetbrains.kotlin.sir.SirForeignFunction
+import org.jetbrains.kotlin.sir.SirOrigin
 import org.jetbrains.kotlin.sir.SirVisibility
 import org.jetbrains.kotlin.sir.visitors.SirTransformer
 import org.jetbrains.kotlin.sir.visitors.SirVisitor

native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirModuleImpl.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.sir.visitors.SirVisitor
 
 internal class SirModuleImpl(
     override val declarations: MutableList<SirDeclaration>,
+    override val name: String,
 ) : SirModule() {
 
     override fun <R, D> acceptChildren(visitor: SirVisitor<R, D>, data: D) {

native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirStructImpl.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+// This file was generated automatically. See native/swift/sir/tree-generator/Readme.md.
+// DO NOT MODIFY IT MANUALLY.
+
+package org.jetbrains.kotlin.sir.impl
+
+import org.jetbrains.kotlin.sir.*
+import org.jetbrains.kotlin.sir.util.transformInPlace
+import org.jetbrains.kotlin.sir.visitors.SirTransformer
+import org.jetbrains.kotlin.sir.visitors.SirVisitor
+
+internal class SirStructImpl(
+    override val origin: SirOrigin,
+    override val visibility: SirVisibility,
+    override val name: String,
+    override val declarations: MutableList<SirDeclaration>,
+) : SirStruct() {
+    override lateinit var parent: SirDeclarationParent
+
+    override fun <R, D> acceptChildren(visitor: SirVisitor<R, D>, data: D) {
+        declarations.forEach { it.accept(visitor, data) }
+    }
+
+    override fun <D> transformChildren(transformer: SirTransformer<D>, data: D) {
+        declarations.transformInPlace(transformer, data)
+    }
+}

native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformer.kt

@@ -54,20 +54,13 @@ abstract class SirTransformer<in D> : SirVisitor<SirElement, D>() {
         return transformForeignDeclaration(foreignDeclaration, data)
     }
 
-    open fun transformDeclarationWithName(declarationWithName: SirDeclarationWithName, data: D): SirDeclaration {
+
-        return transformElement(declarationWithName, data)
+    open fun transformNamedDeclaration(namedDeclaration: SirNamedDeclaration, data: D): SirDeclaration {
+        return transformElement(namedDeclaration, data)
     }
 
-    final override fun visitDeclarationWithName(declarationWithName: SirDeclarationWithName, data: D): SirDeclaration {
+    final override fun visitNamedDeclaration(namedDeclaration: SirNamedDeclaration, data: D): SirDeclaration {
-        return transformDeclarationWithName(declarationWithName, data)
+        return transformNamedDeclaration(namedDeclaration, data)
-    }
-
-    open fun transformNamedTypeDeclaration(namedTypeDeclaration: SirNamedTypeDeclaration, data: D): SirDeclaration {
-        return transformElement(namedTypeDeclaration, data)
-    }
-
-    final override fun visitNamedTypeDeclaration(namedTypeDeclaration: SirNamedTypeDeclaration, data: D): SirDeclaration {
-        return transformNamedTypeDeclaration(namedTypeDeclaration, data)
     }
 
     open fun transformEnum(enum: SirEnum, data: D): SirDeclaration {
@@ -78,6 +71,14 @@ abstract class SirTransformer<in D> : SirVisitor<SirElement, D>() {
         return transformEnum(enum, data)
     }
 
+    open fun transformStruct(struct: SirStruct, data: D): SirDeclaration {
+        return transformElement(struct, data)
+    }
+
+    final override fun visitStruct(struct: SirStruct, data: D): SirDeclaration {
+        return transformStruct(struct, data)
+    }
+
     open fun transformCallable(callable: SirCallable, data: D): SirDeclaration {
         return transformElement(callable, data)
     }

native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitor.kt

@@ -29,14 +29,14 @@ abstract class SirVisitor<out R, in D> {
     open fun visitForeignDeclaration(foreignDeclaration: SirForeignDeclaration, data: D): R =
         visitDeclaration(foreignDeclaration, data)
 
-    open fun visitDeclarationWithName(declarationWithName: SirDeclarationWithName, data: D): R =
+    open fun visitNamedDeclaration(namedDeclaration: SirNamedDeclaration, data: D): R =
-        visitDeclaration(declarationWithName, data)
+        visitDeclaration(namedDeclaration, data)
-
-    open fun visitNamedTypeDeclaration(namedTypeDeclaration: SirNamedTypeDeclaration, data: D): R =
-        visitDeclarationWithName(namedTypeDeclaration, data)
 
     open fun visitEnum(enum: SirEnum, data: D): R =
-        visitNamedTypeDeclaration(enum, data)
+        visitNamedDeclaration(enum, data)
+
+    open fun visitStruct(struct: SirStruct, data: D): R =
+        visitNamedDeclaration(struct, data)
 
     open fun visitCallable(callable: SirCallable, data: D): R =
         visitDeclaration(callable, data)

native/swift/sir/src/org/jetbrains/kotlin/sir/SirOrigin.kt

@@ -5,4 +5,16 @@
 
 package org.jetbrains.kotlin.sir
 
-data class SirOrigin(val path: List<String>)
+sealed interface SirOrigin {
+    sealed  interface Synthetic : SirOrigin
+
+    data class ExternallyDefined(val name: String) : Synthetic
+
+    data class KotlinEntity(val path: List<String>) : SirOrigin
+
+    /**
+     * Value for nodes of unknown or non-viable origin
+     * (e.g. objects created in/for tests)
+     */
+    data object Unknown: SirOrigin
+}

native/swift/sir/src/org/jetbrains/kotlin/sir/SirType.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.sir
 sealed interface SirType
 
 class SirNominalType(
-    val type: SirNamedTypeDeclaration,
+    val type: SirNamedDeclaration,
     val parent: SirNominalType? = null,
 ) : SirType
 

native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirSwiftModule.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.sir.util
+
+import org.jetbrains.kotlin.sir.SirDeclaration
+import org.jetbrains.kotlin.sir.SirModule
+import org.jetbrains.kotlin.sir.SirOrigin
+import org.jetbrains.kotlin.sir.SirVisibility
+import org.jetbrains.kotlin.sir.builder.buildStruct
+import org.jetbrains.kotlin.sir.visitors.SirTransformer
+import org.jetbrains.kotlin.sir.visitors.SirVisitor
+
+/**
+ * A module representing the swift standard library
+ */
+object SirSwiftModule : SirModule() {
+    override val name: String get() = "Swift"
+    override val declarations: List<SirDeclaration> by lazy {
+        listOf(
+            bool,
+            int8,
+            int16,
+            int32,
+            int64,
+            double,
+            float,
+        )
+    }
+
+    val bool = primitive("Bool")
+    val int8 = primitive("Int8")
+    val int16 = primitive("Int16")
+    val int32 = primitive("Int32")
+    val int64 = primitive("Int64")
+    val double = primitive("Double")
+    val float = primitive("Float")
+
+    override fun <R, D> acceptChildren(visitor: SirVisitor<R, D>, data: D) {
+        declarations.forEach { it.accept(visitor, data) }
+    }
+
+    override fun <D> transformChildren(transformer: SirTransformer<D>, data: D) {}
+}
+
+private fun primitive(typeName: String) = buildStruct {
+    origin = SirOrigin.ExternallyDefined("Swift.$typeName")
+    visibility = SirVisibility.PUBLIC
+    name = typeName
+}.also { it.parent = SirSwiftModule }

settings.gradle

@@ -400,6 +400,7 @@ include ":plugins:compose-compiler-plugin:compiler",
 // Swift Export modules
 include ":native:swift:sir",
         ":native:swift:sir-passes",
+        ":native:swift:sir-printer",
         ":native:swift:sir-analysis-api",
         ":native:swift:sir-compiler-bridge",
         ":generators:sir-tests-generator"