StackOverflowError on circular reference #376

Mr3zee · Mr3zee · commit 390b0d71ee55 · 2025-07-07T13:51:25.000+02:00
diff --git a/compiler-plugin/compiler-plugin-k2/src/main/kotlin/kotlinx/rpc/codegen/checkers/FirRpcStrictModeClassChecker.kt b/compiler-plugin/compiler-plugin-k2/src/main/kotlin/kotlinx/rpc/codegen/checkers/FirRpcStrictModeClassChecker.kt
@@ -74,7 +74,7 @@ object FirRpcStrictModeClassChecker {
         } memoryOptimizedPlus (function.resolvedReturnTypeRef.source to function.resolvedReturnTypeRef)
 
         types.forEach { (source, symbol) ->
-            checkSerializableTypes<FirClassLikeSymbol<*>>(
+            checkSerializableTypes(
                 context = context,
                 typeRef = symbol,
                 serializablePropertiesProvider = serializablePropertiesProvider,
@@ -96,8 +96,6 @@ object FirRpcStrictModeClassChecker {
                         }
                     }
                 }
-
-                symbol
             }
         }
 
@@ -106,25 +104,27 @@ object FirRpcStrictModeClassChecker {
         }
     }
 
-    private fun <ContextElement> checkSerializableTypes(
+    private fun checkSerializableTypes(
         context: CheckerContext,
         typeRef: FirTypeRef,
         serializablePropertiesProvider: FirSerializablePropertiesProvider,
-        parentContext: List<ContextElement> = emptyList(),
-        checker: (FirClassLikeSymbol<*>, List<ContextElement>) -> ContextElement?,
+        parentContext: List<FirClassLikeSymbol<*>> = emptyList(),
+        checker: (FirClassLikeSymbol<*>, List<FirClassLikeSymbol<*>>) -> Unit,
     ) {
         val symbol = typeRef.toClassLikeSymbol(context.session) ?: return
-        val newElement = checker(symbol, parentContext)
-        val nextContext = if (newElement != null) {
-            parentContext memoryOptimizedPlus newElement
-        } else {
-            parentContext
+
+        if (symbol in parentContext) {
+            return
         }
 
+        checker(symbol, parentContext)
+
         if (symbol !is FirClassSymbol<*>) {
             return
         }
 
+        val nextContext = parentContext memoryOptimizedPlus symbol
+
         val extracted = extractArgumentsTypeRefAndSource(typeRef)
             .orEmpty()
             .withIndex()
diff --git a/compiler-plugin/gradle.properties b/compiler-plugin/gradle.properties
@@ -15,7 +15,7 @@ org.gradle.parallel=true
 org.gradle.workers.max=8
 org.gradle.caching=true
 org.gradle.configuration-cache=true
-org.gradle.configureondemand=true
+#org.gradle.configureondemand=true // breaks compiler tests
 
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true
diff --git a/dokka-plugin/gradle.properties b/dokka-plugin/gradle.properties
@@ -15,7 +15,7 @@ org.gradle.parallel=true
 org.gradle.workers.max=8
 org.gradle.caching=true
 org.gradle.configuration-cache=true
-org.gradle.configureondemand=true
+#org.gradle.configureondemand=true // breaks compiler tests
 
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true
diff --git a/gradle-conventions/src/main/kotlin/conventions-common.gradle.kts b/gradle-conventions/src/main/kotlin/conventions-common.gradle.kts
@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
 import io.gitlab.arturbosch.detekt.Detekt
diff --git a/gradle-conventions/src/main/kotlin/conventions-kmp.gradle.kts b/gradle-conventions/src/main/kotlin/conventions-kmp.gradle.kts
@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
 @file:OptIn(ExperimentalAbiValidation::class)
diff --git a/gradle-conventions/src/main/kotlin/conventions-publishing.gradle.kts b/gradle-conventions/src/main/kotlin/conventions-publishing.gradle.kts
@@ -138,15 +138,6 @@ fun RepositoryHandler.configureLocalDevRepository() {
     }
 }
 
-val sonatypeRepositoryUri: String?
-    get() {
-        val repositoryId: String = project.getSensitiveProperty("libs.repository.id")
-            ?.takeIf { it.isNotBlank() }
-            ?: return null
-
-        return "https://oss.sonatype.org/service/local/staging/deployByRepositoryId/$repositoryId"
-    }
-
 fun configureEmptyJavadocArtifact(): TaskProvider<Jar?> {
     val javadocJar by project.tasks.registering(Jar::class) {
         archiveClassifier.set("javadoc")
diff --git a/gradle-plugin/gradle.properties b/gradle-plugin/gradle.properties
@@ -15,7 +15,7 @@ org.gradle.parallel=true
 org.gradle.workers.max=8
 org.gradle.caching=true
 org.gradle.configuration-cache=true
-org.gradle.configureondemand=true
+#org.gradle.configureondemand=true // breaks compiler tests
 
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true
diff --git a/gradle.properties b/gradle.properties
@@ -15,7 +15,7 @@ org.gradle.parallel=true
 org.gradle.workers.max=8
 org.gradle.caching=true
 org.gradle.configuration-cache=true
-org.gradle.configureondemand=true
+#org.gradle.configureondemand=true // breaks compiler tests
 
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true
diff --git a/tests/compiler-plugin-tests/src/testData/diagnostics/strictMode.fir.txt b/tests/compiler-plugin-tests/src/testData/diagnostics/strictMode.fir.txt
@@ -48,6 +48,37 @@ FILE: b.kt
 
         public final fun copy(flow1: R|kotlinx/coroutines/flow/Flow<kotlin/Int>| = this@R|/MultiFlow|.R|/MultiFlow.flow1|, flow2: R|kotlinx/coroutines/flow/Flow<kotlin/Int>| = this@R|/MultiFlow|.R|/MultiFlow.flow2|, flow3: R|kotlinx/coroutines/flow/Flow<kotlin/Int>| = this@R|/MultiFlow|.R|/MultiFlow.flow3|): R|MultiFlow|
 
+    }
+    public final data class ComplexFilter : R|kotlin/Any| {
+        public constructor(a: R|SimpleFilter?|, b: R|ComplexFilter?|): R|ComplexFilter| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final val a: R|SimpleFilter?| = R|<local>/a|
+            public get(): R|SimpleFilter?|
+
+        public final val b: R|ComplexFilter?| = R|<local>/b|
+            public get(): R|ComplexFilter?|
+
+        public final operator fun component1(): R|SimpleFilter?|
+
+        public final operator fun component2(): R|ComplexFilter?|
+
+        public final fun copy(a: R|SimpleFilter?| = this@R|/ComplexFilter|.R|/ComplexFilter.a|, b: R|ComplexFilter?| = this@R|/ComplexFilter|.R|/ComplexFilter.b|): R|ComplexFilter|
+
+    }
+    public final data class SimpleFilter : R|kotlin/Any| {
+        public constructor(text: R|kotlin/String|): R|SimpleFilter| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final val text: R|kotlin/String| = R|<local>/text|
+            public get(): R|kotlin/String|
+
+        public final operator fun component1(): R|kotlin/String|
+
+        public final fun copy(text: R|kotlin/String| = this@R|/SimpleFilter|.R|/SimpleFilter.text|): R|SimpleFilter|
+
     }
     @R|kotlinx/rpc/annotations/Rpc|() public abstract interface MyService : R|kotlin/Any| {
         public abstract val flow: R|kotlinx/coroutines/flow/Flow<kotlin/Int>|
@@ -105,6 +136,8 @@ FILE: b.kt
 
         public abstract fun nonSuspendNoFlowString(): R|kotlin/String|
 
+        public abstract suspend fun complex(filter: R|ComplexFilter|): R|kotlin/String|
+
         public final class $rpcServiceStub : R|kotlin/Any| {
             public final companion object Companion : R|kotlin/Any| {
             }
diff --git a/tests/compiler-plugin-tests/src/testData/diagnostics/strictMode.kt b/tests/compiler-plugin-tests/src/testData/diagnostics/strictMode.kt
@@ -29,6 +29,13 @@ data class MultiFlow(
     val flow3: Flow<Int>,
 )
 
+data class ComplexFilter(
+    val a: SimpleFilter?,
+    val b: ComplexFilter?
+)
+
+data class SimpleFilter(val text: String)
+
 @Rpc
 interface MyService {
     <!FIELD_IN_RPC_SERVICE!>val flow: Flow<Int><!>
@@ -44,17 +51,18 @@ interface MyService {
     <!NON_SUSPENDING_REQUEST_WITHOUT_STREAMING_RETURN_TYPE!>fun notTopLevelServerFlow(): <!NON_TOP_LEVEL_SERVER_STREAMING_IN_RPC_SERVICE!>InnerFlow<!><!>
     <!NON_SUSPENDING_REQUEST_WITHOUT_STREAMING_RETURN_TYPE!>fun wrappedNotTopLevelServerFlow(): <!NON_TOP_LEVEL_SERVER_STREAMING_IN_RPC_SERVICE!>Wrapper<Flow<Int>><!><!>
     suspend fun wrappedALot(): Wrapper<Wrapper<Wrapper<Wrapper<Int>>>>
-    <!NON_SUSPENDING_REQUEST_WITHOUT_STREAMING_RETURN_TYPE!>fun wrappedALotFlow(): <!NON_TOP_LEVEL_SERVER_STREAMING_IN_RPC_SERVICE!>Wrapper<Wrapper<Wrapper<Flow<Int>>>><!><!>
+    <!NON_SUSPENDING_REQUEST_WITHOUT_STREAMING_RETURN_TYPE!>fun wrappedALotFlow(): Wrapper<Wrapper<Wrapper<Flow<Int>>>><!>
     suspend fun notTopLevelClientFlow(flow: InnerFlow)
-    fun nestedServerFlow(): <!NESTED_STREAMING_IN_RPC_SERVICE!>Flow<Flow<Int>><!>
-    fun nestedServerTrickyFlow(): <!NESTED_STREAMING_IN_RPC_SERVICE!>Flow<Wrapper<Flow<Int>>><!>
+    fun nestedServerFlow(): Flow<Flow<Int>>
+    fun nestedServerTrickyFlow(): Flow<Wrapper<Flow<Int>>>
     <!NON_SUSPENDING_REQUEST_WITHOUT_STREAMING_RETURN_TYPE!>fun serverMultiFlow(): <!NON_TOP_LEVEL_SERVER_STREAMING_IN_RPC_SERVICE, NON_TOP_LEVEL_SERVER_STREAMING_IN_RPC_SERVICE, NON_TOP_LEVEL_SERVER_STREAMING_IN_RPC_SERVICE!>MultiFlow<!><!>
     suspend fun clientMultiFlow(flow: MultiFlow)
     suspend fun clientMultiFlowMany(flow: MultiFlow, flow2: MultiFlow, flow3: MultiFlow)
     suspend fun clientMultiFlowPlain(flow: Flow<Int>, flow2: Flow<Int>, flow3: Flow<Int>)
     suspend fun clientInnerFlow(inner: InnerFlow)
-    suspend fun clientNestedFlow(<!NESTED_STREAMING_IN_RPC_SERVICE!>inner: Flow<Flow<Int>><!>)
-    suspend fun clientNestedTrickyFlow(<!NESTED_STREAMING_IN_RPC_SERVICE!>inner: Wrapper<Flow<Wrapper<Flow<Int>>>><!>)
+    suspend fun clientNestedFlow(inner: Flow<Flow<Int>>)
+    suspend fun clientNestedTrickyFlow(inner: Wrapper<Flow<Wrapper<Flow<Int>>>>)
     <!NON_SUSPENDING_REQUEST_WITHOUT_STREAMING_RETURN_TYPE!>fun nonSuspendNoFlow()<!>
     <!NON_SUSPENDING_REQUEST_WITHOUT_STREAMING_RETURN_TYPE!>fun nonSuspendNoFlowString(): String<!>
+    suspend fun complex(filter: ComplexFilter): String // doesn't fail on circular dependency
 }
diff --git a/updateTestData.sh b/updateTestData.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 #
-# Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+# Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
 #
 
 if [ "$#" -ne 1 ] && [ "$#" -ne 2 ]; then
@@ -23,4 +23,5 @@ set -o xtrace
     :tests:compiler-plugin-tests:test \
     --tests "kotlinx.rpc.codegen.test.runners.$1Generated$TEST_NAME" \
     --continue \
+    --stacktrace \
     -Pkotlin.test.update.test.data=true

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ object FirRpcStrictModeClassChecker {`
`74`	`74`	`} memoryOptimizedPlus (function.resolvedReturnTypeRef.source to function.resolvedReturnTypeRef)`
`75`	`75`
`76`	`76`	`types.forEach { (source, symbol) ->`
`77`		`- checkSerializableTypes<FirClassLikeSymbol<*>>(`
	`77`	`+ checkSerializableTypes(`
`78`	`78`	`context = context,`
`79`	`79`	`typeRef = symbol,`
`80`	`80`	`serializablePropertiesProvider = serializablePropertiesProvider,`
`@@ -96,8 +96,6 @@ object FirRpcStrictModeClassChecker {`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`}`
`99`		`-`
`100`		`- symbol`
`101`	`99`	`}`
`102`	`100`	`}`
`103`	`101`
`@@ -106,25 +104,27 @@ object FirRpcStrictModeClassChecker {`
`106`	`104`	`}`
`107`	`105`	`}`
`108`	`106`
`109`		`- private fun <ContextElement> checkSerializableTypes(`
	`107`	`+ private fun checkSerializableTypes(`
`110`	`108`	`context: CheckerContext,`
`111`	`109`	`typeRef: FirTypeRef,`
`112`	`110`	`serializablePropertiesProvider: FirSerializablePropertiesProvider,`
`113`		`- parentContext: List<ContextElement> = emptyList(),`
`114`		`- checker: (FirClassLikeSymbol<*>, List<ContextElement>) -> ContextElement?,`
	`111`	`+ parentContext: List<FirClassLikeSymbol<*>> = emptyList(),`
	`112`	`+ checker: (FirClassLikeSymbol<>, List<FirClassLikeSymbol<>>) -> Unit,`
`115`	`113`	`) {`
`116`	`114`	`val symbol = typeRef.toClassLikeSymbol(context.session) ?: return`
`117`		`- val newElement = checker(symbol, parentContext)`
`118`		`- val nextContext = if (newElement != null) {`
`119`		`- parentContext memoryOptimizedPlus newElement`
`120`		`- } else {`
`121`		`- parentContext`
	`115`	`+`
	`116`	`+ if (symbol in parentContext) {`
	`117`	`+ return`
`122`	`118`	`}`
`123`	`119`
	`120`	`+ checker(symbol, parentContext)`
	`121`	`+`
`124`	`122`	`if (symbol !is FirClassSymbol<*>) {`
`125`	`123`	`return`
`126`	`124`	`}`
`127`	`125`
	`126`	`+ val nextContext = parentContext memoryOptimizedPlus symbol`
	`127`	`+`
`128`	`128`	`val extracted = extractArgumentsTypeRefAndSource(typeRef)`
`129`	`129`	`.orEmpty()`
`130`	`130`	`.withIndex()`