[AA] AbstractSymbolTest: improve implicit checks

^KT-54826

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/symbols/AbstractSymbolTest.kt

@@ -85,20 +85,22 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiSingleFileTest() {
             analyseForTest(ktFile) {
                 val (symbols, symbolForPrettyRendering) = collectSymbols(ktFile, testServices)
 
-                val pointerWithRenderedSymbol = symbols.flatMap { symbol ->
+                val pointerWithRenderedSymbol = symbols
-                    listOf(
+                    .asSequence()
+                    .flatMap { symbol ->
+                        sequenceOf(symbol to true) + symbol.withImplicitSymbols().map { implicitSymbol ->
+                            implicitSymbol to false
+                        }
+                    }
+                    .distinctBy { it.first }
+                    .map { (symbol, shouldBeRendered) ->
                         PointerWithRenderedSymbol(
-                            symbol.safePointer(),
+                            pointer = symbol.safePointer(),
-                            renderSymbolForComparison(symbol),
+                            rendered = renderSymbolForComparison(symbol),
-                        )
+                            shouldBeRendered = shouldBeRendered,
-                    ) + symbol.withImplicitSymbols().map { implicitSymbol ->
-                        PointerWithRenderedSymbol(
-                            implicitSymbol.safePointer(),
-                            renderSymbolForComparison(implicitSymbol),
-                            shouldBeRendered = false,
                         )
                     }
-                }
+                    .toList()
 
                 val pointerWithPrettyRenderedSymbol = symbolForPrettyRendering.map { symbol ->
                     PointerWithRenderedSymbol(
@@ -281,10 +283,22 @@ private data class PointerWrapper(
     val pointerWithoutPsiAnchor: KtSymbolPointer<*>?,
 )
 
-private fun KtSymbol?.withImplicitSymbols(): List<KtSymbol> = when (this) {
+private fun KtSymbol?.withImplicitSymbols(): Sequence<KtSymbol> {
-    null -> emptyList()
+    val ktSymbol = this ?: return emptySequence()
-    is KtPropertySymbol -> listOf(this) + setter.withImplicitSymbols() + getter.withImplicitSymbols()
+    return sequence {
-    is KtPropertySetterSymbol -> listOf(this) + parameter
+        yield(ktSymbol)
-    is KtValueParameterSymbol -> listOf(this) + generatedPrimaryConstructorProperty.withImplicitSymbols()
+
-    else -> listOf(this)
+        if (ktSymbol is KtPropertySymbol) {
+            yieldAll(ktSymbol.getter.withImplicitSymbols())
+            yieldAll(ktSymbol.setter.withImplicitSymbols())
+        }
+
+        if (ktSymbol is KtPropertySetterSymbol) {
+            yieldAll(ktSymbol.parameter.withImplicitSymbols())
+        }
+
+        if (ktSymbol is KtValueParameterSymbol) {
+            yieldAll(ktSymbol.generatedPrimaryConstructorProperty.withImplicitSymbols())
+        }
+    }
 }