diff --git a/SKIE/acceptance-tests b/SKIE/acceptance-tests index 5d11cd6ab..60ecd325b 160000 --- a/SKIE/acceptance-tests +++ b/SKIE/acceptance-tests @@ -1 +1 @@ -Subproject commit 5d11cd6ab04f508357535a0133d3ea9a933a86c3 +Subproject commit 60ecd325b63d4d805d77a892093a7f28a178d650 diff --git a/SKIE/common/configuration/annotations/src/commonMain/kotlin/co/touchlab/skie/configuration/annotations/SkieVisibility.kt b/SKIE/common/configuration/annotations/src/commonMain/kotlin/co/touchlab/skie/configuration/annotations/SkieVisibility.kt index 41b89a631..a30172497 100644 --- a/SKIE/common/configuration/annotations/src/commonMain/kotlin/co/touchlab/skie/configuration/annotations/SkieVisibility.kt +++ b/SKIE/common/configuration/annotations/src/commonMain/kotlin/co/touchlab/skie/configuration/annotations/SkieVisibility.kt @@ -54,13 +54,15 @@ annotation class SkieVisibility { annotation class InternalAndReplaced /** - * The declaration will either be Public or Internal. + * The callable declaration will either be Public or Internal. * Which one is chosen depends on whether the declaration is automatically wrapped by SKIE or not. * * For example, a top-level function originally exposed as `FileKt.functionName` will be internal, if SKIE generated the global function wrapper for it. + * + * Note that this setting will only affect callable declarations (functions, properties, constructors) - not classes. */ @Retention(AnnotationRetention.BINARY) - @Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.CONSTRUCTOR) + @Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.CONSTRUCTOR) annotation class InternalIfWrapped /** diff --git a/SKIE/common/configuration/declaration/src/commonMain/kotlin/co/touchlab/skie/configuration/SkieVisibility.kt b/SKIE/common/configuration/declaration/src/commonMain/kotlin/co/touchlab/skie/configuration/SkieVisibility.kt index ca8cc8c4f..8daf1fc93 100644 --- a/SKIE/common/configuration/declaration/src/commonMain/kotlin/co/touchlab/skie/configuration/SkieVisibility.kt +++ b/SKIE/common/configuration/declaration/src/commonMain/kotlin/co/touchlab/skie/configuration/SkieVisibility.kt @@ -45,10 +45,12 @@ object SkieVisibility : ConfigurationKey.Enum() + .forEach { + updateVisibility(it) + } + } + + private fun updateVisibility(sirCallableDeclaration: SirCallableDeclaration) { + when (sirCallableDeclaration) { + is SirConstructor -> updateVisibility(sirCallableDeclaration) + is SirSimpleFunction -> updateVisibility(sirCallableDeclaration) + is SirProperty -> updateVisibility(sirCallableDeclaration) + } + } + + private fun updateVisibility(sirConstructor: SirConstructor) { + val allConstraints = listOfNotNull( + sirConstructor.visibility, + sirConstructor.parent.classDeclaration.visibility, + ) + + sirConstructor.valueParameters.map { it.type.visibilityConstraint } + + sirConstructor.visibility = allConstraints.minimumVisibility() + } + + private fun updateVisibility(sirFunction: SirSimpleFunction) { + val allConstraints = listOfNotNull( + sirFunction.visibility, + sirFunction.memberOwner?.visibility, + sirFunction.returnType.visibilityConstraint, + ) + + sirFunction.valueParameters.map { it.type.visibilityConstraint } + + sirFunction.typeParameters.flatMap { typeParameter -> typeParameter.bounds.map { it.visibilityConstraint } } + + sirFunction.visibility = allConstraints.minimumVisibility() + } + + private fun updateVisibility(sirProperty: SirProperty) { + val allConstraints = listOfNotNull( + sirProperty.visibility, + sirProperty.memberOwner?.visibility, + sirProperty.type.visibilityConstraint, + ) + + sirProperty.visibility = allConstraints.minimumVisibility() + } +} diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/phases/sir/type/PropagateSirVisibilityToClassesPhase.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/phases/sir/type/PropagateSirVisibilityToClassesPhase.kt new file mode 100644 index 000000000..6b105310e --- /dev/null +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/phases/sir/type/PropagateSirVisibilityToClassesPhase.kt @@ -0,0 +1,101 @@ +package co.touchlab.skie.phases.sir.type + +import co.touchlab.skie.kir.element.KirClass +import co.touchlab.skie.phases.SirPhase +import co.touchlab.skie.sir.element.SirClass +import co.touchlab.skie.sir.element.SirModule +import co.touchlab.skie.sir.element.SirVisibility +import co.touchlab.skie.sir.element.coerceAtMostInSwift +import co.touchlab.skie.sir.element.kirClassOrNull +import co.touchlab.skie.sir.element.superClassType +import co.touchlab.skie.sir.element.superProtocolTypes +import co.touchlab.skie.sir.type.SirType + +object PropagateSirVisibilityToClassesPhase : SirPhase { + + context(SirPhase.Context) + override suspend fun execute() { + val updaterProvider = TypeVisibilityUpdaterProvider(sirProvider.allLocalClasses) + + updaterProvider.allTypeVisibilityUpdaters.forEach { + it.propagateVisibility() + } + } + + private class TypeVisibilityUpdaterProvider( + sirClasses: List, + ) { + + private val cache = sirClasses.associateWith { ClassVisibilityUpdater(it) } + + init { + cache.values.forEach { + it.initialize(this) + } + } + + val allTypeVisibilityUpdaters: Collection = cache.values + + operator fun get(sirClass: SirClass): ClassVisibilityUpdater = + cache.getValue(sirClass) + } + + private class ClassVisibilityUpdater(private val sirClass: SirClass) { + + private val directDependents = mutableListOf() + + fun initialize(typeVisibilityUpdaterProvider: TypeVisibilityUpdaterProvider) { + getDependencies() + .filter { it.module is SirModule.Skie || it.module is SirModule.Kotlin } + .forEach { + typeVisibilityUpdaterProvider[it].registerDirectDependentDeclaration(this) + } + } + + private fun registerDirectDependentDeclaration(typeVisibilityUpdater: ClassVisibilityUpdater) { + directDependents.add(typeVisibilityUpdater) + } + + fun propagateVisibility() { + directDependents.forEach { + it.coerceVisibilityAtMost(sirClass.visibility) + } + } + + private fun coerceVisibilityAtMost(limit: SirVisibility) { + val newVisibility = sirClass.visibility.coerceAtMostInSwift(limit) + + if (sirClass.visibility == newVisibility) { + return + } + + sirClass.visibility = newVisibility + + propagateVisibility() + } + + private fun getDependencies(): Set = + setOfNotNull( + sirClass.namespace?.classDeclaration, + (sirClass.kirClassOrNull?.parent as? KirClass)?.originalSirClass, + ) + + sirClass.typeParameters.flatMap { typeParameter -> typeParameter.bounds.flatMap { it.referencedClasses } }.toSet() + + getSuperTypesDependencies() + + private fun getSuperTypesDependencies(): List = + if (sirClass.kind != SirClass.Kind.Protocol) { + val classSuperType = listOfNotNull(sirClass.superClassType) + val protocolSuperTypes = sirClass.superProtocolTypes + + val consideredTypes = protocolSuperTypes.flatMap { it.typeArguments } + classSuperType + + consideredTypes.flatMap { it.referencedClasses } + } else { + sirClass.superTypes.flatMap { it.referencedClasses } + } + + private val SirType.referencedClasses: List + get() = this.normalizedEvaluatedType().referencedTypeDeclarations + .map { it as? SirClass ?: error("Normalized type should only reference SirClasses: $it") } + } +} diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/phases/sir/type/PropagateSirVisibilityToTypeAliasesPhase.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/phases/sir/type/PropagateSirVisibilityToTypeAliasesPhase.kt new file mode 100644 index 000000000..d66f6b1f8 --- /dev/null +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/phases/sir/type/PropagateSirVisibilityToTypeAliasesPhase.kt @@ -0,0 +1,27 @@ +package co.touchlab.skie.phases.sir.type + +import co.touchlab.skie.phases.SirPhase +import co.touchlab.skie.sir.element.SirTypeAlias +import co.touchlab.skie.sir.element.minimumVisibility +import co.touchlab.skie.sir.type.visibilityConstraint + +object PropagateSirVisibilityToTypeAliasesPhase : SirPhase { + + context(SirPhase.Context) + override suspend fun execute() { + sirProvider.allLocalTypeAliases.forEach { + updateVisibility(it) + } + } + + private fun updateVisibility(sirTypeAlias: SirTypeAlias) { + val allConstraints = listOfNotNull( + sirTypeAlias.visibility, + sirTypeAlias.namespace?.classDeclaration?.visibility, + ) + + sirTypeAlias.type.visibilityConstraint + + sirTypeAlias.typeParameters.flatMap { typeParameter -> typeParameter.bounds.map { it.visibilityConstraint } } + + sirTypeAlias.visibility = allConstraints.minimumVisibility() + } +} diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/SirProvider.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/SirProvider.kt index db176a977..e7c859eb9 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/SirProvider.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/SirProvider.kt @@ -17,8 +17,8 @@ import co.touchlab.skie.sir.element.SirFile import co.touchlab.skie.sir.element.SirModule import co.touchlab.skie.sir.element.SirSimpleFunction import co.touchlab.skie.sir.element.SirTopLevelDeclarationParent +import co.touchlab.skie.sir.element.SirTypeAlias import co.touchlab.skie.sir.element.SirTypeDeclaration -import co.touchlab.skie.sir.element.SirVisibility import co.touchlab.skie.sir.element.getAllDeclarationsRecursively import co.touchlab.skie.util.directory.FrameworkLayout import co.touchlab.skie.util.directory.SkieBuildDirectory @@ -61,6 +61,9 @@ class SirProvider( val allLocalClasses: List get() = allLocalTypeDeclarations.filterIsInstance() + val allLocalTypeAliases: List + get() = allLocalTypeDeclarations.filterIsInstance() + val allLocalEnums: List get() = allLocalClasses.filter { it.kind == SirClass.Kind.Enum } diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirClass.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirClass.kt index e8b6871fa..664cb5429 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirClass.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirClass.kt @@ -144,6 +144,10 @@ val SirClass.superClassType: SirDeclaredSirType? get() = superTypes.map { it.resolveAsSirClassType() } .firstOrNull { (it?.declaration as? SirClass)?.kind == SirClass.Kind.Class } +val SirClass.superProtocolTypes: List + get() = superTypes.mapNotNull { it.resolveAsSirClassType() } + .filter { (it.declaration as? SirClass)?.kind == SirClass.Kind.Protocol } + val SirClass.superClass: SirClass? get() = superClassType?.declaration as? SirClass diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirVisibility.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirVisibility.kt index 74e418b91..ddb285bb9 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirVisibility.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/element/SirVisibility.kt @@ -3,14 +3,27 @@ package co.touchlab.skie.sir.element enum class SirVisibility { Public, + /** Applicable only to Obj-C code, Swift code will use Public instead. */ PublicButHidden, Internal, Private, + /** Applicable only to generated code, existing code cannot be removed and will be marked as private instead. */ Removed, } +fun SirVisibility.coerceAtMostInSwift(limit: SirVisibility): SirVisibility = + when (limit) { + SirVisibility.Public, SirVisibility.PublicButHidden -> this + SirVisibility.Internal -> if (this.toSwiftVisibility() == SirVisibility.Public) SirVisibility.Internal else this + SirVisibility.Private -> if (this == SirVisibility.Removed) SirVisibility.Removed else SirVisibility.Private + SirVisibility.Removed -> SirVisibility.Removed + } + +fun List.minimumVisibility(): SirVisibility = + this.fold(SirVisibility.Public) { acc, visibility -> acc.coerceAtMostInSwift(visibility) } + val SirVisibility.isAccessibleFromOtherModules: Boolean get() = when (toSwiftVisibility()) { SirVisibility.Public -> true diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/EvaluatedSirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/EvaluatedSirType.kt index decfe3a0c..96a2eaa5e 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/EvaluatedSirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/EvaluatedSirType.kt @@ -1,5 +1,7 @@ package co.touchlab.skie.sir.type +import co.touchlab.skie.sir.element.SirTypeDeclaration +import co.touchlab.skie.sir.element.SirVisibility import io.outfoxx.swiftpoet.TypeName sealed interface EvaluatedSirType { @@ -12,16 +14,24 @@ sealed interface EvaluatedSirType { // Uses either FqName or internal name depending on context. Used for generating code. val swiftPoetTypeName: TypeName + val visibilityConstraint: SirVisibility + + val referencedTypeDeclarations: Set + class Eager( override val type: SirType, override val canonicalName: String, override val swiftPoetTypeName: TypeName, + override val visibilityConstraint: SirVisibility, + override val referencedTypeDeclarations: Set, ) : EvaluatedSirType class Lazy( typeProvider: kotlin.Lazy, canonicalNameProvider: kotlin.Lazy, swiftPoetTypeNameProvider: kotlin.Lazy, + lowestVisibility: kotlin.Lazy, + referencedTypeDeclarationsProvider: kotlin.Lazy>, ) : EvaluatedSirType { override val type: SirType by typeProvider @@ -29,5 +39,9 @@ sealed interface EvaluatedSirType { override val canonicalName: String by canonicalNameProvider override val swiftPoetTypeName: TypeName by swiftPoetTypeNameProvider + + override val visibilityConstraint: SirVisibility by lowestVisibility + + override val referencedTypeDeclarations: Set by referencedTypeDeclarationsProvider } } diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/LambdaSirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/LambdaSirType.kt index 12444bf27..1ac8985ec 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/LambdaSirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/LambdaSirType.kt @@ -1,6 +1,7 @@ package co.touchlab.skie.sir.type import co.touchlab.skie.sir.element.SirTypeParameter +import co.touchlab.skie.sir.element.minimumVisibility import io.outfoxx.swiftpoet.AttributeSpec import io.outfoxx.swiftpoet.FunctionTypeName import io.outfoxx.swiftpoet.ParameterSpec @@ -37,6 +38,12 @@ data class LambdaSirType( }, ) }, + lowestVisibility = lazy { + (evaluatedValueParameterTypes.value.map { it.visibilityConstraint } + evaluatedReturnType.value.visibilityConstraint).minimumVisibility() + }, + referencedTypeDeclarationsProvider = lazy { + (evaluatedValueParameterTypes.value.flatMap { it.referencedTypeDeclarations } + evaluatedReturnType.value.referencedTypeDeclarations).toSet() + }, ) } diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/NullableSirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/NullableSirType.kt index 5b5ccb161..294b3aa2b 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/NullableSirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/NullableSirType.kt @@ -19,6 +19,8 @@ data class NullableSirType( typeProvider = evaluatedType.map { copy(type = it.type) }, canonicalNameProvider = evaluatedType.map { it.canonicalName + "?" }, swiftPoetTypeNameProvider = evaluatedType.map { it.swiftPoetTypeName.makeOptional() }, + lowestVisibility = evaluatedType.map { it.visibilityConstraint }, + referencedTypeDeclarationsProvider = evaluatedType.map { it.referencedTypeDeclarations }, ) } diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirDeclaredSirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirDeclaredSirType.kt index b223f5518..aa634bd83 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirDeclaredSirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirDeclaredSirType.kt @@ -6,6 +6,8 @@ import co.touchlab.skie.sir.element.SirModule import co.touchlab.skie.sir.element.SirTypeAlias import co.touchlab.skie.sir.element.SirTypeDeclaration import co.touchlab.skie.sir.element.SirTypeParameter +import co.touchlab.skie.sir.element.SirVisibility +import co.touchlab.skie.sir.element.minimumVisibility import co.touchlab.skie.sir.element.module import co.touchlab.skie.sir.element.resolveAsKirClass import io.outfoxx.swiftpoet.DeclaredTypeName @@ -57,6 +59,20 @@ data class SirDeclaredSirType( evaluatedType.value.evaluate().swiftPoetTypeName } }, + lowestVisibility = lazy { + if (evaluatedType.value is SirDeclaredSirType) { + getVisibilityConstraint(evaluatedTypeArguments.value) + } else { + evaluatedType.value.evaluate().visibilityConstraint + } + }, + referencedTypeDeclarationsProvider = lazy { + if (evaluatedType.value is SirDeclaredSirType) { + getReferencedTypeDeclarations(evaluatedTypeArguments.value) + } else { + setOf(declaration) + } + }, ) } @@ -109,6 +125,12 @@ data class SirDeclaredSirType( } } + private fun getVisibilityConstraint(evaluatedTypeArguments: List): SirVisibility = + (evaluatedTypeArguments.map { it.visibilityConstraint } + declaration.visibility).minimumVisibility() + + private fun getReferencedTypeDeclarations(evaluatedTypeArguments: List): Set = + evaluatedTypeArguments.flatMap { it.referencedTypeDeclarations }.toSet() + declaration + private fun SirFqName.toSwiftPoetName(): DeclaredTypeName = parent?.toSwiftPoetName()?.nestedType(simpleName) ?: DeclaredTypeName.qualifiedTypeName(module.name + "." + simpleName) diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirType.kt index 7cfe0804a..052d5c564 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SirType.kt @@ -1,6 +1,7 @@ package co.touchlab.skie.sir.type import co.touchlab.skie.sir.element.SirTypeParameter +import co.touchlab.skie.sir.element.SirVisibility sealed class SirType { @@ -18,8 +19,11 @@ sealed class SirType { */ abstract fun inlineTypeAliases(): SirType + fun normalizedEvaluatedType(): EvaluatedSirType = + inlineTypeAliases().evaluate() + fun normalize(): SirType = - inlineTypeAliases().evaluate().type + normalizedEvaluatedType().type open fun asHashableType(): SirType? = null @@ -40,3 +44,5 @@ fun SirType.toNullable(condition: Boolean = true): SirType = this } +val SirType.visibilityConstraint: SirVisibility + get() = this.normalizedEvaluatedType().visibilityConstraint diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SkieErrorSirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SkieErrorSirType.kt index 8c8abb9f1..ec3a09b42 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SkieErrorSirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SkieErrorSirType.kt @@ -1,6 +1,7 @@ package co.touchlab.skie.sir.type import co.touchlab.skie.sir.element.SirTypeParameter +import co.touchlab.skie.sir.element.SirVisibility import co.touchlab.skie.util.swift.qualifiedLocalTypeName import io.outfoxx.swiftpoet.DeclaredTypeName @@ -21,6 +22,8 @@ sealed class SkieErrorSirType( type = this, canonicalName = objCName, swiftPoetTypeName = DeclaredTypeName.qualifiedLocalTypeName(objCName), + visibilityConstraint = SirVisibility.Public, + referencedTypeDeclarations = emptySet(), ) } diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SpecialSirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SpecialSirType.kt index 8ecb1034e..b61db6538 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SpecialSirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/SpecialSirType.kt @@ -1,6 +1,7 @@ package co.touchlab.skie.sir.type import co.touchlab.skie.sir.element.SirTypeParameter +import co.touchlab.skie.sir.element.SirVisibility import io.outfoxx.swiftpoet.AnyTypeName import io.outfoxx.swiftpoet.ProtocolTypeName import io.outfoxx.swiftpoet.SelfTypeName @@ -19,6 +20,8 @@ sealed class SpecialSirType( type = this, canonicalName = typeName.name, swiftPoetTypeName = typeName, + visibilityConstraint = SirVisibility.Public, + referencedTypeDeclarations = emptySet(), ) } diff --git a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/TypeParameterUsageSirType.kt b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/TypeParameterUsageSirType.kt index 816c5f428..8bb77f61a 100644 --- a/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/TypeParameterUsageSirType.kt +++ b/SKIE/kotlin-compiler/core/src/commonMain/kotlin/co/touchlab/skie/sir/type/TypeParameterUsageSirType.kt @@ -1,6 +1,7 @@ package co.touchlab.skie.sir.type import co.touchlab.skie.sir.element.SirTypeParameter +import co.touchlab.skie.sir.element.SirVisibility import co.touchlab.skie.util.map import io.outfoxx.swiftpoet.TypeVariableName @@ -25,6 +26,8 @@ data class TypeParameterUsageSirType( swiftPoetTypeNameProvider = evaluatedParentScope.map { it?.let { TypeVariableName(it.swiftPoetTypeName.name + "." + typeParameter.name) } ?: TypeVariableName(typeParameter.name) }, + lowestVisibility = lazy { SirVisibility.Public }, + referencedTypeDeclarationsProvider = lazy { emptySet() }, ) } diff --git a/SKIE/kotlin-compiler/linker-plugin/src/kgp_common/kotlin/co/touchlab/skie/phases/LinkerPhaseScheduler.kt b/SKIE/kotlin-compiler/linker-plugin/src/kgp_common/kotlin/co/touchlab/skie/phases/LinkerPhaseScheduler.kt index e0b60b047..dc6b0dfc4 100644 --- a/SKIE/kotlin-compiler/linker-plugin/src/kgp_common/kotlin/co/touchlab/skie/phases/LinkerPhaseScheduler.kt +++ b/SKIE/kotlin-compiler/linker-plugin/src/kgp_common/kotlin/co/touchlab/skie/phases/LinkerPhaseScheduler.kt @@ -64,11 +64,12 @@ import co.touchlab.skie.phases.other.VerifyNoBitcodeEmbeddingPhase import co.touchlab.skie.phases.runtime.ConfigureStableNameTypeAliasesForKotlinRuntimePhase import co.touchlab.skie.phases.runtime.KotlinRuntimeHidingPhase import co.touchlab.skie.phases.runtime.SwiftRuntimeGenerator -import co.touchlab.skie.phases.sir.CommitSirIsReplacedPhase +import co.touchlab.skie.phases.sir.CommitSirIsReplacedPropertyPhase import co.touchlab.skie.phases.sir.member.CreateAsyncSirFunctionsPhase import co.touchlab.skie.phases.sir.member.CreateSirMembersPhase import co.touchlab.skie.phases.sir.member.InitializeSirMembersCachePhase import co.touchlab.skie.phases.sir.member.InitializeSirOverridesPhase +import co.touchlab.skie.phases.sir.member.PropagateSirVisibilityToMembersPhase import co.touchlab.skie.phases.sir.member.StripKonanCallableDeclarationManglingPhase import co.touchlab.skie.phases.sir.type.CreateExternalSirTypesPhase import co.touchlab.skie.phases.sir.type.CreateKotlinSirExtensionsPhase @@ -76,6 +77,8 @@ import co.touchlab.skie.phases.sir.type.CreateKotlinSirTypesPhase import co.touchlab.skie.phases.sir.type.CreateStableNameTypeAliasesPhase import co.touchlab.skie.phases.sir.type.FixNamesOfInaccessibleNestedClassesPhase import co.touchlab.skie.phases.sir.type.InitializeSirSuperTypesPhase +import co.touchlab.skie.phases.sir.type.PropagateSirVisibilityToClassesPhase +import co.touchlab.skie.phases.sir.type.PropagateSirVisibilityToTypeAliasesPhase import co.touchlab.skie.phases.swift.CompileSwiftPhase import co.touchlab.skie.phases.swift.ConvertSirIrFilesToSourceFilesPhase import co.touchlab.skie.phases.swift.ConvertSirSourceFilesToCompilableFilesPhase @@ -177,7 +180,10 @@ class LinkerPhaseScheduler : SkiePhaseScheduler { InitializeSirOverridesPhase, InitializeSirMembersCachePhase, StripKonanCallableDeclarationManglingPhase, - CommitSirIsReplacedPhase, + CommitSirIsReplacedPropertyPhase, + PropagateSirVisibilityToClassesPhase, + PropagateSirVisibilityToTypeAliasesPhase, + PropagateSirVisibilityToMembersPhase, FixNamesOfInaccessibleNestedClassesPhase,