Remove KotlinSirOrigin hierarchy in favour of direct AA usage #KT-65335 Fixed

Merge-request: KT-MR-14229 Merged-by: Artem Olkov <artem.olkov@jetbrains.com>
2024-02-09 18:34:52 +00:00
parent c2e0c8b2e9
commit b6c805bbb6
94 changed files with 548 additions and 1912 deletions
@@ -12,7 +12,6 @@ dependencies {
    compileOnly(kotlinStdlib())

    implementation(project(":native:swift:sir"))
-    implementation(project(":native:swift:sir-analysis-api"))
    implementation(project(":native:swift:sir-compiler-bridge"))
    implementation(project(":native:swift:sir-passes"))
    implementation(project(":native:swift:sir-printer"))
@@ -5,7 +5,10 @@

 package org.jetbrains.kotlin.swiftexport.standalone.builders

-import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtVariableLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.psiSafe
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.sir.SirElement
 import org.jetbrains.kotlin.sir.SirFunction
 import org.jetbrains.kotlin.sir.SirVariable
@@ -13,12 +16,12 @@ import org.jetbrains.kotlin.sir.SirAccessor
 import org.jetbrains.kotlin.sir.SirSetter
 import org.jetbrains.kotlin.sir.SirGetter
 import org.jetbrains.kotlin.sir.util.*
-import org.jetbrains.kotlin.sir.SirKotlinOrigin
 import org.jetbrains.kotlin.sir.SirModule
 import org.jetbrains.kotlin.sir.bridge.BridgeRequest
 import org.jetbrains.kotlin.sir.bridge.createFunctionBodyFromRequest
 import org.jetbrains.kotlin.sir.visitors.SirVisitorVoid
 import org.jetbrains.sir.passes.SirPass
+import org.jetbrains.sir.passes.builder.KotlinSource
 import org.jetbrains.sir.passes.run

 internal fun SirModule.buildFunctionBridges(): List<BridgeRequest> {
@@ -39,7 +42,9 @@ private object BridgeGenerationPass : SirPass<SirElement, Nothing?, List<BridgeR
        }

        override fun visitFunction(function: SirFunction) {
-            val fqName = (function.origin as? SirKotlinOrigin.Function)?.path
+            val fqName = ((function.origin as? KotlinSource)?.symbol as? KtFunctionLikeSymbol)
+                ?.callableIdIfNonLocal?.asSingleFqName()
+                ?.pathSegments()?.map { it.toString() }
                ?: return
            val fqNameForBridge = fqName.forBridge

@@ -53,7 +58,9 @@ private object BridgeGenerationPass : SirPass<SirElement, Nothing?, List<BridgeR
        }

        override fun visitVariable(variable: SirVariable) {
-            val fqName = (variable.origin as? SirKotlinOrigin.Property)?.path?.forBridge
+            val fqName = ((variable.origin as? KotlinSource)?.symbol as? KtVariableLikeSymbol)
+                ?.callableIdIfNonLocal?.asSingleFqName()
+                ?.pathSegments()?.map { it.toString() }
                ?: return
            val fqNameForBridge = fqName.forBridge

@@ -71,13 +78,15 @@ private object BridgeGenerationPass : SirPass<SirElement, Nothing?, List<BridgeR
    }
 }

-private val SirAccessor.bridgeSuffix: String get() = when(this) {
-    is SirGetter -> "get"
-    is SirSetter -> "set"
-}
+private val SirAccessor.bridgeSuffix: String
+    get() = when (this) {
+        is SirGetter -> "get"
+        is SirSetter -> "set"
+    }

-private val List<String>.forBridge: List<String> get() = if (this.count() == 1) {
-    listOf("__root__", this.first()) // todo: should be changed with correct mangling KT-64970
-} else {
-    this
-}
+private val List<String>.forBridge: List<String>
+    get() = if (this.count() == 1) {
+        listOf("__root__", this.first()) // todo: should be changed with correct mangling KT-64970
+    } else {
+        this
+    }
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.swiftexport.standalone.builders

 import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
+import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeTokenProvider
 import org.jetbrains.kotlin.analysis.api.standalone.KtAlwaysAccessibleLifetimeTokenProvider
 import org.jetbrains.kotlin.analysis.api.standalone.buildStandaloneAnalysisAPISession
@@ -13,10 +14,10 @@ import org.jetbrains.kotlin.analysis.project.structure.builder.buildKtSourceModu
 import org.jetbrains.kotlin.platform.konan.NativePlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.sir.SirModule
-import org.jetbrains.kotlin.sir.analysisapi.SirGenerator
 import org.jetbrains.kotlin.sir.builder.buildImport
 import org.jetbrains.kotlin.sir.builder.buildModule
 import org.jetbrains.kotlin.swiftexport.standalone.SwiftExportInput
+import org.jetbrains.sir.passes.builder.buildSirDeclarationList

@OptIn(KtAnalysisApiInternals::class)
 internal fun buildSwiftModule(
@@ -48,17 +49,17 @@ internal fun buildSwiftModule(
        ktFiles = ktFiles.sortedBy { it.name }
    }

-
-    return buildModule {
-        name = sourceModule.moduleName
-        val sirFactory = SirGenerator()
-        declarations += buildImport {
-            moduleName = bridgeModuleName
+    return analyze(sourceModule) {
+        buildModule {
+            name = sourceModule.moduleName
+            declarations += buildImport {
+                moduleName = bridgeModuleName
+            }
+            ktFiles.forEach { file ->
+                declarations += buildSirDeclarationList(file)
+            }
+        }.apply {
+            declarations.forEach { it.parent = this }
        }
-        ktFiles.forEach { file ->
-            declarations += sirFactory.build(file)
-        }
-    }.apply {
-        declarations.forEach { it.parent = this }
    }
 }
@@ -13,7 +13,6 @@ import org.jetbrains.sir.passes.SirInflatePackagesPass
 import org.jetbrains.sir.passes.SirModulePass
 import org.jetbrains.sir.passes.SirPass
 import org.jetbrains.sir.passes.run
-import org.jetbrains.sir.passes.translation.ForeignTranslationPass

 internal fun SirModule.transformToSwift(): SirModule {
    return SirPassesConfiguration.passes.fold(this) { module, pass ->
@@ -24,9 +23,9 @@ internal fun SirModule.transformToSwift(): SirModule {
 private object SirPassesConfiguration {
    val passes: List<SirModulePass> = listOf(
        SirInflatePackagesPass(),
-        WholeModuleTranslationByElementPass(ForeignTranslationPass()),
    )

+    @Suppress("Unused")
    class WholeModuleTranslationByElementPass(
        val pass: SirPass<SirElement, Nothing?, SirDeclaration>
    ) : SirModulePass {
@@ -0,0 +1,4 @@
+#include <stdint.h>
+
+int16_t __root___foo__TypesOfArguments__int32_t_double__(int32_t p, double p2);
+
@@ -0,0 +1,8 @@
+import kotlin.native.internal.ExportedBridge
+
+@ExportedBridge("__root___foo")
+public fun __root___foo(p: Int, p2: Double): Short {
+    val result = foo(p, p2)
+    return result
+}
+
@@ -0,0 +1,15 @@
+import KotlinBridges
+
+/**
+ * Function foo description
+ *
+ * @param p first Integer to consume
+ * @param p2 second Double to consume
+ * @return Short, constant 1
+ */
+public func foo(
+    p: Swift.Int32,
+    p2: Swift.Double
+) -> Swift.Int16 {
+    return __root___foo__TypesOfArguments__int32_t_double__(p, p2)
+}
@@ -0,0 +1,8 @@
+/**
+ * Function foo description
+ *
+ * @param p first Integer to consume
+ * @param p2 second Double to consume
+ * @return Short, constant 1
+ */
+fun foo(p: Int, p2: Double): Short = 1
@@ -0,0 +1,18 @@
+#include <stdint.h>
+
+void namespace1_local_functions_foo();
+
+int32_t namespace1_main_foobar__TypesOfArguments__int32_t__(int32_t param);
+
+void namespace1_main_all_args__TypesOfArguments___Bool_int8_t_int16_t_int32_t_int64_t_float_double__(_Bool arg1, int8_t arg2, int16_t arg3, int32_t arg4, int64_t arg5, float arg10, double arg11);
+
+int32_t namespace1_bar();
+
+int32_t namespace2_foo__TypesOfArguments__int32_t__(int32_t arg1);
+
+int32_t overload_foo__TypesOfArguments__int32_t__(int32_t arg1);
+
+int32_t overload_foo__TypesOfArguments__double__(double arg1);
+
+int32_t __root___foo();
+
@@ -0,0 +1,50 @@
+import kotlin.native.internal.ExportedBridge
+
+@ExportedBridge("namespace1_local_functions_foo")
+public fun namespace1_local_functions_foo(): Unit {
+    val result = namespace1.local_functions.foo()
+    return result
+}
+
+@ExportedBridge("namespace1_main_foobar")
+public fun namespace1_main_foobar(param: Int): Int {
+    val result = namespace1.main.foobar(param)
+    return result
+}
+
+@ExportedBridge("namespace1_main_all_args")
+public fun namespace1_main_all_args(arg1: Boolean, arg2: Byte, arg3: Short, arg4: Int, arg5: Long, arg10: Float, arg11: Double): Unit {
+    val result = namespace1.main.all_args(arg1, arg2, arg3, arg4, arg5, arg10, arg11)
+    return result
+}
+
+@ExportedBridge("namespace1_bar")
+public fun namespace1_bar(): Int {
+    val result = namespace1.bar()
+    return result
+}
+
+@ExportedBridge("namespace2_foo")
+public fun namespace2_foo(arg1: Int): Int {
+    val result = namespace2.foo(arg1)
+    return result
+}
+
+@ExportedBridge("overload_foo")
+public fun overload_foo(arg1: Int): Int {
+    val result = overload.foo(arg1)
+    return result
+}
+
+@ExportedBridge("overload_foo")
+public fun overload_foo(arg1: Double): Int {
+    val result = overload.foo(arg1)
+    return result
+}
+
+@ExportedBridge("__root___foo")
+public fun __root___foo(): Int {
+    val result = foo()
+    return result
+}
+
@@ -0,0 +1,55 @@
+import KotlinBridges
+
+enum namespace1 {
+    enum local_functions {
+        public static func foo() -> Swift.Void {
+            namespace1_local_functions_foo()
+        }
+    }
+    enum main {
+        public static func foobar(
+            param: Swift.Int32
+        ) -> Swift.Int32 {
+            return namespace1_main_foobar__TypesOfArguments__int32_t__(param)
+        }
+        public static func all_args(
+            arg1: Swift.Bool,
+            arg2: Swift.Int8,
+            arg3: Swift.Int16,
+            arg4: Swift.Int32,
+            arg5: Swift.Int64,
+            arg10: Swift.Float,
+            arg11: Swift.Double
+        ) -> Swift.Void {
+            namespace1_main_all_args__TypesOfArguments___Bool_int8_t_int16_t_int32_t_int64_t_float_double__(arg1, arg2, arg3, arg4, arg5, arg10, arg11)
+        }
+    }
+    public static func bar() -> Swift.Int32 {
+        return namespace1_bar()
+    }
+}
+
+enum namespace2 {
+    public static func foo(
+        arg1: Swift.Int32
+    ) -> Swift.Int32 {
+        return namespace2_foo__TypesOfArguments__int32_t__(arg1)
+    }
+}
+
+enum overload {
+    public static func foo(
+        arg1: Swift.Int32
+    ) -> Swift.Int32 {
+        return overload_foo__TypesOfArguments__int32_t__(arg1)
+    }
+    public static func foo(
+        arg1: Swift.Double
+    ) -> Swift.Int32 {
+        return overload_foo__TypesOfArguments__double__(arg1)
+    }
+}
+
+public func foo() -> Swift.Int32 {
+    return __root___foo()
+}
@@ -0,0 +1,3 @@
+package namespace2
+
+fun foo(arg1: Int) = 123
@@ -0,0 +1,2 @@
+
+internal fun foo_internal() = 123
@@ -0,0 +1,7 @@
+package namespace1.local_functions
+
+fun foo() {
+    fun bar() {
+        val baz = 0
+    }
+}
@@ -0,0 +1,24 @@
+package namespace1.main
+
+import namespace1.*
+import namespace2.*
+
+fun foobar(param: Int): Int = foo() + bar() + param
+
+fun all_args(
+    arg1: Boolean,
+
+    arg2: Byte,
+    arg3: Short,
+    arg4: Int,
+    arg5: Long,
+
+    // TODO: support kotlin Unsigned types - KT-65668
+//    arg6: UByte,
+//    arg7: UShort,
+//    arg8: UInt,
+//    arg9: ULong,
+
+    arg10: Float,
+    arg11: Double,
+): Unit = Unit
@@ -0,0 +1,5 @@
+package overload
+
+fun foo(arg1: Int) = 123
+
+fun foo(arg1: Double) = 321
@@ -1,9 +0,0 @@
-#include <stdint.h>
-
-int32_t namespace1_main_foobar(int32_t param);
-
-int32_t namespace1_bar();
-
-int32_t namespace2_foo();
-
-int32_t __root___foo();
@@ -1,25 +0,0 @@
-import kotlin.native.internal.ExportedBridge
-
-@ExportedBridge("namespace1_main_foobar")
-public fun namespace1_main_foobar(param: Int): Int {
-    val result = namespace1.main.foobar(param)
-    return result
-}
-
-@ExportedBridge("namespace1_bar")
-public fun namespace1_bar(): Int {
-    val result = namespace1.bar()
-    return result
-}
-
-@ExportedBridge("namespace2_foo")
-public fun namespace2_foo(): Int {
-    val result = namespace2.foo()
-    return result
-}
-
-@ExportedBridge("__root___foo")
-public fun __root___foo(): Int {
-    val result = foo()
-    return result
-}
@@ -1,24 +0,0 @@
-import KotlinBridges
-
-enum namespace1 {
-    enum main {
-        public static func foobar(
-            param: Swift.Int32
-        ) -> Swift.Int32 {
-            return namespace1_main_foobar(param)
-        }
-    }
-    public static func bar() -> Swift.Int32 {
-        return namespace1_bar()
-    }
-}
-
-enum namespace2 {
-    public static func foo() -> Swift.Int32 {
-        return namespace2_foo()
-    }
-}
-
-public func foo() -> Swift.Int32 {
-    return __root___foo()
-}
@@ -1,3 +0,0 @@
-package namespace2
-
-fun foo(): Int = 321
@@ -1,5 +0,0 @@
-package namespace1.main
-
-import namespace1.*
-import namespace2.*
-fun foobar(param: Int): Int = foo() + bar() + param
@@ -4,9 +4,9 @@ int32_t namespace_main_foo_get();

 int32_t namespace_main_bar_get();

-void namespace_main_bar_set(int32_t newValue);
+void namespace_main_bar_set__TypesOfArguments__int32_t__(int32_t newValue);

-int32_t namespace_main_foobar(int32_t param);
+int32_t namespace_main_foobar__TypesOfArguments__int32_t__(int32_t param);

 int32_t __root___baz();

@@ -12,13 +12,13 @@ enum namespace {
                return namespace_main_bar_get()
            }
            set {
-                namespace_main_bar_set(newValue)
+                namespace_main_bar_set__TypesOfArguments__int32_t__(newValue)
            }
        }
        public static func foobar(
            param: Swift.Int32
        ) -> Swift.Int32 {
-            return namespace_main_foobar(param)
+            return namespace_main_foobar__TypesOfArguments__int32_t__(param)
        }
    }
 }
@@ -25,15 +25,21 @@ public class SwiftExportRunnerTest extends AbstractSwiftRunnerTest {
    }

    @Test
-    @TestMetadata("no_package")
-    public void testNo_package() throws Exception {
-        runTest("native/swift/swift-export-standalone/testData/no_package/");
+    @TestMetadata("documentation")
+    public void testDocumentation() throws Exception {
+        runTest("native/swift/swift-export-standalone/testData/documentation/");
    }

    @Test
-    @TestMetadata("simple")
-    public void testSimple() throws Exception {
-        runTest("native/swift/swift-export-standalone/testData/simple/");
+    @TestMetadata("functions")
+    public void testFunctions() throws Exception {
+        runTest("native/swift/swift-export-standalone/testData/functions/");
+    }
+
+    @Test
+    @TestMetadata("no_package")
+    public void testNo_package() throws Exception {
+        runTest("native/swift/swift-export-standalone/testData/no_package/");
    }

    @Test