Recommendation 4.2.2 type alias

diktat-analysis.yml

@@ -230,4 +230,9 @@
   configuration: {}
 - name: LOCAL_VARIABLE_EARLY_DECLARATION
   enabled: true
-  configuration: {}
+  configuration: {}
+# Type aliases provide alternative names for existing types when type's reference text is longer 25 chars
+- name: TYPE_ALIAS
+  enabled: true
+  configuration:
+    typeReferenceLength: '25' # max length of type reference

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

@@ -147,4 +147,6 @@ object WarningNames {
     const val WRONG_MULTIPLE_MODIFIERS_ORDER: String = "WRONG_MULTIPLE_MODIFIERS_ORDER"
 
     const val LOCAL_VARIABLE_EARLY_DECLARATION: String = "LOCAL_VARIABLE_EARLY_DECLARATION"
+
+    const val TYPE_ALIAS: String = "TYPE_ALIAS"
 }

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

@@ -91,6 +91,7 @@ enum class Warnings(private val canBeAutoCorrected: Boolean, private val warn: S
     WRONG_DECLARATIONS_ORDER(true, "declarations of constants and enum members should be sorted alphabetically"),
     WRONG_MULTIPLE_MODIFIERS_ORDER(true, "sequence of modifiers is incorrect"),
     LOCAL_VARIABLE_EARLY_DECLARATION(false, "local variables should be declared close to the line where they are first used"),
+    TYPE_ALIAS(false, "variable's type is too complex and should be replaced with typealias"),
     ;
 
     /**

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

@@ -49,6 +49,7 @@ class DiktatRuleSetProvider(private val diktatConfigFile: String = "diktat-analy
                 ::SortRule,
                 ::StringConcatenationRule,
                 ::LineLength,
+                ::TypeAliasRule,
                 ::BlankLinesRule,
                 ::WhiteSpaceRule,
                 ::WhenMustHaveElseRule,

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

@@ -0,0 +1,50 @@
+package org.cqfn.diktat.ruleset.rules
+
+import com.pinterest.ktlint.core.Rule
+import com.pinterest.ktlint.core.ast.ElementType.LT
+import com.pinterest.ktlint.core.ast.ElementType.TYPE_REFERENCE
+import com.pinterest.ktlint.core.ast.ElementType.VALUE_PARAMETER
+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.Warnings.TYPE_ALIAS
+import org.cqfn.diktat.ruleset.utils.*
+import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+
+/**
+ * This rule checks if variable has long type reference and two or more nested generics.
+ * Length type reference can be configured
+ */
+class TypeAliasRule(private val configRules: List<RulesConfig>) : Rule("type-alias") {
+
+    companion object {
+        const val TYPE_REFERENCE_MAX_LENGTH = 25
+    }
+
+    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 == TYPE_REFERENCE) {
+            checkTypeReference(node, TypeAliasConfiguration(configRules.getRuleConfig(TYPE_ALIAS)?.configuration ?: mapOf()))
+        }
+    }
+
+    /**
+     * Check properties for nested generics. Count LT for generic types and VALUE_PARAMETER for functional types
+     */
+    private fun checkTypeReference(node: ASTNode, config: TypeAliasConfiguration) {
+        if (node.textLength > config.typeReferenceLength)
+            if (node.findAllNodesWithSpecificType(LT).size > 1 || node.findAllNodesWithSpecificType(VALUE_PARAMETER).size > 1)
+                TYPE_ALIAS.warn(configRules, emitWarn, isFixMode, "too long type reference", node.startOffset, node)
+    }
+
+    class TypeAliasConfiguration(config: Map<String, String>) : RuleConfiguration(config) {
+        val typeReferenceLength = config["typeReferenceLength"]?.toIntOrNull() ?: TYPE_REFERENCE_MAX_LENGTH
+    }
+}

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

@@ -230,4 +230,9 @@
   configuration: {}
 - name: LOCAL_VARIABLE_EARLY_DECLARATION
   enabled: true
-  configuration: {}
+  configuration: {}
+# Type aliases provide alternative names for existing types when type's reference text is longer 25 chars
+- name: TYPE_ALIAS
+  enabled: true
+  configuration:
+    typeReferenceLength: '25' # max length of type reference

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

@@ -234,4 +234,9 @@
 # Inspection that checks if local variables are declared close to the first usage site
 - name: LOCAL_VARIABLE_EARLY_DECLARATION
   enabled: true
-  configuration: {}
+  configuration: {}
+# Type aliases provide alternative names for existing types when type's reference text is longer 25 chars
+- name: TYPE_ALIAS
+  enabled: true
+  configuration:
+    typeReferenceLength: '25' # max length of type reference

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

@@ -0,0 +1,77 @@
+package org.cqfn.diktat.ruleset.chapter3
+
+import com.pinterest.ktlint.core.LintError
+import generated.WarningNames
+import org.cqfn.diktat.common.config.rules.RulesConfig
+import org.cqfn.diktat.ruleset.constants.Warnings.TYPE_ALIAS
+import org.cqfn.diktat.ruleset.rules.DIKTAT_RULE_SET_ID
+import org.cqfn.diktat.ruleset.rules.TypeAliasRule
+import org.cqfn.diktat.util.LintTestBase
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Test
+
+class TypeAliasRuleWarnTest : LintTestBase(::TypeAliasRule) {
+
+    private val ruleId = "$DIKTAT_RULE_SET_ID:type-alias"
+
+    private val rulesConfigListShortType: List<RulesConfig> = listOf(
+            RulesConfig(TYPE_ALIAS.name, true,
+                    mapOf("typeReferenceLength" to "4"))
+    )
+
+    @Test
+    @Tag(WarningNames.TYPE_ALIAS)
+    fun `string concatenation - only strings`() {
+        lintMethod(
+                """
+                    | val b: MutableMap<String, MutableList<String>>
+                    | val b = listof<Int>()
+                """.trimMargin(),
+                LintError(1,9, ruleId, "${TYPE_ALIAS.warnText()} too long type reference", false)
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.TYPE_ALIAS)
+    fun `check long lambda property`() {
+        lintMethod(
+                """
+                    | var emitWarn: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit
+                    | var emitWarn: (offset: Int, (T) -> Boolean) -> Unit
+                """.trimMargin(),
+                LintError(1,16, ruleId, "${TYPE_ALIAS.warnText()} too long type reference", false),
+                LintError(2,16, ruleId, "${TYPE_ALIAS.warnText()} too long type reference", false)
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.TYPE_ALIAS)
+    fun `correct type length`() {
+        lintMethod(
+                """
+                    | var emitWarn: Int
+                    | val b = mutableMapOf<String, MutableList<String>>()
+                    | 
+                    | fun foo(): MutableMap<String, MutableList<String>> {
+                    | }
+                    | 
+                """.trimMargin(),
+                LintError(4,13, ruleId, "${TYPE_ALIAS.warnText()} too long type reference", false)
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.TYPE_ALIAS)
+    fun `correct type length but with configuration`() {
+        lintMethod(
+                """
+                    | var emitWarn: Int
+                    | val flag: (T) -> Boolean
+                    | val list: List<List<Int>>
+                    | 
+                """.trimMargin(),
+                LintError(3,12, ruleId, "${TYPE_ALIAS.warnText()} too long type reference", false),
+                rulesConfigList = rulesConfigListShortType
+        )
+    }
+}

info/available-rules.md

@@ -71,3 +71,4 @@
 |    3 |      3.2 | WRONG_DECLARATIONS_ORDER                               | Check: if order of enum values or constant property inside companion isn't correct                                                                                           | yes | -                         |                                                                                     - |
 |    3 |      3.11 | ANNOTATION_NEW_LINE                    | Check: warns if annotation not on a new single line                                                                                                                          | yes | - | - |
 |    3 |      3.2 | WRONG_MULTIPLE_MODIFIERS_ORDER          | Check: if multiple modifiers sequence is in the wrong order                                                                                                                  | yes | -                         | - |
+|    4 |     4.2.2| TYPE_ALIAS                              | Check: if type reference of property is longer than expected                                                                                                                 | yes | typeReferenceLength       |                                                                                     -|