Rule for typeAlias name (#839)

* Rule for typeAlias name

### What's done:
* add typeAlias name check

diktat-analysis.yml

@@ -38,6 +38,9 @@
 # Checks that function/method name is in lowerCamelCase
 - name: FUNCTION_NAME_INCORRECT_CASE
   enabled: true
+# Checks that typealias name is in PascalCase
+- name: TYPEALIAS_NAME_INCORRECT_CASE
+  enabled: true
 # Checks that generic name doesn't contain more than 1 letter (capital). It can be followed by numbers, example: T12, T
 - name: GENERIC_NAME
   enabled: true

diktat-common/src/test/resources/test-rules-config.yml

@@ -20,6 +20,8 @@
   enabled: true
 - name: FUNCTION_NAME_INCORRECT_CASE
   enabled: true
+- name: TYPEALIAS_NAME_INCORRECT_CASE
+  enabled: true
 - name: GENERIC_NAME
   enabled: true
 - name: IDENTIFIER_LENGTH

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

@@ -41,6 +41,8 @@ public object WarningNames {
 
     public const val FUNCTION_NAME_INCORRECT_CASE: String = "FUNCTION_NAME_INCORRECT_CASE"
 
+    public const val TYPEALIAS_NAME_INCORRECT_CASE: String = "TYPEALIAS_NAME_INCORRECT_CASE"
+
     public const val FUNCTION_BOOLEAN_PREFIX: String = "FUNCTION_BOOLEAN_PREFIX"
 
     public const val FILE_NAME_INCORRECT: String = "FILE_NAME_INCORRECT"

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

@@ -55,6 +55,7 @@ enum class Warnings(
     GENERIC_NAME(true, "1.1.1", "generic name should contain only one single capital letter, it can be followed by a number"),
     BACKTICKS_PROHIBITED(false, "1.1.1", "backticks should not be used in identifier's naming. The only exception test methods marked with @Test annotation"),
     FUNCTION_NAME_INCORRECT_CASE(true, "1.4.1", "function/method name should be in lowerCamelCase"),
+    TYPEALIAS_NAME_INCORRECT_CASE(true, "1.3.1", "typealias name should be in pascalCase"),
     FUNCTION_BOOLEAN_PREFIX(true, "1.6.2", "functions that return the value of Boolean type should have <is> or <has> prefix"),
     FILE_NAME_INCORRECT(true, "1.1.1", "file name is incorrect - it should end with .kt extension and be in PascalCase"),
     EXCEPTION_SUFFIX(true, "1.1.1", "all exception classes should have \"Exception\" suffix"),

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

@@ -14,6 +14,7 @@ import org.cqfn.diktat.ruleset.constants.Warnings.FUNCTION_NAME_INCORRECT_CASE
 import org.cqfn.diktat.ruleset.constants.Warnings.GENERIC_NAME
 import org.cqfn.diktat.ruleset.constants.Warnings.IDENTIFIER_LENGTH
 import org.cqfn.diktat.ruleset.constants.Warnings.OBJECT_NAME_INCORRECT
+import org.cqfn.diktat.ruleset.constants.Warnings.TYPEALIAS_NAME_INCORRECT_CASE
 import org.cqfn.diktat.ruleset.constants.Warnings.VARIABLE_HAS_PREFIX
 import org.cqfn.diktat.ruleset.constants.Warnings.VARIABLE_NAME_INCORRECT
 import org.cqfn.diktat.ruleset.constants.Warnings.VARIABLE_NAME_INCORRECT_FORMAT
@@ -85,7 +86,7 @@ class IdentifierNaming(configRules: List<RulesConfig>) : DiktatRule(
     listOf(BACKTICKS_PROHIBITED, VARIABLE_NAME_INCORRECT, VARIABLE_NAME_INCORRECT_FORMAT, CONSTANT_UPPERCASE,
         VARIABLE_HAS_PREFIX, CONFUSING_IDENTIFIER_NAMING, GENERIC_NAME, CLASS_NAME_INCORRECT,
         ENUM_VALUE, EXCEPTION_SUFFIX, FUNCTION_BOOLEAN_PREFIX, FUNCTION_NAME_INCORRECT_CASE,
-        IDENTIFIER_LENGTH, OBJECT_NAME_INCORRECT)) {
+        IDENTIFIER_LENGTH, OBJECT_NAME_INCORRECT, TYPEALIAS_NAME_INCORRECT_CASE)) {
     private val allMethodPrefixes by lazy {
         if (configuration.allowedBooleanPrefixes.isEmpty()) {
             booleanMethodPrefixes
@@ -119,6 +120,8 @@ class IdentifierNaming(configRules: List<RulesConfig>) : DiktatRule(
             ElementType.ENUM_ENTRY -> Pair(checkEnumValues(node), false)
             // covers global functions, extensions and class methods
             ElementType.FUN -> Pair(checkFunctionName(node), false)
+            // covers case of typeAlias values
+            ElementType.TYPEALIAS -> Pair(checkTypeAliases(node), false)
             else -> Pair(null, false)
         }
 
@@ -385,6 +388,18 @@ class IdentifierNaming(configRules: List<RulesConfig>) : DiktatRule(
         return listOf(functionName)
     }
 
+    @Suppress("UnsafeCallOnNullableType")
+    private fun checkTypeAliases(node: ASTNode): List<ASTNode> {
+        val aliasName = node.getIdentifierName()!!
+
+        if (!aliasName.text.isPascalCase()) {
+            TYPEALIAS_NAME_INCORRECT_CASE.warnAndFix(configRules, emitWarn, isFixMode, aliasName.text, aliasName.startOffset, aliasName) {
+                (aliasName as LeafPsiElement).replaceWithText(aliasName.text.toPascalCase())
+            }
+        }
+        return listOf(aliasName)
+    }
+
     /**
      * check that generic name has single capital letter, can be followed by a number
      * this method will check it for both generic classes and generic methods

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

@@ -38,6 +38,9 @@
 # Checks that function/method name is in lowerCamelCase
 - name: FUNCTION_NAME_INCORRECT_CASE
   enabled: true
+# Checks that typealias name is in PascalCase
+- name: TYPEALIAS_NAME_INCORRECT_CASE
+  enabled: true
 # Checks that generic name doesn't contain more than 1 letter (capital). It can be followed by numbers, example: T12, T
 - name: GENERIC_NAME
   enabled: true

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

@@ -36,6 +36,9 @@
 # Checks that function/method name is in lowerCamelCase
 - name: FUNCTION_NAME_INCORRECT_CASE
   enabled: true
+# Checks that typealias name is in PascalCase
+- name: TYPEALIAS_NAME_INCORRECT_CASE
+  enabled: true
 # Checks that generic name doesn't contain more than 1 letter (capital). It can be followed by numbers, example: T12, T
 - name: GENERIC_NAME
   enabled: true

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter1/IdentifierNamingFixTest.kt

@@ -57,4 +57,10 @@ class IdentifierNamingFixTest : FixTestBase(
     fun `incorrect lambda argument case fix`() {
         fixAndCompare("identifiers/LambdaArgExpected.kt", "identifiers/LambdaArgTest.kt")
     }
+
+    @Test
+    @Tag(WarningNames.TYPEALIAS_NAME_INCORRECT_CASE)
+    fun `typeAlias name incorrect`() {
+        fixAndCompare("identifiers/TypeAliasNameExpected.kt", "identifiers/TypeAliasNameTest.kt")
+    }
 }

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter1/MethodNamingWarnTest.kt

@@ -2,6 +2,7 @@ package org.cqfn.diktat.ruleset.chapter1
 
 import org.cqfn.diktat.ruleset.constants.Warnings.FUNCTION_BOOLEAN_PREFIX
 import org.cqfn.diktat.ruleset.constants.Warnings.FUNCTION_NAME_INCORRECT_CASE
+import org.cqfn.diktat.ruleset.constants.Warnings.TYPEALIAS_NAME_INCORRECT_CASE
 import org.cqfn.diktat.ruleset.rules.DIKTAT_RULE_SET_ID
 import org.cqfn.diktat.ruleset.rules.chapter1.IdentifierNaming
 import org.cqfn.diktat.util.LintTestBase
@@ -85,6 +86,30 @@ class MethodNamingWarnTest : LintTestBase(::IdentifierNaming) {
         lintMethod(code, LintError(2, 7, ruleId, "${FUNCTION_NAME_INCORRECT_CASE.warnText()} methODTREE", true))
     }
 
+    @Test
+    @Tag(WarningNames.TYPEALIAS_NAME_INCORRECT_CASE)
+    fun `typeAlias name incorrect, part 1`() {
+        val code =
+                """
+                      class TestPackageName {
+                        typealias relatedClasses = List<Pair<String, String>>
+                      }
+                """.trimIndent()
+        lintMethod(code, LintError(2, 13, ruleId, "${TYPEALIAS_NAME_INCORRECT_CASE.warnText()} relatedClasses", true))
+    }
+
+    @Test
+    @Tag(WarningNames.TYPEALIAS_NAME_INCORRECT_CASE)
+    fun `typeAlias name incorrect, part 2`() {
+        lintMethod(
+            """
+                  class TestPackageName {
+                    typealias RelatedClasses = List<Pair<String, String>>
+                  }
+                """.trimIndent()
+        )
+    }
+
     @Test
     @Tag(WarningNames.FUNCTION_BOOLEAN_PREFIX)
     fun `boolean method name incorrect`() {

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/smoke/DiktatSmokeTest.kt

@@ -31,7 +31,7 @@ import kotlin.io.path.ExperimentalPathApi
 import kotlin.io.path.createTempFile
 import kotlinx.serialization.encodeToString
 
-typealias ruleToConfig = Map<String, Map<String, String>>
+typealias RuleToConfig = Map<String, Map<String, String>>
 
 /**
  * Test for [DiktatRuleSetProvider] in autocorrect mode as a whole. All rules are applied to a file.
@@ -48,7 +48,7 @@ class DiktatSmokeTest : FixTestBase("test/smoke/src/main/kotlin",
      * Disable some of the rules.
      */
     @Suppress("UnsafeCallOnNullableType")
-    private fun overrideRulesConfig(rulesToDisable: List<Warnings>, rulesToOverride: ruleToConfig = emptyMap()) {
+    private fun overrideRulesConfig(rulesToDisable: List<Warnings>, rulesToOverride: RuleToConfig = emptyMap()) {
         val rulesConfig = RulesConfigReader(javaClass.classLoader).readResource(configFilePath)!!
             .toMutableList()
             .also { rulesConfig ->

diktat-rules/src/test/resources/test/paragraph1/naming/identifiers/TypeAliasNameExpected.kt

@@ -0,0 +1,5 @@
+package test.paragraph1.naming.identifiers
+
+class TypeAliasName {
+    typealias RelatedClasses = List<Pair<String, String>>
+}

diktat-rules/src/test/resources/test/paragraph1/naming/identifiers/TypeAliasNameTest.kt

@@ -0,0 +1,5 @@
+package test.paragraph1.naming.identifiers
+
+class TypeAliasName {
+    typealias relatedClasses = List<Pair<String, String>>
+}

info/available-rules.md

@@ -18,6 +18,7 @@
 |    1  |     1.3.1  |  ENUM_VALUE                               |  Check: warns if enum value is in non UPPER_SNAKE_CASE or non PascalCase depending on the config, UPPER_SNAKE_CASE by default<br>Fix: automatically converting case to selected case |  yes  |  enumStyle: snakeCase, pascalCase  | Recursively update usages of this identifier in the project|
 |    1  |     1.1.1  |  GENERIC_NAME                             |  Check: warns if generic name contains more than 1 letter (capital). It can be followed by numbers, example: T12, T<br>Fix:                                                    |  yes  |  no  | Recursively update usages of this identifier in the project|
 |    1  |     1.4.1  |  FUNCTION_NAME_INCORRECT_CASE             |  Check: function/method name should be in lowerCamelCase:<br>Fix:                                                                                                              |  yes  |  no  | Recursively update usages of this function in the project|
+|    1  |     1.3.1  |  TYPEALIAS_NAME_INCORRECT_CASE            |  Check: typealias name should be in pascalCase:<br>Fix:                                                                                                                        |  yes  |  no  | Recursively update usages of this typealias in the project|
 |    1  |     1.6.2  |  FUNCTION_BOOLEAN_PREFIX                  |  Check: functions/methods that return boolean should have special prefix like "is/should/e.t.c"<br>Fix:                                                                        |  yes  |  no  | Recursively update usages of this function in the projectAggressive fix - what if new name will not be valid|
 |    1  |     1.1.1  |  FILE_NAME_INCORRECT                      |  Check: warns if file name does not have extension .kt/.kts<br>Fix: no                                                                                                         |   no  |  no  | Extensions should be configurableIt can be aggressively autofixed|
 |    1  |     3.1.2  |  FILE_NAME_MATCH_CLASS                    |  Check: warns<br>Fix: no                                                                                                                                                       |   no  |  no  |  Probably it can be autofixed, but it will be aggressive fix|

info/guide/diktat-coding-convention.md

@@ -273,9 +273,9 @@ package your.company.domain.mobilecontrol.views
 ```
 
 <!-- =============================================================================== -->
-### <a name="c1.3"></a> 1.3 Classes, enumerations, interfaces
+### <a name="c1.3"></a> 1.3 Classes, enumerations, typealias, interfaces
 This section describes the general rules for naming classes, enumerations, and interfaces.
-### <a name="r1.3.1"></a> 1.3.1 Classes, enumerations, interface names use Camel case
+### <a name="r1.3.1"></a> 1.3.1 Classes, enumerations, typealias, interface names use Camel case
 Classes, enumerations, and interface names use `UpperCamelCase` nomenclature. Follow the naming rules described below:
 1.	A class name is usually a noun (or a noun phrase) denoted using the camel case nomenclature, such as UpperCamelCase. For example: `Character` or `ImmutableList`.
 An interface name can also be a noun or noun phrase (such as `List`) or an adjective or adjective phrase (such as `Readable`).

info/guide/guide-chapter-1.md

@@ -86,9 +86,9 @@ package your.company.domain.mobilecontrol.views
 ```
 
 <!-- =============================================================================== -->
-### <a name="c1.3"></a> 1.3 Classes, enumerations, interfaces
+### <a name="c1.3"></a> 1.3 Classes, enumerations, typealias, interfaces
 This section describes the general rules for naming classes, enumerations, and interfaces.
-### <a name="r1.3.1"></a> 1.3.1 Classes, enumerations, interface names use Camel case
+### <a name="r1.3.1"></a> 1.3.1 Classes, enumerations, typealias, interface names use Camel case
 Classes, enumerations, and interface names use `UpperCamelCase` nomenclature. Follow the naming rules described below:
 1.	A class name is usually a noun (or a noun phrase) denoted using the camel case nomenclature, such as UpperCamelCase. For example: `Character` or `ImmutableList`.
 An interface name can also be a noun or noun phrase (such as `List`) or an adjective or adjective phrase (such as `Readable`).

info/rules-mapping.md

@@ -17,6 +17,7 @@
 | CLASS_NAME_INCORRECT | [1.3.1](guide/diktat-coding-convention.md#r1.3.1) | yes | Naming |
 | OBJECT_NAME_INCORRECT | [1.3.1](guide/diktat-coding-convention.md#r1.3.1) | yes | Naming |
 | ENUM_VALUE | [1.3.1](guide/diktat-coding-convention.md#r1.3.1) | yes | Naming |
+| TYPEALIAS_NAME_INCORRECT_CASE | [1.3.1](guide/diktat-coding-convention.md#r1.3.1) | yes | Naming |
 | FUNCTION_NAME_INCORRECT_CASE | [1.4.1](guide/diktat-coding-convention.md#r1.4.1) | yes | Naming |
 | CONSTANT_UPPERCASE | [1.5.1](guide/diktat-coding-convention.md#r1.5.1) | yes | Naming |
 | VARIABLE_NAME_INCORRECT_FORMAT | [1.6.1](guide/diktat-coding-convention.md#r1.6.1) | yes | Naming |