[K/N] Add support for custom entry points filter to ObjCExport

A new `-Xbinary=objcExportEntryPointsPath` flag is added, which
allows providing a file with custom ObjC entry points.

Each entry point matches the following pattern: `<kind> <pattern>`,
where:
* `<kind>` is one of: `function`, `property` or `callable`,
* `<pattern>` is a fully qualified name with potential wildcard.

Examples:

```
// Explicit pattern matching a given function (with all overloads).
function kotlin.collections.Collection.contains

// Explicit pattern matching a given property.
function kotlin.collections.Collection.size

// Wildcard pattern matching any function or property in a given class.
callable kotlin.Throwable.*
```

At this moment, it's only possible to provide an explicit list of
functions / properties. The mechanism could be extended to provide
explicit classes, by adding a new `class` kind.

This feature is experimental.

^KT-69789

Author: micapolos-google

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BinaryOptions.kt

@@ -39,6 +39,8 @@ object BinaryOptions : BinaryOptionRegistry() {
 
     val objcExportErrorOnNameCollisions by booleanOption()
 
+    val objcExportEntryPointsPath by stringOption()
+
     val gc by option<GC>(shortcut = { it.shortcut })
 
     val gcSchedulerType by option<GCSchedulerType>(hideValue = { it.deprecatedWithReplacement != null })

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt

@@ -9,13 +9,14 @@ import com.google.common.base.StandardSystemProperty
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.linkage.issues.UserVisibleIrModulesSupport
 import org.jetbrains.kotlin.backend.konan.ir.BridgesPolicy
+import org.jetbrains.kotlin.backend.konan.objcexport.ObjCEntryPoints
+import org.jetbrains.kotlin.backend.konan.objcexport.readObjCEntryPoints
 import org.jetbrains.kotlin.backend.konan.serialization.KonanUserVisibleIrModulesSupport
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.IrVerificationMode
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.ir.linkage.partial.partialLinkageConfig
 import org.jetbrains.kotlin.konan.file.File
@@ -230,6 +231,13 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
         configuration.get(BinaryOptions.objcDisposeWithRunLoop) ?: true
     }
 
+    val objcEntryPoints: ObjCEntryPoints by lazy {
+        configuration
+                .get(BinaryOptions.objcExportEntryPointsPath)
+                ?.let { File(it).readObjCEntryPoints() }
+                ?: ObjCEntryPoints.ALL
+    }
+
     val enableSafepointSignposts: Boolean = configuration.get(BinaryOptions.enableSafepointSignposts)?.also {
         if (it && !target.supportsSignposts) {
             configuration.report(CompilerMessageSeverity.STRONG_WARNING, "Signposts are not available on $target. The setting will have no effect.")

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExport.kt

@@ -47,7 +47,11 @@ internal fun produceObjCExportInterface(
     //   and can't do this per-module, e.g. due to global name conflict resolution.
 
     val unitSuspendFunctionExport = config.unitSuspendFunctionObjCExport
-    val mapper = ObjCExportMapper(frontendServices.deprecationResolver, unitSuspendFunctionExport = unitSuspendFunctionExport)
+    val entryPoints = config.objcEntryPoints
+    val mapper = ObjCExportMapper(
+            frontendServices.deprecationResolver,
+            unitSuspendFunctionExport = unitSuspendFunctionExport,
+            entryPoints = entryPoints)
     val moduleDescriptors = listOf(moduleDescriptor) + moduleDescriptor.getExportedDependencies(config)
     val objcGenerics = config.configuration.getBoolean(KonanConfigKeys.OBJC_GENERICS)
     val disableSwiftMemberNameMangling = config.configuration.getBoolean(BinaryOptions.objcExportDisableSwiftMemberNameMangling)

native/objcexport-header-generator/impl/k1/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCEntryPoint.kt

@@ -0,0 +1,97 @@
+/*
+ * 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.backend.konan.objcexport
+
+import org.jetbrains.kotlin.backend.konan.objcexport.ObjCEntryPoint.Kind.*
+import org.jetbrains.kotlin.konan.file.File
+
+/**
+ * An entry point which matches declarations of a given kind and fully-qualified name pattern.
+ *
+ * @property kind a kind of entry point.
+ * @property pattern a pattern which matches fully-qualified declaration name.
+ */
+data class ObjCEntryPoint(val kind: Kind, val pattern: Pattern) {
+    /** Entry point kind. */
+    enum class Kind {
+        /** A function. */
+        FUNCTION,
+
+        /** A property. */
+        PROPERTY,
+
+        /** A callable: function or property. */
+        CALLABLE,
+    }
+
+    /**
+     * A pattern which matches fully-qualified name.
+     *
+     * @property path Fully-qualified name components preceding the final name component.
+     * @property name The last component in a fully-qualified name, which may either be an explicit name or a wildcard.
+     */
+    data class Pattern(val path: List<String>, val name: Name) {
+        /** The last component of a pattern. */
+        sealed class Name {
+            /** Matches explicit name. */
+            data class Explicit(val string: String) : Name()
+
+            /** Matches any name. */
+            data object Wildcard : Name()
+        }
+    }
+}
+
+/** Parent kind in a hierarchy of kinds, or null for root. */
+val ObjCEntryPoint.Kind.parentOrNull: ObjCEntryPoint.Kind?
+    get() =
+        when (this) {
+            FUNCTION -> CALLABLE
+            PROPERTY -> CALLABLE
+            CALLABLE -> null
+        }
+
+/** Reads a list of entry points from this file. */
+fun File.readObjCEntryPointList(): List<ObjCEntryPoint> =
+    readStrings()
+        .asSequence()
+        .map { it.trim() }  // Strip leading / trailing whitespaces
+        .filter { !it.startsWith("//") }  // Strip comment lines
+        .filter { it.isNotBlank() }  // Remove empty lines
+        .map { it.toObjCEntryPoint() }
+        .toList()
+
+/** Convert this string to an entry point kind. */
+private fun String.toObjCEntryPointKind(): ObjCEntryPoint.Kind =
+    when (this) {
+        "function" -> FUNCTION
+        "property" -> PROPERTY
+        "callable" -> CALLABLE
+        else -> throw IllegalArgumentException("invalid kind: $this, should be one of: function, property or callable")
+    }
+
+/** Convert this string to an entry point pattern. */
+private fun String.toObjCEntryPointPattern(): ObjCEntryPoint.Pattern =
+    split('.').let { components ->
+        ObjCEntryPoint.Pattern(
+            components.dropLast(1),
+            components.lastOrNull()
+                .let { it ?: throw IllegalArgumentException("invalid pattern: \"$this\", should be non-empty") }
+                .toObjCEntryPointPatternName())
+    }
+
+/** Convert this string to an entry point pattern name. */
+private fun String.toObjCEntryPointPatternName(): ObjCEntryPoint.Pattern.Name =
+    when (this) {
+        "*" -> ObjCEntryPoint.Pattern.Name.Wildcard
+        else -> ObjCEntryPoint.Pattern.Name.Explicit(this)
+    }
+
+/** Convert this string to an entry point. */
+private fun String.toObjCEntryPoint(): ObjCEntryPoint =
+    split(' ')
+        .also { if (it.size != 2) throw IllegalArgumentException("invalid entry point: \"$this\", should match: \"<kind> <pattern>\"") }
+        .let { ObjCEntryPoint(it[0].toObjCEntryPointKind(), it[1].toObjCEntryPointPattern()) }

native/objcexport-header-generator/impl/k1/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCEntryPoints.kt

@@ -0,0 +1,67 @@
+/*
+ * 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.backend.konan.objcexport
+
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.konan.file.File
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+
+/** A predicate which checks whether the given declaration is entry point, and should be exposed in Objective-C. */
+interface ObjCEntryPoints {
+    fun shouldBeExposed(descriptor: CallableMemberDescriptor) = true
+
+    companion object {
+        val ALL: ObjCEntryPoints = object : ObjCEntryPoints {}
+    }
+}
+
+/**
+ * Reads entry points from this file.
+ */
+fun File.readObjCEntryPoints(): ObjCEntryPoints =
+    readObjCEntryPointList()
+        .toSet()
+        .let { entryPointSet ->
+            object : ObjCEntryPoints {
+                override fun shouldBeExposed(descriptor: CallableMemberDescriptor): Boolean =
+                    descriptor.objCEntryPointKindOrNull
+                        ?.let { objcEntryPointKind -> shouldBeExposed(objcEntryPointKind, descriptor.fqNameSafe) }
+                        ?: false
+
+                private fun shouldBeExposed(kind: ObjCEntryPoint.Kind, fqName: FqName): Boolean =
+                    entryPointSet.contains(ObjCEntryPoint(kind, fqName.toObjCExplicitPattern())) ||
+                        entryPointSet.contains(ObjCEntryPoint(kind, fqName.toObjCWildcardPattern())) ||
+                        kind.parentOrNull?.let { shouldBeExposed(it, fqName) }.let { it ?: false }
+
+                /** A kind which matches this descriptor. */
+                private val DeclarationDescriptor.objCEntryPointKindOrNull: ObjCEntryPoint.Kind?
+                    get() = when (this) {
+                        is FunctionDescriptor -> ObjCEntryPoint.Kind.FUNCTION
+                        is PropertyDescriptor -> ObjCEntryPoint.Kind.PROPERTY
+                        is CallableDescriptor -> ObjCEntryPoint.Kind.CALLABLE
+                        else -> null
+                    }
+
+                /** Convert this fully-qualified name to a pattern path, containing all but last components. */
+                private fun FqName.toObjCPatternPath(): List<String> =
+                    pathSegments().map { it.asString() }
+
+                /** Convert this fully-qualified name to an explicit pattern. */
+                private fun FqName.toObjCExplicitPattern(): ObjCEntryPoint.Pattern =
+                    ObjCEntryPoint.Pattern(
+                        parent().toObjCPatternPath(),
+                        ObjCEntryPoint.Pattern.Name.Explicit(shortName().asString())
+                    )
+
+                /** Convert this fully-qualified name to a wildcard pattern. */
+                private fun FqName.toObjCWildcardPattern(): ObjCEntryPoint.Pattern =
+                    ObjCEntryPoint.Pattern(
+                        parent().toObjCPatternPath(),
+                        ObjCEntryPoint.Pattern.Name.Wildcard
+                    )
+            }
+        }

native/objcexport-header-generator/impl/k1/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExportLazy.kt

@@ -53,6 +53,9 @@ interface ObjCExportLazy {
         val unitSuspendFunctionExport: UnitSuspendFunctionObjCExport
         val ignoreInterfaceMethodCollisions: Boolean
             get() = false
+
+        val entryPoints: ObjCEntryPoints
+            get() = ObjCEntryPoints.ALL
     }
 
     fun generateBase(): List<ObjCTopLevel>
@@ -97,7 +100,12 @@ class ObjCExportLazyImpl(
 
     private val nameTranslator: ObjCExportNameTranslator = ObjCExportNameTranslatorImpl(namerConfiguration)
 
-    private val mapper = ObjCExportMapper(deprecationResolver, local = true, configuration.unitSuspendFunctionExport)
+    private val mapper = ObjCExportMapper(
+        deprecationResolver,
+        local = true,
+        configuration.unitSuspendFunctionExport,
+        configuration.entryPoints,
+    )
 
     private val namer = ObjCExportNamerImpl(namerConfiguration, builtIns, mapper, problemCollector, local = true)
 

native/objcexport-header-generator/impl/k1/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExportMapper.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.backend.konan.descriptors.isArray
 import org.jetbrains.kotlin.backend.konan.descriptors.isInterface
 import org.jetbrains.kotlin.builtins.*
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.objcinterop.isObjCObjectType
 import org.jetbrains.kotlin.name.ClassId
@@ -30,6 +31,7 @@ class ObjCExportMapper(
     internal val deprecationResolver: DeprecationResolver? = null,
     private val local: Boolean = false,
     internal val unitSuspendFunctionExport: UnitSuspendFunctionObjCExport,
+    internal val entryPoints: ObjCEntryPoints = ObjCEntryPoints.ALL,
 ) {
     fun getCustomTypeMapper(descriptor: ClassDescriptor): CustomTypeMapper? = CustomTypeMappers.getMapper(descriptor)
 
@@ -49,7 +51,7 @@ class ObjCExportMapper(
 internal fun isSpecialMapped(descriptor: ClassDescriptor): Boolean {
     // TODO: this method duplicates some of the [ObjCExportTranslatorImpl.mapReferenceType] logic.
     return KotlinBuiltIns.isAny(descriptor) ||
-            descriptor.getAllSuperClassifiers().any { it is ClassDescriptor && CustomTypeMappers.hasMapper(it) }
+        descriptor.getAllSuperClassifiers().any { it is ClassDescriptor && CustomTypeMappers.hasMapper(it) }
 }
 
 /**
@@ -125,25 +127,26 @@ fun ObjCExportMapper.shouldBeExposed(descriptor: CallableMemberDescriptor): Bool
     // because they are useless in Objective-C/Swift.
     isComponentNMethod(descriptor) && descriptor.overriddenDescriptors.isEmpty() -> false
     descriptor.isHiddenFromObjC() -> false
+    !entryPoints.shouldBeExposed(descriptor) -> false
     else -> true
 }
 
+private fun AnnotationDescriptor.hidesFromObjC(): Boolean =
+    annotationClass?.annotations?.any { it.fqName == KonanFqNames.hidesFromObjC } ?: false
+
 private fun CallableMemberDescriptor.isHiddenFromObjC(): Boolean = when {
     // Note: the front-end checker requires all overridden descriptors to be either refined or not refined.
     overriddenDescriptors.isNotEmpty() -> overriddenDescriptors.first().isHiddenFromObjC()
-    else -> annotations.any { annotation ->
-        annotation.annotationClass?.annotations?.any { it.fqName == KonanFqNames.hidesFromObjC } == true
-    }
+    else -> annotations.any(AnnotationDescriptor::hidesFromObjC)
 }
 
 /**
  * Check if the given class or its enclosing declaration is marked as @HiddenFromObjC.
  */
 internal fun ClassDescriptor.isHiddenFromObjC(): Boolean = when {
-    (this.containingDeclaration as? ClassDescriptor)?.isHiddenFromObjC() == true -> true
-    else -> annotations.any { annotation ->
-        annotation.annotationClass?.annotations?.any { it.fqName == KonanFqNames.hidesFromObjC } == true
-    }
+    containingDeclaration.let { it as? ClassDescriptor }?.isHiddenFromObjC() ?: false -> true
+    annotations.any(AnnotationDescriptor::hidesFromObjC) -> true
+    else -> false
 }
 
 internal fun ObjCExportMapper.shouldBeExposed(descriptor: ClassDescriptor): Boolean =
@@ -211,10 +214,15 @@ private fun ObjCExportMapper.isHiddenByDeprecation(descriptor: ClassDescriptor):
 
 // Note: the logic is partially duplicated in ObjCExportLazyImpl.translateClasses.
 internal fun ObjCExportMapper.shouldBeVisible(descriptor: ClassDescriptor): Boolean =
-    descriptor.isEffectivelyPublicApi && when (descriptor.kind) {
-        ClassKind.CLASS, ClassKind.INTERFACE, ClassKind.ENUM_CLASS, ClassKind.OBJECT -> true
-        ClassKind.ENUM_ENTRY, ClassKind.ANNOTATION_CLASS -> false
-    } && !descriptor.isExpect && !descriptor.isInlined() && !isHiddenByDeprecation(descriptor) && !descriptor.isHiddenFromObjC()
+    descriptor.isEffectivelyPublicApi &&
+        when (descriptor.kind) {
+            ClassKind.CLASS, ClassKind.INTERFACE, ClassKind.ENUM_CLASS, ClassKind.OBJECT -> true
+            ClassKind.ENUM_ENTRY, ClassKind.ANNOTATION_CLASS -> false
+        } &&
+        !descriptor.isExpect &&
+        !descriptor.isInlined() &&
+        !isHiddenByDeprecation(descriptor) &&
+        !descriptor.isHiddenFromObjC()
 
 private fun ObjCExportMapper.isBase(descriptor: CallableMemberDescriptor): Boolean =
     descriptor.overriddenDescriptors.all { !shouldBeExposed(it) }
@@ -369,7 +377,7 @@ private fun ObjCExportMapper.bridgeReturnType(
         }
 
         descriptor.containingDeclaration.let { it is ClassDescriptor && KotlinBuiltIns.isAny(it) } &&
-                descriptor.name.asString() == "hashCode" -> {
+            descriptor.name.asString() == "hashCode" -> {
             assert(!convertExceptionsToErrors)
             MethodBridge.ReturnValue.HashCode
         }
@@ -460,4 +468,3 @@ internal fun ObjCExportMapper.bridgePropertyType(descriptor: PropertyDescriptor)
 
     return bridgeType(descriptor.type)
 }
-

native/objcexport-header-generator/impl/k1/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjCExportTranslatorMobile.kt

@@ -11,7 +11,11 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 class ObjCExportTranslatorMobile internal constructor(private val delegate: ObjCExportTranslatorImpl) : ObjCExportTranslator by delegate {
     companion object {
         fun create(namer: ObjCExportNamer, configuration: ObjCExportLazy.Configuration): ObjCExportTranslatorMobile {
-            val mapper = ObjCExportMapper(local = true, unitSuspendFunctionExport = configuration.unitSuspendFunctionExport)
+            val mapper = ObjCExportMapper(
+                local = true,
+                unitSuspendFunctionExport = configuration.unitSuspendFunctionExport,
+                entryPoints = configuration.entryPoints,
+            )
             return ObjCExportTranslatorMobile(
                 ObjCExportTranslatorImpl(
                     null,
@@ -29,4 +33,4 @@ class ObjCExportTranslatorMobile internal constructor(private val delegate: ObjC
         val scope = classDescriptor?.let { delegate.createGenericExportScope(it) } ?: ObjCRootExportScope
         return delegate.buildMethod(descriptor, descriptor, scope)
     }
-}
+}

native/objcexport-header-generator/impl/k1/src/org/jetbrains/kotlin/backend/konan/objcexport/ObjcExportHeaderGeneratorMobile.kt

@@ -30,7 +30,7 @@ class ObjcExportHeaderGeneratorMobile internal constructor(
             local: Boolean = false,
             restrictToLocalModules: Boolean = false,
         ): ObjCExportHeaderGenerator {
-            val mapper = ObjCExportMapper(deprecationResolver, local, configuration.unitSuspendFunctionExport)
+            val mapper = ObjCExportMapper(deprecationResolver, local, configuration.unitSuspendFunctionExport, configuration.entryPoints)
             val namerConfiguration = createNamerConfiguration(configuration)
             val namer = ObjCExportNamerImpl(namerConfiguration, builtIns, mapper, problemCollector, local)
 

native/objcexport-header-generator/impl/k1/test/org/jetbrains/kotlin/backend/konan/testUtils/Fe10ObjCExportHeaderGenerator.kt

@@ -69,13 +69,22 @@ private class Fe10HeaderGeneratorImpl(private val disposable: Disposable) : Head
         val kotlinFiles = root.walkTopDown().filter { it.isFile }.filter { it.extension == "kt" }.toList()
         val moduleDescriptors = setOf(createModuleDescriptor(environment, kotlinFiles, configuration.dependencies))
 
+        // Parse objc-entry-points file if present
+        val entryPoints = File(root, "objc-entry-points")
+            .takeIf { it.isFile }
+            ?.toPath()
+            ?.let { org.jetbrains.kotlin.konan.file.File(it) }
+            ?.readObjCEntryPoints()
+            ?: ObjCEntryPoints.ALL
+
         val mapper = ObjCExportMapper(
             deprecationResolver = DeprecationResolver(
                 storageManager = LockBasedStorageManager.NO_LOCKS,
                 languageVersionSettings = createLanguageVersionSettings(),
                 deprecationSettings = JavaDeprecationSettings
             ),
-            unitSuspendFunctionExport = UnitSuspendFunctionObjCExport.DEFAULT
+            unitSuspendFunctionExport = UnitSuspendFunctionObjCExport.DEFAULT,
+            entryPoints = entryPoints,
         )
 
         val exportedModuleDescriptors = moduleDescriptors + moduleDescriptors