Do not filter out accessors of sythetic properties

Author: vmishenev

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

@@ -318,7 +318,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)
@@ -328,6 +328,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 {
@@ -362,7 +363,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,7 +412,51 @@ class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
         }
     }
 
+    @OnlyJavaPsi("do not filter out accessors of Java synthetic properties")
     @Test
+    fun `javaPSI - 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(4, regularSetterFunctions.size)
+            }
+        }
+    }
+
+    @Test
+    @OnlyJavaSymbols("do not filter out accessors of Java synthetic properties")
     fun `should ignore additional non-accessor setters`() {
         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)
             }
         }