compose-compiler: stableprop generation

shishkin-pavel · Space Cloud · commit b47f431fe8e2 · 2024-07-01T17:40:58.000Z
generate stableprop and getter function exported to metadata
so it is visible from outside of the module
and can be accessed witout hacks
diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/ComposeIrGenerationExtension.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/ComposeIrGenerationExtension.kt
@@ -43,6 +43,9 @@ import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureFactory
 import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsGlobalDeclarationTable
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -51,6 +54,7 @@ import org.jetbrains.kotlin.platform.isJs
 import org.jetbrains.kotlin.platform.isWasm
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.platform.konan.isNative
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 
 class ComposeIrGenerationExtension(
     @Suppress("unused") private val liveLiteralsEnabled: Boolean = false,
@@ -69,6 +73,7 @@ class ComposeIrGenerationExtension(
     private val stableTypeMatchers: Set<FqNameMatcher> = emptySet(),
     private val moduleMetricsFactory: ((StabilityInferencer) -> ModuleMetrics)? = null,
     private val descriptorSerializerContext: ComposeDescriptorSerializerContext? = null,
+    private val messageCollector: MessageCollector? = null
 ) : IrGenerationExtension {
     var metrics: ModuleMetrics = EmptyModuleMetrics
         private set
@@ -124,7 +129,8 @@ class ComposeIrGenerationExtension(
             classStabilityInferredCollection = descriptorSerializerContext
                 ?.classStabilityInferredCollection?.takeIf {
                     !pluginContext.platform.isJvm()
-                }
+                },
+            messageCollector
         ).lower(moduleFragment)
 
         LiveLiteralTransformer(
diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/ComposePlugin.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/ComposePlugin.kt
@@ -479,6 +479,7 @@ class ComposePluginRegistrar : org.jetbrains.kotlin.compiler.plugin.ComponentReg
                 stableTypeMatchers = stableTypeMatchers,
                 moduleMetricsFactory = moduleMetricsFactory,
                 descriptorSerializerContext = descriptorSerializerContext,
+                messageCollector = msgCollector
             )
         }
     }
diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/KtxNameConventions.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/KtxNameConventions.kt
@@ -9,6 +9,7 @@ object KtxNameConventions {
     val FORCE_PARAMETER = Name.identifier("\$force")
     val STABILITY_FLAG = Name.identifier("\$stable")
     val STABILITY_PROP_FLAG = Name.identifier("\$stableprop")
+    val STABILITY_GETTER_FLAG = Name.identifier("\$stableprop_getter")
     val DEFAULT_PARAMETER = Name.identifier("\$default")
     val JOINKEY = Name.identifier("joinKey")
     val STARTRESTARTGROUP = Name.identifier("startRestartGroup")
diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/AbstractComposeLowering.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/AbstractComposeLowering.kt
@@ -34,6 +34,7 @@ import androidx.compose.compiler.plugins.kotlin.analysis.knownUnstable
 import androidx.compose.compiler.plugins.kotlin.irTrace
 import com.intellij.openapi.progress.ProcessCanceledException
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
+import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder
 import org.jetbrains.kotlin.backend.jvm.ir.isInlineClassType
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
@@ -45,10 +46,11 @@ import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter
 import org.jetbrains.kotlin.ir.builders.declarations.buildField
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.builders.declarations.buildProperty
+import org.jetbrains.kotlin.ir.builders.irBlockBody
+import org.jetbrains.kotlin.ir.builders.irReturn
 import org.jetbrains.kotlin.ir.declarations.IrAnnotationContainer
 import org.jetbrains.kotlin.ir.declarations.IrAttributeContainer
 import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationContainer
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.IrFile
@@ -86,6 +88,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrBranchImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrElseBranchImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionExpressionImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
@@ -128,6 +131,7 @@ import org.jetbrains.kotlin.ir.types.typeWith
 import org.jetbrains.kotlin.ir.util.DeepCopySymbolRemapper
 import org.jetbrains.kotlin.ir.util.SYNTHETIC_OFFSET
 import org.jetbrains.kotlin.ir.util.addChild
+import org.jetbrains.kotlin.ir.util.constructors
 import org.jetbrains.kotlin.ir.util.defaultType
 import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization
 import org.jetbrains.kotlin.ir.util.functions
@@ -155,11 +159,23 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.DFS
 
+import androidx.compose.compiler.plugins.kotlin.lower.hiddenfromobjc.hiddenFromObjCClassId
+import org.jetbrains.kotlin.GeneratedDeclarationKey
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.fir.declarations.utils.klibSourceFile
+import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyClass
+import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
+import org.jetbrains.kotlin.ir.util.packageFqName
+import org.jetbrains.kotlin.library.metadata.DeserializedSourceFile
+
+object ComposeCompilerKey : GeneratedDeclarationKey()
+
 abstract class AbstractComposeLowering(
     val context: IrPluginContext,
     val symbolRemapper: DeepCopySymbolRemapper,
     val metrics: ModuleMetrics,
-    val stabilityInferencer: StabilityInferencer
+    val stabilityInferencer: StabilityInferencer,
+    protected val unstableClassesWarning: MutableSet<ClassDescriptor>? = null
 ) : IrElementTransformerVoid(), ModuleLoweringPass {
     protected val builtIns = context.irBuiltIns
 
@@ -379,15 +395,7 @@ abstract class AbstractComposeLowering(
                 null
 
         is Stability.Parameter -> resolve(parameter)
-        is Stability.Runtime -> {
-            val stableField = declaration.makeStabilityField()
-            IrGetFieldImpl(
-                UNDEFINED_OFFSET,
-                UNDEFINED_OFFSET,
-                stableField.symbol,
-                stableField.type
-            )
-        }
+        is Stability.Runtime -> declaration.getRuntimeStabilityValue()
 
         is Stability.Unknown -> null
     }
@@ -778,6 +786,15 @@ abstract class AbstractComposeLowering(
         return irGet(variable.type, variable.symbol)
     }
 
+    protected fun irGetField(field: IrField): IrGetField {
+        return IrGetFieldImpl(
+            UNDEFINED_OFFSET,
+            UNDEFINED_OFFSET,
+            field.symbol,
+            field.type
+        )
+    }
+
     protected fun irIf(condition: IrExpression, body: IrExpression): IrExpression {
         return IrIfThenElseImpl(
             UNDEFINED_OFFSET,
@@ -898,61 +915,146 @@ abstract class AbstractComposeLowering(
         kotlinFqName.asString().replace(".", "_") + KtxNameConventions.STABILITY_PROP_FLAG
     )
 
-    fun IrClass.makeStabilityField(): IrField {
+    private fun IrClass.uniqueStabilityGetterName(): Name = Name.identifier(
+        kotlinFqName.asString().replace(".", "_") + KtxNameConventions.STABILITY_GETTER_FLAG
+    )
+
+    private fun IrClass.getMetadataStabilityGetterFun(): IrSimpleFunctionSymbol? {
+        val suitableFunctions = context.referenceFunctions(CallableId(this.packageFqName!!, uniqueStabilityGetterName()))
+        return suitableFunctions.singleOrNull()
+    }
+
+    private fun IrClass.getRuntimeStabilityValue(): IrExpression {
+        if (context.platform.isJvm()) {
+            val stableField = this.makeStabilityFieldJvm()
+            return irGetField(stableField)
+        } else {
+            // since k2.0.10 compiler plugin adds special getter function that should be visible in metadata declarations
+            val stabilityGetter = getMetadataStabilityGetterFun()
+            if (stabilityGetter != null) {
+                return irCall(stabilityGetter)
+            }
+
+            // in case we have not found getter function and dependency was compiled with k1.9, we can rely on
+            // IrGetField over property backing field because it was generated with `isConst = true` and should be initialized
+            val classKotlinVersion =
+                ((this as? Fir2IrLazyClass)?.fir?.klibSourceFile as? DeserializedSourceFile)?.library?.versions?.compilerVersion
+            if (classKotlinVersion != null && classKotlinVersion.startsWith("1.9")) {
+                val stableField = this.buildStabilityProp(false)
+                val backingField = stableField.backingField!!
+
+                return irGetField(backingField)
+            }
+
+            // if we can not find stability getter function in metadata, dependency was compiled with older version of compiler plugin,
+            // so we can not trust value produced from `irGetField` because it may contain uninitialized data on native targets
+            //   (there is no guarantees that any of static/toplevel functions were called at this point,
+            //    so no guarantees that package initializer was called and field value was initialized)
+            // we treat those classes as `Unstable` and produce compilation warning that user may observe additional recompositions
+            // and may need to update dependencies to version compiled with newer compiler plugin to get rid of them
+            unstableClassesWarning?.add(this.descriptor)
+            return irConst(StabilityBits.UNSTABLE.bitsForSlot(0))
+        }
+    }
+
+    internal fun IrClass.makeStabilityField(): IrField {
         return if (context.platform.isJvm()) {
-            this.makeStabilityFieldJvm()
+            makeStabilityFieldJvm()
         } else {
-            this.makeStabilityFieldNonJvm()
+            makeStabilityFieldNonJvm()
         }
     }
 
     private fun IrClass.makeStabilityFieldJvm(): IrField {
-        return context.irFactory.buildField {
-            startOffset = SYNTHETIC_OFFSET
-            endOffset = SYNTHETIC_OFFSET
-            name = KtxNameConventions.STABILITY_FLAG
-            isStatic = true
-            isFinal = true
-            type = context.irBuiltIns.intType
-            visibility = DescriptorVisibilities.PUBLIC
-        }.also { stabilityField ->
+        return buildStabilityField(KtxNameConventions.STABILITY_FLAG).also { stabilityField ->
             stabilityField.parent = this@makeStabilityFieldJvm
+            declarations += stabilityField
         }
     }
 
     private fun IrClass.makeStabilityFieldNonJvm(): IrField {
-        val stabilityFieldName = this.uniqueStabilityFieldName()
-        val fieldParent = this.getPackageFragment()
+        val prop = this.buildStabilityProp(true)
+        return prop.backingField!!
+    }
 
+    private fun buildStabilityField(fieldName: Name): IrField {
         return context.irFactory.buildField {
             startOffset = SYNTHETIC_OFFSET
             endOffset = SYNTHETIC_OFFSET
-            name = stabilityFieldName
+            name = fieldName
             isStatic = true
             isFinal = true
             type = context.irBuiltIns.intType
             visibility = DescriptorVisibilities.PUBLIC
-        }.also { stabilityField ->
-            stabilityField.parent = fieldParent
-            makeStabilityProp(stabilityField, fieldParent)
         }
     }
 
-    private fun IrClass.makeStabilityProp(
-        stabilityField: IrField,
-        fieldParent: IrDeclarationContainer
-    ): IrProperty {
-        return context.irFactory.buildProperty {
+    private fun IrClass.buildStabilityProp(buildGetter: Boolean): IrProperty {
+        val parent = this.getPackageFragment()
+
+        val propName = this.uniqueStabilityPropertyName()
+        val existingProp = parent.declarations.firstOrNull {
+            it is IrProperty && it.name == propName
+        } as? IrProperty
+        if (existingProp != null) {
+            return existingProp
+        }
+
+        val stabilityField = buildStabilityField(uniqueStabilityFieldName()).also {
+            it.parent = parent
+        }
+
+        val property = context.irFactory.buildProperty {
             startOffset = SYNTHETIC_OFFSET
             endOffset = SYNTHETIC_OFFSET
-            name = this@makeStabilityProp.uniqueStabilityPropertyName()
+            name = propName
             visibility = DescriptorVisibilities.PUBLIC
         }.also { property ->
-            property.parent = fieldParent
+            property.parent = parent
             stabilityField.correspondingPropertySymbol = property.symbol
             property.backingField = stabilityField
-            fieldParent.addChild(property)
+            parent.addChild(property)
         }
+
+        if (buildGetter) {
+            this.buildStabilityGetter(property, parent)
+        }
+
+        return property
+    }
+
+    private val hiddenFromObjCAnnotationSymbol: IrClassSymbol = getTopLevelClass(hiddenFromObjCClassId)
+    private val hiddenFromObjCAnnotation = IrConstructorCallImpl.fromSymbolOwner(
+        type = hiddenFromObjCAnnotationSymbol.defaultType,
+        constructorSymbol = hiddenFromObjCAnnotationSymbol.constructors.first()
+    )
+
+    private fun IrClass.buildStabilityGetter(stabilityProp: IrProperty, parent: IrPackageFragment) {
+        val getterName = uniqueStabilityGetterName()
+
+        val stabilityField = stabilityProp.backingField!!
+
+        // we could have created getter instead of separate function,
+        // but `registerFunctionAsMetadataVisible` is not working for field getter for some reason
+        // and there is no api to register properties as metadata-visible
+        val stabilityGetter = context.irFactory.buildFun {
+            startOffset = SYNTHETIC_OFFSET
+            endOffset = SYNTHETIC_OFFSET
+            name = getterName
+            returnType = stabilityField.type
+            visibility = DescriptorVisibilities.PUBLIC
+            origin = IrDeclarationOrigin.GeneratedByPlugin(ComposeCompilerKey)
+            annotations = listOf(hiddenFromObjCAnnotation)
+        }.also { fn ->
+            fn.parent = parent
+            fn.body = DeclarationIrBuilder(context, fn.symbol).irBlockBody {
+                +irReturn(irGetField(stabilityField))
+            }
+            parent.addChild(fn)
+        }
+
+        context.metadataDeclarationRegistrar.addMetadataVisibleAnnotationsToElement(stabilityGetter, hiddenFromObjCAnnotation)
+        context.metadataDeclarationRegistrar.registerFunctionAsMetadataVisible(stabilityGetter)
     }
 
     fun IrExpression.isStatic(): Boolean {
diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/ClassStabilityTransformer.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/ClassStabilityTransformer.kt
@@ -27,6 +27,9 @@ import androidx.compose.compiler.plugins.kotlin.analysis.normalize
 import org.jetbrains.kotlin.backend.common.ClassLoweringPass
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.backend.jvm.ir.isInlineClassType
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.ir.IrImplementationDetail
 import org.jetbrains.kotlin.ir.IrStatement
@@ -36,7 +39,6 @@ import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.symbols.UnsafeDuringIrConstructionAPI
 import org.jetbrains.kotlin.ir.types.defaultType
 import org.jetbrains.kotlin.ir.util.DeepCopySymbolRemapper
@@ -50,6 +52,7 @@ import org.jetbrains.kotlin.ir.util.isFileClass
 import org.jetbrains.kotlin.ir.util.isInterface
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
 import org.jetbrains.kotlin.platform.jvm.isJvm
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 
 enum class StabilityBits(val bits: Int) {
     UNSTABLE(0b100),
@@ -67,8 +70,9 @@ class ClassStabilityTransformer(
     symbolRemapper: DeepCopySymbolRemapper,
     metrics: ModuleMetrics,
     stabilityInferencer: StabilityInferencer,
-    private val classStabilityInferredCollection: ClassStabilityInferredCollection? = null
-) : AbstractComposeLowering(context, symbolRemapper, metrics, stabilityInferencer),
+    private val classStabilityInferredCollection: ClassStabilityInferredCollection? = null,
+    private val messageCollector: MessageCollector? = null
+) : AbstractComposeLowering(context, symbolRemapper, metrics, stabilityInferencer, mutableSetOf<ClassDescriptor>()),
     ClassLoweringPass,
     ModuleLoweringPass {
 
@@ -78,6 +82,18 @@ class ClassStabilityTransformer(
 
     override fun lower(module: IrModuleFragment) {
         module.transformChildrenVoid(this)
+
+        if (!context.platform.isJvm() && !unstableClassesWarning.isNullOrEmpty()) {
+            val classIds = unstableClassesWarning.mapTo(mutableSetOf()) { it.fqNameSafe.toString() }
+            val classesConcatenated = classIds.sorted().joinToString("\n")
+            messageCollector?.report(
+                CompilerMessageSeverity.WARNING,
+                "Due to some of dependencies were built using older compiler plugin, stability of following classes " +
+                        "is considered `Unstable`, which may cause additional recompositions happening at runtime on non-JVM targets. " +
+                        "To prevent that consider updating dependency libraries to a newer version built with newer compose compiler plugin.\n" +
+                        classesConcatenated
+            )
+        }
     }
 
     override fun lower(irClass: IrClass) {
@@ -197,16 +213,11 @@ class ClassStabilityTransformer(
 
     @OptIn(IrImplementationDetail::class, UnsafeDuringIrConstructionAPI::class)
     private fun IrClass.addStabilityMarkerField(stabilityExpression: IrExpression) {
-        val stabilityField = this.makeStabilityField().apply {
-            initializer = context.irFactory.createExpressionBody(
-                UNDEFINED_OFFSET,
-                UNDEFINED_OFFSET,
-                stabilityExpression
-            )
-        }
-
-        if (context.platform.isJvm()) {
-            declarations += stabilityField
-        }
+        val stabilityField = makeStabilityField()
+        stabilityField.initializer = context.irFactory.createExpressionBody(
+            UNDEFINED_OFFSET,
+            UNDEFINED_OFFSET,
+            stabilityExpression
+        )
     }
 }
diff --git a/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/hiddenfromobjc/AddHiddenFromObjCLowering.kt b/plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/hiddenfromobjc/AddHiddenFromObjCLowering.kt

Original file line number	Diff line number	Diff line change
`@@ -479,6 +479,7 @@ class ComposePluginRegistrar : org.jetbrains.kotlin.compiler.plugin.ComponentReg`
`479`	`479`	`stableTypeMatchers = stableTypeMatchers,`
`480`	`480`	`moduleMetricsFactory = moduleMetricsFactory,`
`481`	`481`	`descriptorSerializerContext = descriptorSerializerContext,`
	`482`	`+ messageCollector = msgCollector`
`482`	`483`	`)`
`483`	`484`	`}`
`484`	`485`	`}`