diff --git a/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/SirGenerator.kt b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/SirGenerator.kt index 2c8771388bb..03a6d683050 100644 --- a/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/SirGenerator.kt +++ b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/SirGenerator.kt @@ -6,13 +6,17 @@ package org.jetbrains.kotlin.sir.analysisapi import org.jetbrains.kotlin.analysis.api.analyze +import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtModifierListOwner import org.jetbrains.kotlin.psi.KtNamedFunction +import org.jetbrains.kotlin.psi.KtProperty import org.jetbrains.kotlin.psi.KtTreeVisitorVoid import org.jetbrains.kotlin.psi.psiUtil.isPublic import org.jetbrains.kotlin.sir.SirDeclaration import org.jetbrains.kotlin.sir.SirForeignFunction import org.jetbrains.kotlin.sir.analysisapi.transformers.toForeignFunction +import org.jetbrains.kotlin.sir.analysisapi.transformers.toForeignVariable /** * A root interface for classes that produce Swift IR elements. @@ -23,17 +27,25 @@ public interface SirFactory { public class SirGenerator : SirFactory { override fun build(fromFile: KtFile): List = analyze(fromFile) { - val res = mutableListOf() + val res = mutableListOf() fromFile.accept(Visitor(res)) return res.toList() } - private class Visitor(val res: MutableList) : KtTreeVisitorVoid() { + private class Visitor(val res: MutableList) : KtTreeVisitorVoid() { override fun visitNamedFunction(function: KtNamedFunction) { super.visitNamedFunction(function) - function - .takeIf { function.isPublic } - ?.toForeignFunction() + function.process(KtNamedFunction::toForeignFunction) + } + + override fun visitProperty(property: KtProperty) { + super.visitProperty(property) + property.process(KtProperty::toForeignVariable) + } + + private inline fun T.process(converter: T.() -> SirDeclaration) { + this.takeIf { it.isPublic } + ?.let(converter) ?.let { res.add(it) } } } diff --git a/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/NamedFunction.kt b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/NamedFunction.kt index 0b9b71030a2..de769578204 100644 --- a/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/NamedFunction.kt +++ b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/NamedFunction.kt @@ -44,14 +44,6 @@ private class AAFunction( get() = originalFunction.docComment?.let { AADocumentation(it) } } -private data class AAParameter( - override val name: String, - override val type: SirKotlinOrigin.Type -) : SirKotlinOrigin.Parameter - -private data class AAKotlinType( - override val name: String -) : SirKotlinOrigin.Type private data class AADocumentation( private val kdoc: KDoc diff --git a/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/Types.kt b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/Types.kt new file mode 100644 index 00000000000..f73d579f73d --- /dev/null +++ b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/Types.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2024 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.analysisapi.transformers + +import org.jetbrains.kotlin.sir.SirKotlinOrigin + +internal data class AAParameter( + override val name: String, + override val type: SirKotlinOrigin.Type +) : SirKotlinOrigin.Parameter + +internal data class AAKotlinType( + override val name: String +) : SirKotlinOrigin.Type diff --git a/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/Variable.kt b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/Variable.kt new file mode 100644 index 00000000000..eff3d212c87 --- /dev/null +++ b/native/swift/sir-analysis-api/src/org/jetbrains/kotlin/sir/analysisapi/transformers/Variable.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. + */ + +package org.jetbrains.kotlin.sir.analysisapi.transformers + +import org.jetbrains.kotlin.analysis.api.analyze +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.psi.KtVariableDeclaration +import org.jetbrains.kotlin.sir.* +import org.jetbrains.kotlin.sir.builder.buildForeignVariable + +internal fun KtVariableDeclaration.toForeignVariable(): SirForeignVariable = buildForeignVariable { + origin = AAVariable(this@toForeignVariable) +} + +private class AAVariable( + private val original: KtVariableDeclaration +) : SirKotlinOrigin.Property { + override val fqName: FqName + get() = original.fqName ?: FqName.fromSegments(emptyList()) + + override val type: SirKotlinOrigin.Type + get() = analyze(original) { + AAKotlinType(name = original.getReturnKtType().toString()) + } + + override val isWriteable: Boolean + get() = original.isVar +} \ No newline at end of file diff --git a/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/BridgeGenerator.kt b/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/BridgeGenerator.kt index ebe374f7189..e67db157865 100644 --- a/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/BridgeGenerator.kt +++ b/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/BridgeGenerator.kt @@ -5,20 +5,25 @@ package org.jetbrains.kotlin.sir.bridge -import org.jetbrains.kotlin.sir.SirFunction +import org.jetbrains.kotlin.sir.SirCallable import org.jetbrains.kotlin.sir.SirFunctionBody +import org.jetbrains.kotlin.sir.SirNativeCallable import org.jetbrains.kotlin.sir.bridge.impl.BridgeGeneratorImpl import org.jetbrains.kotlin.sir.bridge.impl.CBridgePrinter import org.jetbrains.kotlin.sir.bridge.impl.KotlinBridgePrinter +import org.jetbrains.kotlin.sir.util.allParameters +import org.jetbrains.kotlin.sir.util.isVoid +import org.jetbrains.kotlin.sir.util.name +import org.jetbrains.kotlin.sir.util.returnType /** * Description of a Kotlin function for which we are creating the bridge. * - * @param function SIR function we are generating bridge for + * @param callable SIR function we are generating bridge for * @param bridgeName C name of the bridge */ public class BridgeRequest( - public val function: SirFunction, + public val callable: SirNativeCallable, public val bridgeName: String, public val fqName: List, ) @@ -31,10 +36,11 @@ public class BridgeRequest( */ public fun createFunctionBodyFromRequest(request: BridgeRequest): SirFunctionBody { val callee = request.bridgeName - val calleeArguments = request.function.parameters.map { it.argumentName } + val calleeArguments = request.callable.allParameters.map { it.name } val callSite = "$callee(${calleeArguments.joinToString(separator = ", ")})" + val callStatement = if (request.callable.returnType.isVoid) callSite else "return $callSite" return SirFunctionBody( - listOf("return $callSite") + listOf(callStatement) ) } diff --git a/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/impl/BridgeGeneratorImpl.kt b/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/impl/BridgeGeneratorImpl.kt index 0b20fe5f4a6..d305215ec9b 100644 --- a/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/impl/BridgeGeneratorImpl.kt +++ b/native/swift/sir-compiler-bridge/src/org/jetbrains/kotlin/sir/bridge/impl/BridgeGeneratorImpl.kt @@ -9,15 +9,15 @@ import org.jetbrains.kotlin.sir.SirNominalType import org.jetbrains.kotlin.sir.SirParameter import org.jetbrains.kotlin.sir.SirType import org.jetbrains.kotlin.sir.bridge.* -import org.jetbrains.kotlin.sir.util.SirSwiftModule +import org.jetbrains.kotlin.sir.util.* private const val exportAnnotationFqName = "kotlin.native.internal.ExportedBridge" private const val stdintHeader = "stdint.h" internal class BridgeGeneratorImpl : BridgeGenerator { override fun generate(request: BridgeRequest): FunctionBridge { - val (kotlinReturnType, cReturnType) = bridgeType(request.function.returnType) - val parameterBridges = request.function.parameters.map { bridgeParameter(it) } + val (kotlinReturnType, cReturnType) = bridgeType(request.callable.returnType) + val parameterBridges = request.callable.allParameters.mapIndexed { index, value -> bridgeParameter(value, index) } val cDeclaration = createCDeclaration(request.bridgeName, cReturnType, parameterBridges.map { it.c }) val kotlinBridge = createKotlinBridge(request.bridgeName, request.fqName, kotlinReturnType, parameterBridges.map { it.kotlin }) @@ -71,6 +71,8 @@ private fun createCDeclaration(bridgeName: String, returnType: CType, parameters private fun bridgeType(type: SirType): Pair { require(type is SirNominalType) return when (type.type) { + SirSwiftModule.void -> (KotlinType.Unit to CType.Void) + SirSwiftModule.bool -> (KotlinType.Boolean to CType.Bool) SirSwiftModule.int8 -> (KotlinType.Byte to CType.Int8) @@ -87,8 +89,10 @@ private fun bridgeType(type: SirType): Pair { } } -private fun bridgeParameter(parameter: SirParameter): BridgeParameter { - val bridgeParameterName = parameter.argumentName?.let(::createBridgeParameterName) ?: "" +private fun bridgeParameter(parameter: SirParameter, index: Int): BridgeParameter { + val bridgeParameterName = parameter.name?.let(::createBridgeParameterName) ?: "_$index" + // TODO: Remove this check when non-trivial type bridges are supported + check(!parameter.type.isVoid) { "The parameter $bridgeParameterName can not have Void type" } val (kotlinType, cType) = bridgeType(parameter.type) return BridgeParameter( KotlinBridgeParameter(bridgeParameterName, kotlinType), @@ -112,6 +116,8 @@ internal data class CBridgeParameter( ) public enum class CType(public val repr: String) { + Void("void"), + Bool("_Bool"), Int8("int8_t"), @@ -131,6 +137,8 @@ internal data class KotlinBridgeParameter( ) internal enum class KotlinType(val repr: String) { + Unit("Unit"), + Boolean("Boolean"), Byte("Byte"), diff --git a/native/swift/sir-compiler-bridge/test/org/jetbrains/kotlin/sir/bridge/AbstractKotlinSirBridgeTest.kt b/native/swift/sir-compiler-bridge/test/org/jetbrains/kotlin/sir/bridge/AbstractKotlinSirBridgeTest.kt index 150402679af..2b2b5c093b9 100644 --- a/native/swift/sir-compiler-bridge/test/org/jetbrains/kotlin/sir/bridge/AbstractKotlinSirBridgeTest.kt +++ b/native/swift/sir-compiler-bridge/test/org/jetbrains/kotlin/sir/bridge/AbstractKotlinSirBridgeTest.kt @@ -10,6 +10,9 @@ import org.jetbrains.kotlin.sir.SirNominalType import org.jetbrains.kotlin.sir.SirParameter import org.jetbrains.kotlin.sir.SirType import org.jetbrains.kotlin.sir.builder.buildFunction +import org.jetbrains.kotlin.sir.builder.buildGetter +import org.jetbrains.kotlin.sir.builder.buildSetter +import org.jetbrains.kotlin.sir.builder.buildVariable import org.jetbrains.kotlin.sir.util.SirSwiftModule import org.jetbrains.kotlin.test.services.JUnit5Assertions import org.jetbrains.kotlin.test.util.KtTestUtil @@ -86,11 +89,48 @@ private fun readRequestFromFile(file: File): BridgeRequest { ) } } - val function = buildFunction { - this.name = fqName.last() - this.returnType = returnType - this.parameters += parameters - this.isStatic = false + + val kind = BridgeRequestKind.valueOf(properties.getProperty("kind", "FUNCTION")) + + val callable = when (kind) { + BridgeRequestKind.FUNCTION -> buildFunction { + this.name = fqName.last() + this.returnType = returnType + this.parameters += parameters + this.isStatic = false + } + BridgeRequestKind.PROPERTY_GETTER -> { + val getter = buildGetter() + + getter.parent = buildVariable { + this.name = fqName.last() + this.type = returnType + check(parameters.isEmpty()) + this.isStatic = false + this.getter = getter + } + + getter + } + BridgeRequestKind.PROPERTY_SETTER -> { + val setter = buildSetter() + + setter.parent = buildVariable { + this.name = fqName.last() + this.type = returnType + check(parameters.isEmpty()) + this.isStatic = false + this.getter = buildGetter() + this.setter = setter + } + + setter + } } - return BridgeRequest(function, bridgeName, fqName) + + return BridgeRequest(callable, bridgeName, fqName) +} + +private enum class BridgeRequestKind { + FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER } \ No newline at end of file diff --git a/native/swift/sir-compiler-bridge/testData/property_accessors/expected.h b/native/swift/sir-compiler-bridge/testData/property_accessors/expected.h new file mode 100644 index 00000000000..b7f09f68c0c --- /dev/null +++ b/native/swift/sir-compiler-bridge/testData/property_accessors/expected.h @@ -0,0 +1,5 @@ +#include + +_Bool getter_bridge(); + +void setter_bridge(_Bool newValue); diff --git a/native/swift/sir-compiler-bridge/testData/property_accessors/expected.kt b/native/swift/sir-compiler-bridge/testData/property_accessors/expected.kt new file mode 100644 index 00000000000..84c12917333 --- /dev/null +++ b/native/swift/sir-compiler-bridge/testData/property_accessors/expected.kt @@ -0,0 +1,13 @@ +import kotlin.native.internal.ExportedBridge + +@ExportedBridge("getter_bridge") +public fun getter_bridge(): Boolean { + val result = variable() + return result +} + +@ExportedBridge("setter_bridge") +public fun setter_bridge(newValue: Boolean): Unit { + val result = variable(newValue) + return result +} diff --git a/native/swift/sir-compiler-bridge/testData/property_accessors/request0.properties b/native/swift/sir-compiler-bridge/testData/property_accessors/request0.properties new file mode 100644 index 00000000000..32401e93e94 --- /dev/null +++ b/native/swift/sir-compiler-bridge/testData/property_accessors/request0.properties @@ -0,0 +1,4 @@ +fqName=variable +kind=PROPERTY_GETTER +bridgeName=getter_bridge +returnType=boolean \ No newline at end of file diff --git a/native/swift/sir-compiler-bridge/testData/property_accessors/request1.properties b/native/swift/sir-compiler-bridge/testData/property_accessors/request1.properties new file mode 100644 index 00000000000..8743dae9c6c --- /dev/null +++ b/native/swift/sir-compiler-bridge/testData/property_accessors/request1.properties @@ -0,0 +1,4 @@ +fqName=variable +kind=PROPERTY_SETTER +bridgeName=setter_bridge +returnType=boolean \ No newline at end of file diff --git a/native/swift/sir-compiler-bridge/tests-gen/org/jetbrains/kotlin/sir/bridge/SirCompilerBridgeTestGenerated.java b/native/swift/sir-compiler-bridge/tests-gen/org/jetbrains/kotlin/sir/bridge/SirCompilerBridgeTestGenerated.java index 6bd665b72b0..a7ea214a221 100644 --- a/native/swift/sir-compiler-bridge/tests-gen/org/jetbrains/kotlin/sir/bridge/SirCompilerBridgeTestGenerated.java +++ b/native/swift/sir-compiler-bridge/tests-gen/org/jetbrains/kotlin/sir/bridge/SirCompilerBridgeTestGenerated.java @@ -42,6 +42,12 @@ public class SirCompilerBridgeTestGenerated extends AbstractKotlinSirBridgeTest runTest("native/swift/sir-compiler-bridge/testData/primitive_types/"); } + @Test + @TestMetadata("property_accessors") + public void testProperty_accessors() throws Exception { + runTest("native/swift/sir-compiler-bridge/testData/property_accessors/"); + } + @Test @TestMetadata("smoke0") public void testSmoke0() throws Exception { diff --git a/native/swift/sir-passes/src/org/jetbrains/sir/passes/translation/ForeignIntoSwiftFunctionTranslationPass.kt b/native/swift/sir-passes/src/org/jetbrains/sir/passes/translation/ForeignTranslationPass.kt similarity index 61% rename from native/swift/sir-passes/src/org/jetbrains/sir/passes/translation/ForeignIntoSwiftFunctionTranslationPass.kt rename to native/swift/sir-passes/src/org/jetbrains/sir/passes/translation/ForeignTranslationPass.kt index 864115ce5a4..4993d38ce1b 100644 --- a/native/swift/sir-passes/src/org/jetbrains/sir/passes/translation/ForeignIntoSwiftFunctionTranslationPass.kt +++ b/native/swift/sir-passes/src/org/jetbrains/sir/passes/translation/ForeignTranslationPass.kt @@ -7,6 +7,9 @@ package org.jetbrains.sir.passes.translation import org.jetbrains.kotlin.sir.* import org.jetbrains.kotlin.sir.builder.buildFunction +import org.jetbrains.kotlin.sir.builder.buildGetter +import org.jetbrains.kotlin.sir.builder.buildSetter +import org.jetbrains.kotlin.sir.builder.buildVariable import org.jetbrains.kotlin.sir.util.SirSwiftModule import org.jetbrains.kotlin.sir.constants.* import org.jetbrains.kotlin.sir.visitors.SirTransformerVoid @@ -15,13 +18,9 @@ import java.lang.IllegalStateException /** - * Translates `SirForeignFunction` into `SirFunction`. - * Works only with Nominal Types and top-level functions, currently. - * If received `element` of different type than `SirForeignFunction`, - * or `element` does not contain origin of type `SirOrigin.KotlinEntity.Function`, - * returns original element. + * Translates `SirForeign*` nodes into their regular "native" counterparts. */ -public class ForeignIntoSwiftFunctionTranslationPass : SirPass { +public class ForeignTranslationPass : SirPass { private class Transformer : SirTransformerVoid() { override fun transformElement(element: E): E { @@ -29,6 +28,12 @@ public class ForeignIntoSwiftFunctionTranslationPass : SirPass SirSwiftModule.void BYTE -> SirSwiftModule.int8 SHORT -> SirSwiftModule.int16 INT -> SirSwiftModule.int32 diff --git a/native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/SirPassTests.kt b/native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/SirPassTests.kt index 093fe478474..ccf3cc6c113 100644 --- a/native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/SirPassTests.kt +++ b/native/swift/sir-passes/tests/org/jetbrains/kotlin/sir/passes/SirPassTests.kt @@ -17,7 +17,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.translation.ForeignIntoSwiftFunctionTranslationPass +import org.jetbrains.sir.passes.translation.ForeignTranslationPass import kotlin.test.Test import kotlin.test.assertNotNull @@ -36,7 +36,7 @@ class SirPassTests { visibility = SirVisibility.PUBLIC } mySirElement.parent = module - val myPass = ForeignIntoSwiftFunctionTranslationPass() + val myPass = ForeignTranslationPass() val result = myPass.runWithAsserts(mySirElement, null) as? SirFunction assertNotNull(result, "SirFunction should be produced") val exp = MockSirFunction( @@ -67,7 +67,7 @@ class SirPassTests { visibility = SirVisibility.PUBLIC } mySirElement.parent = mySirEnum - val myPass = ForeignIntoSwiftFunctionTranslationPass() + val myPass = ForeignTranslationPass() val result = myPass.runWithAsserts(mySirElement, null) as? SirFunction assertNotNull(result, "SirFunction should be produced") val exp = MockSirFunction( @@ -123,7 +123,7 @@ class SirPassTests { visibility = SirVisibility.PUBLIC } mySirElement.parent = module - val myPass = ForeignIntoSwiftFunctionTranslationPass() + val myPass = ForeignTranslationPass() val result = myPass.runWithAsserts(mySirElement, null) as? SirFunction assertNotNull(result, "SirFunction should be produced") val exp = MockSirFunction( @@ -171,7 +171,7 @@ class SirPassTests { visibility = SirVisibility.PUBLIC } mySirElement.parent = module - val myPass = ForeignIntoSwiftFunctionTranslationPass() + val myPass = ForeignTranslationPass() val result = myPass.runWithAsserts(mySirElement, null) as? SirFunction assertNotNull(result, "SirFunction should be produced") val exp = MockSirFunction( diff --git a/native/swift/sir-printer/src/org/jetbrains/sir/printer/SirAsSwiftSourcesPrinter.kt b/native/swift/sir-printer/src/org/jetbrains/sir/printer/SirAsSwiftSourcesPrinter.kt index 95a68b0cb7e..05e9607da80 100644 --- a/native/swift/sir-printer/src/org/jetbrains/sir/printer/SirAsSwiftSourcesPrinter.kt +++ b/native/swift/sir-printer/src/org/jetbrains/sir/printer/SirAsSwiftSourcesPrinter.kt @@ -28,11 +28,54 @@ public class SirAsSwiftSourcesPrinter(private val printer: SmartPrinter) : SirVi } } + override fun visitVariable(variable: SirVariable): Unit = with(printer) { + print( + variable.visibility.takeIf { it != SirVisibility.INTERNAL }?.let { "${it.swift} " } ?: "", + if (variable.isStatic) "static " else "", + "var ", + variable.name.swiftIdentifier, + ": ", + variable.type.swift, + ) + println(" {") + withIndent { + variable.getter.accept(this@SirAsSwiftSourcesPrinter) + variable.setter?.accept(this@SirAsSwiftSourcesPrinter) + } + println("}") + } + + override fun visitSetter(setter: SirSetter): Unit = with(printer) { + print("set") + setter.body?.let { body -> + println(" {") + withIndent { + printFunctionBody(body).forEach { println(it) } + } + println("}") + } ?: println("") + } + + override fun visitGetter(getter: SirGetter): Unit = with(printer) { + print("get") + getter.body?.let { body -> + println(" {") + withIndent { + printFunctionBody(body).forEach { println(it) } + } + println("}") + } ?: println("") + } + override fun visitFunction(function: SirFunction): Unit = with(printer) { function.documentation?.let { println(it) } print( function.visibility.takeIf { it != SirVisibility.INTERNAL }?.let { "${it.swift} " } ?: "", - if (function.isStatic) { "static " } else { "" }, + if (function.isStatic) { + "static " + } else { + "" + }, "func ", function.name.swiftIdentifier, "(" @@ -57,7 +100,7 @@ public class SirAsSwiftSourcesPrinter(private val printer: SmartPrinter) : SirVi ) println(" {") withIndent { - printFunctionBody(function).forEach { + printFunctionBody(function.body).forEach { println(it) } } @@ -72,15 +115,19 @@ public class SirAsSwiftSourcesPrinter(private val printer: SmartPrinter) : SirVi println("}") } - override fun visitForeignFunction(function: SirForeignFunction) {} // we do not write foreign nodes + // we do not write foreign nodes + + override fun visitForeignFunction(function: SirForeignFunction) {} + + override fun visitForeignVariable(variable: SirForeignVariable) {} override fun visitElement(element: SirElement): Unit = with(printer) { println("/* ERROR: unsupported element type: " + element.javaClass.simpleName + " */") } } -private fun printFunctionBody(function: SirFunction): List { - return function.body?.statements ?: listOf("fatalError()") +private fun printFunctionBody(body: SirFunctionBody?): List { + return body?.statements ?: listOf("fatalError()") } private val SirVisibility.swift diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirAccessor.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirAccessor.kt new file mode 100644 index 00000000000..3cdd66c7f6a --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirAccessor.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2024 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 + +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +/** + * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.accessor] + */ +sealed class SirAccessor : SirNativeCallable() { + abstract override val origin: SirOrigin + abstract override val visibility: SirVisibility + abstract override var parent: SirDeclarationParent + abstract var body: SirFunctionBody? + + override fun accept(visitor: SirVisitor, data: D): R = + visitor.visitAccessor(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: SirTransformer, data: D): E = + transformer.transformAccessor(this, data) as E +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirForeignVariable.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirForeignVariable.kt new file mode 100644 index 00000000000..3217c01d2ff --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirForeignVariable.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2024 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 + +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +/** + * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.foreignVariable] + */ +abstract class SirForeignVariable : SirForeignDeclaration() { + abstract override val origin: SirOrigin + abstract override val visibility: SirVisibility + abstract override var parent: SirDeclarationParent + + override fun accept(visitor: SirVisitor, data: D): R = + visitor.visitForeignVariable(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: SirTransformer, data: D): E = + transformer.transformForeignVariable(this, data) as E +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirFunction.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirFunction.kt index 03a143ed122..d0cfa50a4f1 100644 --- a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirFunction.kt +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirFunction.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.sir.visitors.SirVisitor /** * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.function] */ -abstract class SirFunction : SirElementBase(), SirCallable { +abstract class SirFunction : SirNativeCallable() { abstract override val origin: SirOrigin abstract override val visibility: SirVisibility abstract override var parent: SirDeclarationParent diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirGetter.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirGetter.kt new file mode 100644 index 00000000000..6eadd78dc77 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirGetter.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2024 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 + +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +/** + * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.getter] + */ +abstract class SirGetter : SirAccessor() { + abstract override val origin: SirOrigin + abstract override val visibility: SirVisibility + abstract override var parent: SirDeclarationParent + abstract override var body: SirFunctionBody? + + override fun accept(visitor: SirVisitor, data: D): R = + visitor.visitGetter(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: SirTransformer, data: D): E = + transformer.transformGetter(this, data) as E +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirNativeCallable.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirNativeCallable.kt new file mode 100644 index 00000000000..231d6db9331 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirNativeCallable.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2024 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 + +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +/** + * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.nativeCallable] + */ +sealed class SirNativeCallable : SirElementBase(), SirCallable { + abstract override val origin: SirOrigin + abstract override val visibility: SirVisibility + abstract override var parent: SirDeclarationParent + + override fun accept(visitor: SirVisitor, data: D): R = + visitor.visitNativeCallable(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: SirTransformer, data: D): E = + transformer.transformNativeCallable(this, data) as E +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirSetter.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirSetter.kt new file mode 100644 index 00000000000..2150ddfb38b --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirSetter.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2024 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 + +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +/** + * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.setter] + */ +abstract class SirSetter : SirAccessor() { + abstract override val origin: SirOrigin + abstract override val visibility: SirVisibility + abstract override var parent: SirDeclarationParent + abstract override var body: SirFunctionBody? + abstract val parameterName: String + + override fun accept(visitor: SirVisitor, data: D): R = + visitor.visitSetter(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: SirTransformer, data: D): E = + transformer.transformSetter(this, data) as E +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirVariable.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirVariable.kt new file mode 100644 index 00000000000..4e33a782e13 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/SirVariable.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2024 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 + +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +/** + * Generated from: [org.jetbrains.kotlin.sir.tree.generator.SwiftIrTree.variable] + */ +abstract class SirVariable : SirDeclarationParent(), SirDeclaration { + abstract override val origin: SirOrigin + abstract override val visibility: SirVisibility + abstract override var parent: SirDeclarationParent + abstract val name: String + abstract val type: SirType + abstract val getter: SirGetter + abstract val setter: SirSetter? + abstract val isStatic: Boolean + + override fun accept(visitor: SirVisitor, data: D): R = + visitor.visitVariable(this, data) + + @Suppress("UNCHECKED_CAST") + override fun transform(transformer: SirTransformer, data: D): E = + transformer.transformVariable(this, data) as E +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirForeignVariableBuilder.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirForeignVariableBuilder.kt new file mode 100644 index 00000000000..8cffd963e74 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirForeignVariableBuilder.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2024 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.SirBuilderDsl +import org.jetbrains.kotlin.sir.SirForeignVariable +import org.jetbrains.kotlin.sir.SirOrigin +import org.jetbrains.kotlin.sir.SirVisibility +import org.jetbrains.kotlin.sir.impl.SirForeignVariableImpl + +@SirBuilderDsl +class SirForeignVariableBuilder { + var origin: SirOrigin = SirOrigin.Unknown + var visibility: SirVisibility = SirVisibility.PUBLIC + + fun build(): SirForeignVariable { + return SirForeignVariableImpl( + origin, + visibility, + ) + } +} + +@OptIn(ExperimentalContracts::class) +inline fun buildForeignVariable(init: SirForeignVariableBuilder.() -> Unit = {}): SirForeignVariable { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + return SirForeignVariableBuilder().apply(init).build() +} + +@OptIn(ExperimentalContracts::class) +inline fun buildForeignVariableCopy(original: SirForeignVariable, init: SirForeignVariableBuilder.() -> Unit = {}): SirForeignVariable { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + val copyBuilder = SirForeignVariableBuilder() + copyBuilder.origin = original.origin + copyBuilder.visibility = original.visibility + return copyBuilder.apply(init).build() +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirGetterBuilder.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirGetterBuilder.kt new file mode 100644 index 00000000000..e3891ec0882 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirGetterBuilder.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2024 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.SirGetterImpl + +@SirBuilderDsl +class SirGetterBuilder { + var origin: SirOrigin = SirOrigin.Unknown + var visibility: SirVisibility = SirVisibility.PUBLIC + var body: SirFunctionBody? = null + + fun build(): SirGetter { + return SirGetterImpl( + origin, + visibility, + body, + ) + } + +} + +@OptIn(ExperimentalContracts::class) +inline fun buildGetter(init: SirGetterBuilder.() -> Unit = {}): SirGetter { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + return SirGetterBuilder().apply(init).build() +} + +@OptIn(ExperimentalContracts::class) +inline fun buildGetterCopy(original: SirGetter, init: SirGetterBuilder.() -> Unit = {}): SirGetter { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + val copyBuilder = SirGetterBuilder() + copyBuilder.origin = original.origin + copyBuilder.visibility = original.visibility + copyBuilder.body = original.body + return copyBuilder.apply(init).build() +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirSetterBuilder.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirSetterBuilder.kt new file mode 100644 index 00000000000..464b8059ac1 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirSetterBuilder.kt @@ -0,0 +1,54 @@ +/* + * Copyright 2010-2024 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.SirSetterImpl + +@SirBuilderDsl +class SirSetterBuilder { + var origin: SirOrigin = SirOrigin.Unknown + var visibility: SirVisibility = SirVisibility.PUBLIC + var body: SirFunctionBody? = null + var parameterName: String = "newValue" + + fun build(): SirSetter { + return SirSetterImpl( + origin, + visibility, + body, + parameterName, + ) + } + +} + +@OptIn(ExperimentalContracts::class) +inline fun buildSetter(init: SirSetterBuilder.() -> Unit = {}): SirSetter { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + return SirSetterBuilder().apply(init).build() +} + +@OptIn(ExperimentalContracts::class) +inline fun buildSetterCopy(original: SirSetter, init: SirSetterBuilder.() -> Unit = {}): SirSetter { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + val copyBuilder = SirSetterBuilder() + copyBuilder.origin = original.origin + copyBuilder.visibility = original.visibility + copyBuilder.body = original.body + copyBuilder.parameterName = original.parameterName + return copyBuilder.apply(init).build() +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirVariableBuilder.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirVariableBuilder.kt new file mode 100644 index 00000000000..e164ed10f1a --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/builder/SirVariableBuilder.kt @@ -0,0 +1,63 @@ +/* + * Copyright 2010-2024 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.SirVariableImpl + +@SirBuilderDsl +class SirVariableBuilder { + var origin: SirOrigin = SirOrigin.Unknown + var visibility: SirVisibility = SirVisibility.PUBLIC + lateinit var name: String + lateinit var type: SirType + lateinit var getter: SirGetter + var setter: SirSetter? = null + var isStatic: Boolean by kotlin.properties.Delegates.notNull() + + fun build(): SirVariable { + return SirVariableImpl( + origin, + visibility, + name, + type, + getter, + setter, + isStatic, + ) + } + +} + +@OptIn(ExperimentalContracts::class) +inline fun buildVariable(init: SirVariableBuilder.() -> Unit): SirVariable { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + return SirVariableBuilder().apply(init).build() +} + +@OptIn(ExperimentalContracts::class) +inline fun buildVariableCopy(original: SirVariable, init: SirVariableBuilder.() -> Unit): SirVariable { + contract { + callsInPlace(init, InvocationKind.EXACTLY_ONCE) + } + val copyBuilder = SirVariableBuilder() + copyBuilder.origin = original.origin + copyBuilder.visibility = original.visibility + copyBuilder.name = original.name + copyBuilder.type = original.type + copyBuilder.getter = original.getter + copyBuilder.setter = original.setter + copyBuilder.isStatic = original.isStatic + return copyBuilder.apply(init).build() +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirForeignVariableImpl.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirForeignVariableImpl.kt new file mode 100644 index 00000000000..ec6b2f041ff --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirForeignVariableImpl.kt @@ -0,0 +1,31 @@ +/* + * Copyright 2010-2024 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.impl + +import org.jetbrains.kotlin.sir.SirDeclarationParent +import org.jetbrains.kotlin.sir.SirForeignVariable +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 + +internal class SirForeignVariableImpl( + override val origin: SirOrigin, + override val visibility: SirVisibility, +) : SirForeignVariable() { + override lateinit var parent: SirDeclarationParent + + override fun acceptChildren(visitor: SirVisitor, data: D) { + } + + override fun transformChildren(transformer: SirTransformer, data: D) { + } +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirGetterImpl.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirGetterImpl.kt new file mode 100644 index 00000000000..fdcdde16251 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirGetterImpl.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2024 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.impl + +import org.jetbrains.kotlin.sir.* +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +internal class SirGetterImpl( + override val origin: SirOrigin, + override val visibility: SirVisibility, + override var body: SirFunctionBody?, +) : SirGetter() { + override lateinit var parent: SirDeclarationParent + + override fun acceptChildren(visitor: SirVisitor, data: D) { + } + + override fun transformChildren(transformer: SirTransformer, data: D) { + } +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirSetterImpl.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirSetterImpl.kt new file mode 100644 index 00000000000..66426516e79 --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirSetterImpl.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2024 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.impl + +import org.jetbrains.kotlin.sir.* +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +internal class SirSetterImpl( + override val origin: SirOrigin, + override val visibility: SirVisibility, + override var body: SirFunctionBody?, + override val parameterName: String, +) : SirSetter() { + override lateinit var parent: SirDeclarationParent + + override fun acceptChildren(visitor: SirVisitor, data: D) { + } + + override fun transformChildren(transformer: SirTransformer, data: D) { + } +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirVariableImpl.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirVariableImpl.kt new file mode 100644 index 00000000000..3e10a1c842f --- /dev/null +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/impl/SirVariableImpl.kt @@ -0,0 +1,35 @@ +/* + * Copyright 2010-2024 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.impl + +import org.jetbrains.kotlin.sir.* +import org.jetbrains.kotlin.sir.visitors.SirTransformer +import org.jetbrains.kotlin.sir.visitors.SirVisitor + +internal class SirVariableImpl( + override val origin: SirOrigin, + override val visibility: SirVisibility, + override val name: String, + override val type: SirType, + override val getter: SirGetter, + override val setter: SirSetter?, + override val isStatic: Boolean, +) : SirVariable() { + override lateinit var parent: SirDeclarationParent + + override fun acceptChildren(visitor: SirVisitor, data: D) { + getter.accept(visitor, data) + setter?.accept(visitor, data) + } + + override fun transformChildren(transformer: SirTransformer, data: D) { + } +} diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformer.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformer.kt index 095533c457c..2b9b848c827 100644 --- a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformer.kt +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformer.kt @@ -87,6 +87,14 @@ abstract class SirTransformer : SirVisitor() { return transformCallable(callable, data) } + open fun transformNativeCallable(nativeCallable: SirNativeCallable, data: D): SirDeclaration { + return transformCallable(nativeCallable, data) + } + + final override fun visitNativeCallable(nativeCallable: SirNativeCallable, data: D): SirDeclaration { + return transformNativeCallable(nativeCallable, data) + } + open fun transformFunction(function: SirFunction, data: D): SirDeclaration { return transformCallable(function, data) } @@ -102,4 +110,44 @@ abstract class SirTransformer : SirVisitor() { final override fun visitForeignFunction(function: SirForeignFunction, data: D): SirDeclaration { return transformForeignFunction(function, data) } + + open fun transformAccessor(accessor: SirAccessor, data: D): SirDeclaration { + return transformCallable(accessor, data) + } + + final override fun visitAccessor(accessor: SirAccessor, data: D): SirDeclaration { + return transformAccessor(accessor, data) + } + + open fun transformGetter(getter: SirGetter, data: D): SirDeclaration { + return transformAccessor(getter, data) + } + + final override fun visitGetter(getter: SirGetter, data: D): SirDeclaration { + return transformGetter(getter, data) + } + + open fun transformSetter(setter: SirSetter, data: D): SirDeclaration { + return transformAccessor(setter, data) + } + + final override fun visitSetter(setter: SirSetter, data: D): SirDeclaration { + return transformSetter(setter, data) + } + + open fun transformVariable(variable: SirVariable, data: D): SirDeclaration { + return transformDeclaration(variable, data) + } + + final override fun visitVariable(variable: SirVariable, data: D): SirDeclaration { + return transformVariable(variable, data) + } + + open fun transformForeignVariable(foreignVariable: SirForeignVariable, data: D): SirDeclaration { + return transformDeclaration(foreignVariable, data) + } + + final override fun visitForeignVariable(variable: SirForeignVariable, data: D): SirDeclaration { + return transformForeignVariable(variable, data) + } } diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformerVoid.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformerVoid.kt index 29a1040948c..027cd1630db 100644 --- a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformerVoid.kt +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirTransformerVoid.kt @@ -68,6 +68,12 @@ abstract class SirTransformerVoid : SirTransformer() { final override fun transformCallable(callable: SirCallable, data: Nothing?): SirDeclaration = transformCallable(callable) + open fun transformNativeCallable(nativeCallable: SirNativeCallable): SirDeclaration = + transformCallable(nativeCallable) + + final override fun transformNativeCallable(nativeCallable: SirNativeCallable, data: Nothing?): SirDeclaration = + transformNativeCallable(nativeCallable) + open fun transformFunction(function: SirFunction): SirDeclaration = transformCallable(function) @@ -79,4 +85,34 @@ abstract class SirTransformerVoid : SirTransformer() { final override fun transformForeignFunction(function: SirForeignFunction, data: Nothing?): SirDeclaration = transformForeignFunction(function) + + open fun transformAccessor(accessor: SirAccessor): SirDeclaration = + transformCallable(accessor) + + final override fun transformAccessor(accessor: SirAccessor, data: Nothing?): SirDeclaration = + transformAccessor(accessor) + + open fun transformGetter(getter: SirGetter): SirDeclaration = + transformAccessor(getter) + + final override fun transformGetter(getter: SirGetter, data: Nothing?): SirDeclaration = + transformGetter(getter) + + open fun transformSetter(setter: SirSetter): SirDeclaration = + transformAccessor(setter) + + final override fun transformSetter(setter: SirSetter, data: Nothing?): SirDeclaration = + transformSetter(setter) + + open fun transformVariable(variable: SirVariable): SirDeclaration = + transformDeclaration(variable) + + final override fun transformVariable(variable: SirVariable, data: Nothing?): SirDeclaration = + transformVariable(variable) + + open fun transformForeignVariable(variable: SirForeignVariable): SirDeclaration = + transformDeclaration(variable) + + final override fun transformForeignVariable(variable: SirForeignVariable, data: Nothing?): SirDeclaration = + transformForeignVariable(variable) } diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitor.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitor.kt index 6122615fe9c..31bf757e235 100644 --- a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitor.kt +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitor.kt @@ -41,9 +41,27 @@ abstract class SirVisitor { open fun visitCallable(callable: SirCallable, data: D): R = visitDeclaration(callable, data) + open fun visitNativeCallable(nativeCallable: SirNativeCallable, data: D): R = + visitCallable(nativeCallable, data) + open fun visitFunction(function: SirFunction, data: D): R = visitCallable(function, data) open fun visitForeignFunction(function: SirForeignFunction, data: D): R = visitCallable(function, data) + + open fun visitAccessor(accessor: SirAccessor, data: D): R = + visitCallable(accessor, data) + + open fun visitGetter(getter: SirGetter, data: D): R = + visitAccessor(getter, data) + + open fun visitSetter(setter: SirSetter, data: D): R = + visitAccessor(setter, data) + + open fun visitVariable(variable: SirVariable, data: D): R = + visitDeclaration(variable, data) + + open fun visitForeignVariable(variable: SirForeignVariable, data: D): R = + visitDeclaration(variable, data) } diff --git a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitorVoid.kt b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitorVoid.kt index c7264ea3c30..381e9f3acb0 100644 --- a/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitorVoid.kt +++ b/native/swift/sir/gen/org/jetbrains/kotlin/sir/visitors/SirVisitorVoid.kt @@ -86,6 +86,14 @@ abstract class SirVisitorVoid : SirVisitor() { visitDeclaration(callable) } + final override fun visitNativeCallable(nativeCallable: SirNativeCallable, data: Nothing?) { + visitNativeCallable(nativeCallable) + } + + open fun visitNativeCallable(nativeCallable: SirNativeCallable) { + visitCallable(nativeCallable) + } + final override fun visitFunction(function: SirFunction, data: Nothing?) { visitFunction(function) } @@ -101,4 +109,44 @@ abstract class SirVisitorVoid : SirVisitor() { open fun visitForeignFunction(function: SirForeignFunction) { visitCallable(function) } + + final override fun visitAccessor(accessor: SirAccessor, data: Nothing?) { + visitAccessor(accessor) + } + + open fun visitAccessor(accessor: SirAccessor) { + visitCallable(accessor) + } + + final override fun visitGetter(getter: SirGetter, data: Nothing?) { + visitGetter(getter) + } + + open fun visitGetter(getter: SirGetter) { + visitAccessor(getter) + } + + final override fun visitSetter(setter: SirSetter, data: Nothing?) { + visitSetter(setter) + } + + open fun visitSetter(setter: SirSetter) { + visitAccessor(setter) + } + + final override fun visitVariable(variable: SirVariable, data: Nothing?) { + visitVariable(variable) + } + + open fun visitVariable(variable: SirVariable) { + visitDeclaration(variable) + } + + final override fun visitForeignVariable(variable: SirForeignVariable, data: Nothing?) { + visitForeignVariable(variable) + } + + open fun visitForeignVariable(variable: SirForeignVariable) { + visitDeclaration(variable) + } } diff --git a/native/swift/sir/src/org/jetbrains/kotlin/sir/SirKotlinOrigin.kt b/native/swift/sir/src/org/jetbrains/kotlin/sir/SirKotlinOrigin.kt index b24d4666999..29f57f29b20 100644 --- a/native/swift/sir/src/org/jetbrains/kotlin/sir/SirKotlinOrigin.kt +++ b/native/swift/sir/src/org/jetbrains/kotlin/sir/SirKotlinOrigin.kt @@ -19,6 +19,11 @@ sealed interface SirKotlinOrigin : SirOrigin.Foreign { val returnType: Type } + interface Property : SirKotlinOrigin { + val type: Type + val isWriteable: Boolean + } + interface Parameter { val name: String val type: Type diff --git a/native/swift/sir/src/org/jetbrains/kotlin/sir/constants/KotlinBuiltinTypes.kt b/native/swift/sir/src/org/jetbrains/kotlin/sir/constants/KotlinBuiltinTypes.kt new file mode 100644 index 00000000000..a4ad91d64e6 --- /dev/null +++ b/native/swift/sir/src/org/jetbrains/kotlin/sir/constants/KotlinBuiltinTypes.kt @@ -0,0 +1,19 @@ +/* + * 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.constants + +private const val KOTLIN_PACKAGE = "kotlin" +private const val DELIMITER = "/" +private const val KOTLIN_BUILTIN_TYPE_PREFIX = "${KOTLIN_PACKAGE}${DELIMITER}" + +const val UNIT = "${KOTLIN_BUILTIN_TYPE_PREFIX}Unit" +const val BYTE = "${KOTLIN_BUILTIN_TYPE_PREFIX}Byte" +const val SHORT = "${KOTLIN_BUILTIN_TYPE_PREFIX}Short" +const val INT = "${KOTLIN_BUILTIN_TYPE_PREFIX}Int" +const val LONG = "${KOTLIN_BUILTIN_TYPE_PREFIX}Long" +const val BOOLEAN = "${KOTLIN_BUILTIN_TYPE_PREFIX}Boolean" +const val DOUBLE = "${KOTLIN_BUILTIN_TYPE_PREFIX}Double" +const val FLOAT = "${KOTLIN_BUILTIN_TYPE_PREFIX}Float" diff --git a/native/swift/sir/src/org/jetbrains/kotlin/sir/constants/NumericTypes.kt b/native/swift/sir/src/org/jetbrains/kotlin/sir/constants/NumericTypes.kt deleted file mode 100644 index 2567cbf885a..00000000000 --- a/native/swift/sir/src/org/jetbrains/kotlin/sir/constants/NumericTypes.kt +++ /dev/null @@ -1,18 +0,0 @@ -/* - * 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.constants - -private const val KOTLIN_PACKAGE = "kotlin" -private const val DELIMITER = "/" -private const val KOTLIN_NUMERIC_TYPE_PREFIX = "${KOTLIN_PACKAGE}${DELIMITER}" - -const val BYTE = "${KOTLIN_NUMERIC_TYPE_PREFIX}Byte" -const val SHORT = "${KOTLIN_NUMERIC_TYPE_PREFIX}Short" -const val INT = "${KOTLIN_NUMERIC_TYPE_PREFIX}Int" -const val LONG = "${KOTLIN_NUMERIC_TYPE_PREFIX}Long" -const val BOOLEAN = "${KOTLIN_NUMERIC_TYPE_PREFIX}Boolean" -const val DOUBLE = "${KOTLIN_NUMERIC_TYPE_PREFIX}Double" -const val FLOAT = "${KOTLIN_NUMERIC_TYPE_PREFIX}Float" diff --git a/native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirExtensions.kt b/native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirExtensions.kt new file mode 100644 index 00000000000..23565b94fee --- /dev/null +++ b/native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirExtensions.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2024 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.* + +val SirNativeCallable.allParameters: List + get() = when (this) { + is SirFunction -> this.parameters + is SirSetter -> listOf(SirParameter(parameterName = parameterName, type = this.valueType)) + is SirGetter -> listOf() + } + +val SirNativeCallable.returnType: SirType + get() = when (this) { + is SirFunction -> this.returnType + is SirGetter -> this.valueType + is SirSetter -> SirNominalType(SirSwiftModule.void) + } + +val SirAccessor.valueType: SirType + get() = this.parent.let { + when (it) { + is SirVariable -> it.type + else -> error("Invalid accessor parent $parent") + } + } + +val SirVariable.accessors: List + get() = listOfNotNull( + getter, + setter, + ) + +val SirParameter.name: String? get() = parameterName ?: argumentName + +val SirType.isVoid: Boolean get() = this is SirNominalType && this.type == SirSwiftModule.void \ No newline at end of file diff --git a/native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirSwiftModule.kt b/native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirSwiftModule.kt index a7839f53a05..adcfacbe0a3 100644 --- a/native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirSwiftModule.kt +++ b/native/swift/sir/src/org/jetbrains/kotlin/sir/util/SirSwiftModule.kt @@ -20,6 +20,8 @@ object SirSwiftModule : SirModule() { override val name: String get() = "Swift" override val declarations: List by lazy { listOf( + void, + bool, int8, @@ -52,6 +54,12 @@ object SirSwiftModule : SirModule() { val double = primitive("Double") val float = primitive("Float") + val void = buildStruct { + origin = SirOrigin.ExternallyDefined(name = "Swift.Void") + visibility = SirVisibility.PUBLIC + name = "Void" + }.also { it.parent = SirSwiftModule } + override fun acceptChildren(visitor: SirVisitor, data: D) { declarations.forEach { it.accept(visitor, data) } } diff --git a/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/BuilderConfigurator.kt b/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/BuilderConfigurator.kt index c92eeb4f245..db9c1d3e391 100644 --- a/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/BuilderConfigurator.kt +++ b/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/BuilderConfigurator.kt @@ -22,5 +22,9 @@ class BuilderConfigurator(elements: List) : AbstractSwiftIrTreeBuilderC configureFieldInAllLeafBuilders("visibility") { default(it, "SirVisibility.PUBLIC") } + + builder(setter) { + default("parameterName", "\"newValue\"") + } } } diff --git a/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/SwiftIrTree.kt b/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/SwiftIrTree.kt index 43e3da239d9..51ad90d334b 100644 --- a/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/SwiftIrTree.kt +++ b/native/swift/sir/tree-generator/src/org/jetbrains/kotlin/sir/tree/generator/SwiftIrTree.kt @@ -78,9 +78,15 @@ object SwiftIrTree : AbstractSwiftIrTreeBuilder() { parent(declaration) } + // Denotes "actual" callable node. (I.e. SirCallable & !SIRForeignDeclaration) + // TODO: remove along with foreign declaration (KT-65335); replace usages with just SIRCallable + val nativeCallable by sealedElement { + parent(callable) + } + val function by element { customParentInVisitor = callable - parent(callable) + parent(nativeCallable) +field("isStatic", boolean) // todo: KT-65046 Method|function distinction in SIR +field("name", string) @@ -98,4 +104,42 @@ object SwiftIrTree : AbstractSwiftIrTreeBuilder() { visitorParameterName = "function" } + + val accessor by sealedElement { + customParentInVisitor = callable + parent(nativeCallable) + + +field("body", functionBodyType, nullable = true, mutable = true) + } + + val getter by element { + parent(accessor) + } + + val setter by element { + parent(accessor) + + +field("parameterName", string, initializer = { }) + } + + val variable by element { + customParentInVisitor = declaration + parent(declaration) + parent(declarationParent) + + +field("name", string) + +field("type", typeType) + + +field("getter", getter) + +field("setter", setter, nullable = true) + + +field("isStatic", boolean) // todo: KT-65046 Method|function distinction in SIR + } + + val foreignVariable by element { + customParentInVisitor = declaration + parent(foreignDeclaration) + + visitorParameterName = "variable" + } } diff --git a/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/builders/buildFunctionBridges.kt b/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/builders/buildFunctionBridges.kt index cb784e1c449..e71f9bf38d5 100644 --- a/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/builders/buildFunctionBridges.kt +++ b/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/builders/buildFunctionBridges.kt @@ -5,8 +5,14 @@ package org.jetbrains.kotlin.swiftexport.standalone.builders +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.sir.SirElement import org.jetbrains.kotlin.sir.SirFunction +import org.jetbrains.kotlin.sir.SirVariable +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 @@ -35,11 +41,8 @@ private object BridgeGenerationPass : SirPass "get" + is SirSetter -> "set" +} + +private val List.forBridge: List get() = if (this.count() == 1) { + listOf("__root__", this.first()) // todo: should be changed with correct mangling KT-64970 +} else { + this +} \ No newline at end of file diff --git a/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/transformation/toSwift.kt b/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/transformation/toSwift.kt index ae7f1ca5baa..79e949b8841 100644 --- a/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/transformation/toSwift.kt +++ b/native/swift/swift-export-standalone/src/org/jetbrains/kotlin/swiftexport/standalone/transformation/toSwift.kt @@ -13,7 +13,7 @@ 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.ForeignIntoSwiftFunctionTranslationPass +import org.jetbrains.sir.passes.translation.ForeignTranslationPass internal fun SirModule.transformToSwift(): SirModule { return SirPassesConfiguration.passes.fold(this) { module, pass -> @@ -24,7 +24,7 @@ internal fun SirModule.transformToSwift(): SirModule { private object SirPassesConfiguration { val passes: List = listOf( SirInflatePackagesPass(), - WholeModuleTranslationByElementPass(ForeignIntoSwiftFunctionTranslationPass()), + WholeModuleTranslationByElementPass(ForeignTranslationPass()), ) class WholeModuleTranslationByElementPass( diff --git a/native/swift/swift-export-standalone/testData/variables/golden_result/result.h b/native/swift/swift-export-standalone/testData/variables/golden_result/result.h new file mode 100644 index 00000000000..90ed2a56c21 --- /dev/null +++ b/native/swift/swift-export-standalone/testData/variables/golden_result/result.h @@ -0,0 +1,12 @@ +#include + +int32_t namespace_main_foo_get(); + +int32_t namespace_main_bar_get(); + +void namespace_main_bar_set(int32_t newValue); + +int32_t namespace_main_foobar(int32_t param); + +int32_t __root___baz(); + diff --git a/native/swift/swift-export-standalone/testData/variables/golden_result/result.kt b/native/swift/swift-export-standalone/testData/variables/golden_result/result.kt new file mode 100644 index 00000000000..904b74ac19e --- /dev/null +++ b/native/swift/swift-export-standalone/testData/variables/golden_result/result.kt @@ -0,0 +1,32 @@ +import kotlin.native.internal.ExportedBridge + +@ExportedBridge("namespace_main_foo_get") +public fun namespace_main_foo_get(): Int { + val result = namespace.main.foo() + return result +} + +@ExportedBridge("namespace_main_bar_get") +public fun namespace_main_bar_get(): Int { + val result = namespace.main.bar() + return result +} + +@ExportedBridge("namespace_main_bar_set") +public fun namespace_main_bar_set(newValue: Int): Unit { + val result = namespace.main.bar(newValue) + return result +} + +@ExportedBridge("namespace_main_foobar") +public fun namespace_main_foobar(param: Int): Int { + val result = namespace.main.foobar(param) + return result +} + +@ExportedBridge("__root___baz") +public fun __root___baz(): Int { + val result = baz() + return result +} + diff --git a/native/swift/swift-export-standalone/testData/variables/golden_result/result.swift b/native/swift/swift-export-standalone/testData/variables/golden_result/result.swift new file mode 100644 index 00000000000..3761f5228f7 --- /dev/null +++ b/native/swift/swift-export-standalone/testData/variables/golden_result/result.swift @@ -0,0 +1,26 @@ +enum namespace { + enum main { + public static var foo: Swift.Int32 { + get { + return namespace_main_foo_get() + } + } + public static var bar: Swift.Int32 { + get { + return namespace_main_bar_get() + } + set { + namespace_main_bar_set(newValue) + } + } + public static func foobar( + param: Swift.Int32 + ) -> Swift.Int32 { + return namespace_main_foobar(param) + } + } +} + +public func baz() -> Swift.Int32 { + return __root___baz() +} diff --git a/native/swift/swift-export-standalone/testData/variables/input_root/main.kt b/native/swift/swift-export-standalone/testData/variables/input_root/main.kt new file mode 100644 index 00000000000..bba55fd4bfe --- /dev/null +++ b/native/swift/swift-export-standalone/testData/variables/input_root/main.kt @@ -0,0 +1,9 @@ +package namespace.main + +import namespace.* + +val foo: Int get() = 10 + +var bar: Int = 20 + +fun foobar(param: Int): Int = foo + bar + param + baz diff --git a/native/swift/swift-export-standalone/testData/variables/input_root/no_package.kt b/native/swift/swift-export-standalone/testData/variables/input_root/no_package.kt new file mode 100644 index 00000000000..011cbb06a8d --- /dev/null +++ b/native/swift/swift-export-standalone/testData/variables/input_root/no_package.kt @@ -0,0 +1 @@ +fun baz: Int = 30 \ No newline at end of file diff --git a/native/swift/swift-export-standalone/tests-gen/org/jetbrains/kotlin/swiftexport/standalone/SwiftExportRunnerTest.java b/native/swift/swift-export-standalone/tests-gen/org/jetbrains/kotlin/swiftexport/standalone/SwiftExportRunnerTest.java index dc441651cb8..f4efb08fabf 100644 --- a/native/swift/swift-export-standalone/tests-gen/org/jetbrains/kotlin/swiftexport/standalone/SwiftExportRunnerTest.java +++ b/native/swift/swift-export-standalone/tests-gen/org/jetbrains/kotlin/swiftexport/standalone/SwiftExportRunnerTest.java @@ -35,4 +35,10 @@ public class SwiftExportRunnerTest extends AbstractSwiftRunnerTest { public void testSimple() throws Exception { runTest("native/swift/swift-export-standalone/testData/simple/"); } + + @Test + @TestMetadata("variables") + public void testVariables() throws Exception { + runTest("native/swift/swift-export-standalone/testData/variables/"); + } }