Wrong newlines in functional style

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

@@ -23,6 +23,7 @@ import com.pinterest.ktlint.core.ast.ElementType.IDENTIFIER
 import com.pinterest.ktlint.core.ast.ElementType.IF
 import com.pinterest.ktlint.core.ast.ElementType.IMPORT_DIRECTIVE
 import com.pinterest.ktlint.core.ast.ElementType.LAMBDA_ARGUMENT
+import com.pinterest.ktlint.core.ast.ElementType.LBRACE
 import com.pinterest.ktlint.core.ast.ElementType.LPAR
 import com.pinterest.ktlint.core.ast.ElementType.MINUS
 import com.pinterest.ktlint.core.ast.ElementType.MINUSEQ
@@ -40,9 +41,11 @@ import com.pinterest.ktlint.core.ast.ElementType.SAFE_ACCESS
 import com.pinterest.ktlint.core.ast.ElementType.SAFE_ACCESS_EXPRESSION
 import com.pinterest.ktlint.core.ast.ElementType.SECONDARY_CONSTRUCTOR
 import com.pinterest.ktlint.core.ast.ElementType.SEMICOLON
+import com.pinterest.ktlint.core.ast.ElementType.VALUE_ARGUMENT
 import com.pinterest.ktlint.core.ast.ElementType.VALUE_ARGUMENT_LIST
 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
@@ -52,6 +55,7 @@ import org.cqfn.diktat.ruleset.constants.Warnings.WRONG_NEWLINES
 import org.cqfn.diktat.ruleset.utils.appendNewlineMergingWhiteSpace
 import org.cqfn.diktat.ruleset.utils.emptyBlockList
 import org.cqfn.diktat.ruleset.utils.extractLineOfText
+import org.cqfn.diktat.ruleset.utils.findAllNodesWithSpecificType
 import org.cqfn.diktat.ruleset.utils.getAllLeafsWithSpecificType
 import org.cqfn.diktat.ruleset.utils.isBeginByNewline
 import org.cqfn.diktat.ruleset.utils.isEol
@@ -141,6 +145,7 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
         }
     }
 
+    @Suppress("ComplexMethod")
     private fun handleOperatorWithLineBreakBefore(node: ASTNode) {
         if (node.isDotFromPackageOrImport()) {
             return
@@ -305,6 +310,20 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
                     getAllLeafsWithSpecificType(SAFE_ACCESS, it)
                 }
             }
+            ?.filter {
+                // should skip node's that are val params. For example: b.some(z.a()) -> skip z.a()
+                if (it.treeParent.treeParent != null && it.treeParent.treeParent.elementType == VALUE_ARGUMENT)
+                    return@filter false
+                true
+            }
+            ?.dropWhile { !it.treeParent.textContains('(') && !it.treeParent.textContains('{') }
+            // fixme: we can't distinguish fully qualified names from chain of calls for now
+            ?.filterIndexed { index, it ->
+                // if first callee is multiline lambda, then we let user decide how to line lambda
+                if (index == 0 && isMultilineLambda(it.treeParent))
+                    return@filterIndexed false
+                true
+            }
             ?.filter { it.getParentExpressions().count() > 1 }
             ?.count()
             ?.let { it > 1 }
@@ -313,6 +332,10 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
     private fun ASTNode.getParentExpressions() =
             parents().takeWhile { it.elementType in chainExpressionTypes && it.elementType != LAMBDA_ARGUMENT }
 
+    private fun isMultilineLambda(node: ASTNode): Boolean =
+            node.findAllNodesWithSpecificType(LAMBDA_ARGUMENT).firstOrNull()?.text?.count { it == '\n' } ?: -1 > 0
+
+
     /**
      * This method should be called on OPERATION_REFERENCE in the middle of BINARY_EXPRESSION
      */

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

@@ -502,4 +502,56 @@ class NewlinesRuleWarnTest : LintTestBase(::NewlinesRule) {
                 LintError(2, 5, ruleId, singleReturnWarn, true)
         )
     }
+
+    @Test
+    @Tag(WarningNames.WRONG_NEWLINES)
+    fun `should not trigger`() {
+        lintMethod(
+                """
+                    |fun foo(): String {
+                    |        val isParallelMode: Boolean
+                    |            get() = java.lang.Boolean.getBoolean(properties.getProperty("parallel.mode"))
+                    |        
+                    |        allProperties.filter {
+                    |           predicate(it)
+                    |        }
+                    |        .foo()
+                    |        .bar()
+                    |        
+                    |        allProperties
+                    |        .filter {
+                    |           predicate(it)
+                    |        }
+                    |        .foo()
+                    |        .bar()
+                    |        
+                    |        allProperties?.filter {
+                    |           predicate(it)
+                    |        }
+                    |        .foo()
+                    |        .bar()
+                    |}
+                """.trimMargin()
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.WRONG_NEWLINES)
+    fun `should trigger on non-multiline lambdas`() {
+        lintMethod(
+                """
+                    |fun foo(): String {
+                    |        allProperties.filter { predicate(it) }
+                    |        .foo()
+                    |        .bar()
+                    |        
+                    |        allProperties?.filter { predicate(it) }
+                    |        .foo()
+                    |        .bar()
+                    |}
+                """.trimMargin(),
+                LintError(2, 22, ruleId,"${WRONG_NEWLINES.warnText()} should follow functional style at .", true),
+                LintError(6, 22, ruleId,"${WRONG_NEWLINES.warnText()} should follow functional style at ?.", true)
+        )
+    }
 }