[AA] improve symbol pointers for property accessors

Fe10:
* supported default setter
* support default getter
* support parameter from default setter

Fir:
* support java synthetic properties
* support parameter from default setter

^KT-54051

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/symbols/pointers/KtPropertyAccessorSymbolPointer.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.impl.base.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyAccessorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+
+@KtAnalysisApiInternals
+class KtPropertyAccessorSymbolPointer(
+    private val propertySymbolPointer: KtSymbolPointer<KtPropertySymbol>,
+    private val isGetter: Boolean,
+) : KtSymbolPointer<KtPropertyAccessorSymbol>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtPropertyAccessorSymbol? {
+        val propertySymbol = with(analysisSession) {
+            propertySymbolPointer.restoreSymbol()
+        } ?: return null
+
+        return if (isGetter) propertySymbol.getter else propertySymbol.setter
+    }
+}

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/symbols/pointers/KtValueParameterFromDefaultSetterSymbolPointer.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.impl.base.symbols.pointers
+
+import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+
+@KtAnalysisApiInternals
+class KtValueParameterFromDefaultSetterSymbolPointer(
+    private val ownerPointer: KtSymbolPointer<KtPropertySymbol>,
+) : KtSymbolPointer<KtValueParameterSymbol>() {
+    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
+    override fun restoreSymbol(analysisSession: KtAnalysisSession): KtValueParameterSymbol? {
+        val ownerSymbol = with(analysisSession) {
+            ownerPointer.restoreSymbol()
+        }
+
+        return ownerSymbol?.setter?.parameter
+    }
+}

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/scopes/AbstractMemberScopeByFqNameTest.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.impl.base.test.SymbolByFqName
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.AbstractSymbolByFqNameTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolsData
-import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.services.TestServices

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

@@ -85,11 +85,19 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiSingleFileTest() {
             analyseForTest(ktFile) {
                 val (symbols, symbolForPrettyRendering) = collectSymbols(ktFile, testServices)
 
-                val pointerWithRenderedSymbol = symbols.map { symbol ->
-                    PointerWithRenderedSymbol(
-                        symbol.safePointer(),
-                        renderSymbolForComparison(symbol),
-                    )
+                val pointerWithRenderedSymbol = symbols.flatMap { symbol ->
+                    listOf(
+                        PointerWithRenderedSymbol(
+                            symbol.safePointer(),
+                            renderSymbolForComparison(symbol),
+                        )
+                    ) + symbol.withImplicitSymbols().map { implicitSymbol ->
+                        PointerWithRenderedSymbol(
+                            implicitSymbol.safePointer(),
+                            renderSymbolForComparison(implicitSymbol),
+                            shouldBeRendered = false,
+                        )
+                    }
                 }
 
                 val pointerWithPrettyRenderedSymbol = symbolForPrettyRendering.map { symbol ->
@@ -105,7 +113,7 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiSingleFileTest() {
 
                             is KtReceiverParameterSymbol -> DebugSymbolRenderer().render(symbol)
                             else -> error(symbol::class.toString())
-                        }
+                        },
                     )
                 }
 
@@ -168,7 +176,7 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiSingleFileTest() {
     }
 
     private fun List<PointerWithRenderedSymbol>.renderDeclarations(): String =
-        map { it.rendered }.renderAsDeclarations()
+        mapNotNull { it.rendered.takeIf { _ -> it.shouldBeRendered } }.renderAsDeclarations()
 
     private fun List<String>.renderAsDeclarations(): String =
         if (isEmpty()) "NO_SYMBOLS"
@@ -184,10 +192,16 @@ abstract class AbstractSymbolTest : AbstractAnalysisApiSingleFileTest() {
         var failed = false
         try {
             val restored = analyseForTest(ktFile) {
-                pointersWithRendered.map { (pointerWrapper, expectedRender) ->
+                pointersWithRendered.mapNotNull { (pointerWrapper, expectedRender, shouldBeRendered) ->
                     val pointer = pointerWrapper?.let(pointerAccessor) ?: error("Symbol pointer for $expectedRender was not created")
                     val restored = pointer.restoreSymbol() ?: error("Symbol $expectedRender was not restored")
-                    renderSymbolForComparison(restored)
+                    val actualRender = renderSymbolForComparison(restored)
+                    if (shouldBeRendered) {
+                        actualRender
+                    } else {
+                        testServices.assertions.assertEquals(expectedRender, actualRender) { "${restored::class}" }
+                        null
+                    }
                 }
             }
 
@@ -259,9 +273,18 @@ private data class SymbolPointersData(
 private data class PointerWithRenderedSymbol(
     val pointer: PointerWrapper?,
     val rendered: String,
+    val shouldBeRendered: Boolean = true,
 )
 
 private data class PointerWrapper(
     val regularPointer: KtSymbolPointer<*>,
     val pointerWithoutPsiAnchor: KtSymbolPointer<*>?,
 )
+
+private fun KtSymbol?.withImplicitSymbols(): List<KtSymbol> = when (this) {
+    null -> emptyList()
+    is KtPropertySymbol -> listOf(this) + setter.withImplicitSymbols() + getter.withImplicitSymbols()
+    is KtPropertySetterSymbol -> listOf(this) + parameter
+    is KtValueParameterSymbol -> listOf(this) + generatedPrimaryConstructorProperty.withImplicitSymbols()
+    else -> listOf(this)
+}