疑似修复了某些情况下不生成合成函数或属性的问题

Author: ForteScarlet

compiler/suspend-transform-plugin/src/main/kotlin/love/forte/plugin/suspendtrans/fir/SuspendTransformFirTransformer.kt

@@ -2,6 +2,7 @@ package love.forte.plugin.suspendtrans.fir
 
 import love.forte.plugin.suspendtrans.configuration.MarkAnnotation
 import love.forte.plugin.suspendtrans.configuration.SuspendTransformConfiguration
+import love.forte.plugin.suspendtrans.configuration.TargetPlatform
 import love.forte.plugin.suspendtrans.configuration.Transformer
 import love.forte.plugin.suspendtrans.fqn
 import love.forte.plugin.suspendtrans.utils.*
@@ -101,16 +102,24 @@ class SuspendTransformFirTransformer(
             Name.identifier("CoroutineScope")
         )
 
-        coroutineScopeSymbol = session.symbolProvider.getClassLikeSymbolByClassId(classId)
-            ?: session.dependenciesSymbolProvider.getClassLikeSymbolByClassId(classId)
-                    ?: error("Cannot resolve `kotlinx.coroutines.CoroutineScope` symbol.")
+        if (!(::coroutineScopeSymbol.isInitialized)) {
+            coroutineScopeSymbol = session.symbolProvider.getClassLikeSymbolByClassId(classId)
+                ?: session.dependenciesSymbolProvider.getClassLikeSymbolByClassId(classId)
+                        ?: error("Cannot resolve `kotlinx.coroutines.CoroutineScope` symbol.")
+        }
+
     }
 
-    private fun initTransformerFunctionSymbolMap() {
+    private fun initTransformerFunctionSymbolMap(
+        classSymbol: FirClassSymbol<*>,
+        memberScope: FirClassDeclaredMemberScope?
+    ): Map<Transformer, FirNamedFunctionSymbol> {
         // 尝试找到所有配置的 bridge function, 例如 `runBlocking` 等
         val symbolProvider = session.symbolProvider
         val dependenciesSymbolProvider = session.dependenciesSymbolProvider
 
+        val map = mutableMapOf<Transformer, FirNamedFunctionSymbol>()
+
         suspendTransformConfiguration.transformers
             .forEach { (_, transformerList) ->
                 for (transformer in transformerList) {
@@ -136,6 +145,7 @@ class SuspendTransformFirTransformer(
                     if (transformerFunctionSymbols.isNotEmpty()) {
                         if (transformerFunctionSymbols.size == 1) {
                             transformerFunctionSymbolMap[transformer] = transformerFunctionSymbols.first()
+                            map[transformer] = transformerFunctionSymbols.first()
                         } else {
                             error("Found multiple transformer function symbols for transformer: $transformer")
                         }
@@ -145,15 +155,18 @@ class SuspendTransformFirTransformer(
                     }
                 }
             }
+
+        return map
     }
 
     //    private val cache: FirCache<Pair<FirClassSymbol<*>, FirClassDeclaredMemberScope?>, Map<Name, Map<FirNamedFunctionSymbol, FunData>>?, Nothing?> =
     private val cache: FirCache<FirCacheKey, Map<Name, Map<FirNamedFunctionSymbol, SyntheticFunData>>?, Nothing?> =
-        session.firCachesFactory.createCache { (symbol, scope), c ->
+        session.firCachesFactory.createCache { cacheKey, c ->
+            val (symbol, scope) = cacheKey
             initScopeSymbol()
-            initTransformerFunctionSymbolMap()
+            val transformerFunctionMap = initTransformerFunctionSymbolMap(symbol, scope)
 
-            createCache(symbol, scope)
+            createCache(symbol, scope, transformerFunctionMap)
         }
 
 
@@ -337,9 +350,12 @@ class SuspendTransformFirTransformer(
         val lambdaTarget = FirFunctionTarget(null, isLambda = true)
         val lambda = buildAnonymousFunction {
             this.resolvePhase = FirResolvePhase.BODY_RESOLVE
+            // this.resolvePhase = FirResolvePhase.RAW_FIR
             this.isLambda = true
             this.moduleData = originFunSymbol.moduleData
-            this.origin = FirDeclarationOrigin.Synthetic.FakeFunction
+            // this.origin = FirDeclarationOrigin.Source
+            // this.origin = FirDeclarationOrigin.Synthetic.FakeFunction
+            this.origin = FirDeclarationOrigin.Plugin(SuspendTransformK2V3Key)
             this.returnTypeRef = originFunSymbol.resolvedReturnTypeRef
             this.hasExplicitParameterList = false
             this.status = FirResolvedDeclarationStatusImpl.DEFAULT_STATUS_FOR_SUSPEND_FUNCTION_EXPRESSION
@@ -385,7 +401,6 @@ class SuspendTransformFirTransformer(
                                 source = thisReceiverParameter.source
                                 calleeReference = buildImplicitThisReference {
                                     boundSymbol = thisReceiverParameter.symbol
-                                    // println("[${newFunSymbol}] thisReceiverParameter.symbol: ${thisReceiverParameter.symbol}")
                                 }
                             }
                         }
@@ -591,6 +606,7 @@ class SuspendTransformFirTransformer(
 
             val newFunTarget = FirFunctionTarget(null, isLambda = false)
             val newFun = buildSimpleFunctionCopy(originFunc) {
+                origin = FirDeclarationOrigin.Plugin(SuspendTransformK2V3Key)
                 name = callableId.callableName
                 symbol = newFunSymbol
                 status = originFunc.status.copy(
@@ -871,46 +887,53 @@ class SuspendTransformFirTransformer(
         return isOverride
     }
 
-    private val annotationPredicates: DeclarationPredicate? =
-        if (suspendTransformConfiguration.transformers.values.isEmpty()) {
-            null
-        } else {
-            DeclarationPredicate.create {
-                var predicate: DeclarationPredicate? = null
-                for (value in suspendTransformConfiguration.transformers.values) {
-                    for (transformer in value) {
-                        val afq = transformer.markAnnotation.fqName
-                        predicate = predicate?.also { p -> p or annotated(afq) } ?: annotated(afq)
-                    }
-                }
-
-                predicate ?: annotated()
+    private val annotationPredicates = DeclarationPredicate.create {
+        val annotationFqNames = suspendTransformConfiguration.transformers.values
+            .flatMapTo(mutableSetOf()) { transformerList ->
+                transformerList.map { it.markAnnotation.fqName }
             }
-        }
+
+        hasAnnotated(annotationFqNames)
+        // var predicate: DeclarationPredicate? = null
+        // for (value in suspendTransformConfiguration.transformers.values) {
+        //     for (transformer in value) {
+        //         val afq = transformer.markAnnotation.fqName
+        //         predicate = if (predicate == null) {
+        //             annotated(afq)
+        //         } else {
+        //             predicate or annotated(afq)
+        //         }
+        //     }
+        // }
+        //
+        // predicate ?: annotated()
+    }
+
 
     /**
      * NB: The predict needs to be *registered* in order to parse the [@XSerializable] type
      * otherwise, the annotation remains unresolved
      */
     override fun FirDeclarationPredicateRegistrar.registerPredicates() {
-        annotationPredicates?.also { register(it) }
+        register(annotationPredicates)
     }
 
     private fun createCache(
         classSymbol: FirClassSymbol<*>,
-        declaredScope: FirClassDeclaredMemberScope?
+        declaredScope: FirClassDeclaredMemberScope?,
+        transformerFunctionSymbolMap: Map<Transformer, FirNamedFunctionSymbol>
     ): Map<Name, Map<FirNamedFunctionSymbol, SyntheticFunData>>? {
         if (declaredScope == null) return null
 
-        fun check(targetPlatform: love.forte.plugin.suspendtrans.configuration.TargetPlatform): Boolean {
+        fun check(targetPlatform: TargetPlatform): Boolean {
             val platform = classSymbol.moduleData.platform
 
             return when {
-                platform.isJvm() && targetPlatform == love.forte.plugin.suspendtrans.configuration.TargetPlatform.JVM -> true
-                platform.isJs() && targetPlatform == love.forte.plugin.suspendtrans.configuration.TargetPlatform.JS -> true
-                platform.isWasm() && targetPlatform == love.forte.plugin.suspendtrans.configuration.TargetPlatform.WASM -> true
-                platform.isNative() && targetPlatform == love.forte.plugin.suspendtrans.configuration.TargetPlatform.NATIVE -> true
-                platform.isCommon() && targetPlatform == love.forte.plugin.suspendtrans.configuration.TargetPlatform.COMMON -> true
+                platform.isJvm() && targetPlatform == TargetPlatform.JVM -> true
+                platform.isJs() && targetPlatform == TargetPlatform.JS -> true
+                platform.isWasm() && targetPlatform == TargetPlatform.WASM -> true
+                platform.isNative() && targetPlatform == TargetPlatform.NATIVE -> true
+                platform.isCommon() && targetPlatform == TargetPlatform.COMMON -> true
                 else -> false
             }
         }
@@ -945,7 +968,6 @@ class SuspendTransformFirTransformer(
                         // 读不到注解的参数？
                         // 必须使用 anno.getXxxArgument(Name(argument name)),
                         // 使用 argumentMapping.mapping 获取不到结果
-//                        println("RAW AnnoData: ${anno.argumentMapping.mapping}")
                         val annoData = anno.toTransformAnnotationData(markAnnotation, functionName)
 
                         val syntheticFunNameString = annoData.functionName
@@ -1274,11 +1296,9 @@ class SuspendTransformFirTransformer(
 
         when (this) {
             is ConeDynamicType -> {
-                //println("Dynamic type: $this")
             }
 
             is ConeFlexibleType -> {
-                //println("Flexible type: $this")
             }
 
             is ConeClassLikeType -> {

plugins/suspend-transform-plugin-gradle/src/main/kotlin/love/forte/plugin/suspendtrans/gradle/SuspendTransformGradlePlugin.kt

@@ -57,6 +57,8 @@ open class SuspendTransformGradlePlugin : KotlinCompilerPluginSupportPlugin {
         val isApplicable = project.plugins.hasPlugin(SuspendTransformGradlePlugin::class.java)
                 && project.configOrNull?.enabled?.get() != false
 
+        project.logger.info("Is suspend transform plugin applicable for {}: {}", kotlinCompilation, isApplicable)
+
         return isApplicable
     }
 
@@ -75,22 +77,21 @@ open class SuspendTransformGradlePlugin : KotlinCompilerPluginSupportPlugin {
         val target = kotlinCompilation.target
         val project = target.project
 
-        return project.provider { resolveSubpluginOptions(target, project) }
+        project.logger.info("Apply suspend transform plugin to compilation {}, target: {}", kotlinCompilation, target)
+
+        val extension = resolveExtension(project)
+        return project.provider { extension.toSubpluginOptions(target, project) }
     }
 
-    private fun resolveSubpluginOptions(target: KotlinTarget, project: Project): List<SubpluginOption> {
+    private fun resolveExtension(project: Project): SuspendTransformPluginExtension {
         val extension = project.extensions.getByType(SuspendTransformPluginExtension::class.java)
 
         @Suppress("DEPRECATION") val oldExtension =
             project.extensions.getByType(SuspendTransformGradleExtension::class.java)
         @Suppress("DEPRECATION")
-        if (oldExtension.enabled || oldExtension.transformers.isNotEmpty()) {
-            val showError =
-                project.providers.gradleProperty("love.forte.plugin.suspend-transform.deprecatedExtensionError")
-                    .map { it.toBoolean() }.getOrElse(true)
-
-            val showWarn =
-                project.providers.gradleProperty("love.forte.plugin.suspend-transform.deprecatedExtensionWarn")
+        if (oldExtension.enabled && oldExtension.transformers.isNotEmpty()) {
+            val dontShowWarn =
+                project.providers.gradleProperty("love.forte.plugin.suspend-transform.suppressDeprecatedExtensionWarn")
                     .map { it.toBoolean() }.getOrElse(false)
 
             val msg = "The `love.forte.plugin.suspendtrans.gradle.SuspendTransformGradleExtension` " +
@@ -101,20 +102,14 @@ open class SuspendTransformGradlePlugin : KotlinCompilerPluginSupportPlugin {
                     "will currently be aggregated with `SuspendTransformPluginExtension`, " +
                     "but it will soon be deprecated completely. "
 
-            when {
-                showError -> {
-                    project.logger.error(msg)
-                }
-
-                showWarn -> {
-                    project.logger.warn(msg)
-                }
+            if (!dontShowWarn) {
+                project.logger.warn(msg)
             }
 
             oldExtension.mergeTo(extension)
         }
 
-        return extension.toSubpluginOptions(target, project)
+        return extension
     }
 }
 
@@ -132,13 +127,13 @@ private fun SuspendTransformGradleExtension.mergeTo(extension: SuspendTransformP
     // Not the default value
     if (deprecatedAnnotationVersion != SuspendTransPluginConstants.ANNOTATION_VERSION) {
         extension.annotationDependency {
-            it.version.convention(deprecatedAnnotationVersion)
+            version.convention(deprecatedAnnotationVersion)
         }
     }
     val deprecatedAnnotationConfigurationName = this.annotationConfigurationName
     if (deprecatedAnnotationConfigurationName != "compileOnly") {
         extension.annotationDependency {
-            it.configurationName.convention(deprecatedAnnotationConfigurationName)
+            configurationName.convention(deprecatedAnnotationConfigurationName)
         }
     }
 
@@ -150,13 +145,13 @@ private fun SuspendTransformGradleExtension.mergeTo(extension: SuspendTransformP
     val deprecatedRuntimeVersion = this.runtimeDependencyVersion
     if (deprecatedRuntimeVersion != SuspendTransPluginConstants.RUNTIME_VERSION) {
         extension.runtimeDependency {
-            it.version.convention(deprecatedRuntimeVersion)
+            version.convention(deprecatedRuntimeVersion)
         }
     }
     val deprecatedRuntimeConfigurationName = this.runtimeConfigurationName
     if (deprecatedRuntimeConfigurationName != "implementation") {
         extension.runtimeDependency {
-            it.configurationName.convention(deprecatedRuntimeConfigurationName)
+            configurationName.convention(deprecatedRuntimeConfigurationName)
         }
     }
 
@@ -370,6 +365,9 @@ fun Project.configureMultiplatformDependency(conf: SuspendTransformPluginExtensi
         return
     }
 
+    val sourceSetsByCompilation = sourceSetsByCompilation()
+    project.logger.info("Suspend transform sourceSetsByCompilation: $sourceSetsByCompilation")
+
     // 时间久远，已经忘记为什么要做这个判断了，也忘记这段是在哪儿参考来的了💀
     if (rootProject.getBooleanProperty("kotlin.mpp.enableGranularSourceSetsMetadata")) {
         val multiplatformExtensions = project.extensions.getByType(KotlinMultiplatformExtension::class.java)
@@ -403,7 +401,7 @@ fun Project.configureMultiplatformDependency(conf: SuspendTransformPluginExtensi
 
         // For each source set that is only used in Native compilations, add an implementation dependency so that it
         // gets published and is properly consumed as a transitive dependency:
-        sourceSetsByCompilation().forEach { (sourceSet, compilations) ->
+        sourceSetsByCompilation.forEach { (sourceSet, compilations) ->
             val isSharedSourceSet = compilations.all {
                 it.platformType == KotlinPlatformType.common || it.platformType == KotlinPlatformType.native
                         || it.platformType == KotlinPlatformType.js || it.platformType == KotlinPlatformType.wasm
@@ -434,7 +432,7 @@ fun Project.configureMultiplatformDependency(conf: SuspendTransformPluginExtensi
             }
         }
     } else {
-        sourceSetsByCompilation().forEach { (sourceSet, compilations) ->
+        sourceSetsByCompilation.forEach { (sourceSet, compilations) ->
             val platformTypes = compilations.map { it.platformType }.toSet()
             logger.info(
                 "Configure sourceSet [{}]. compilations: {}, platformTypes: {}",