Fix invalid rewrite in UseExplicitNilCheckInConditions by skipping when explicit optional type annotation is present

Author: TTOzzi

Sources/SwiftFormat/Rules/UseExplicitNilCheckInConditions.swift

@@ -29,7 +29,8 @@ public final class UseExplicitNilCheckInConditions: SyntaxFormatRule {
     case .optionalBinding(let optionalBindingCondition):
       guard
         let initializerClause = optionalBindingCondition.initializer,
-        isDiscardedAssignmentPattern(optionalBindingCondition.pattern)
+        isDiscardedAssignmentPattern(optionalBindingCondition.pattern),
+        !hasOptionalTypeAnnotation(optionalBindingCondition)
       else {
         return node
       }
@@ -71,6 +72,19 @@ public final class UseExplicitNilCheckInConditions: SyntaxFormatRule {
     return exprPattern.expression.is(DiscardAssignmentExprSyntax.self)
   }
 
+  /// Returns true if the conditional binding carries an explicit optional type annotation,
+  /// e.g. `if let _: S? = expr { ... }`.
+  ///
+  /// We skip rewriting in this case. While we could preserve the coercion by rewriting
+  /// to `(expr as S?) != nil`, skipping is safer—it avoids potential changes in operator
+  /// precedence and keeps the original semantics intact.
+  private func hasOptionalTypeAnnotation(_ bindingCondition: OptionalBindingConditionSyntax) -> Bool {
+    guard let typeAnnotation = bindingCondition.typeAnnotation else {
+      return false
+    }
+    return typeAnnotation.type.is(OptionalTypeSyntax.self)
+  }
+
   /// Adds parentheses around the given expression if necessary to ensure that it will be parsed
   /// correctly when followed by `!= nil`.
   ///

Tests/SwiftFormatTests/Rules/UseExplicitNilCheckInConditionsTests.swift

@@ -160,4 +160,21 @@ final class UseExplicitNilCheckInConditionsTests: LintOrFormatRuleTestCase {
       ]
     )
   }
+
+  func testTypeAnnotations() {
+    assertFormatting(
+      UseExplicitNilCheckInConditions.self,
+      input: """
+        if 1️⃣let _: F = foo() {}
+        if let _: S? = foo() {}
+        """,
+      expected: """
+        if foo() != nil {}
+        if let _: S? = foo() {}
+        """,
+      findings: [
+        FindingSpec("1️⃣", message: "compare this value using `!= nil` instead of binding and discarding it")
+      ]
+    )
+  }
 }