feat: deprecatedUntilVersion ktlint rule

Author: 0marperez

gradle/libs.versions.toml

@@ -9,18 +9,21 @@ smithy-version = "1.60.2"
 smithy-gradle-plugin-version = "1.3.0"
 junit-version = "5.10.1"
 coroutines-version = "1.10.2"
+slf4j = "2.0.17"
 
 [libraries]
 aws-sdk-cloudwatch = { module = "aws.sdk.kotlin:cloudwatch", version.ref = "aws-sdk-version" }
 aws-sdk-s3 = { module = "aws.sdk.kotlin:s3", version.ref = "aws-sdk-version" }
 ktlint-cli = { module = "com.pinterest.ktlint:ktlint-cli", version.ref = "ktlint" }
 ktlint-cli-ruleset-core = { module = "com.pinterest.ktlint:ktlint-cli-ruleset-core", version.ref = "ktlint" }
+ktlint-rule-engine = { module = "com.pinterest.ktlint:ktlint-rule-engine", version.ref = "ktlint" }
 nexus-publish-plugin = { module = "io.github.gradle-nexus:publish-plugin", version.ref = "nexus-plugin-version" }
 jreleaser-plugin = { module = "org.jreleaser:jreleaser-gradle-plugin", version.ref = "jreleaser-plugin-version" }
 smithy-model = { module = "software.amazon.smithy:smithy-model", version.ref = "smithy-version" }
 smithy-gradle-base-plugin = { module = "software.amazon.smithy.gradle:smithy-base", version.ref = "smithy-gradle-plugin-version" }
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-version" }
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines-version" }
+slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
 
 [plugins]
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin-version" }

ktlint/minor-version-rules/src/main/kotlin/software/aws/ktlint/rules/DeprecatedApiRule.kt

@@ -23,7 +23,7 @@ internal fun deprecatedUntilVersionRegex(major: Int, minor: Int): Regex =
 /**
  * Creates a ktlint rule that detects APIs annotated with @DeprecatedUntilVersion for the upcoming minor version.
  */
-class DeprecatedApiRule : Rule(RuleId("minor-version-strategy-rules:deprecated-apis"), About()) {
+class DeprecatedApiRule : Rule(RuleId("$ruleSetId:deprecated-apis"), About()) {
     override fun beforeVisitChildNodes(
         node: ASTNode,
         autoCorrect: Boolean,
@@ -43,7 +43,7 @@ class DeprecatedApiRule : Rule(RuleId("minor-version-strategy-rules:deprecated-a
                 emit(
                     node.startOffset,
                     "The deprecated API is scheduled for removal, please remove it before releasing the next minor version.",
-                    true,
+                    false,
                 )
             }
         }

ktlint/minor-version-rules/src/main/kotlin/software/aws/ktlint/rules/MinorVersionRuleSetProvider.kt

@@ -8,7 +8,9 @@ import com.pinterest.ktlint.cli.ruleset.core.api.RuleSetProviderV3
 import com.pinterest.ktlint.rule.engine.core.api.RuleProvider
 import com.pinterest.ktlint.rule.engine.core.api.RuleSetId
 
-class MinorVersionRuleSetProvider : RuleSetProviderV3(RuleSetId("minor-version-strategy-rules")) {
+internal const val ruleSetId = "aws-kotlin-repo-tools-rules"
+
+class MinorVersionRuleSetProvider : RuleSetProviderV3(RuleSetId(ruleSetId)) {
     override fun getRuleProviders() = setOf(
         RuleProvider { DeprecatedApiRule() },
     )

ktlint/style-rules/build.gradle.kts

@@ -19,6 +19,23 @@ kotlin {
                 implementation(libs.ktlint.cli.ruleset.core)
             }
         }
+        test {
+            dependencies {
+                implementation(kotlin("test"))
+                implementation(libs.ktlint.rule.engine)
+                implementation(libs.slf4j.simple) // Required by ktlint rule engine tests
+            }
+        }
+    }
+}
+
+tasks.test {
+    testLogging {
+        events("passed", "skipped", "failed")
+        showStandardStreams = true
+        showStackTraces = true
+        showExceptions = true
+        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
     }
 }
 

ktlint/style-rules/src/main/kotlin/software/aws/ktlint/rules/CopyrightHeaderRule.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.PsiCommentImpl
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.stubs.elements.KtFileElementType
 
-class CopyrightHeaderRule : Rule(RuleId("aws-kotlin-repo-tools-rules:copyright-header"), About()) {
+class CopyrightHeaderRule : Rule(RuleId("$ruleSetId:copyright-header"), About()) {
     companion object {
         private val header = """
         /*

ktlint/style-rules/src/main/kotlin/software/aws/ktlint/rules/DeprecatedUntilVersionRule.kt

@@ -0,0 +1,31 @@
+package software.aws.ktlint.rules
+
+import com.pinterest.ktlint.rule.engine.core.api.ElementType
+import com.pinterest.ktlint.rule.engine.core.api.Rule
+import com.pinterest.ktlint.rule.engine.core.api.RuleId
+import org.jetbrains.kotlin.com.intellij.lang.ASTNode
+
+/**
+ * Creates a ktlint rule that forces APIs annotated with @DeprecatedUntilVersion to also be annotated with @Deprecated.
+ */
+class DeprecatedUntilVersionRule : Rule(RuleId("$ruleSetId:deprecated-until-version"), About()) {
+    override fun beforeVisitChildNodes(
+        node: ASTNode,
+        autoCorrect: Boolean,
+        emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit,
+    ) {
+        if (node.elementType == ElementType.MODIFIER_LIST) {
+            val annotations = node.getChildren(null).filter { it.elementType == ElementType.ANNOTATION_ENTRY }
+            val deprecated = annotations.any { it.text == "@Deprecated" }
+            val deprecatedUntilVersion = annotations.any { it.text.startsWith("@DeprecatedUntilVersion") }
+
+            if (deprecatedUntilVersion && !deprecated) {
+                emit(
+                    node.startOffset,
+                    "APIs annotated with @DeprecatedUntilVersion must also be annotated with @Deprecated",
+                    false,
+                )
+            }
+        }
+    }
+}

ktlint/style-rules/src/main/kotlin/software/aws/ktlint/rules/ExpressionBodyRule.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtReturnExpression
 
-class ExpressionBodyRule : Rule(RuleId("aws-kotlin-repo-tools-rules:expression-body"), About()) {
+class ExpressionBodyRule : Rule(RuleId("$ruleSetId:expression-body"), About()) {
     override fun beforeVisitChildNodes(
         node: ASTNode,
         autoCorrect: Boolean,

ktlint/style-rules/src/main/kotlin/software/aws/ktlint/rules/MultilineIfElseBlockRule.kt

@@ -9,7 +9,7 @@ import com.pinterest.ktlint.rule.engine.core.api.Rule
 import com.pinterest.ktlint.rule.engine.core.api.RuleId
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 
-class MultilineIfElseBlockRule : Rule(RuleId("aws-kotlin-repo-tools-rules:multiline-if-else-block"), About()) {
+class MultilineIfElseBlockRule : Rule(RuleId("$ruleSetId:multiline-if-else-block"), About()) {
     override fun beforeVisitChildNodes(
         node: ASTNode,
         autoCorrect: Boolean,

ktlint/style-rules/src/main/kotlin/software/aws/ktlint/rules/StyleRuleSetProvider.kt

@@ -8,10 +8,13 @@ import com.pinterest.ktlint.cli.ruleset.core.api.RuleSetProviderV3
 import com.pinterest.ktlint.rule.engine.core.api.RuleProvider
 import com.pinterest.ktlint.rule.engine.core.api.RuleSetId
 
-class StyleRuleSetProvider : RuleSetProviderV3(RuleSetId("aws-kotlin-repo-tools-rules")) {
+internal const val ruleSetId = "aws-kotlin-repo-tools-rules"
+
+class StyleRuleSetProvider : RuleSetProviderV3(RuleSetId(ruleSetId)) {
     override fun getRuleProviders() = setOf(
         RuleProvider { CopyrightHeaderRule() },
         RuleProvider { ExpressionBodyRule() },
         RuleProvider { MultilineIfElseBlockRule() },
+        RuleProvider { DeprecatedUntilVersionRule() },
     )
 }

ktlint/style-rules/src/test/kotlin/software/aws/ktlint/rules/DeprecatedUntilVersionRuleTest.kt

@@ -0,0 +1,86 @@
+package software.aws.ktlint.rules
+
+import com.pinterest.ktlint.rule.engine.api.Code
+import com.pinterest.ktlint.rule.engine.api.KtLintRuleEngine
+import com.pinterest.ktlint.rule.engine.core.api.RuleProvider
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DeprecatedUntilVersionRuleTest {
+    val ruleEngine = KtLintRuleEngine(
+        setOf(
+            RuleProvider { DeprecatedUntilVersionRule() },
+        ),
+    )
+
+    private fun hasLintingErrors(codeSnippet: String): Boolean {
+        val code = Code.fromSnippet(codeSnippet)
+        var hasErrors = false
+        ruleEngine.lint(code) {
+            // Error callback function
+            hasErrors = true
+        }
+        return hasErrors
+    }
+
+    @Test
+    fun testRule() {
+        assertEquals(
+            false,
+            hasLintingErrors(
+                """
+                @DeprecatedUntilVersion(1, 2)
+                @Deprecated
+                class Foo {}
+            """.trimIndent(),
+            )
+        )
+
+        assertEquals(
+            false,
+            hasLintingErrors(
+                """
+                @Deprecated
+                @DeprecatedUntilVersion(1, 2)
+                class Foo {}
+            """.trimIndent(),
+            )
+        )
+
+        assertEquals(
+            true,
+            hasLintingErrors(
+                """
+                @DeprecatedUntilVersion(1, 2)
+                class Foo {}
+            """.trimIndent(),
+            )
+        )
+
+        assertEquals(
+            true,
+            hasLintingErrors(
+                """
+                @DeprecatedUntilVersion(1, 2)
+                class Foo {}
+                
+                @Deprecated
+                class Bar {}
+            """.trimIndent(),
+            )
+        )
+
+        assertEquals(
+            true,
+            hasLintingErrors(
+                """
+                @DeprecatedUntilVersion(1, 2)
+                class Foo {}
+                
+                @DeprecatedUntilVersion(1, 2)
+                class Bar {}
+            """.trimIndent(),
+            )
+        )
+    }
+}