feat: Previous issues resolved

Author: ForteScarlet

compiler/suspend-transform-plugin-annotation/src/main/kotlin/love/forte/plugin/suspendtrans/annotation/ExperimentalReturnTypeOverrideGenericApi.kt

@@ -2,12 +2,13 @@ package love.forte.plugin.suspendtrans.annotation
 
 /**
  * The API related to _return type override generic_ is experimental.
- * It may be changed in the future without notice.
+ * It may be changed in the future without notice and without guarantee of compatibility.
  *
  * @since 0.14.0
  */
 @RequiresOptIn(
- message = "This API is experimental. It may be changed in the future without notice.",
+ message = "The API related to return type override generic is experimental. " +
+ "It may be changed in the future without notice and without guarantee of compatibility.",
  level = RequiresOptIn.Level.ERROR
 )
 @Target(

compiler/suspend-transform-plugin/src/main/kotlin/LocalLoggerHelper.kt

@@ -1,15 +1,22 @@
-//internal object LocalLoggerHelper {
-// private val dir = System.getenv("kstcp.logger.dir")
-// private val path = Path(dir ?: ".plugin-logger") / Path("${System.currentTimeMillis()}.log")
-// init {
-// path.parent.createDirectories()
-// if (path.notExists()) {
-// path.createFile()
-// }
-// }
+// import java.time.LocalDateTime
+// import kotlin.io.path.*
 //
-// fun println(value: Any?) {
-// kotlin.io.println(value)
-// path.appendText("[${LocalDateTime.now()}] $value\n", Charsets.UTF_8)
-// }
-//}
+// internal object LocalLoggerHelper {
+// private val dir = System.getenv("kstcp.logger.dir")
+// private val userDir = System.getProperty("user.dir")
+// private val path = Path(
+// dir ?: userDir?.plus("/.kstcp-plugin-logger") ?: "~/.kstcp-plugin-logger"
+// ) / Path("${System.currentTimeMillis()}.log")
+//
+// init {
+// path.parent.createDirectories()
+// if (path.notExists()) {
+// path.createFile()
+// }
+// }
+//
+// fun println(value: Any?) {
+// kotlin.io.println(value)
+// path.appendText("[${LocalDateTime.now()}] $value\n", Charsets.UTF_8)
+// }
+// }

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

@@ -45,9 +45,10 @@ import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
-import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.builder.buildTypeProjectionWithVariance
 import org.jetbrains.kotlin.name.*
 import org.jetbrains.kotlin.types.ConstantValueKind
+import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.keysToMap
 import java.util.concurrent.ConcurrentHashMap
 
@@ -202,11 +203,11 @@ class SuspendTransformFirTransformer(
  ): FirReceiverParameter? {
  return typeRef.coneTypeOrNull
  ?.copyWithTypeParameters(originalTypeParameterCache)
- ?.let { foundCopied ->
+ ?.let { copied ->
  buildReceiverParameterCopy(this) {
  symbol = FirReceiverParameterSymbol()
  containingDeclarationSymbol = newContainingDeclarationSymbol
- typeRef = typeRef.withReplacedConeType(foundCopied)
+ typeRef = typeRef.withReplacedConeType(copied)
  }
  }
  }
@@ -245,6 +246,10 @@ class SuspendTransformFirTransformer(
  this.receiverParameter = it
  }
 
+ copyReturnType(originalTypeParameterCache)
+ }
+
+ private fun FirSimpleFunctionBuilder.copyReturnType(originalTypeParameterCache: MutableList<CopiedTypeParameterPair>) {
  val coneTypeOrNull = returnTypeRef.coneTypeOrNull
  if (coneTypeOrNull != null) {
  returnTypeRef = returnTypeRef
@@ -311,32 +316,30 @@ class SuspendTransformFirTransformer(
  thisContextParameters: List<FirValueParameter>,
  thisReceiverParameter: FirReceiverParameter?,
  thisValueParameters: List<FirValueParameter>,
+ thisTypeParameters: List<FirTypeParameter>,
  bridgeFunSymbol: FirNamedFunctionSymbol,
  newFunTarget: FirFunctionTarget,
  originalTypeParameterCache: MutableList<CopiedTypeParameterPair>,
  functionReturnTypeRef: FirTypeRef,
  ): FirBlock = buildBlock {
  this.source = originFunc.body?.source
 
- val originalFunReturnType = originFunSymbol.resolvedReturnTypeRef.coneType.copyConeTypeOrSelf(originalTypeParameterCache)
+ val originalFunReturnType =
+ originFunSymbol.resolvedReturnTypeRef.coneType.copyConeTypeOrSelf(originalTypeParameterCache)
 
  // lambda: suspend () -> T
  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.Source
  // this.origin = FirDeclarationOrigin.Synthetic.FakeFunction
  this.origin = SuspendTransformK2V3Key.origin
  // lambda 的返回值类型，() -> T 的 T, 应当是原始函数真正的返回值
- this.returnTypeRef = buildResolvedTypeRef {
- coneType = originalFunReturnType
- }
+ this.returnTypeRef = originalFunReturnType.toResolvedTypeRef()
 
  this.hasExplicitParameterList = false
- // this.status = FirResolvedDeclarationStatusImpl.DEFAULT_STATUS_FOR_SUSPEND_FUNCTION_EXPRESSION
  this.status = this.status.copy(isSuspend = true)
  this.symbol = FirAnonymousFunctionSymbol()
  this.body = buildSingleExpressionBlock(
@@ -347,6 +350,14 @@ class SuspendTransformFirTransformer(
  // this.coneTypeOrNull = originFunSymbol.resolvedReturnTypeRef.coneType
  this.coneTypeOrNull = originalFunReturnType
  this.source = originFunSymbol.source
+ for (tp in thisTypeParameters) {
+ val ta = buildTypeProjectionWithVariance {
+ typeRef = tp.toConeType().toResolvedTypeRef()
+ this.variance = Variance.INVARIANT
+ }
+ this.typeArguments.add(ta)
+ }
+
  this.calleeReference = buildResolvedNamedReference {
  this.source = originFunSymbol.source
  this.name = originFunSymbol.name
@@ -402,11 +413,10 @@ class SuspendTransformFirTransformer(
  }
  )
 
- this.typeRef = buildResolvedTypeRef {
- this.coneType = StandardClassIds.SuspendFunctionN(0)
- // .createConeType(session, arrayOf(originFunSymbol.resolvedReturnType))
- .createConeType(session, arrayOf(originalFunReturnType))
- }
+ this.typeRef = StandardClassIds.SuspendFunctionN(0)
+ .createConeType(session, arrayOf(originalFunReturnType))
+ .toResolvedTypeRef()
+
  }
  lambdaTarget.bind(lambda)
 
@@ -584,6 +594,16 @@ class SuspendTransformFirTransformer(
  ),
  )
 
+ val returnTypeProjection = funData.markAnnotationTypeArgument
+ if (returnTypeProjection != null) {
+ val returnTypeProjectionType = returnTypeProjection.toConeTypeProjection().type
+ returnTypeRef = if (returnTypeProjectionType != null) {
+ returnTypeRef.withReplacedConeType(returnTypeProjectionType)
+ } else {
+ session.builtinTypes.nullableAnyType
+ }
+ }
+
  // Copy the typeParameters.
  // Otherwise, in functions like the following, an error will occur
  // suspend fun <A> data(value: A): T = ...
@@ -604,17 +624,20 @@ class SuspendTransformFirTransformer(
  val thisReceiverParameter = this.receiverParameter
  val thisContextParameters = this.contextParameters
  val thisValueParameters = this.valueParameters
+ val thisTypeParameters = this.typeParameters
 
  annotations.clear()
  annotations.addAll(functionAnnotations)
 
+
  body = generateSyntheticFunctionBody(
  originFunc,
  originFunSymbol,
  owner,
  thisContextParameters,
  thisReceiverParameter,
  thisValueParameters,
+ thisTypeParameters,
  realBridgeFunSymbol,
  newFunTarget,
  originalTypeParameterCache,
@@ -662,34 +685,33 @@ class SuspendTransformFirTransformer(
 
  val pSymbol = FirPropertySymbol(callableId)
 
-// val pKey = SuspendTransformPluginKey(
-// data = SuspendTransformUserDataFir(
-// markerId = uniqueFunHash,
-// originSymbol = original.symbol.asOriginSymbol(
-// targetMarkerAnnotation,
-// typeParameters = original.typeParameters,
-// valueParameters = original.valueParameters,
-// original.returnTypeRef.coneTypeOrNull?.classId,
-// session
-// ),
-// asProperty = true,
-// transformer = funData.transformer
-// )
-// )
  val pKey = SuspendTransformK2V3Key
 
- val originalReturnType = original.returnTypeRef
+ val returnTypeProjection = funData.markAnnotationTypeArgument
 
- val copiedReturnType = originalReturnType.withReplacedConeType(
- originalReturnType.coneTypeOrNull?.copyConeTypeOrSelf(originalTypeParameterCache)
- )
+ val originalReturnType: FirTypeRef = original.returnTypeRef
+
+ val copiedReturnType: FirResolvedTypeRef = if (returnTypeProjection != null) {
+ returnTypeProjection.toConeTypeProjection().type
+ ?.copyConeTypeOrSelf(originalTypeParameterCache)
+ ?.let(originalReturnType::withReplacedConeType)
+ ?: session.builtinTypes.nullableAnyType
+ } else {
+ originalReturnType.withReplacedConeType(
+ originalReturnType.coneTypeOrNull?.copyConeTypeOrSelf(originalTypeParameterCache)
+ )
+ }
+
+ // val copiedReturnType = originalReturnType.withReplacedConeType(
+ // originalReturnType.coneTypeOrNull?.copyConeTypeOrSelf(originalTypeParameterCache)
+ // )
 
  // copy完了再resolve，这样里面包的type parameter就不会有问题了（如果有type parameter的话）
  val resolvedReturnType = resolveReturnType(
  funData,
  copiedReturnType,
  originalTypeParameterCache,
- funData.markAnnotationTypeArgument
+ returnTypeProjection
  )
 
  val newFunTarget = FirFunctionTarget(null, isLambda = false)
@@ -768,6 +790,7 @@ class SuspendTransformFirTransformer(
  emptyList(),
  null,
  thisValueParameters,
+ emptyList(),
  funData.transformerFunctionSymbol(
  transformerFunctionSymbolMap,
  ::findTransformerFunctionSymbol
@@ -987,24 +1010,29 @@ class SuspendTransformFirTransformer(
  ): FirTypeRef {
  val transformer = funData.transformer
 
- val returnTypeConeType: ConeKotlinType = returnTypeFromProjection?.toConeTypeProjection()?.let {
- // TODO if is star projection, use Any or Nothing? and the nullable?
- it.type
- ?.copyConeTypeOrSelf(originalTypeParameterCache)
- ?: session.builtinTypes.nullableAnyType.coneType
- } ?: returnTypeRef.coneType
+ // val returnTypeConeType: ConeKotlinType = if (returnTypeFromProjection != null) {
+ // returnTypeFromProjection.toConeTypeProjection().type
+ // ?: session.builtinTypes.nullableAnyType.coneType
+ // } else {
+ // returnTypeRef.coneType
+ // }
+
+ // val returnTypeConeType: ConeKotlinType = returnTypeFromProjection?.toConeTypeProjection()?.let {
+ // // TODO if is star projection, use Any or Nothing? and the nullable?
+ // it.type
+ // ?.copyConeTypeOrSelf(originalTypeParameterCache)
+ // ?: session.builtinTypes.nullableAnyType.coneType
+ // } ?: returnTypeRef.coneType
 
- val resultConeType: ConeKotlinType = resolveReturnConeType(transformer, returnTypeConeType)
+ val resultConeType: ConeKotlinType = resolveReturnConeType(transformer, returnTypeRef.coneType)
 
  return if (resultConeType is ConeErrorType) {
  buildErrorTypeRef {
  diagnostic = resultConeType.diagnostic
  coneType = resultConeType
  }
  } else {
- buildResolvedTypeRef {
- coneType = resultConeType
- }
+ resultConeType.toResolvedTypeRef()
  }
  }
 
@@ -1073,9 +1101,7 @@ class SuspendTransformFirTransformer(
  */
  val copied: List<FirAnnotation> = notCompileAnnotationsCopied.map { a ->
  buildAnnotation {
- annotationTypeRef = buildResolvedTypeRef {
- coneType = a.resolvedType
- }
+ annotationTypeRef = a.resolvedType.toResolvedTypeRef()
 
  this.typeArguments.addAll(a.typeArguments)
  this.argumentMapping = buildAnnotationArgumentMapping {
@@ -1099,9 +1125,7 @@ class SuspendTransformFirTransformer(
 
  val includeAnnotation = buildAnnotation {
  argumentMapping = buildAnnotationArgumentMapping()
- annotationTypeRef = buildResolvedTypeRef {
- coneType = classId.createConeType(session)
- }
+ annotationTypeRef = classId.createConeType(session).toResolvedTypeRef()
  }
  add(includeAnnotation)
  }
@@ -1125,9 +1149,7 @@ class SuspendTransformFirTransformer(
  mapping[Name.identifier(annotationMarkNamePropertyName)] = markNameArgument
  }
  val markNameAnnotationClassId = markNameProperty.annotation.toClassId()
- annotationTypeRef = buildResolvedTypeRef {
- coneType = markNameAnnotationClassId.createConeType(session)
- }
+ annotationTypeRef = markNameAnnotationClassId.createConeType(session).toResolvedTypeRef()
  }
 
  add(markNameAnnotation)
@@ -1152,9 +1174,7 @@ class SuspendTransformFirTransformer(
  val classId = include.classId
  val includeAnnotation = buildAnnotation {
  argumentMapping = buildAnnotationArgumentMapping()
- annotationTypeRef = buildResolvedTypeRef {
- coneType = classId.createConeType(session)
- }
+ annotationTypeRef = classId.createConeType(session).toResolvedTypeRef()
  }
  add(includeAnnotation)
  }
@@ -1175,9 +1195,7 @@ class SuspendTransformFirTransformer(
 
  buildAnnotation {
  argumentMapping = buildAnnotationArgumentMapping()
- annotationTypeRef = buildResolvedTypeRef {
- coneType = classId.createConeType(session)
- }
+ annotationTypeRef = classId.createConeType(session).toResolvedTypeRef()
  }
  }
 

compiler/suspend-transform-plugin/src/main/kotlin/love/forte/plugin/suspendtrans/utils/FirUtils.kt

@@ -2,7 +2,18 @@ package love.forte.plugin.suspendtrans.utils
 
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.builder.FirResolvedTypeRefBuilder
+import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 
-fun FirSimpleFunction.includeAnnotations(includes: List<FirAnnotation>) {
+internal fun FirSimpleFunction.includeAnnotations(includes: List<FirAnnotation>) {
  replaceAnnotations(symbol.resolvedAnnotationsWithArguments + includes)
 }
+
+internal inline fun ConeKotlinType.toResolvedTypeRef(
+ block: FirResolvedTypeRefBuilder.() -> Unit = {}
+): FirResolvedTypeRef = buildResolvedTypeRef {
+ coneType = this@toResolvedTypeRef
+ block()
+}

compiler/suspend-transform-plugin/src/test-gen/love/forte/plugin/suspendtrans/runners/CodeGenTestRunnerGenerated.java

@@ -85,10 +85,4 @@ public void testVarargParam() {
  public void testMarkName() {
  runTest("src/testData/codegen/markName.kt");
  }
-
- @Test
- @TestMetadata("typedAnno.kt")
- public void typedAnno() {
- runTest("src/testData/codegen/typedAnno.kt");
- }
 }

compiler/suspend-transform-plugin/src/test/love/forte/plugin/suspendtrans/runners/AbstractTestRunner.kt

@@ -39,14 +39,13 @@ abstract class AbstractTestRunner : AbstractKotlinCompilerTest() {
  val targetFrontend: FrontendKind<*> = FrontendKinds.FIR
  builder.globalDefaults {
  frontend = targetFrontend
- targetBackend = TargetBackend.JVM_IR
+ targetBackend = TargetBackend.JVM_IR_SERIALIZE
  targetPlatform = JvmPlatforms.defaultJvmPlatform
  artifactKind = ArtifactKinds.Jvm
  dependencyKind = DependencyKind.Source
  backendKind = BackendKinds.IrBackendForK1AndK2
 // this.languageVersionSettings
 
-
 // languageSettings {
 // languageVersion = LanguageVersion.KOTLIN_2_1
 // apiVersion = ApiVersion.KOTLIN_2_1