Bugfix. A lot of FP LOCAL_VARIABLE_EARLY_DECLARATION (#642)

* bugfix/fp-local-variable(#589)

### What's done:
  * Fixed bugs

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/generation/GenerationDocs.kt

@@ -152,7 +152,6 @@ private fun findBoldOrItalicText(regex: Regex,
             .findAll(line)
             .map { it.value }
             .toMutableList()
-    var correctedLine = line.replace(regex, REGEX_PLACEHOLDER)
     allRegex.forEachIndexed { index, value ->
         when (type) {
             FindType.BOLD -> allRegex[index] = "\\textbf{${value.replace("**", "")}}"
@@ -165,6 +164,7 @@ private fun findBoldOrItalicText(regex: Regex,
             FindType.BACKTICKS -> allRegex[index] = value.replace("\\_", "_")
         }
     }
+    var correctedLine = line.replace(regex, REGEX_PLACEHOLDER)
     allRegex.forEach {
         correctedLine = correctedLine.replaceFirst(REGEX_PLACEHOLDER, it)
     }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/LineLength.kt

@@ -239,7 +239,7 @@ class LineLength(private val configRules: List<RulesConfig>) : Rule("line-length
         }
     }
 
-    @Suppress("UnsafeCallOnNullableType", "LOCAL_VARIABLE_EARLY_DECLARATION")
+    @Suppress("UnsafeCallOnNullableType")
     private fun findAllText(astNode: ASTNode): String {
         var text = ""
         var node = astNode
@@ -277,10 +277,10 @@ class LineLength(private val configRules: List<RulesConfig>) : Rule("line-length
         return text
     }
 
-    @Suppress("UnsafeCallOnNullableType", "LOCAL_VARIABLE_EARLY_DECLARATION")
+    @Suppress("UnsafeCallOnNullableType")
     private fun getBraceAndBeforeText(node: ASTNode, prevNode: ASTNode): String {
-        var text = ""
         val par = prevNode.prevSibling { it.elementType == OPERATION_REFERENCE }?.let { LPAR } ?: RPAR
+        var text = ""
         if (node.findChildByType(par)!!.treePrev != null &&
                 node.findChildByType(par)!!.treePrev.elementType == WHITE_SPACE) {
             text += node.findChildByType(par)!!.treePrev.text

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/identifiers/LocalVariablesRule.kt

@@ -92,9 +92,17 @@ class LocalVariablesRule(private val configRules: List<RulesConfig>) : Rule("loc
 
         val firstUsageStatementLine = getFirstUsageStatementOrBlock(usages, declarationScope).node.getLineNumber()
         val firstUsage = usages.minBy { it.node.getLineNumber() }!!
-        checkLineNumbers(property, firstUsageStatementLine, firstUsageLine = firstUsage.node.getLineNumber())
+
+        // should skip val and var before it's statement
+        val offset = property
+            .siblings(forward = true, withItself = false)
+            .takeWhile { it != getFirstUsageStatementOrBlock(usages, declarationScope) }
+            .filter { it is KtProperty }
+            .count()
+        checkLineNumbers(property, firstUsageStatementLine, firstUsageLine = firstUsage.node.getLineNumber(), offset = offset)
     }
 
+    @Suppress("TOO_LONG_FUNCTION")
     private fun handleConsecutiveDeclarations(statement: PsiElement, properties: List<KtProperty>) {
         val numLinesAfterLastProp =
                 properties
@@ -108,19 +116,38 @@ class LocalVariablesRule(private val configRules: List<RulesConfig>) : Rule("loc
                     }
                     ?: 0
 
+        val sortedProperties = properties.sortedBy { it.node.getLineNumber() }
         // need to check that properties are declared consecutively with only maybe empty lines
-        properties
-            .sortedBy { it.node.getLineNumber() }
+        sortedProperties
             .zip(
-                (properties.size - 1 downTo 0).map { it + numLinesAfterLastProp }
-            )
-            .forEachIndexed { index, (property, offset) ->
-                if (index != properties.lastIndex) {
-                    checkLineNumbers(property, statement.node.getLineNumber(), offset)
-                } else {
-                    // since offset after last property is calculated in this method, we pass offset = 0
-                    checkLineNumbers(property, statement.node.getLineNumber(), 0)
+                (properties.size - 1 downTo 0).map { index ->
+                    val siblings = sortedProperties[properties.lastIndex - index].siblings(forward = true, withItself = false)
+
+                    // Also we need to count number of comments to skip. See `should skip comments` test
+                    // For the last property we don't need to count, because they will be counted in checkLineNumbers
+                    // We count number of comments beginning from next property
+                    val numberOfComments = siblings
+                        .takeWhile { it != statement }
+                        .dropWhile { it !is KtProperty }
+                        .filter { it.node.isPartOfComment() }
+                        .count()
+
+                    // We should also skip all vars that were not included in properties list, but they are between statement and current property
+                    val numberOfVarWithInitializer = siblings
+                        .takeWhile { it != statement }
+                        .filter { it is KtProperty && it !in properties }
+                        .count()
+
+                    // If it is not last property we should consider number on new lines after last property in list
+                    if (index != 0) {
+                        index + numLinesAfterLastProp + numberOfComments + numberOfVarWithInitializer
+                    } else {
+                        index + numberOfComments + numberOfVarWithInitializer
+                    }
                 }
+            )
+            .forEach { (property, offset) ->
+                checkLineNumbers(property, statement.node.getLineNumber(), offset)
             }
     }