Add new invisible_characters rule

Author: sm-eminiakhmetov

CHANGELOG.md

@@ -12,7 +12,11 @@
 
 ### Enhancements
 
-* None.
+* Add new default `invisible_characters` rule that detects invisible characters
+  like zero-width space (U+200B) and FEFF formatting character (U+FEFF) in
+  string literals, which can cause hard-to-debug issues.  
+  [kapitoshka438](https://github.com/kapitoshka438)
+  [#6416](https://github.com/realm/SwiftLint/issues/6045)
 
 ### Bug Fixes
 

Source/SwiftLintBuiltInRules/Models/BuiltInRules.swift

@@ -92,6 +92,7 @@ public let builtInRules: [any Rule.Type] = [
     ImplicitReturnRule.self,
     ImplicitlyUnwrappedOptionalRule.self,
     InclusiveLanguageRule.self,
+    InvisibleCharactersRule.self,
     IncompatibleConcurrencyAnnotationRule.self,
     IndentationWidthRule.self,
     InvalidSwiftLintCommandRule.self,

Source/SwiftLintBuiltInRules/Rules/Lint/InvisibleCharactersRule.swift

@@ -0,0 +1,92 @@
+import SwiftSyntax
+
+@SwiftSyntaxRule
+struct InvisibleCharactersRule: Rule {
+    var configuration = SeverityConfiguration<Self>(.error)
+
+    static let description = RuleDescription(
+        identifier: "invisible_characters",
+        name: "Invisible Characters",
+        description: "Disallows invisible characters like zero-width space (U+200B) " +
+                     "and FEFF formatting character (U+FEFF) " +
+                     "in string literals as they can cause hard-to-debug issues",
+        kind: .lint,
+        nonTriggeringExamples: [
+            Example(#"let s = "HelloWorld""#),
+            Example(#"let s = "Hello World""#),
+            Example(#"let url = "https://example.com/api""#),
+            Example(##"let s = #"Hello World"#"##),
+            Example("""
+            let multiline = \"\"\"
+            Hello
+            World
+            \"\"\"
+            """),
+        ],
+        triggeringExamples: [
+            Example(#"let s = "Hello↓​World""#), // U+200B zero-width space
+            Example(#"let s = "Hello↓World""#), // U+FEFF formatting character
+            Example(#"let url = "https://example↓​.com""#), // U+200B in URL
+            Example("""
+            let multiline = \"\"\"
+            Hello↓​World
+            \"\"\"
+            """), // U+200B in multiline string
+        ]
+    )
+
+    private static let invisibleCharacters: Set<Unicode.Scalar> = [
+        "\u{200B}", // Zero-width space
+        "\u{FEFF}", // Zero-width no-break space (BOM/FEFF)
+    ]
+}
+
+private extension InvisibleCharactersRule {
+    final class Visitor: ViolationsSyntaxVisitor<ConfigurationType> {
+        override func visitPost(_ node: StringLiteralExprSyntax) {
+            for segment in node.segments {
+                guard let stringSegment = segment.as(StringSegmentSyntax.self) else {
+                    continue
+                }
+
+                let text = stringSegment.content.text
+
+                // Early exit if no invisible characters present
+                guard text.unicodeScalars.contains(where: { InvisibleCharactersRule.invisibleCharacters.contains($0) }) else {
+                    continue
+                }
+
+                // Find all invisible characters and their positions
+                var utf8Offset = 0
+                for scalar in text.unicodeScalars {
+                    if InvisibleCharactersRule.invisibleCharacters.contains(scalar) {
+                        // Calculate absolute position of the invisible character
+                        let invisibleCharPosition = stringSegment.content.positionAfterSkippingLeadingTrivia
+                            .advanced(by: utf8Offset)
+
+                        let charName = characterName(for: scalar)
+                        let reason = "String literal should not contain invisible character: \(charName)"
+                        violations.append(
+                            ReasonedRuleViolation(
+                                position: invisibleCharPosition,
+                                reason: reason
+                            )
+                        )
+                    }
+                    utf8Offset += String(scalar).utf8.count
+                }
+            }
+        }
+
+        private func characterName(for scalar: Unicode.Scalar) -> String {
+            switch scalar {
+            case "\u{200B}":
+                return "U+200B (zero-width space)"
+            case "\u{FEFF}":
+                return "U+FEFF (zero-width no-break space)"
+            default:
+                return "U+\(String(scalar.value, radix: 16, uppercase: true))"
+            }
+        }
+    }
+}

Tests/BuiltInRulesTests/InvisibleCharactersRuleTests.swift

@@ -0,0 +1,46 @@
+@testable import SwiftLintBuiltInRules
+import TestHelpers
+
+final class InvisibleCharactersRuleTests: SwiftLintTestCase {
+    func testInvisibleCharacters() {
+        let nonTriggeringExamples = [
+            Example(#"let s = "HelloWorld""#),
+            Example(#"let s = "Hello World""#),
+            Example(#"let url = "https://example.com/api""#),
+            Example(##"let s = #"Hello World"#"##),
+            Example("""
+            let multiline = \"\"\"
+            Hello
+            World
+            \"\"\"
+            """),
+            Example(#"let empty = """#),
+            Example(#"let tab = "Hello\tWorld""#),
+            Example(#"let newline = "Hello\nWorld""#),
+            Example(#"let unicode = "Hello 👋 World""#),
+        ]
+
+        let triggeringExamples = [
+            // Zero-width space (U+200B)
+            Example(#"let s = "Hello↓​World""#),
+            // Zero-width no-break space / BOM (U+FEFF)
+            Example(#"let s = "Hello↓World""#),
+            // Zero-width space in URL
+            Example(#"let url = "https://example↓​.com""#),
+            // Zero-width space in multiline string
+            Example("""
+            let multiline = \"\"\"
+            Hello↓​World
+            \"\"\"
+            """),
+            // Multiple invisible characters
+            Example(#"let s = "Test↓​String↓Here""#),
+        ]
+
+        let description = InvisibleCharactersRule.description
+            .with(triggeringExamples: triggeringExamples)
+            .with(nonTriggeringExamples: nonTriggeringExamples)
+
+        verifyRule(description)
+    }
+}