Do not filter out accessors of synthetic properties

dokka-subprojects/analysis-kotlin-symbols/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt

@@ -461,15 +461,8 @@ internal class DokkaSymbolVisitor(
         val javaFields = callables.filterIsInstance<KaJavaFieldSymbol>()
             .filterOutSyntheticJavaPropBackingField()
 
-
-        fun List<KaNamedFunctionSymbol>.filterOutSyntheticJavaPropAccessors() = filterNot { fn ->
-            if ((fn.origin == KaSymbolOrigin.JAVA_SOURCE || fn.origin == KaSymbolOrigin.JAVA_LIBRARY) && fn.psi != null)
-                syntheticJavaProperties.any { fn.psi == it.javaGetterSymbol.psi || fn.psi == it.javaSetterSymbol?.psi }
-            else false
-        }
-
         val functions = callables.filterIsInstance<KaNamedFunctionSymbol>()
-            .filterOutSyntheticJavaPropAccessors().map { visitFunctionSymbol(it, dri, isJavaContext) }
+            .map { visitFunctionSymbol(it, dri, isJavaContext) }
 
 
         val properties = callables.filterIsInstance<KaPropertySymbol>().map { visitPropertySymbol(it, dri, isJavaContext) } +

dokka-subprojects/plugin-base/src/test/kotlin/superFields/DescriptorSuperPropertiesTest.kt

@@ -220,7 +220,7 @@ class DescriptorSuperPropertiesTest : BaseAbstractTest() {
                 assertEquals("setA", property.setter?.name)
 
 
-                assertEquals(0, testedClass.functions.size)
+                assertEquals(2, testedClass.functions.size)
 
                 val inheritedFrom = property.extra[InheritedMember]?.inheritedFrom?.values?.single()
                 assertEquals(DRI(packageName = "test", classNames = "A"), inheritedFrom)
@@ -230,6 +230,7 @@ class DescriptorSuperPropertiesTest : BaseAbstractTest() {
         }
     }
 
+    @OnlySymbols("do not filter out accessors of Java synthetic properties")
     @Test
     fun `should inherit property visibility from getter`() {
         val configuration = dokkaConfiguration {
@@ -264,7 +265,7 @@ class DescriptorSuperPropertiesTest : BaseAbstractTest() {
         ) {
             documentablesMergingStage = { module ->
                 val testedClass = module.packages.single().classlikes.single { it.name == "B" }
-                assertEquals(0, testedClass.functions.size)
+                assertEquals(2, testedClass.functions.size)
 
                 val property = testedClass.properties.single { it.name == "a" }
 

dokka-subprojects/plugin-base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt

@@ -412,8 +412,9 @@ class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
         }
     }
 
+    @OnlyJavaPsi("do not filter out accessors of Java synthetic properties")
     @Test
-    fun `should ignore additional non-accessor setters`() {
+    fun `javaPSI - should ignore additional non-accessor setters`() {
         testInline(
             """
             |/src/main/java/test/A.java
@@ -454,6 +455,49 @@ class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
         }
     }
 
+    @Test
+    @OnlyJavaSymbols("do not filter out accessors of Java synthetic properties")
+    fun `should ignore additional non-accessor setters`() {
+        testInline(
+            """
+            |/src/main/java/test/A.java
+            |package test;
+            |public class A {
+            |   private int a = 1;
+            |
+            |   public int getA() { return a; }
+            |
+            |   public void setA(long a) { }
+            |   public void setA(Number a) {}
+            |
+            |   // the qualifying setter is intentionally in the middle
+            |   // to rule out the order making a difference
+            |   public void setA(int a) { }
+            |
+            |   public void setA(String a) {}
+            |   public void setA() {}
+            |
+            |}
+        """.trimIndent(),
+            configuration
+        ) {
+            documentablesMergingStage = { module ->
+                val testClass = module.packages.single().classlikes.single { it.name == "A" }
+
+                val property = testClass.properties.single { it.name == "a" }
+                assertNotNull(property.getter)
+
+                val setter = property.setter
+                assertNotNull(setter)
+                assertEquals(1, setter.parameters.size)
+                assertEquals(PrimitiveJavaType("int"), setter.parameters[0].type)
+
+                val regularSetterFunctions = testClass.functions.filter { it.name == "setA" }
+                assertEquals(5, regularSetterFunctions.size)
+            }
+        }
+    }
+
     @Test
     fun `should not qualify methods with subtype parameters as type accessors`() {
         testInline(
@@ -531,6 +575,7 @@ class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
     }
 
     @Test
+    @OnlyJavaSymbols("do not filter out accessors of Java synthetic properties")
     fun `should not mark a multi-param setter overload as an accessor`() {
         testInline(
             """
@@ -554,7 +599,7 @@ class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
 
 
                 // the setField function should not qualify to be an accessor due to the second param
-                assertEquals(1, testClass.functions.size)
+                assertEquals(2, testClass.functions.size)
                 assertEquals("setField", testClass.functions[0].name)
             }
         }