Rule 6.1.6 abstract classes should have at least one abstract method (#…

…457)

rule-6.1.6-abstract-classes(#442)

### What's done:
  * Rule logic made
  * Added fix and warn tests

diktat-analysis.yml

@@ -331,5 +331,9 @@
   configuration: {}
 # Checks that never use the name of a variable in the custom getter or setter
 - name: WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR
+  enabled: true
+  configuration: {}
+# Checks that there are abstract functions in abstract class
+- name: CLASS_SHOULD_NOT_BE_ABSTRACT
   enabled: true
   configuration: {}

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

@@ -196,4 +196,6 @@ public object WarningNames {
 
     public const val WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR: String =
             "WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR"
+
+    public const val CLASS_SHOULD_NOT_BE_ABSTRACT: String = "CLASS_SHOULD_NOT_BE_ABSTRACT"
 }

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

@@ -119,6 +119,7 @@ enum class Warnings(private val canBeAutoCorrected: Boolean, private val warn: S
     // ======== chapter 6 ========
     USE_DATA_CLASS(false, "this class can be converted to a data class"),
     WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR(false, "Use `field` keyword instead of property name inside property accessors"),
+    CLASS_SHOULD_NOT_BE_ABSTRACT(true, "class should not be abstract, because it has no abstract functions"),
     ;
 
     /**

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

@@ -7,6 +7,7 @@ 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.rules.calculations.AccurateCalculationsRule
+import org.cqfn.diktat.ruleset.rules.classes.AbstractClassesRule
 import org.cqfn.diktat.ruleset.rules.classes.DataClassesRule
 import org.cqfn.diktat.ruleset.rules.comments.CommentsRule
 import org.cqfn.diktat.ruleset.rules.comments.HeaderCommentRule
@@ -63,6 +64,7 @@ class DiktatRuleSetProvider(private val diktatConfigFile: String = "diktat-analy
                 ::SmartCastRule,
                 ::PropertyAccessorFields,
                 ::EnumsSeparated,
+                ::AbstractClassesRule,
                 ::VariableGenericTypeDeclarationRule,
                 ::SingleLineStatementsRule,
                 ::CommentsFormatting,

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

@@ -0,0 +1,75 @@
+package org.cqfn.diktat.ruleset.rules.classes
+
+import com.pinterest.ktlint.core.Rule
+import com.pinterest.ktlint.core.ast.ElementType.ABSTRACT_KEYWORD
+import com.pinterest.ktlint.core.ast.ElementType.CLASS
+import com.pinterest.ktlint.core.ast.ElementType.CLASS_BODY
+import com.pinterest.ktlint.core.ast.ElementType.FUN
+import com.pinterest.ktlint.core.ast.ElementType.IDENTIFIER
+import com.pinterest.ktlint.core.ast.ElementType.MODIFIER_LIST
+import com.pinterest.ktlint.core.ast.ElementType.WHITE_SPACE
+import com.pinterest.ktlint.core.ast.isWhiteSpace
+import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.ruleset.constants.Warnings.CLASS_SHOULD_NOT_BE_ABSTRACT
+import org.cqfn.diktat.ruleset.utils.getAllChildrenWithType
+import org.cqfn.diktat.ruleset.utils.getFirstChildWithType
+import org.cqfn.diktat.ruleset.utils.hasChildOfType
+import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+
+/**
+ * Checks if abstract class has any abstract method. If not, warns that class should not be abstract
+ */
+class AbstractClassesRule(private val configRule: List<RulesConfig>) : Rule("abstract-classes") {
+    private lateinit var emitWarn: ((offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit)
+    private var isFixMode: Boolean = false
+
+    override fun visit(node: ASTNode,
+                       autoCorrect: Boolean,
+                       emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit) {
+        emitWarn = emit
+        isFixMode = autoCorrect
+
+        if (node.elementType == CLASS) {
+            val classBody = node.getFirstChildWithType(CLASS_BODY) ?: return
+
+            if (hasAbstractModifier(node)) {
+                handleAbstractClass(classBody, node)
+            }
+        }
+    }
+
+    private fun hasAbstractModifier(node: ASTNode): Boolean =
+            node.getFirstChildWithType(MODIFIER_LIST)?.hasChildOfType(ABSTRACT_KEYWORD) ?: false
+
+    @Suppress("UnsafeCallOnNullableType")
+    private fun handleAbstractClass(node: ASTNode, classNode: ASTNode) {
+        val functions = node.getAllChildrenWithType(FUN)
+
+        val identifier = classNode.getFirstChildWithType(IDENTIFIER)!!.text
+
+        if (functions.isNotEmpty() && functions.none { hasAbstractModifier(it) }) {
+            CLASS_SHOULD_NOT_BE_ABSTRACT.warnAndFix(configRule, emitWarn, isFixMode, identifier, node.startOffset, node) {
+                val modList = classNode.getFirstChildWithType(MODIFIER_LIST)!!
+                if (modList.getChildren(null).size > 1) {
+                    val abstractKeyword = modList.getFirstChildWithType(ABSTRACT_KEYWORD)!!
+
+                    // we are deleting one keyword, so we need to delete extra space
+                    val spaceInModifiers = if (abstractKeyword == modList.firstChildNode) {
+                        abstractKeyword.treeNext
+                    } else {
+                        abstractKeyword.treePrev
+                    }
+                    modList.removeChild(abstractKeyword)
+                    if (spaceInModifiers != null && spaceInModifiers.isWhiteSpace()) {
+                        modList.removeChild(spaceInModifiers)
+                    }
+                } else {
+                    if (modList.treeNext.isWhiteSpace()) {
+                        classNode.removeChild(modList.treeNext)
+                    }
+                    classNode.removeChild(modList)
+                }
+            }
+        }
+    }
+}

diktat-rules/src/main/resources/diktat-analysis-huawei.yml

@@ -330,5 +330,9 @@
   configuration: {}
 # Checks that never use the name of a variable in the custom getter or setter
 - name: WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR
+  enabled: true
+  configuration: {}
+# Checks that there are abstract functions in abstract class
+- name: CLASS_SHOULD_NOT_BE_ABSTRACT
   enabled: true
   configuration: {}

diktat-rules/src/main/resources/diktat-analysis.yml

@@ -332,5 +332,9 @@
   configuration: {}
 # Checks that never use the name of a variable in the custom getter or setter
 - name: WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR
+  enabled: true
+  configuration: {}
+# Checks that there are abstract functions in abstract class
+- name: CLASS_SHOULD_NOT_BE_ABSTRACT
   enabled: true
   configuration: {}

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter6/AbstractClassesFixTest.kt

@@ -0,0 +1,16 @@
+package org.cqfn.diktat.ruleset.chapter6
+
+import generated.WarningNames
+import generated.WarningNames.CLASS_SHOULD_NOT_BE_ABSTRACT
+import org.cqfn.diktat.util.FixTestBase
+import org.cqfn.diktat.ruleset.rules.classes.AbstractClassesRule
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+
+class AbstractClassesFixTest : FixTestBase("test/paragraph6/abstract_classes", ::AbstractClassesRule) {
+    @Test
+    @Tag(CLASS_SHOULD_NOT_BE_ABSTRACT)
+    fun `fix abstract class`() {
+        fixAndCompare("ShouldRemoveAbstractKeywordExpected.kt", "ShouldRemoveAbstractKeywordTest.kt")
+    }
+}

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter6/AbstractClassesWarnTest.kt

@@ -0,0 +1,59 @@
+package org.cqfn.diktat.ruleset.chapter6
+
+import com.pinterest.ktlint.core.LintError
+import generated.WarningNames.CLASS_SHOULD_NOT_BE_ABSTRACT
+import org.cqfn.diktat.ruleset.constants.Warnings
+import org.cqfn.diktat.ruleset.rules.DIKTAT_RULE_SET_ID
+import org.cqfn.diktat.ruleset.rules.classes.AbstractClassesRule
+import org.cqfn.diktat.util.LintTestBase
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+
+class AbstractClassesWarnTest : LintTestBase(::AbstractClassesRule) {
+    private val ruleId = "$DIKTAT_RULE_SET_ID:abstract-classes"
+
+    @Test
+    @Tag(CLASS_SHOULD_NOT_BE_ABSTRACT)
+    fun `should not remove abstract`() {
+        lintMethod(
+                """
+                    |abstract class Some(val a: Int = 5) {
+                    |   abstract fun func() {}
+                    |   
+                    |   fun another() {}
+                    |}
+                """.trimMargin()
+        )
+    }
+
+
+    @Test
+    @Tag(CLASS_SHOULD_NOT_BE_ABSTRACT)
+    fun `should remove abstract`() {
+        lintMethod(
+                """
+                    |abstract class Some(val a: Int = 5) {
+                    |    fun func() {}
+                    |}
+                """.trimMargin(),
+                LintError(1, 37, ruleId, "${Warnings.CLASS_SHOULD_NOT_BE_ABSTRACT.warnText()} Some", true)
+        )
+    }
+
+    @Test
+    @Tag(CLASS_SHOULD_NOT_BE_ABSTRACT)
+    fun `should remove abstract with inner`() {
+        lintMethod(
+                """
+                    |class Some(val a: Int = 5) {
+                    |    fun func() {}
+                    |    
+                    |    inner abstract class Inner {
+                    |       fun another()
+                    |    }
+                    |}
+                """.trimMargin(),
+                LintError(4, 32, ruleId, "${Warnings.CLASS_SHOULD_NOT_BE_ABSTRACT.warnText()} Inner", true)
+        )
+    }
+}

diktat-rules/src/test/resources/test/paragraph6/abstract_classes/ShouldRemoveAbstractKeywordExpected.kt

@@ -0,0 +1,21 @@
+package test.paragraph6.abstract_classes
+
+class Some() {
+    fun some(){}
+
+    fun another(){}
+
+    @SomeAnnotation @Another inner class Any {
+        fun func(){}
+    }
+
+    inner class Second {
+        fun someFunc(){}
+    }
+}
+
+abstract class Another {
+    abstract fun absFunc()
+
+    fun someFunc(){}
+}

diktat-rules/src/test/resources/test/paragraph6/abstract_classes/ShouldRemoveAbstractKeywordTest.kt

@@ -0,0 +1,21 @@
+package test.paragraph6.abstract_classes
+
+abstract class Some() {
+    fun some(){}
+
+    fun another(){}
+
+    @SomeAnnotation @Another abstract inner class Any {
+        fun func(){}
+    }
+
+    inner abstract class Second {
+        fun someFunc(){}
+    }
+}
+
+abstract class Another {
+    abstract fun absFunc()
+
+    fun someFunc(){}
+}

info/available-rules.md

@@ -92,4 +92,5 @@
 |    5 |     5.2.2 | TOO_MANY_PARAMETERS                    | Check: if function contains more parameters than allowed                                                                                                                     |  no | maxParameterListSize |
 |    5 |     5.2.3 | WRONG_OVERLOADING_FUNCTION_ARGUMENTS   | Check: function has overloading instead use default arguments                                                                                                                |  no |  -|
 |    6 |     6.1.2 | USE_DATA_CLASS                         | Check: if class can be made as data class                                                                                                                                    | no | - | yes |
-|    6 |     6.1.9 | WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR | Check: used the name of a variable in the custom getter or setter                                                                                                            |  no | - |
+|    6 |     6.1.9 | WRONG_NAME_OF_VARIABLE_INSIDE_ACCESSOR | Check: used the name of a variable in the custom getter or setter                                                                                                            |  no | - |
+|    6 |     6.1.6 | CLASS_SHOULD_NOT_BE_ABSTRACT           | Checks: if abstract class has any abstract method. If not, warns that class should not be abstract<br>Fix: deletes abstract modifier                                         | yes | - | - |