Update Kotlin to v2.1.20

.github/workflows/publish-release.yml

@@ -17,6 +17,7 @@ env:
   IS_CI: true
   SIMBOT_LOCAL: false
   GRADLE_OPTS: "-Dfile.encoding=UTF-8"
+  GRADLE_VERSION: 8.10.2
 
 jobs:
   test:
@@ -34,7 +35,7 @@ jobs:
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v3
         with:
-          gradle-version: 8.5
+          gradle-version: ${{ env.GRADLE_VERSION }}
       - run: gradle assemble build -s
 
   publish:
@@ -53,7 +54,7 @@ jobs:
       - name: Test and publish to sonatype
         uses: gradle/actions/setup-gradle@v3
         with:
-          gradle-version: 8.5
+          gradle-version: ${{ env.GRADLE_VERSION }}
           arguments:
             publishToSonatype
             closeAndReleaseStagingRepositories
@@ -86,7 +87,7 @@ jobs:
       - name: Publish to gradle
         uses: gradle/actions/setup-gradle@v3
         with:
-          gradle-version: 8.5
+          gradle-version: ${{ env.GRADLE_VERSION }}
           arguments: |
             build
             publishPlugins
@@ -117,7 +118,7 @@ jobs:
       - name: Create changelog
         uses: gradle/actions/setup-gradle@v3
         with:
-          gradle-version: 8.5
+          gradle-version: ${{ env.GRADLE_VERSION }}
           arguments: createChangelog
 
         # https://github.com/softprops/action-gh-release

.github/workflows/test-branch.yml

@@ -0,0 +1,59 @@
+name: Test Branch
+on:
+  pull_request:
+    branches:
+      - 'dev'
+    paths:
+      - '**.java'
+      - '**.kt'
+      - '**.kts'
+      - '*/src/*/kotlin/**'
+      - '*/src/*/java/**'
+      - '*/src/*/resource/**'
+      - 'gradle/**'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  IS_CI: true
+  GRADLE_OPTS: "-Dfile.encoding=UTF-8"
+  GRADLE_VERSION: 8.10.2
+
+jobs:
+  build-test:
+    name: Build and test
+    strategy:
+      matrix:
+        os: [ macos-latest, windows-latest, ubuntu-latest ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: 11
+          cache: 'gradle'
+
+      - name: Run All Tests
+        uses: gradle/actions/setup-gradle@v3
+        with:
+          gradle-version: ${{ env.GRADLE_VERSION }}
+          arguments: |
+            assemble
+            build
+            test
+            --info 
+            --warning-mode all
+#            --build-cache
+#            -Porg.gradle.daemon=false
+#            -Porg.gradle.jvmargs="-Xmx4g -Xms2g -XX:MaxMetaspaceSize=1g -Dfile.encoding=UTF-8"
+
+      - name: Upload test reports
+        uses: actions/upload-artifact@v4
+        if: ${{ always() }}
+        with:
+          name: test-reports-${{ matrix.os }}
+          path: '**/build/reports/tests'
+          retention-days: 7

buildSrc/src/main/kotlin/IProject.kt

@@ -10,7 +10,7 @@ object IProject : ProjectDetail() {
     const val HOMEPAGE = "https://github.com/ForteScarlet/kotlin-suspend-transform-compiler-plugin"
 
     // Remember the libs.versions.toml!
-    val ktVersion = "2.1.0"
+    val ktVersion = "2.1.20"
     val pluginVersion = "0.11.1"
 
     override val version: String = "$ktVersion-$pluginVersion"

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

@@ -195,11 +195,13 @@ class SuspendTransformFirTransformer(
     }
 
     private fun List<FirValueParameter>.mapToNewValueParameters(
-        originalTypeParameterCache: MutableList<CopiedTypeParameterPair>
+        originalTypeParameterCache: MutableList<CopiedTypeParameterPair>,
+        newContainingDeclarationSymbol: FirBasedSymbol<*>
     ): List<FirValueParameter> {
         return map { vp ->
             buildValueParameterCopy(vp) {
                 symbol = FirValueParameterSymbol(vp.symbol.name)
+                containingDeclarationSymbol = newContainingDeclarationSymbol
 
                 val copiedConeType = vp.returnTypeRef.coneTypeOrNull
                     ?.copyWithTypeParameters(originalTypeParameterCache)
@@ -211,11 +213,16 @@ class SuspendTransformFirTransformer(
         }
     }
 
-    private fun FirReceiverParameter.copyToNew(originalTypeParameterCache: MutableList<CopiedTypeParameterPair>): FirReceiverParameter? {
+    private fun FirReceiverParameter.copyToNew(
+        originalTypeParameterCache: MutableList<CopiedTypeParameterPair>,
+        newContainingDeclarationSymbol: FirBasedSymbol<*>
+    ): FirReceiverParameter? {
         return typeRef.coneTypeOrNull
             ?.copyWithTypeParameters(originalTypeParameterCache)
             ?.let { foundCopied ->
                 buildReceiverParameterCopy(this) {
+                    symbol = FirReceiverParameterSymbol()
+                    containingDeclarationSymbol = newContainingDeclarationSymbol
                     typeRef = typeRef.withReplacedConeType(foundCopied)
                 }
             }
@@ -231,17 +238,28 @@ class SuspendTransformFirTransformer(
     }
 
     private fun FirSimpleFunctionBuilder.copyParameters() {
+        val newFunSymbol = symbol
         val originalTypeParameterCache = mutableListOf<CopiedTypeParameterPair>()
 
-        val newTypeParameters = typeParameters.mapToNewTypeParameters(symbol, originalTypeParameterCache)
+        val newTypeParameters = typeParameters.mapToNewTypeParameters(newFunSymbol, originalTypeParameterCache)
         typeParameters.clear()
         typeParameters.addAll(newTypeParameters)
 
-        val newValueParameters = valueParameters.mapToNewValueParameters(originalTypeParameterCache)
+        val newContextParameters = contextParameters.mapToNewValueParameters(
+            originalTypeParameterCache,
+            newFunSymbol,
+        )
+        contextParameters.clear()
+        contextParameters.addAll(newContextParameters)
+
+        val newValueParameters = valueParameters.mapToNewValueParameters(
+            originalTypeParameterCache,
+            newFunSymbol
+        )
         valueParameters.clear()
         valueParameters.addAll(newValueParameters)
 
-        receiverParameter?.copyToNew(originalTypeParameterCache)?.also {
+        receiverParameter?.copyToNew(originalTypeParameterCache, newFunSymbol)?.also {
             this.receiverParameter = it
         }
 
@@ -254,13 +272,18 @@ class SuspendTransformFirTransformer(
 
     private fun FirPropertyAccessorBuilder.copyParameters(
         originalTypeParameterCache: MutableList<CopiedTypeParameterPair> = mutableListOf(),
-        copyReturnType: Boolean = true
+        copyReturnType: Boolean = true,
+        newFunSymbol: FirBasedSymbol<*>,
     ) {
-        val newTypeParameters = typeParameters.mapToNewTypeParameters(symbol, originalTypeParameterCache)
-        typeParameters.clear()
-        typeParameters.addAll(newTypeParameters)
-
-        val newValueParameters = valueParameters.mapToNewValueParameters(originalTypeParameterCache)
+        // 的确，property 哪儿来的 type parameter
+//        val newTypeParameters = typeParameters.mapToNewTypeParameters(symbol, originalTypeParameterCache)
+//        typeParameters.clear()
+//        typeParameters.addAll(newTypeParameters)
+
+        val newValueParameters = valueParameters.mapToNewValueParameters(
+            originalTypeParameterCache,
+            newFunSymbol
+        )
         valueParameters.clear()
         valueParameters.addAll(newValueParameters)
 
@@ -303,10 +326,12 @@ class SuspendTransformFirTransformer(
         originFunc: FirSimpleFunction,
         originFunSymbol: FirNamedFunctionSymbol,
         owner: FirClassSymbol<*>,
-        thisContextReceivers: MutableList<FirContextReceiver>,
+//        thisContextReceivers: MutableList<FirContextReceiver>,
+        thisContextParameters: List<FirValueParameter>,
         thisReceiverParameter: FirReceiverParameter?,
         newFunSymbol: FirBasedSymbol<*>,
-        thisValueParameters: MutableList<FirValueParameter>,
+//        newFunSymbol: FirNamedFunctionSymbol,
+        thisValueParameters: List<FirValueParameter>,
         bridgeFunSymbol: FirNamedFunctionSymbol,
         newFunTarget: FirFunctionTarget,
         transformer: Transformer
@@ -347,13 +372,13 @@ class SuspendTransformFirTransformer(
                             }
                         }
 
-                        this.contextReceiverArguments.addAll(thisContextReceivers.map { receiver ->
+                        this.contextArguments.addAll(thisContextParameters.map { receiver ->
                             buildThisReceiverExpression {
-                                coneTypeOrNull = receiver.typeRef.coneTypeOrNull
+                                coneTypeOrNull = receiver.returnTypeRef.coneTypeOrNull
                                 source = receiver.source
                                 calleeReference = buildExplicitThisReference {
                                     source = receiver.source
-                                    labelName = receiver.labelName?.asString()
+                                    // labelName = receiver.labelName?.asString()
                                 }
                             }
                         })
@@ -364,7 +389,8 @@ class SuspendTransformFirTransformer(
                                 coneTypeOrNull = thisReceiverParameter.typeRef.coneTypeOrNull
                                 source = thisReceiverParameter.source
                                 calleeReference = buildImplicitThisReference {
-                                    boundSymbol = newFunSymbol
+                                    boundSymbol = thisReceiverParameter.symbol
+                                    println("[${newFunSymbol}] thisReceiverParameter.symbol: ${thisReceiverParameter.symbol}")
                                 }
                             }
                         }
@@ -596,7 +622,7 @@ class SuspendTransformFirTransformer(
                 returnTypeRef = resolveReturnType(funData.transformer, returnTypeRef)
 
                 val thisReceiverParameter = this.receiverParameter
-                val thisContextReceivers = this.contextReceivers
+                val thisContextParameters = this.contextParameters
                 val thisValueParameters = this.valueParameters
 
                 annotations.clear()
@@ -606,7 +632,7 @@ class SuspendTransformFirTransformer(
                     originFunc,
                     originFunSymbol,
                     owner,
-                    thisContextReceivers,
+                    thisContextParameters,
                     thisReceiverParameter,
                     newFunSymbol,
                     thisValueParameters,
@@ -713,7 +739,8 @@ class SuspendTransformFirTransformer(
                 deprecationsProvider = UnresolvedDeprecationProvider //original.deprecationsProvider
                 containerSource = original.containerSource
                 dispatchReceiverType = original.dispatchReceiverType
-                contextReceivers.addAll(original.contextReceivers)
+                contextParameters.addAll(original.contextParameters)
+//                contextReceivers.addAll(original.contextReceivers)
                 // annotations
                 annotations.addAll(propertyAnnotations)
                 typeParameters.addAll(original.typeParameters)
@@ -745,19 +772,19 @@ class SuspendTransformFirTransformer(
                     )
 
                     valueParameters.addAll(original.valueParameters)
-                    typeParameters.addAll(original.typeParameters)
-                    contextReceivers.addAll(original.contextReceivers)
+//                    typeParameters.addAll(original.typeParameters)
+//                    contextReceivers.addAll(original.contextReceivers)
 
-                    copyParameters(originalTypeParameterCache, false)
+                    copyParameters(originalTypeParameterCache, false, propertyAccessorSymbol)
 
-                    val thisContextReceivers = this.contextReceivers
+//                    val thisContextReceivers = this.contextReceivers
                     val thisValueParameters = this.valueParameters
 
                     body = generateSyntheticFunctionBody(
                         original,
                         originalFunSymbol,
                         owner,
-                        thisContextReceivers,
+                        emptyList(),
                         null,
                         propertyAccessorSymbol,
                         thisValueParameters,
@@ -991,7 +1018,6 @@ class SuspendTransformFirTransformer(
         transformer: Transformer,
         returnTypeRef: FirTypeRef
     ): ConeKotlinType {
-        val transformer = transformer
         val returnType = transformer.transformReturnType
             ?: return returnTypeRef.coneType // OrNull // original.symbol.resolvedReturnType
 
@@ -1370,12 +1396,13 @@ class SuspendTransformFirTransformer(
                         typeArguments = typeArguments,
                         nullable = isMarkedNullable
                     )
-                    // typeArguments.forEach { projection ->
-                    //     projection.type?.copyWithTypeParameters(parameters)
-                    // }
                 }
 
-                return null
+                if (isPrimitiveType()) {
+                    return this
+                }
+
+                return classId?.createConeType(session = session, nullable = isMarkedNullable)
             }
 
             is ConeTypeParameterType -> {

compiler/suspend-transform-plugin/src/main/kotlin/love/forte/plugin/suspendtrans/ir/SuspendTransformTransformer.kt

@@ -22,11 +22,10 @@ import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionExpressionImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.util.file
-import org.jetbrains.kotlin.ir.util.isAnnotationWithEqualFqName
-import org.jetbrains.kotlin.ir.util.kotlinFqName
-import org.jetbrains.kotlin.ir.util.primaryConstructor
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.defaultType
+import org.jetbrains.kotlin.ir.types.typeWith
+import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.wasm.ir.source.location.SourceLocation
@@ -43,7 +42,8 @@ class SuspendTransformTransformer(
     // TODO What should be used in K2?
     private val reporter = kotlin.runCatching {
         // error: "This API is not supported for K2"
-        pluginContext.createDiagnosticReporter(PLUGIN_REPORT_ID)
+        pluginContext.messageCollector
+//        pluginContext.createDiagnosticReporter(PLUGIN_REPORT_ID)
     }.getOrNull()
 
 
@@ -344,14 +344,14 @@ private fun IrFunction.reportLocation(): CompilerMessageSourceLocation? {
     return when (val sourceLocation =
 //        getSourceLocation(runCatching { fileEntry }.getOrNull())) {
         getSourceLocation(declaration = symbol, file = file)) {
-        is SourceLocation.Location -> {
+
+        is SourceLocation.WithFileAndLineNumberInformation ->
             CompilerMessageLocation.create(
                 path = sourceLocation.file,
                 line = sourceLocation.line,
                 column = sourceLocation.column,
                 lineContent = null
             )
-        }
 
         else -> null
     }
@@ -460,7 +460,14 @@ private fun generateTransformBodyForFunctionLambda(
                 for (index in 1..ownerValueParameters.lastIndex) {
                     val valueParameter = ownerValueParameters[index]
                     val type = valueParameter.type
-                    tryResolveCoroutineScopeValueParameter(type, context, function, transformFunctionOwner, this@irBlockBody, index)
+                    tryResolveCoroutineScopeValueParameter(
+                        type,
+                        context,
+                        function,
+                        transformFunctionOwner,
+                        this@irBlockBody,
+                        index
+                    )
                 }
             }