Add option to enable specific experimental rules

CHANGELOG.md

@@ -4,6 +4,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 ### Added
+- Support for globally enabling experimental rules via `--experimental_rules` command line flag.
+- Support for globally enabling experimental rules via custom `experimental_rules` property in `.editorconfig`
 
 ### Fixed
 - Incorrect indentation with multiple interfaces ([#1003](https://github.com/pinterest/ktlint/issues/1003))

README.md

@@ -89,6 +89,7 @@ max_line_length=off
 # Note that rules in any ruleset other than the standard ruleset will need to be prefixed 
 # by the ruleset identifier.
 disabled_rules=no-wildcard-imports,experimental:annotation,my-custom-ruleset:my-custom-rule
+experimental_rules=multiline-if-else,annotation
 
 # Defines the imports layout. The layout can be composed by the following symbols:
 # "*" - wildcard. There must be at least one entry of a single wildcard to match all other imports. Matches anything after a specified symbol/import as well.
@@ -533,6 +534,13 @@ See the [EditorConfig section](https://github.com/pinterest/ktlint#editorconfig)
 
 You may also pass a list of disabled rules via the `--disabled_rules` command line flag. It has the same syntax as the EditorConfig property.
 
+### How do I globally enable an experimental rule?
+Experimental rules are not enabled by default.
+
+See the [EditorConfig section](https://github.com/pinterest/ktlint#editorconfig) for details on how to use the `experimental_rules` property.
+
+You may also pass a list of enabled experimental rules via the `--experimental_rules` command line flag. It has the same syntax as the EditorConfig property.
+
 ## Development
 
 > Make sure to read [CONTRIBUTING.md](CONTRIBUTING.md).

ktlint-core/src/main/kotlin/com/pinterest/ktlint/core/KtLint.kt

@@ -33,6 +33,7 @@ public object KtLint {
     public val EDITOR_CONFIG_PROPERTIES_USER_DATA_KEY: Key<EditorConfigProperties> =
         Key<EditorConfigProperties>("EDITOR_CONFIG_PROPERTIES")
     public val DISABLED_RULES: Key<Set<String>> = Key<Set<String>>("DISABLED_RULES")
+    private val EXPERIMENTAL_RULES: Key<Set<String>> = Key<Set<String>>("EXPERIMENTAL_RULES")
     private const val UTF8_BOM = "\uFEFF"
     public const val STDIN_FILE: String = "<stdin>"
 
@@ -202,13 +203,17 @@ public object KtLint {
             DISABLED_RULES,
             userData["disabled_rules"]?.split(",")?.map { it.trim() }?.toSet() ?: emptySet()
         )
+        node.putUserData(
+            EXPERIMENTAL_RULES,
+            userData["experimental_rules"]?.split(",")?.map { it.trim() }?.toSet() ?: emptySet()
+        )
     }
 
     private fun visitor(
         rootNode: ASTNode,
         ruleSets: Iterable<RuleSet>,
         concurrent: Boolean = true,
-        filter: (rootNode: ASTNode, fqRuleId: String) -> Boolean = this::filterDisabledRules
+        filter: (rootNode: ASTNode, ruleSet: RuleSet, fqRuleId: String) -> Boolean = this::isEnabledRule
 
     ): ((node: ASTNode, rule: Rule, fqRuleId: String) -> Unit) -> Unit {
         val fqrsRestrictedToRoot = mutableListOf<Pair<String, Rule>>()
@@ -219,7 +224,7 @@ public object KtLint {
             val prefix = if (ruleSet.id === "standard") "" else "${ruleSet.id}:"
             for (rule in ruleSet) {
                 val fqRuleId = "$prefix${rule.id}"
-                if (!filter(rootNode, fqRuleId)) {
+                if (!filter(rootNode, ruleSet, fqRuleId)) {
                     continue
                 }
                 val fqr = fqRuleId to rule
@@ -269,10 +274,31 @@ public object KtLint {
         }
     }
 
-    private fun filterDisabledRules(rootNode: ASTNode, fqRuleId: String): Boolean {
-        return rootNode.getUserData(DISABLED_RULES)?.contains(fqRuleId) == false
+    private fun isEnabledRule(rootNode: ASTNode, ruleSet: RuleSet, fqRuleId: String): Boolean {
+        return if (ruleSet.id == "experimental" && hasEnabledExperimentalRules(rootNode)) {
+            isEnabledExperimentalRule(rootNode, fqRuleId)
+        } else {
+            isNotDisabledRule(rootNode, fqRuleId)
+        }
     }
 
+    private fun hasEnabledExperimentalRules(rootNode: ASTNode) =
+        !rootNode.getUserData(EXPERIMENTAL_RULES).isNullOrEmpty()
+
+    private fun isNotDisabledRule(
+        rootNode: ASTNode,
+        fqRuleId: String
+    ) = rootNode.getUserData(DISABLED_RULES)?.contains(fqRuleId) == false
+
+    private fun isEnabledExperimentalRule(
+        rootNode: ASTNode,
+        fqRuleId: String
+    ) = rootNode.getUserData(EXPERIMENTAL_RULES)
+        .orEmpty()
+        .let {
+            it.contains("all") || it.contains(fqRuleId.removePrefix("experimental:"))
+        }
+
     @Deprecated(
         message = "Should not be a part of public api. Will be removed in future release.",
         level = DeprecationLevel.WARNING

ktlint-core/src/test/kotlin/com/pinterest/ktlint/core/internal/EditorConfigLoaderTest.kt

@@ -170,6 +170,7 @@ internal class EditorConfigLoaderTest {
             [*.{kt,kts}]
             insert_final_newline = true
             disabled_rules = import-ordering
+            experimental_rules = annotation
             """.trimIndent()
         tempFileSystem.writeEditorConfigFile(projectDir, editorconfigFile)
 
@@ -182,6 +183,7 @@ internal class EditorConfigLoaderTest {
             mapOf(
                 "insert_final_newline" to "true",
                 "disabled_rules" to "import-ordering",
+                "experimental_rules" to "annotation"
             )
         )
     }
@@ -216,6 +218,7 @@ internal class EditorConfigLoaderTest {
             """
             [*.{kt,kts}]
             disabled_rules=import-ordering, no-wildcard-imports
+            experimental_rules=annotation, multiline-if-else
             """.trimIndent()
         tempFileSystem.writeEditorConfigFile(projectDir, editorconfigFile)
         val lintFile = tempFileSystem.normalizedPath(projectDir).resolve("test.kts")
@@ -227,6 +230,7 @@ internal class EditorConfigLoaderTest {
         assertThat(parsedEditorConfig).isEqualTo(
             mapOf(
                 "disabled_rules" to "import-ordering, no-wildcard-imports",
+                "experimental_rules" to "annotation, multiline-if-else"
             )
         )
     }
@@ -256,6 +260,7 @@ internal class EditorConfigLoaderTest {
             [*.{kt,kts}]
             insert_final_newline = true
             disabled_rules = import-ordering
+            experimental_rules = annotation
             """.trimIndent()
         tempFileSystem.writeEditorConfigFile(".", editorconfigFile)
 
@@ -271,7 +276,8 @@ internal class EditorConfigLoaderTest {
         assertThat(parsedEditorConfig).isEqualTo(
             mapOf(
                 "insert_final_newline" to "true",
-                "disabled_rules" to "import-ordering"
+                "disabled_rules" to "import-ordering",
+                "experimental_rules" to "annotation"
             )
         )
     }
@@ -380,9 +386,11 @@ internal class EditorConfigLoaderTest {
             [*.{kt,kts}]
             insert_final_newline = true
             disabled_rules = import-ordering
+            experimental_rules = annotation
 
             [api/*.{kt,kts}]
             disabled_rules = class-must-be-internal
+            experimental_rules = multiline-if-else
             """.trimIndent()
         tempFileSystem.writeEditorConfigFile(projectDir, editorconfigFile)
 
@@ -397,6 +405,7 @@ internal class EditorConfigLoaderTest {
             mapOf(
                 "insert_final_newline" to "true",
                 "disabled_rules" to "class-must-be-internal",
+                "experimental_rules" to "multiline-if-else"
             )
         )
     }

ktlint/src/main/kotlin/com/pinterest/ktlint/Main.kt

@@ -218,6 +218,15 @@ class KtlintCommandLine {
     )
     var experimental: Boolean = false
 
+    @Option(
+        names = ["--experimental_rules"],
+        description = [
+            "Comma-separated list of experimental rules to globally enable." +
+                " To enable all experimental rules use --experimental"
+        ]
+    )
+    var experimentalRules: String = ""
+
     @Option(
         names = ["--baseline"],
         description = ["Defines a baseline file to check against"]
@@ -237,7 +246,10 @@ class KtlintCommandLine {
         val start = System.currentTimeMillis()
 
         val baselineResults = loadBaseline(baseline)
-        val ruleSetProviders = rulesets.loadRulesets(experimental, debug, disabledRules)
+        if (experimental) {
+            experimentalRules = "all"
+        }
+        val ruleSetProviders = rulesets.loadRulesets(debug, disabledRules, experimentalRules)
         var reporter = loadReporter()
         if (baselineResults.baselineGenerationNeeded) {
             val baselineReporter = ReporterTemplate("baseline", null, emptyMap(), baseline)
@@ -246,7 +258,8 @@ class KtlintCommandLine {
         }
         val userData = listOfNotNull(
             "android" to android.toString(),
-            if (disabledRules.isNotBlank()) "disabled_rules" to disabledRules else null
+            if (disabledRules.isNotBlank()) "disabled_rules" to disabledRules else null,
+            if (experimentalRules.isNotBlank()) "experimental_rules" to experimentalRules else null
         ).toMap()
 
         reporter.beforeAll()

ktlint/src/main/kotlin/com/pinterest/ktlint/internal/GenerateEditorConfigSubCommand.kt

@@ -31,9 +31,9 @@ class GenerateEditorConfigSubCommand : Runnable {
                 text = "",
                 ruleSets = ktlintCommand.rulesets
                     .loadRulesets(
-                        ktlintCommand.experimental,
                         ktlintCommand.debug,
-                        ktlintCommand.disabledRules
+                        ktlintCommand.disabledRules,
+                        ktlintCommand.experimentalRules
                     )
                     .map { it.value.get() },
                 userData = mapOf(

ktlint/src/main/kotlin/com/pinterest/ktlint/internal/RuleSetsLoader.kt

@@ -10,9 +10,9 @@ import java.util.ServiceLoader
  * @return map of ruleset ids to ruleset providers
  */
 internal fun JarFiles.loadRulesets(
-    loadExperimental: Boolean,
     debug: Boolean,
-    disabledRules: String
+    disabledRules: String,
+    enabledExperimentalRules: String
 ) = ServiceLoader
     .load(
         RuleSetProvider::class.java,
@@ -23,7 +23,7 @@ internal fun JarFiles.loadRulesets(
         // standard should go first
         if (key == "standard") "\u0000$key" else key
     }
-    .filterKeys { loadExperimental || it != "experimental" }
+    .filterKeys { it != "experimental" || !enabledExperimentalRules.isNullOrEmpty() }
     .filterKeys { !(disabledRules.isStandardRuleSetDisabled() && it == "\u0000standard") }
     .toSortedMap()
     .also {