Fixed false positive MISSING_KDOC_ON_FUNCTION on local function (function inside another function)

diktat-rules/src/main/kotlin/com/saveourtool/diktat/ruleset/rules/chapter1/IdentifierNaming.kt

@@ -30,10 +30,15 @@
 import org.jetbrains.kotlin.KtNodeTypes.DESTRUCTURING_DECLARATION
 import org.jetbrains.kotlin.KtNodeTypes.DESTRUCTURING_DECLARATION_ENTRY
 import org.jetbrains.kotlin.KtNodeTypes.FUNCTION_TYPE
+import org.jetbrains.kotlin.KtNodeTypes.MODIFIER_LIST
+import org.jetbrains.kotlin.KtNodeTypes.NULLABLE_TYPE
 import org.jetbrains.kotlin.KtNodeTypes.OBJECT_DECLARATION
+import org.jetbrains.kotlin.KtNodeTypes.PROPERTY
+import org.jetbrains.kotlin.KtNodeTypes.PROPERTY_ACCESSOR
 import org.jetbrains.kotlin.KtNodeTypes.REFERENCE_EXPRESSION
 import org.jetbrains.kotlin.KtNodeTypes.TYPE_PARAMETER
 import org.jetbrains.kotlin.KtNodeTypes.TYPE_REFERENCE
+import org.jetbrains.kotlin.KtNodeTypes.USER_TYPE
 import org.jetbrains.kotlin.KtNodeTypes.VALUE_PARAMETER_LIST
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
@@ -43,6 +48,7 @@
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.CATCH_KEYWORD
 import org.jetbrains.kotlin.lexer.KtTokens.IDENTIFIER
+import org.jetbrains.kotlin.lexer.KtTokens.PRIVATE_KEYWORD
 import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.KtPrimaryConstructor
 import org.jetbrains.kotlin.psi.KtProperty
@@ -139,6 +145,36 @@
         return false
     }
 
+    /**
+     * method checks that identifier is correct backing field
+     */
+    private fun ASTNode.isCorrectBackingField(variableName: ASTNode): Boolean {
+        val propertyNodes = this.treeParent.getAllChildrenWithType(KtNodeTypes.PROPERTY)
+        val variableNameCut = variableName.text.drop(1)
+        // check that backing field name is correct
+
+        if (variableName.text.startsWith("_") && variableNameCut.isLowerCamelCase()) {
+            val matchingNode = propertyNodes.find { propertyNode ->
+                val nodeType = this.getFirstChildWithType(TYPE_REFERENCE)
+                val propertyType = propertyNode.getFirstChildWithType(TYPE_REFERENCE)
+                // check that property and backing field has same type
+                val sameType = propertyType?.text == nodeType?.text
+                // check that property USER_TYPE is same as backing field NULLABLE_TYPE
+                val nodeNullableType = nodeType?.getFirstChildWithType(NULLABLE_TYPE)
+                val sameTypeWithNullable = propertyType?.getFirstChildWithType(USER_TYPE)?.text ==
+                        nodeNullableType?.getFirstChildWithType(USER_TYPE)?.text
+                val matchingNames = propertyNode.getFirstChildWithType(IDENTIFIER)?.text == variableNameCut
+                val isPrivate = this.getFirstChildWithType(MODIFIER_LIST)?.getFirstChildWithType(PRIVATE_KEYWORD) != null
+
+                matchingNames && (sameType || sameTypeWithNullable) && isPrivate &&
+                        this.getFirstChildWithType(PROPERTY_ACCESSOR) == null &&
+                        propertyNode.getFirstChildWithType(PROPERTY_ACCESSOR) != null
+            }
+            return matchingNode?.let { true } ?: false
+        }
+        return false
+    }
+
     /**
      * all checks for case and naming for vals/vars/constants
      */

diktat-rules/src/main/kotlin/com/saveourtool/diktat/ruleset/rules/chapter2/kdoc/KdocMethods.kt

@@ -98,7 +98,22 @@ class KdocMethods(configRules: List<RulesConfig>) : DiktatRule(
         }
     }
 
-    @Suppress("UnsafeCallOnNullableType", "AVOID_NULL_CHECKS")
+    private fun hasFunParent(node: ASTNode): Boolean {
+        var parent = node.treeParent
+        while (parent != null) {
+            if (parent.elementType == FUN) {
+                return true
+            }
+            parent = parent.treeParent
+        }
+        return false
+    }
+
+    @Suppress(
+        "UnsafeCallOnNullableType",
+        "AVOID_NULL_CHECKS",
+        "CyclomaticComplexMethod"
+    )
     private fun checkSignatureDescription(node: ASTNode) {
         val kdoc = node.getFirstChildWithType(KDOC)
         val kdocTags = kdoc?.kDocTags()
@@ -119,7 +134,9 @@ class KdocMethods(configRules: List<RulesConfig>) : DiktatRule(
 
         val anyTagFailed = paramCheckFailed || returnCheckFailed || throwsCheckFailed
         // if no tag failed, we have too little information to suggest KDoc - it would just be empty
-        if (kdoc == null && anyTagFailed) {
+        if (kdoc == null && hasFunParent(node)) {
+            return
+        } else if (kdoc == null && anyTagFailed) {
             addKdocTemplate(node, name, missingParameters, explicitlyThrownExceptions, returnCheckFailed)
         } else if (kdoc == null && !isReferenceExpressionWithSameName(node)) {
             MISSING_KDOC_ON_FUNCTION.warn(configRules, emitWarn, name, node.startOffset, node)

diktat-rules/src/test/kotlin/com/saveourtool/diktat/ruleset/chapter2/KdocMethodsTest.kt

@@ -425,4 +425,28 @@ class KdocMethodsTest : LintTestBase(::KdocMethods) {
             DiktatError(2, 1, ruleId, "${MISSING_KDOC_ON_FUNCTION.warnText()} writeToConsoleEx", true),
         )
     }
+
+    @Test
+    @Tag(WarningNames.MISSING_KDOC_ON_FUNCTION)
+    fun `KDoc shouldn't trigger on local functions`() {
+        lintMethod(
+            """
+                |fun printHelloAndBye() {
+                |    fun printHello() {
+                |        print("Hello")
+                |    }
+                |    printHello()
+                |    val ab = 5
+                |    ab?.let {
+                |        fun printBye() {
+                |            print("Bye")
+                |        }
+                |        printBye()
+                |    }
+                |}
+            """.trimMargin(),
+            DiktatError(1, 1, ruleId, "${MISSING_KDOC_ON_FUNCTION.warnText()} printHelloAndBye", false),
+        )
+    }
+
 }