Allow property, function and class name to be same as keyword wrapped…

… with backticks (#2405) * Allow property, function and class name to be same as keyword wrapped with backticks Closes #2352
pinterest · Dec 3, 2023 · c670818 · c670818
1 parent 07a43f4
commit c670818
Show file tree

Hide file tree

Showing 7 changed files with 134 additions and 11 deletions.
diff --git a/documentation/snapshot/docs/rules/standard.md b/documentation/snapshot/docs/rules/standard.md
@@ -346,6 +346,8 @@ Enforce naming of class and objects.
     class Foo
 
     class Foo1
+
+    class `class` // Any keyword is allowed when wrapped between backticks
     ```
 === "[:material-heart:](#) Ktlint JUnit Test"
 
@@ -384,6 +386,8 @@ Enforce naming of function.
     fun foo() {}
 
     fun fooBar() {}
+
+    fun `fun` {} // Any keyword is allowed when wrapped between backticks
     ```
 === "[:material-heart:](#) Ktlint Test"
 
@@ -469,6 +473,8 @@ Enforce naming of property.
             val FOO1 = Foo() // In case developer want to communicate that Foo is deeply immutable
         }
     }
+
+    var `package` = "foo" // Any keyword is allowed when wrapped between backticks
     ```
 === "[:material-heart-off-outline:](#) Disallowed"
 

diff --git a/...t-standard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/rules/ClassNamingRule.kt b/...t-standard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/rules/ClassNamingRule.kt
@@ -11,6 +11,7 @@ import com.pinterest.ktlint.rule.engine.core.api.SinceKtlint.Status.EXPERIMENTAL
 import com.pinterest.ktlint.ruleset.standard.StandardRule
 import com.pinterest.ktlint.ruleset.standard.rules.internal.regExIgnoringDiacriticsAndStrokesOnLetters
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+import org.jetbrains.kotlin.lexer.KtTokens
 
 /**
  * https://kotlinlang.org/docs/coding-conventions.html#naming-rules
@@ -42,7 +43,7 @@ public class ClassNamingRule : StandardRule("class-naming") {
         node
             .takeIf { node.elementType == CLASS || node.elementType == OBJECT_DECLARATION }
             ?.findChildByType(IDENTIFIER)
-            ?.takeUnless { it.isValidFunctionName() || it.isTestClass() }
+            ?.takeUnless { it.isValidFunctionName() || it.isTestClass() || it.isTokenKeywordBetweenBackticks() }
             ?.let {
                 emit(it.startOffset, "Class or object name should start with an uppercase letter and use camel case", false)
             }
@@ -54,9 +55,25 @@ public class ClassNamingRule : StandardRule("class-naming") {
 
     private fun ASTNode.hasBackTickedIdentifier() = text.matches(BACK_TICKED_FUNCTION_NAME_REGEXP)
 
+    private fun ASTNode.isTokenKeywordBetweenBackticks() =
+        this
+            .takeIf { it.elementType == IDENTIFIER }
+            ?.text
+            .orEmpty()
+            .removeSurrounding("`")
+            .let { KEYWORDS.contains(it) }
+
     private companion object {
         val VALID_CLASS_NAME_REGEXP = "[A-Z][A-Za-z\\d]*".regExIgnoringDiacriticsAndStrokesOnLetters()
         val BACK_TICKED_FUNCTION_NAME_REGEXP = Regex("`.*`")
+        private val KEYWORDS =
+            setOf(KtTokens.KEYWORDS, KtTokens.SOFT_KEYWORDS)
+                .flatMap { tokenSet -> tokenSet.types.mapNotNull { it.debugName } }
+                .filterNot { keyword ->
+                    // The keyword sets contain a few 'keywords' which should be ignored. All valid keywords only contain lowercase
+                    // characters
+                    keyword.any { it.isUpperCase() }
+                }.toSet()
     }
 }
 

diff --git a/...tandard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/rules/FunctionNamingRule.kt b/...tandard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/rules/FunctionNamingRule.kt
@@ -11,6 +11,7 @@ import com.pinterest.ktlint.rule.engine.core.api.ElementType.IMPORT_DIRECTIVE
 import com.pinterest.ktlint.rule.engine.core.api.ElementType.MODIFIER_LIST
 import com.pinterest.ktlint.rule.engine.core.api.ElementType.OVERRIDE_KEYWORD
 import com.pinterest.ktlint.rule.engine.core.api.ElementType.REFERENCE_EXPRESSION
+import com.pinterest.ktlint.rule.engine.core.api.ElementType.TYPE_REFERENCE
 import com.pinterest.ktlint.rule.engine.core.api.ElementType.USER_TYPE
 import com.pinterest.ktlint.rule.engine.core.api.ElementType.VALUE_PARAMETER_LIST
 import com.pinterest.ktlint.rule.engine.core.api.RuleId
@@ -26,6 +27,7 @@ import com.pinterest.ktlint.ruleset.standard.StandardRule
 import com.pinterest.ktlint.ruleset.standard.rules.internal.regExIgnoringDiacriticsAndStrokesOnLetters
 import org.ec4j.core.model.PropertyType
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtImportDirective
 
@@ -68,14 +70,11 @@ public class FunctionNamingRule :
                     node.isAnonymousFunction() ||
                     node.isOverrideFunction() ||
                     node.isAnnotatedWithAnyOf(ignoreWhenAnnotatedWith)
-            }?.let {
-                val identifierOffset =
-                    node
-                        .findChildByType(IDENTIFIER)
-                        ?.startOffset
-                        ?: 1
+            }?.findChildByType(IDENTIFIER)
+            ?.takeUnless { it.isTokenKeywordBetweenBackticks() }
+            ?.let { identifier ->
                 emit(
-                    identifierOffset,
+                    identifier.startOffset,
                     "Function name should start with a lowercase letter (except factory methods) and use camel case",
                     false,
                 )
@@ -165,12 +164,20 @@ public class FunctionNamingRule :
 
     private fun ASTNode.annotationEntryName() =
         findChildByType(ElementType.CONSTRUCTOR_CALLEE)
-            ?.findChildByType(ElementType.TYPE_REFERENCE)
-            ?.findChildByType(ElementType.USER_TYPE)
-            ?.findChildByType(ElementType.REFERENCE_EXPRESSION)
+            ?.findChildByType(TYPE_REFERENCE)
+            ?.findChildByType(USER_TYPE)
+            ?.findChildByType(REFERENCE_EXPRESSION)
             ?.findChildByType(IDENTIFIER)
             ?.text
 
+    private fun ASTNode.isTokenKeywordBetweenBackticks() =
+        this
+            .takeIf { it.elementType == IDENTIFIER }
+            ?.text
+            .orEmpty()
+            .removeSurrounding("`")
+            .let { KEYWORDS.contains(it) }
+
     public companion object {
         public val IGNORE_WHEN_ANNOTATED_WITH_PROPERTY: EditorConfigProperty<Set<String>> =
             EditorConfigProperty(
@@ -185,6 +192,14 @@ public class FunctionNamingRule :
 
         private val VALID_FUNCTION_NAME_REGEXP = "[a-z][A-Za-z\\d]*".regExIgnoringDiacriticsAndStrokesOnLetters()
         private val VALID_TEST_FUNCTION_NAME_REGEXP = "(`.*`)|([a-z][A-Za-z\\d_]*)".regExIgnoringDiacriticsAndStrokesOnLetters()
+        private val KEYWORDS =
+            setOf(KtTokens.KEYWORDS, KtTokens.SOFT_KEYWORDS)
+                .flatMap { tokenSet -> tokenSet.types.mapNotNull { it.debugName } }
+                .filterNot { keyword ->
+                    // The keyword sets contain a few 'keywords' which should be ignored. All valid keywords only contain lowercase
+                    // characters
+                    keyword.any { it.isUpperCase() }
+                }.toSet()
         private val TEST_LIBRARIES_SET =
             setOf(
                 "io.kotest",

diff --git a/...tandard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/rules/PropertyNamingRule.kt b/...tandard/src/main/kotlin/com/pinterest/ktlint/ruleset/standard/rules/PropertyNamingRule.kt
@@ -26,6 +26,7 @@ import com.pinterest.ktlint.ruleset.standard.StandardRule
 import com.pinterest.ktlint.ruleset.standard.rules.internal.regExIgnoringDiacriticsAndStrokesOnLetters
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.com.intellij.psi.tree.IElementType
+import org.jetbrains.kotlin.lexer.KtTokens
 
 /**
  * https://kotlinlang.org/docs/coding-conventions.html#function-names
@@ -50,6 +51,7 @@ public class PropertyNamingRule : StandardRule("property-naming") {
     ) {
         property
             .findChildByType(IDENTIFIER)
+            ?.takeUnless { it.isTokenKeywordBetweenBackticks() }
             ?.let { identifier ->
                 when {
                     property.hasConstModifier() -> {
@@ -187,11 +189,27 @@ public class PropertyNamingRule : StandardRule("property-naming") {
             !hasModifier(PROTECTED_KEYWORD) &&
             !hasModifier(INTERNAL_KEYWORD)
 
+    private fun ASTNode.isTokenKeywordBetweenBackticks() =
+        this
+            .takeIf { it.elementType == IDENTIFIER }
+            ?.text
+            .orEmpty()
+            .removeSurrounding("`")
+            .let { KEYWORDS.contains(it) }
+
     private companion object {
         val LOWER_CAMEL_CASE_REGEXP = "[a-z][a-zA-Z0-9]*".regExIgnoringDiacriticsAndStrokesOnLetters()
         val SCREAMING_SNAKE_CASE_REGEXP = "[A-Z][_A-Z0-9]*".regExIgnoringDiacriticsAndStrokesOnLetters()
         val BACKING_PROPERTY_LOWER_CAMEL_CASE_REGEXP = "_[a-z][a-zA-Z0-9]*".regExIgnoringDiacriticsAndStrokesOnLetters()
         const val SERIAL_VERSION_UID_PROPERTY_NAME = "serialVersionUID"
+        val KEYWORDS =
+            setOf(KtTokens.KEYWORDS, KtTokens.SOFT_KEYWORDS)
+                .flatMap { tokenSet -> tokenSet.types.mapNotNull { it.debugName } }
+                .filterNot { keyword ->
+                    // The keyword sets contain a few 'keywords' which should be ignored. All valid keywords only contain lowercase
+                    // characters
+                    keyword.any { it.isUpperCase() }
+                }.toSet()
     }
 }
 

diff --git a/...andard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/rules/ClassNamingRuleTest.kt b/...andard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/rules/ClassNamingRuleTest.kt
@@ -139,4 +139,25 @@ class ClassNamingRuleTest {
             """.trimIndent()
         classNamingRuleAssertThat(code).hasNoLintViolations()
     }
+
+    @ParameterizedTest(name = "Keyword: {0}")
+    @Suppress("ktlint:standard:argument-list-wrapping")
+    @ValueSource(
+        strings = [
+            "abstract", "actual", "annotation", "as", "break", "by", "catch", "class", "companion", "const", "constructor", "context",
+            "continue", "contract", "crossinline", "data", "delegate", "do", "dynamic", "else", "enum", "expect", "external", "false",
+            "field", "file", "final", "finally", "for", "fun", "get", "header", "if", "impl", "import", "in", "infix", "init", "inline",
+            "inner", "interface", "internal", "is", "lateinit", "noinline", "null", "object", "open", "operator", "out", "override",
+            "package", "param", "private", "property", "protected", "public", "receiver", "reified", "return", "sealed", "set", "setparam",
+            "super", "suspend", "tailrec", "this", "throw", "true", "try", "typealias", "typeof", "val", "value", "var", "vararg", "when",
+            "where", "while",
+        ],
+    )
+    fun `Issue 2352 - Given a keyword then allow it to be wrapped between backticks`(keyword: String) {
+        val code =
+            """
+            class `$keyword`
+            """.trimIndent()
+        classNamingRuleAssertThat(code).hasNoLintViolations()
+    }
 }
diff --git a/...ard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/rules/FunctionNamingRuleTest.kt b/...ard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/rules/FunctionNamingRuleTest.kt
@@ -271,4 +271,25 @@ class FunctionNamingRuleTest {
             """.trimIndent()
         functionNamingRuleAssertThat(code).hasNoLintViolations()
     }
+
+    @ParameterizedTest(name = "Keyword: {0}")
+    @Suppress("ktlint:standard:argument-list-wrapping")
+    @ValueSource(
+        strings = [
+            "abstract", "actual", "annotation", "as", "break", "by", "catch", "class", "companion", "const", "constructor", "context",
+            "continue", "contract", "crossinline", "data", "delegate", "do", "dynamic", "else", "enum", "expect", "external", "false",
+            "field", "file", "final", "finally", "for", "fun", "get", "header", "if", "impl", "import", "in", "infix", "init", "inline",
+            "inner", "interface", "internal", "is", "lateinit", "noinline", "null", "object", "open", "operator", "out", "override",
+            "package", "param", "private", "property", "protected", "public", "receiver", "reified", "return", "sealed", "set", "setparam",
+            "super", "suspend", "tailrec", "this", "throw", "true", "try", "typealias", "typeof", "val", "value", "var", "vararg", "when",
+            "where", "while",
+        ],
+    )
+    fun `Issue 2352 - Given a keyword then allow it to be wrapped between backticks`(keyword: String) {
+        val code =
+            """
+            fun `$keyword`() = "foo"
+            """.trimIndent()
+        functionNamingRuleAssertThat(code).hasNoLintViolations()
+    }
 }
diff --git a/...ard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/rules/PropertyNamingRuleTest.kt b/...ard/src/test/kotlin/com/pinterest/ktlint/ruleset/standard/rules/PropertyNamingRuleTest.kt
@@ -329,6 +329,31 @@ class PropertyNamingRuleTest {
         }
     }
 
+    @ParameterizedTest(name = "Keyword: {0}")
+    @Suppress("ktlint:standard:argument-list-wrapping")
+    @ValueSource(
+        strings = [
+            "abstract", "actual", "annotation", "as", "break", "by", "catch", "class", "companion", "const", "constructor", "context",
+            "continue", "contract", "crossinline", "data", "delegate", "do", "dynamic", "else", "enum", "expect", "external", "false",
+            "field", "file", "final", "finally", "for", "fun", "get", "header", "if", "impl", "import", "in", "infix", "init", "inline",
+            "inner", "interface", "internal", "is", "lateinit", "noinline", "null", "object", "open", "operator", "out", "override",
+            "package", "param", "private", "property", "protected", "public", "receiver", "reified", "return", "sealed", "set", "setparam",
+            "super", "suspend", "tailrec", "this", "throw", "true", "try", "typealias", "typeof", "val", "value", "var", "vararg", "when",
+            "where", "while",
+        ],
+    )
+    fun `Issue 2352 - Given a keyword then allow it to be wrapped between backticks`(keyword: String) {
+        val code =
+            """
+            var `$keyword` = "some-value"
+            fun foo() {
+                var `$keyword` = "some-value"
+                val `$keyword` = "some-value"
+            }
+            """.trimIndent()
+        propertyNamingRuleAssertThat(code).hasNoLintViolations()
+    }
+
     @KtlintDocumentationTest
     fun `Ktlint allowed examples`() {
         val code =