Add new opt-in non_final_class rule

Author: JaviSoto

CHANGELOG.md

@@ -30,6 +30,9 @@
   [kapitoshka438](https://github.com/kapitoshka438)
   [#3723](https://github.com/realm/SwiftLint/issues/3723)
 
+* Add new `non_final_class` opt-in rule that triggers when a class isn't `final`.
+  [JaviSoto](https://github.com/JaviSoto)
+
 ### Bug Fixes
 
 * Fix issue referencing the Tests package from another Bazel workspace.  

Source/SwiftLintBuiltInRules/Models/BuiltInRules.swift

@@ -133,6 +133,7 @@ public let builtInRules: [any Rule.Type] = [
     NoGroupingExtensionRule.self,
     NoMagicNumbersRule.self,
     NoSpaceInMethodCallRule.self,
+    NonFinalClassRule.self,
     NonOptionalStringDataConversionRule.self,
     NonOverridableClassDeclarationRule.self,
     NotificationCenterDetachmentRule.self,

Source/SwiftLintBuiltInRules/Rules/Style/NonFinalClassRule.swift

@@ -0,0 +1,50 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+@SwiftSyntaxRule(correctable: true, optIn: true)
+struct NonFinalClassRule: Rule {
+    var configuration = SeverityConfiguration<Self>(.warning)
+
+    static let description = RuleDescription(
+        identifier: "non_final_class",
+        name: "Non-Final Class",
+        description: "Classes should be marked as `final` unless they are explicitly `open`.",
+        kind: .idiomatic,
+        nonTriggeringExamples: [
+            Example("final class MyClass {}"),
+            Example("open class MyClass {}"),
+            Example("public final class MyClass {}"),
+        ],
+        triggeringExamples: [
+            Example("class MyClass {}"),
+            Example("public class MyClass {}"),
+        ],
+        corrections: [
+            Example("class MyClass {}"): Example("final class MyClass {}"),
+            Example("public class MyClass {}"): Example("public final class MyClass {}"),
+        ]
+    )
+
+    func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor<ConfigurationType>? {
+        Visitor(configuration: configuration, file: file)
+    }
+
+    private final class Visitor: ViolationsSyntaxVisitor<ConfigurationType> {
+        override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
+            let modifiers = node.modifiers
+            if !modifiers.contains(where: { $0.name.text == "final" }) && !modifiers.contains(where: { $0.name.text == "open" }) {
+                let classToken = node.classKeyword
+                violations.append(.init(
+                    position: classToken.positionAfterSkippingLeadingTrivia,
+                    reason: "Classes should be marked as `final` unless they are explicitly `open`",
+                    correction: .init(
+                        start: classToken.positionAfterSkippingLeadingTrivia,
+                        end: classToken.positionAfterSkippingLeadingTrivia,
+                        replacement: "final "
+                    )
+                ))
+            }
+            return .visitChildren
+        }
+    }
+}

Tests/GeneratedTests/GeneratedTests.swift

@@ -787,6 +787,12 @@ final class NoSpaceInMethodCallRuleGeneratedTests: SwiftLintTestCase {
     }
 }
 
+final class NonFinalClassRuleGeneratedTests: SwiftLintTestCase {
+    func testWithDefaultConfiguration() {
+        verifyRule(NonFinalClassRule.description)
+    }
+}
+
 final class NonOptionalStringDataConversionRuleGeneratedTests: SwiftLintTestCase {
     func testWithDefaultConfiguration() {
         verifyRule(NonOptionalStringDataConversionRule.description)

Tests/SwiftLintBuiltInRulesTests/Rules/Style/NonFinalClassRuleTests.swift

@@ -0,0 +1,36 @@
+@testable import SwiftLintFramework
+import XCTest
+
+final class NonFinalClassRuleTests: XCTestCase {
+    func testNonTriggeringExamples() {
+        let examples = [
+            "final class MyClass {}",
+            "open class MyClass {}",
+            "public final class MyClass {}",
+        ]
+        examples.forEach { example in
+            verifyRule(NonFinalClassRule.description, string: example, expected: [])
+        }
+    }
+
+    func testTriggeringExamples() {
+        let examples = [
+            "class MyClass {}",
+            "public class MyClass {}",
+        ]
+        examples.forEach { example in
+            let violations = violationsForRule(NonFinalClassRule.description, string: example)
+            XCTAssertEqual(violations.count, 1, "Expected one violation in: \(example)")
+            XCTAssertEqual(violations.first?.reason, "Classes should be marked as `final` unless they are explicitly `open`")
+        }
+    }
+
+    func testCorrections() {
+        assertCorrection(NonFinalClassRule.description,
+                         input: "class MyClass {}",
+                         expected: "final class MyClass {}")
+        assertCorrection(NonFinalClassRule.description,
+                         input: "public class MyClass {}",
+                         expected: "public final class MyClass {}")
+    }
+}