KT-64931: add convertion of kotlin top-lvl functions into swift static functions

Merge-request: KT-MR-13878
Merged-by: Artem Olkov <artem.olkov@jetbrains.com>

native/swift/sir-passes/src/org/jetbrains/sir/passes/translation/ForeignIntoSwiftFunctionTranslationPass.kt

@@ -35,7 +35,9 @@ public class ForeignIntoSwiftFunctionTranslationPass : SirPass<SirElement, Nothi
             return buildFunction {
                 origin = function.origin
                 visibility = function.visibility
-                name = kotlinOrigin.fqName.last()
+
+                isStatic = function.parent is SirDeclaration
+                name = kotlinOrigin.path.last()
                 kotlinOrigin.parameters.mapTo(parameters) { it.toSir() }
 
                 returnType = kotlinOrigin.returnType.toSir()

native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/SirParentPatcherTests.kt

@@ -29,6 +29,7 @@ class SirParentPatcherTests {
         val function = buildFunction {
             name = "foo"
             returnType = SirNominalType(SirSwiftModule.bool)
+            isStatic = false
         }
         function.parent = wrongEnum
         val wrongModule = buildModule { name = "wrongModule" }

native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/SirPassTests.kt

@@ -5,10 +5,12 @@
 
 package org.jetbrains.kotlin.sir.passes
 
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.sir.SirFunction
 import org.jetbrains.kotlin.sir.SirNominalType
 import org.jetbrains.kotlin.sir.SirParameter
 import org.jetbrains.kotlin.sir.SirVisibility
+import org.jetbrains.kotlin.sir.builder.buildEnum
 import org.jetbrains.kotlin.sir.builder.buildForeignFunction
 import org.jetbrains.kotlin.sir.builder.buildModule
 import org.jetbrains.kotlin.sir.constants.*
@@ -19,9 +21,7 @@ import org.jetbrains.kotlin.sir.passes.asserts.assertSirFunctionsEquals
 import org.jetbrains.kotlin.sir.passes.mocks.MockSirFunction
 import org.jetbrains.kotlin.sir.passes.util.runWithAsserts
 import org.jetbrains.kotlin.sir.util.SirSwiftModule
-import org.jetbrains.sir.passes.run
 import org.jetbrains.sir.passes.translation.ForeignIntoSwiftFunctionTranslationPass
-import org.jetbrains.sir.passes.utility.assertValid
 import kotlin.test.Test
 import kotlin.test.assertNotNull
 
@@ -33,7 +33,7 @@ class SirPassTests {
         }
         val mySirElement = buildForeignFunction {
             origin = MockFunction(
-                fqName = listOf("foo"),
+                fqName = FqName.fromSegments(listOf("foo")),
                 parameters = emptyList(),
                 returnType = MockKotlinType(BOOLEAN),
             )
@@ -48,6 +48,38 @@ class SirPassTests {
             parameters = emptyList(),
             returnType = SirNominalType(SirSwiftModule.bool),
             parent = module,
+            isStatic = false,
+        )
+        assertSirFunctionsEquals(actual = result, expected = exp)
+    }
+
+    @Test
+    fun `foreign toplevel function without params with package should be translated as static`() {
+        val module = buildModule {
+            name = "demo"
+        }
+        val mySirEnum = buildEnum {
+            name = "bar"
+        }
+        mySirEnum.parent = module
+        val mySirElement = buildForeignFunction {
+            origin = MockFunction(
+                fqName = FqName.fromSegments(listOf("bar", "foo")),
+                parameters = emptyList(),
+                returnType = MockKotlinType(BOOLEAN),
+            )
+            visibility = SirVisibility.PUBLIC
+        }
+        mySirElement.parent = mySirEnum
+        val myPass = ForeignIntoSwiftFunctionTranslationPass()
+        val result = myPass.runWithAsserts(mySirElement, null) as? SirFunction
+        assertNotNull(result, "SirFunction should be produced")
+        val exp = MockSirFunction(
+            name = "foo",
+            parameters = emptyList(),
+            returnType = SirNominalType(SirSwiftModule.bool),
+            parent = mySirEnum,
+            isStatic = true,
         )
         assertSirFunctionsEquals(actual = result, expected = exp)
     }
@@ -59,7 +91,7 @@ class SirPassTests {
         }
         val mySirElement = buildForeignFunction {
             origin = MockFunction(
-                fqName = listOf("foo"),
+                fqName = FqName.fromSegments(listOf("foo")),
                 parameters = listOf(
                     MockParameter(
                         name = "arg1",
@@ -112,7 +144,8 @@ class SirPassTests {
                 SirParameter(argumentName = "arg7", type = SirNominalType(SirSwiftModule.bool)),
             ),
             returnType = SirNominalType(SirSwiftModule.int8),
-            parent = module
+            parent = module,
+            isStatic = false,
         )
         assertSirFunctionsEquals(actual = result, expected = exp)
     }

native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/SirValidatorTests.kt

@@ -5,12 +5,11 @@
 
 package org.jetbrains.kotlin.sir.passes
 
-import org.jetbrains.kotlin.sir.SirOrigin
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.sir.builder.buildForeignFunction
 import org.jetbrains.kotlin.sir.builder.buildModule
 import org.jetbrains.kotlin.sir.mock.MockFunction
 import org.jetbrains.kotlin.sir.mock.MockKotlinType
-import org.jetbrains.sir.passes.utility.PatchDeclarationParentVisitor
 import org.jetbrains.sir.passes.utility.SirValidatorConfig
 import org.jetbrains.sir.passes.utility.ValidationError
 import org.jetbrains.sir.passes.utility.validate
@@ -40,9 +39,9 @@ class SirValidatorTests {
         }
         val foreignFunction = buildForeignFunction {
             val kotlinEntity = MockFunction(
-                fqName = listOf("foo"),
+                fqName = FqName.fromSegments(listOf("foo")),
                 parameters = emptyList(),
-                returnType = MockKotlinType("kotlin/Byte")
+                returnType = MockKotlinType("kotlin/Byte"),
             )
             origin = kotlinEntity
         }
@@ -60,4 +59,4 @@ class SirValidatorTests {
         assertEquals(foreignFunction, error.declaration)
         assertEquals(module, error.expectedParent)
     }
-}
+}

native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/asserts/functionEquality.kt

@@ -25,4 +25,8 @@ fun assertSirFunctionsEquals(expected: SirFunction, actual: SirFunction) {
         actual = actual.returnType,
         expected = expected.returnType
     )
+    assertEquals(
+        actual = actual.isStatic,
+        expected = expected.isStatic
+    )
 }

native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/mocks/MockSirFunction.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.sir.visitors.SirVisitor
 
 class MockSirFunction(
     override val origin: SirOrigin = SirOrigin.Unknown,
+    override val isStatic: Boolean,
     override val visibility: SirVisibility = SirVisibility.PUBLIC,
     override var parent: SirDeclarationParent,
     override val name: String,