String concatenation: automatic code fixes (#208)

* Adding logic and tests for fixing string concatenation

### What's done:
Adding fix logic (not supported fully yet)
Adding tests
Making changes in tests to support several rules

diktat-rules/src/main/kotlin/generated/WarningNames.kt

@@ -5,6 +5,8 @@ package generated
 import kotlin.String
 
 public object WarningNames {
+    public const val DUMMY_TEST_WARNING: String = "DUMMY_TEST_WARNING"
+
     public const val PACKAGE_NAME_MISSING: String = "PACKAGE_NAME_MISSING"
 
     public const val PACKAGE_NAME_INCORRECT_CASE: String = "PACKAGE_NAME_INCORRECT_CASE"

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

@@ -31,6 +31,9 @@ enum class Warnings(
     val canBeAutoCorrected: Boolean,
     val ruleId: String,
     private val warn: String) : Rule {
+    // ======== dummy test warning ======
+    DUMMY_TEST_WARNING(true, "0.0.0", "this is a dummy warning that can be used for manual testing of fixer/checker"),
+
     // ======== chapter 1 ========
     PACKAGE_NAME_MISSING(true, "1.2.1", "no package name declared in a file"),
     PACKAGE_NAME_INCORRECT_CASE(true, "1.2.1", "package name should be completely in a lower case"),
@@ -112,7 +115,7 @@ enum class Warnings(
     COMPLEX_EXPRESSION(false, "3.6.3", "complex dot qualified expression should be replaced with variable"),
 
     // FixMe: autofixing will be added for this rule
-    STRING_CONCATENATION(false, "3.15.1", "strings should not be concatenated using plus operator - use string templates instead if the statement fits one line"),
+    STRING_CONCATENATION(true, "3.15.1", "strings should not be concatenated using plus operator - use string templates instead if the statement fits one line"),
     TOO_MANY_BLANK_LINES(true, "3.7.1", "too many consecutive blank lines"),
     WRONG_WHITESPACE(true, "3.8.1", "incorrect usage of whitespaces for code separation"),
     TOO_MANY_CONSECUTIVE_SPACES(true, "3.8.1", "too many consecutive spaces"),

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

@@ -0,0 +1,24 @@
+package org.cqfn.diktat.ruleset.dummy
+
+import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.ruleset.constants.Warnings
+import org.cqfn.diktat.ruleset.rules.DiktatRule
+import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+
+/**
+ * Dummy warning used for testing and debug purposes.
+ * Can be used in manual testing.
+ */
+class DummyWarning(configRules: List<RulesConfig>) : DiktatRule(
+    "dummy-rule",
+    configRules,
+    listOf(
+        Warnings.FILE_NAME_INCORRECT,
+        Warnings.FILE_NAME_MATCH_CLASS
+    )
+) {
+    private lateinit var filePath: String
+
+    @Suppress("EmptyFunctionBlock")
+    override fun logic(node: ASTNode) {}
+}

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

@@ -4,6 +4,7 @@ import org.cqfn.diktat.common.config.rules.DIKTAT_COMMON
 import org.cqfn.diktat.common.config.rules.RulesConfig
 import org.cqfn.diktat.common.config.rules.RulesConfigReader
 import org.cqfn.diktat.ruleset.constants.Warnings
+import org.cqfn.diktat.ruleset.dummy.DummyWarning
 import org.cqfn.diktat.ruleset.rules.chapter1.FileNaming
 import org.cqfn.diktat.ruleset.rules.chapter1.IdentifierNaming
 import org.cqfn.diktat.ruleset.rules.chapter1.PackageNaming
@@ -133,6 +134,9 @@ class DiktatRuleSetProvider(private var diktatConfigFile: String = DIKTAT_ANALYS
         // We don't have a way to enforce a specific order, so we should just be careful when adding new rules to this list and, when possible,
         // cover new rules in smoke test as well. If a rule needs to be at a specific position in a list, please add comment explaining it (like for NewlinesRule).
         val rules = listOf(
+            // test warning that can be used for manual testing of diktat
+            ::DummyWarning,
+
             // comments & documentation
             ::CommentsRule,
             ::SingleConstructorRule,  // this rule can add properties to a primary constructor, so should be before KdocComments
@@ -164,7 +168,6 @@ class DiktatRuleSetProvider(private var diktatConfigFile: String = DIKTAT_ANALYS
             ::CheckInverseMethodRule,
             ::StatelessClassesRule,
             ::ImplicitBackingPropertyRule,
-            ::StringTemplateFormatRule,
             ::DataClassesRule,
             ::LocalVariablesRule,
             ::SmartCastRule,
@@ -180,6 +183,7 @@ class DiktatRuleSetProvider(private var diktatConfigFile: String = DIKTAT_ANALYS
             ::AnnotationNewLineRule,
             ::SortRule,
             ::StringConcatenationRule,
+            ::StringTemplateFormatRule,
             ::AccurateCalculationsRule,
             ::LineLength,
             ::RunInScript,
@@ -204,7 +208,8 @@ class DiktatRuleSetProvider(private var diktatConfigFile: String = DIKTAT_ANALYS
             ::FileStructureRule,  // this rule should be right before indentation because it should operate on already valid code
             ::NewlinesRule,  // newlines need to be inserted right before fixing indentation
             ::WhiteSpaceRule,  // this rule should be after other rules that can cause wrong spacing
-            ::IndentationRule  // indentation rule should be the last because it fixes formatting after all the changes done by previous rules
+            ::IndentationRule,  // indentation rule should be the last because it fixes formatting after all the changes done by previous rules
+
         )
             .map {
                 it.invoke(configRules)

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

@@ -58,7 +58,7 @@ class PackageNaming(configRules: List<RulesConfig>) : DiktatRule(
                 }
 
                 // getting all identifiers from existing package name into the list like [org, diktat, project]
-                val wordsInPackageName = node.findAllNodesWithSpecificType(IDENTIFIER)
+                val wordsInPackageName = node.findAllDescendantsWithSpecificType(IDENTIFIER)
 
                 // no need to check that packageIdentifiers is empty, because in this case parsing will fail
                 checkPackageName(wordsInPackageName, node)

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/chapter2/comments/CommentsRule.kt

@@ -4,7 +4,7 @@ import org.cqfn.diktat.common.config.rules.RulesConfig
 import org.cqfn.diktat.ruleset.constants.ListOfPairs
 import org.cqfn.diktat.ruleset.constants.Warnings.COMMENTED_OUT_CODE
 import org.cqfn.diktat.ruleset.rules.DiktatRule
-import org.cqfn.diktat.ruleset.utils.findAllNodesWithSpecificType
+import org.cqfn.diktat.ruleset.utils.findAllDescendantsWithSpecificType
 
 import com.pinterest.ktlint.core.ast.ElementType.BLOCK_COMMENT
 import com.pinterest.ktlint.core.ast.ElementType.EOL_COMMENT
@@ -52,7 +52,7 @@ class CommentsRule(configRules: List<RulesConfig>) : DiktatRule(
         val errorNodesWithText: ListOfPairs = mutableListOf()
         val eolCommentsOffsetToText = getOffsetsToTextBlocksFromEolComments(node, errorNodesWithText)
         val blockCommentsOffsetToText = node
-            .findAllNodesWithSpecificType(BLOCK_COMMENT)
+            .findAllDescendantsWithSpecificType(BLOCK_COMMENT)
             .map {
                 errorNodesWithText.add(it to it.text.trim().removeSurrounding("/*", "*/"))
                 it.startOffset to it.text.trim().removeSurrounding("/*", "*/")
@@ -80,7 +80,7 @@ class CommentsRule(configRules: List<RulesConfig>) : DiktatRule(
             }
             .filter { (_, parsedNode) ->
                 parsedNode
-                    .findAllNodesWithSpecificType(TokenType.ERROR_ELEMENT)
+                    .findAllDescendantsWithSpecificType(TokenType.ERROR_ELEMENT)
                     .isEmpty()
             }
             .forEach { (offset, parsedNode) ->
@@ -97,7 +97,7 @@ class CommentsRule(configRules: List<RulesConfig>) : DiktatRule(
      */
     private fun getOffsetsToTextBlocksFromEolComments(node: ASTNode, errorNodesWithText: ListOfPairs): List<Pair<Int, String>> {
         val comments = node
-            .findAllNodesWithSpecificType(EOL_COMMENT)
+            .findAllDescendantsWithSpecificType(EOL_COMMENT)
             .filter { !it.text.contains(eolCommentStart) || isCodeAfterCommentStart(it.text) }
         return if (comments.isNotEmpty()) {
             val result = mutableListOf(mutableListOf(comments.first()))

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/chapter2/kdoc/CommentsFormatting.kt

@@ -270,10 +270,10 @@ class CommentsFormatting(configRules: List<RulesConfig>) : DiktatRule(
                 EOL_COMMENT -> (node as LeafPsiElement).replaceWithText("// $commentText")
                 BLOCK_COMMENT -> (node as LeafPsiElement).replaceWithText("/* $commentText")
                 KDOC -> {
-                    node.findAllNodesWithSpecificType(KDOC_TEXT).forEach {
+                    node.findAllDescendantsWithSpecificType(KDOC_TEXT).forEach {
                         modifyKdocText(it, configuration)
                     }
-                    node.findAllNodesWithSpecificType(KDOC_CODE_BLOCK_TEXT).forEach {
+                    node.findAllDescendantsWithSpecificType(KDOC_CODE_BLOCK_TEXT).forEach {
                         modifyKdocText(it, configuration)
                     }
                 }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/chapter2/kdoc/KdocMethods.kt

@@ -10,7 +10,7 @@ import org.cqfn.diktat.ruleset.constants.Warnings.MISSING_KDOC_ON_FUNCTION
 import org.cqfn.diktat.ruleset.rules.DiktatRule
 import org.cqfn.diktat.ruleset.utils.KotlinParser
 import org.cqfn.diktat.ruleset.utils.appendNewlineMergingWhiteSpace
-import org.cqfn.diktat.ruleset.utils.findAllNodesWithSpecificType
+import org.cqfn.diktat.ruleset.utils.findAllDescendantsWithSpecificType
 import org.cqfn.diktat.ruleset.utils.findChildAfter
 import org.cqfn.diktat.ruleset.utils.getBodyLines
 import org.cqfn.diktat.ruleset.utils.getFilePath
@@ -155,7 +155,7 @@ class KdocMethods(configRules: List<RulesConfig>) : DiktatRule(
 
     private fun getExplicitlyThrownExceptions(node: ASTNode): Set<String> {
         val codeBlock = node.getFirstChildWithType(BLOCK)
-        val throwKeywords = codeBlock?.findAllNodesWithSpecificType(THROW)
+        val throwKeywords = codeBlock?.findAllDescendantsWithSpecificType(THROW)
         return throwKeywords
             ?.map { it.psi as KtThrowExpression }
             ?.mapNotNull { it.thrownExpression?.referenceExpression()?.text }

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

@@ -91,7 +91,7 @@ class BlockStructureBraces(configRules: List<RulesConfig>) : DiktatRule(
         val catchBlocks = tryBlock.catchClauses.map { it.node }
         val finallyBlock = tryBlock.finallyBlock?.node
         checkOpenBraceOnSameLine(tryBlock.node, BLOCK, configuration)
-        val allMiddleSpaceNodes = node.findAllNodesWithSpecificType(CATCH).map { it.treePrev }
+        val allMiddleSpaceNodes = node.findAllDescendantsWithSpecificType(CATCH).map { it.treePrev }
         checkMidBrace(allMiddleSpaceNodes, node, CATCH_KEYWORD)
         catchBlocks.forEach {
             checkOpenBraceOnSameLine(it, BLOCK, configuration)
@@ -100,7 +100,7 @@ class BlockStructureBraces(configRules: List<RulesConfig>) : DiktatRule(
         finallyBlock?.let { block ->
             checkOpenBraceOnSameLine(block, BLOCK, configuration)
             checkCloseBrace(block.findChildByType(BLOCK)!!, configuration)
-            val newAllMiddleSpaceNodes = node.findAllNodesWithSpecificType(FINALLY).map { it.treePrev }
+            val newAllMiddleSpaceNodes = node.findAllDescendantsWithSpecificType(FINALLY).map { it.treePrev }
             checkMidBrace(newAllMiddleSpaceNodes, node, FINALLY_KEYWORD)
         }
     }

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

@@ -80,7 +80,7 @@ class ClassLikeStructuresOrderRule(configRules: List<RulesConfig>) : DiktatRule(
                     node
                         .parents()
                         .last()
-                        .findAllNodesWithSpecificType(REFERENCE_EXPRESSION)
+                        .findAllDescendantsWithSpecificType(REFERENCE_EXPRESSION)
                         .any { ref ->
                             ref.parent({ it == classNode }) == null && ref.text.contains(identifierNode.text)
                         }

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

@@ -4,7 +4,7 @@ import org.cqfn.diktat.common.config.rules.RulesConfig
 import org.cqfn.diktat.ruleset.constants.Warnings.NULLABLE_PROPERTY_TYPE
 import org.cqfn.diktat.ruleset.rules.DiktatRule
 import org.cqfn.diktat.ruleset.utils.KotlinParser
-import org.cqfn.diktat.ruleset.utils.findAllNodesWithSpecificType
+import org.cqfn.diktat.ruleset.utils.findAllDescendantsWithSpecificType
 import org.cqfn.diktat.ruleset.utils.hasChildOfType
 
 import com.pinterest.ktlint.core.ast.ElementType.BOOLEAN_CONSTANT
@@ -53,7 +53,7 @@ class NullableTypeRule(configRules: List<RulesConfig>) : DiktatRule(
             val typeReferenceNode = node.findChildByType(TYPE_REFERENCE)!!
             // check that property has nullable type, right value one of allow expression
             if (!node.hasChildOfType(NULL) &&
-                    node.findAllNodesWithSpecificType(DOT_QUALIFIED_EXPRESSION).isEmpty() &&
+                    node.findAllDescendantsWithSpecificType(DOT_QUALIFIED_EXPRESSION).isEmpty() &&
                     typeReferenceNode.hasChildOfType(NULLABLE_TYPE) &&
                     typeReferenceNode.findChildByType(NULLABLE_TYPE)!!.hasChildOfType(QUEST) &&
                     (node.findChildByType(CALL_EXPRESSION)?.findChildByType(REFERENCE_EXPRESSION) == null ||

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

@@ -5,7 +5,7 @@ import org.cqfn.diktat.common.config.rules.RulesConfig
 import org.cqfn.diktat.common.config.rules.getRuleConfig
 import org.cqfn.diktat.ruleset.constants.Warnings.WRONG_DECLARATIONS_ORDER
 import org.cqfn.diktat.ruleset.rules.DiktatRule
-import org.cqfn.diktat.ruleset.utils.findAllNodesWithSpecificType
+import org.cqfn.diktat.ruleset.utils.findAllDescendantsWithSpecificType
 import org.cqfn.diktat.ruleset.utils.hasChildOfType
 import org.cqfn.diktat.ruleset.utils.isClassEnum
 
@@ -81,7 +81,7 @@ class SortRule(configRules: List<RulesConfig>) : DiktatRule(
         nonSortList: List<ASTNode>,
         node: ASTNode) {
         val isEnum = nonSortList.first().elementType == ENUM_ENTRY
-        val spaceBefore = if (node.findAllNodesWithSpecificType(EOL_COMMENT).isNotEmpty() && isEnum) {
+        val spaceBefore = if (node.findAllDescendantsWithSpecificType(EOL_COMMENT).isNotEmpty() && isEnum) {
             nonSortList.last().run {
                 if (this.hasChildOfType(EOL_COMMENT) && !this.hasChildOfType(COMMA)) {
                     this.addChild(LeafPsiElement(COMMA, ","), this.findChildByType(EOL_COMMENT))
@@ -142,7 +142,7 @@ class SortRule(configRules: List<RulesConfig>) : DiktatRule(
                 val hasTrailingComma = (sortList.last() != enumEntryList.last() && enumEntryList.last().hasChildOfType(COMMA))
                 swapSortNodes(sortList, enumEntryList, node)
                 if (!hasTrailingComma) {
-                    val lastEntry = node.findAllNodesWithSpecificType(ENUM_ENTRY).last()
+                    val lastEntry = node.findAllDescendantsWithSpecificType(ENUM_ENTRY).last()
                     lastEntry.removeChild(lastEntry.findChildByType(COMMA)!!)
                 }
                 if (isEndSpace) {