function style bug in NewlinesRule (#580)

* function style bug in NewlinesRule

### What's done:
    Fixed bugs and added tests

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

@@ -8,6 +8,8 @@ import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 
 typealias EmitType = ((offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit)
 
+typealias ListOfList = MutableList<MutableList<ASTNode>>
+
 /**
  * This class represent individual inspections of diktat code style.
  * A [Warnings] entry contains rule name, warning message and is used in code check.

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

@@ -311,7 +311,6 @@ class LineLength(private val configRules: List<RulesConfig>) : Rule("line-length
      *@param node node in which to search
      *@param binList mutable list of ASTNode to store nodes
      */
-    @Suppress("WRONG_NEWLINES")
     private fun searchBinaryExpression(node: ASTNode, binList: MutableList<ASTNode>) {
         if (node.hasChildOfType(BINARY_EXPRESSION) || node.hasChildOfType(PARENTHESIZED) ||
                 node.hasChildOfType(POSTFIX_EXPRESSION)) {

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

@@ -136,7 +136,6 @@ class LongNumericalValuesSeparatedRule(private val configRules: List<RulesConfig
         }
     }
 
-    @Suppress("WRONG_NEWLINES")
     private fun removePrefixSuffix(text: String): String {
         if (text.startsWith("0x")) {
             return text.removePrefix("0x")

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

@@ -39,7 +39,6 @@ class NestedFunctionBlock(private val configRules: List<RulesConfig>) : Rule("ne
         }
     }
 
-    @Suppress("WRONG_NEWLINES")
     private fun countNestedBlocks(node: ASTNode, maxNestedBlockCount: Long) {
         node.findAllNodesWithSpecificType(LBRACE)
             .reversed()

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

@@ -4,6 +4,7 @@ import org.cqfn.diktat.common.config.rules.RuleConfiguration
 import org.cqfn.diktat.common.config.rules.RulesConfig
 import org.cqfn.diktat.common.config.rules.getRuleConfig
 import org.cqfn.diktat.ruleset.constants.EmitType
+import org.cqfn.diktat.ruleset.constants.ListOfList
 import org.cqfn.diktat.ruleset.constants.Warnings.REDUNDANT_SEMICOLON
 import org.cqfn.diktat.ruleset.constants.Warnings.WRONG_NEWLINES
 import org.cqfn.diktat.ruleset.utils.appendNewlineMergingWhiteSpace
@@ -57,6 +58,7 @@ import com.pinterest.ktlint.core.ast.ElementType.OROR
 import com.pinterest.ktlint.core.ast.ElementType.PACKAGE_DIRECTIVE
 import com.pinterest.ktlint.core.ast.ElementType.PLUS
 import com.pinterest.ktlint.core.ast.ElementType.PLUSEQ
+import com.pinterest.ktlint.core.ast.ElementType.POSTFIX_EXPRESSION
 import com.pinterest.ktlint.core.ast.ElementType.PRIMARY_CONSTRUCTOR
 import com.pinterest.ktlint.core.ast.ElementType.RETURN
 import com.pinterest.ktlint.core.ast.ElementType.RETURN_KEYWORD
@@ -69,13 +71,15 @@ import com.pinterest.ktlint.core.ast.ElementType.VALUE_ARGUMENT_LIST
 import com.pinterest.ktlint.core.ast.ElementType.VALUE_PARAMETER
 import com.pinterest.ktlint.core.ast.ElementType.VALUE_PARAMETER_LIST
 import com.pinterest.ktlint.core.ast.ElementType.WHITE_SPACE
+import com.pinterest.ktlint.core.ast.isWhiteSpaceWithNewline
 import com.pinterest.ktlint.core.ast.nextCodeSibling
 import com.pinterest.ktlint.core.ast.parent
 import com.pinterest.ktlint.core.ast.prevCodeSibling
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.PsiWhiteSpaceImpl
+import org.jetbrains.kotlin.com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.com.intellij.psi.tree.TokenSet
 import org.jetbrains.kotlin.psi.KtParameterList
 import org.jetbrains.kotlin.psi.KtSuperTypeList
@@ -161,7 +165,7 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
         if (node.isDotFromPackageOrImport()) {
             return
         }
-        val isIncorrect = node.run {
+        val isIncorrect = (if (node.elementType == ELVIS) node.treeParent else node).run {
             if (isCallsChain()) {
                 val isSingleLineIfElse = parent({ it.elementType == IF }, true)?.isSingleLineIfElse() ?: false
                 // to follow functional style these operators should be started by newline
@@ -327,7 +331,6 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
         }
     }
 
-    @Suppress("WRONG_NEWLINES")
     private fun handleFirstValueParameter(node: ASTNode) = node
         .children()
         .takeWhile { !it.textContains('\n') }
@@ -375,24 +378,29 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
     private fun ASTNode.getOrderedCallExpressions(psi: PsiElement, result: MutableList<ASTNode>) {
         // if statements here have the only right order - don't change it
 
-        if (psi.children.isNotEmpty() && (psi.children[0].node.elementType != DOT_QUALIFIED_EXPRESSION &&
-                psi.children[0].node.elementType != SAFE_ACCESS_EXPRESSION)) {
-            result.add(
-                psi.children[0]
-                    .node
-                    .siblings(true)
-                    .dropWhile { it.elementType in dropChainValues }
-                    .first()  // node treeNext is ".", "?.", "!!", "::"
+        if (psi.children.isNotEmpty() && (!psi.isFirstChildElementType(DOT_QUALIFIED_EXPRESSION) &&
+                !psi.isFirstChildElementType(SAFE_ACCESS_EXPRESSION))) {
+            val firstChild = psi.firstChild
+            if (firstChild.isFirstChildElementType(POSTFIX_EXPRESSION)) {
+                if (firstChild.isFirstChildElementType(DOT_QUALIFIED_EXPRESSION) ||
+                        firstChild.isFirstChildElementType(SAFE_ACCESS_EXPRESSION)) {
+                    getOrderedCallExpressions(firstChild.firstChild, result)
+                }
+                result.add(firstChild.node)
+            }
+            result.add(firstChild.node
+                .siblings(true)
+                .dropWhile { it.elementType in dropChainValues }
+                .first()  // node treeNext is ".", "?.", "!!", "::"
             )
         } else if (psi.children.isNotEmpty()) {
-            getOrderedCallExpressions(psi.children[0], result)
-
-            result.add(
-                psi.children[0]
-                    .node
-                    .siblings(true)
-                    .dropWhile { it.elementType in dropChainValues }
-                    .first()  // node treeNext is ".", "?.", "!!", "::"
+            getOrderedCallExpressions(psi.firstChild, result)
+
+            result.add(psi.firstChild
+                .node
+                .siblings(true)
+                .dropWhile { it.elementType in dropChainValues }
+                .first()  // node treeNext is ".", "?.", "!!", "::"
             )
         }
     }
@@ -413,27 +421,53 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
     private fun ASTNode.isDotFromPackageOrImport() = elementType == DOT &&
             parent({ it.elementType == IMPORT_DIRECTIVE || it.elementType == PACKAGE_DIRECTIVE }, true) != null
 
+    private fun PsiElement.isFirstChildElementType(elementType: IElementType) =
+            this.firstChild.node.elementType == elementType
+
+    /**
+     * This method collects chain calls and checks it
+     *
+     * @return true - if there is error, false, if there is no error and null if there is two calls in chain
+     */
     private fun ASTNode.isCallsChain() = getParentExpressions()
         .lastOrNull()
         ?.run {
             mutableListOf<ASTNode>().also {
                 getOrderedCallExpressions(psi, it)
             }
         }
-        ?.dropWhile { !it.treeParent.textContains('(') && !it.treeParent.textContains('{') }
         // fixme: we can't distinguish fully qualified names (like java.lang) from chain of property accesses (like list.size) for now
-        ?.filter { it.getParentExpressions().count() > 1 }
-        ?.count()
-        ?.let { it > 1 }
-        ?: false
+        ?.dropWhile { !it.treeParent.textContains('(') && !it.treeParent.textContains('{') }
+        ?.isNotValidCalls(this) ?: false
+
+    private fun List<ASTNode>.isNotValidCalls(node: ASTNode): Boolean {
+        if (this.size == 1) {
+            return false
+        }
+        val callsByNewLine: ListOfList = mutableListOf()
+        var callsInOneNewLine: MutableList<ASTNode> = mutableListOf()
+        this.forEach {
+            if (it.treePrev.isFollowedByNewline() || it.treePrev.isWhiteSpaceWithNewline()) {
+                callsByNewLine.add(callsInOneNewLine)
+                callsInOneNewLine = mutableListOf()
+                callsInOneNewLine.add(it)
+            } else {
+                callsInOneNewLine.add(it)
+            }
+            if (it.treePrev.elementType == POSTFIX_EXPRESSION && !it.treePrev.isFollowedByNewline() && configuration.maxCallsInOneLine == 1) {
+                return true
+            }
+        }
+        callsByNewLine.add(callsInOneNewLine)
+        return (callsByNewLine.find { it.contains(node) } ?: return false).indexOf(node) + 1 > configuration.maxCallsInOneLine
+    }
 
     /**
      *  taking all expressions inside complex expression until we reach lambda arguments
      */
     private fun ASTNode.getParentExpressions() =
             parents().takeWhile { it.elementType in chainExpressionTypes && it.elementType != LAMBDA_ARGUMENT }
 
-    @Suppress("WRONG_NEWLINES")
     private fun isMultilineLambda(node: ASTNode): Boolean =
             node.findAllNodesWithSpecificType(LAMBDA_ARGUMENT)
                 .firstOrNull()
@@ -467,14 +501,17 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
          * If the number of parameters on one line is more than this threshold, all parameters should be placed on separate lines.
          */
         val maxParametersInOneLine = config["maxParametersInOneLine"]?.toInt() ?: 2
+        val maxCallsInOneLine = config["maxCallsInOneLine"]?.toInt() ?: MAX_CALLS_IN_ONE_LINE
     }
 
     companion object {
+        const val MAX_CALLS_IN_ONE_LINE = 3
+
         // fixme: these token sets can be not full, need to add new once as corresponding cases are discovered.
         // error is raised if these operators are prepended by newline
         private val lineBreakAfterOperators = TokenSet.create(ANDAND, OROR, PLUS, PLUSEQ, MINUS, MINUSEQ, MUL, MULTEQ, DIV, DIVEQ)
-
         // error is raised if these operators are followed by newline
+
         private val lineBreakBeforeOperators = TokenSet.create(DOT, SAFE_ACCESS, ELVIS, COLONCOLON)
         private val expressionTypes = TokenSet.create(DOT_QUALIFIED_EXPRESSION, SAFE_ACCESS_EXPRESSION, CALLABLE_REFERENCE_EXPRESSION, BINARY_EXPRESSION)
         private val chainExpressionTypes = TokenSet.create(DOT_QUALIFIED_EXPRESSION, SAFE_ACCESS_EXPRESSION)

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

@@ -434,7 +434,6 @@ fun ASTNode?.isAccessibleOutside(): Boolean =
  * @param warningName a name of the warning which is checked
  * @return boolean result
  */
-@Suppress("WRONG_NEWLINES")
 fun ASTNode.hasSuppress(warningName: String) = parent({ node ->
     val annotationNode = if (node.elementType != FILE) {
         node.findChildByType(MODIFIER_LIST)
@@ -693,10 +692,7 @@ fun ASTNode.lastLineNumber(isFixMode: Boolean) = getLineNumber(isFixMode)?.plus(
 /**
  * copy-pasted method from ktlint to determine line and column number by offset
  */
-@Suppress("WRONG_NEWLINES")  // to keep this function with explicit return type
-fun ASTNode.calculateLineColByOffset(): (offset: Int) -> Pair<Int, Int> {
-    return buildPositionInTextLocator(text)
-}
+fun ASTNode.calculateLineColByOffset() = buildPositionInTextLocator(text)
 
 /**
  * Retrieves file name from user data of this node

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

@@ -33,7 +33,6 @@ fun ASTNode.parameterNames(): Collection<String?> {
  *
  * @return function body text as a list of strings
  */
-@Suppress("WRONG_NEWLINES")
 fun ASTNode.getBodyLines(): List<String> {
     checkNodeIsFun(this)
     return this.getFirstChildWithType(BLOCK)?.let { blockNode ->

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

@@ -69,7 +69,6 @@ fun String.countSubStringOccurrences(sub: String) = this.split(sub).size - 1
  *
  * @return list of path parts
  */
-@Suppress("WRONG_NEWLINES")
 fun String.splitPathToDirs(): List<String> =
         this.replace("\\", "/")
             .replace("//", "/")

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/utils/indentation/Checkers.kt

@@ -89,7 +89,7 @@ internal class ValueParameterListChecker(configuration: IndentationConfig) : Cus
                     }
 
     @ExperimentalStdlibApi  // to use `scan` on sequence
-    @Suppress("WRONG_NEWLINES", "ANNOTATION_NEW_LINE")  // https://github.com/cqfn/diKTat/issues/609
+    @Suppress("ANNOTATION_NEW_LINE")  // https://github.com/cqfn/diKTat/issues/609
     override fun checkNode(whiteSpace: PsiWhiteSpace, indentError: IndentationError): CheckResult? {
         if (isCheckNeeded(whiteSpace)) {
             val parameterList = whiteSpace.parent.node

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/utils/search/VariablesSearch.kt

@@ -81,7 +81,6 @@ abstract class VariablesSearch(val node: ASTNode, private val filterForVariables
      *  all these scopes are on lower level of inheritance that's why if in one of these scopes we will find any
      *  variable declaration with the same name - we will understand that it is usage of another variable
      */
-    @Suppress("WRONG_NEWLINES")
     protected fun isReferenceToOtherVariableWithSameName(expression: KtNameReferenceExpression,
                                                          codeBlock: KtElement,
                                                          property: KtProperty) = expression.parents

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/utils/search/VariablesWithAssignmentSearch.kt

@@ -21,7 +21,6 @@ class VariablesWithAssignmentSearch(fileNode: ASTNode,
      * @param property
      * @return
      */
-    @Suppress("WRONG_NEWLINES")
     override fun KtElement.getAllSearchResults(property: KtProperty) = this.node
         .findAllNodesWithSpecificType(ElementType.BINARY_EXPRESSION)
         // filtering out all usages that are declared in the same context but are going before the variable declaration

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/utils/search/VariablesWithUsagesSearch.kt

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.psi.KtProperty
 
 class VariablesWithUsagesSearch(fileNode: ASTNode,
                                 filterForVariables: (KtProperty) -> Boolean) : VariablesSearch(fileNode, filterForVariables) {
-    @Suppress("WRONG_NEWLINES")
     override fun KtElement.getAllSearchResults(property: KtProperty) = this.node
         .findAllNodesWithSpecificType(ElementType.REFERENCE_EXPRESSION)
         // filtering out all usages that are declared in the same context but are going before the variable declaration

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter3/files/NewlinesRuleFixTest.kt

@@ -1,5 +1,7 @@
 package org.cqfn.diktat.ruleset.chapter3.files
 
+import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.ruleset.constants.Warnings
 import org.cqfn.diktat.ruleset.rules.files.NewlinesRule
 import org.cqfn.diktat.util.FixTestBase
 
@@ -8,6 +10,11 @@ import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 
 class NewlinesRuleFixTest : FixTestBase("test/paragraph3/newlines", ::NewlinesRule) {
+    private val rulesConfigListShort: List<RulesConfig> = listOf(
+        RulesConfig(Warnings.WRONG_NEWLINES.name, true,
+            mapOf("maxCallsInOneLine" to "1"))
+    )
+
     @Test
     @Tag(WarningNames.REDUNDANT_SEMICOLON)
     fun `should remove redundant semicolons`() {
@@ -23,7 +30,7 @@ class NewlinesRuleFixTest : FixTestBase("test/paragraph3/newlines", ::NewlinesRu
     @Test
     @Tag(WarningNames.WRONG_NEWLINES)
     fun `should fix newlines to follow functional style`() {
-        fixAndCompare("FunctionalStyleExpected.kt", "FunctionalStyleTest.kt")
+        fixAndCompare("FunctionalStyleExpected.kt", "FunctionalStyleTest.kt", rulesConfigListShort)
     }
 
     @Test