fix LintCache fingerprint to invalidate on binary rebuild; add sm:ignore:next directive; cover ternary case 2

Author: Jason-Abbott

.issues/p/pel-a08--wrapternarybranches-still-fires-on-single-line-ter.md

@@ -0,0 +1,70 @@
+---
+# pel-a08
+title: WrapTernaryBranches still fires on single-line ternary after multi-line call
+status: completed
+type: bug
+priority: normal
+created_at: 2026-05-02T00:28:00Z
+updated_at: 2026-05-02T00:47:56Z
+sync:
+    github:
+        issue_number: "621"
+        synced_at: "2026-05-02T00:48:50Z"
+---
+
+Recent commit (8b4d1e03) claimed to fix this via 'scalar-pass WrapTernaryBranches.singleLineLength', but the rule still flags ternaries that fit on one line when the LHS is a multi-line function call.
+
+## Repro
+
+```swift
+return attribute(
+  key,
+  at: index,
+  longestEffectiveRange: &valueRange,
+  in: fullRange,
+) != nil ? valueRange : nil
+```
+
+The ternary line `) != nil ? valueRange : nil` fits well within the line limit and should not be wrapped. WrapTernaryBranches fires twice (once for each branch).
+
+## Expected
+
+No findings — the ternary fits on a single line, so the singleLineLength scalar pass should suppress the diagnostic.
+
+## Notes
+
+- The LHS of the ternary spans multiple lines (the `attribute(...)` call), which may be confusing the line-length calculation.
+- Check whether the scalar pass measures from the start of the ternary expression vs the start of its line, and whether multi-line LHS triggers an early bail-out that skips the singleLineLength check.
+
+
+
+## Summary of Changes
+
+The fix from commit `8b4d1e03` is **already working correctly** — both reported cases produce zero findings when linted via the installed `sm` binary, and the existing + new test pass:
+
+- Case 1 (`attribute(...) != nil ? valueRange : nil`) — covered by existing `ternaryAfterMultiLineConditionDoesNotWrapWhenOperatorLineFits`.
+- Case 2 (`isValidQuery || !matches.isEmpty ? .top(...) : .all(...)` inside a function-call argument) — added regression test `ternaryWithMultiLineDisjunctionConditionDoesNotWrapWhenOperatorLineFits` in `Tests/SwiftiomaticTests/Rules/Wrap/WrapTernaryBranchesTests.swift`.
+
+Verified: `/opt/homebrew/bin/sm lint` on both inputs emits no findings. `WrapTernaryBranchesTests` 7/7 green.
+
+The warnings shown in Xcode are **stale lint diagnostics** cached by SourceKit/the "Lint Source Code" SPM plugin. They will clear on the next explicit lint invocation (right-click → Lint Source Code) or after editing+saving the file. No code change needed beyond the added test.
+
+
+
+## Actual Root Cause (correction to earlier summary)
+
+The rule fix from `8b4d1e03` was correct — but the user was seeing **stale findings replayed from `.build/sm-lint-cache/`**, not fresh ones. The cache fingerprint hashed sorted rule type names + configuration, but **not** the rule logic. So a binary rebuild that changed rule behavior without renaming/adding/removing rules left the fingerprint unchanged → cache hit → previous (pre-fix) findings replayed.
+
+### Fix
+
+`Sources/SwiftiomaticKit/Support/LintCache.swift` — `ruleSetIdentifier` now also mixes in the running executable's path + size + mtime. Any rebuild changes mtime+size, which cycles the fingerprint and orphans every prior cache subtree. Bumped the fingerprint prefix from `rules.v1` → `rules.v2` to flush all existing caches one final time.
+
+### User-side cleanup
+
+Removed the stale cache at `/Users/jason/Developer/toba/thesis/.build/sm-lint-cache/`. After the next Xcode build the inline warnings should be gone.
+
+### Verification
+
+- Filtered test: `LintCache|WrapTernaryBranches` 17/17 passed.
+- Reproduced and confirmed fix: with `--no-cache` the rule never fires; with the new binary the cache stays consistent across rebuilds.
+- New `sm` binary deployed to `/opt/homebrew/Cellar/sm/3.0.5/bin/sm`.

.issues/w/w0n-ctq--add-smignorenext-directive-scoped-to-next-line-onl.md

@@ -0,0 +1,32 @@
+---
+# w0n-ctq
+title: Add sm:ignore:next directive scoped to next line only
+status: completed
+type: feature
+priority: normal
+created_at: 2026-05-02T00:32:08Z
+updated_at: 2026-05-02T00:35:00Z
+sync:
+    github:
+        issue_number: "620"
+        synced_at: "2026-05-02T00:48:50Z"
+---
+
+Add a new ignore directive form: `// sm:ignore:next <rules>` that applies only to the next statement/member, not from the comment to EOF.
+
+## Tasks
+- [x] Add tests in RuleMaskTests for the new `:next` form
+- [x] Update regex in RuleStatusCollectionVisitor to capture optional `:next` scope
+- [x] When directive has `:next` scope, record nodeRange instead of restOfFileRange
+- [x] Update doc comment in RuleMask.swift
+- [x] Verify full test suite passes
+
+
+## Summary of Changes
+
+- New directive form `// sm:ignore:next [rules]` applies the ignore only to the immediately following statement or member, instead of extending to EOF.
+- Updated regex in `RuleStatusCollectionVisitor` to capture optional `:next` scope; threaded scope through to range selection in `applyDirectives` (uses `nodeRange` for `:next`, `restOfFileRange` otherwise).
+- Updated `isFormatterIgnorePresent` in `CommentMovingRewriter` to also recognize the bare `// sm:ignore:next` form for skipping pretty-printing of the next node.
+- Added 4 new tests covering `:next` with rule names, bare `:next`, multi-line statement scope, and member scope.
+- Updated `RuleMask.swift` doc comment to describe the three forms.
+- Full test suite (3179 tests) passes.

CHANGELOG.md

@@ -40,9 +40,11 @@
 - `PreferTypedThrowsOverResult`; lint `Result<T, E>` returns with a single do/catch ([#572](https://github.com/toba/swiftiomatic/issues/572))
 - `WarnSwapThenRemoveAll`; lint `swap(&a, &b)` followed by `a.removeAll`/`b.removeAll` ([#577](https://github.com/toba/swiftiomatic/issues/577))
 - `// sm:ignore`; unified directive replaces `// sm:ignore-file`; applies from comment to end of file (lone-line) or to the line only (trailing) ([#595](https://github.com/toba/swiftiomatic/issues/595))
+- `// sm:ignore:next`; new directive scoped to the next line only ([#620](https://github.com/toba/swiftiomatic/issues/620))
 
 ### 🐞 Fixes
 
+- `LintCache`; mix the running executable's path/size/mtime into the rule-set fingerprint so binary rebuilds invalidate stale cached findings ([#621](https://github.com/toba/swiftiomatic/issues/621))
 - `SimplifyGenericConstraints`; anchor diagnostics to the original `where` clause instead of the rewritten subtree's detached position ([#615](https://github.com/toba/swiftiomatic/issues/615))
 - `wrapTernaryBranches`; skip when both `?` and `:` source lines already fit, even when an operand is a multi-line chain ([#614](https://github.com/toba/swiftiomatic/issues/614))
 - `ReflowComments`; preserve CommonMark link reference definitions (`[label]: url`) instead of merging adjacent definitions into one paragraph ([#613](https://github.com/toba/swiftiomatic/issues/613))

Sources/SwiftiomaticKit/Layout/Tokens/CommentMovingRewriter.swift

@@ -138,13 +138,14 @@ final class CommentMovingRewriter: SyntaxRewriter {
 /// Returns whether the given trivia includes a directive to ignore formatting for the next node.
 ///
 /// - Parameter trivia: Leading trivia for a node that the formatter supports ignoring.
-/// - Returns: Whether the trivia contains a bare `sm:ignore` directive (no rule names).
+/// - Returns: Whether the trivia contains a bare `sm:ignore` (or `sm:ignore:next`) directive
+///   (no rule names).
 func isFormatterIgnorePresent(inTrivia trivia: Trivia) -> Bool {
     func isFormatterIgnore(in commentText: String, prefix: String, suffix: String) -> Bool {
         let trimmed = commentText.dropFirst(prefix.count)
             .dropLast(suffix.count)
             .trimmingCharacters(in: .whitespaces)
-        return trimmed == "sm:ignore"
+        return trimmed == "sm:ignore" || trimmed == "sm:ignore:next"
     }
 
     for piece in trivia {

Sources/SwiftiomaticKit/Support/LintCache.swift

@@ -99,19 +99,38 @@ package final class LintCache: Sendable {
 
     /// A binary-stable identifier for the rule set compiled into this `sm` .
     ///
-    /// Computed once per process from sorted rule type names. When the binary gains, loses, or
-    /// renames a rule the value changes, which combined with the per-configuration JSON hash
-    /// produces a new fingerprint and orphans every prior cache subtree.
+    /// Computed once per process from sorted rule type names plus the running executable's
+    /// (path, size, mtime). When the binary gains, loses, or renames a rule, *or* when the
+    /// executable is rebuilt with no surface change but altered rule logic, the value changes,
+    /// which combined with the per-configuration JSON hash produces a new fingerprint and
+    /// orphans every prior cache subtree.
     private static let ruleSetIdentifier: String = {
         var hasher = SHA256()
-        hasher.update(data: Data("rules.v1\n".utf8))
+        hasher.update(data: Data("rules.v2\n".utf8))
         let names = ConfigurationRegistry.allRuleTypes
             .map { String(reflecting: $0) }
             .sorted()
         for name in names {
             hasher.update(data: Data(name.utf8))
             hasher.update(data: Data([0]))
         }
+        // Mix in the running executable's identity so that rebuilding `sm` (which can change
+        // rule logic without changing rule names) invalidates the cache. Falls back to the
+        // unmodified rule-name digest if the executable's attributes are unreadable.
+        if let exePath = CommandLine.arguments.first,
+            let attrs = try? FileManager.default.attributesOfItem(atPath: exePath)
+        {
+            hasher.update(data: Data(exePath.utf8))
+            hasher.update(data: Data([0]))
+            if let size = attrs[.size] as? NSNumber {
+                hasher.update(data: Data("\(size.uint64Value)".utf8))
+                hasher.update(data: Data([0]))
+            }
+            if let mtime = attrs[.modificationDate] as? Date {
+                hasher.update(data: Data("\(mtime.timeIntervalSince1970)".utf8))
+                hasher.update(data: Data([0]))
+            }
+        }
         return hexEncode(hasher.finalize())
     }()
 

Sources/SwiftiomaticKit/Syntax/RuleMask.swift

@@ -14,18 +14,22 @@ import Foundation
 import SwiftSyntax
 
 /// Scans the source for `// sm:ignore` directives and records which rules are disabled in which
-/// ranges. There are two forms:
+/// ranges. There are three forms:
 ///
 /// - **Lone-line** `// sm:ignore [Rule1, Rule2]` on a line by itself → rules disabled from the
 ///   comment's position through end of file. Placing it at the top of a file therefore
 ///   disables those rules for the whole file (replaces the older `sm:ignore-file`).
+/// - **Lone-line scoped** `// sm:ignore:next [Rule1, Rule2]` on a line by itself → rules
+///   disabled only for the immediately following statement (or member).
 /// - **Trailing** `// sm:ignore [Rule1, Rule2]` on the same line as a statement (or member) →
 ///   rules disabled for that statement only.
 ///
 /// Examples:
 ///
 ///   // sm:ignore                                  — ignore all rules from here to EOF
 ///   // sm:ignore fileLength, typeBodyLength       — those rules off from here to EOF
+///   // sm:ignore:next                             — ignore all rules for the next statement
+///   // sm:ignore:next Rule1                       — ignore Rule1 for the next statement
 ///   let x = "trouble" // sm:ignore                — ignore all rules for this line only
 ///   let x = 1 // sm:ignore Rule1                  — ignore Rule1 for this line only
 ///
@@ -99,14 +103,14 @@ private final class RuleStatusCollectionVisitor: SyntaxVisitor {
         case subset(ruleNames: [String])
     }
 
-    typealias RegexExpression = Regex<(Substring, ruleNames: Substring?)>
+    typealias RegexExpression = Regex<(Substring, scope: Substring?, ruleNames: Substring?)>
 
     /// Cached regex object for the unified `sm:ignore` directive.
     ///
     /// Note: We are using a string-based regex instead of a regex literal ( `#/regex/#` ) because
     /// Windows did not have full support for regex literals until Swift 5.10.
     private static nonisolated(unsafe) let ignoreRegex: RegexExpression = {
-        let pattern = #"^\s*\/\/\s*sm:ignore(?:\s+(?<ruleNames>\S.*))?$"#
+        let pattern = #"^\s*\/\/\s*sm:ignore(?<scope>:next)?(?:\s+(?<ruleNames>\S.*))?$"#
         return try! Regex(pattern).matchingSemantics(.unicodeScalar)
     }()
 
@@ -171,8 +175,9 @@ private final class RuleStatusCollectionVisitor: SyntaxVisitor {
 
         let isFirstInFile = firstToken.previousToken(viewMode: .sourceAccurate) == nil
         for comment in loneLineComments(in: firstToken.leadingTrivia, isFirstToken: isFirstInFile) {
-            guard let match = ruleStatusDirectiveMatch(in: comment) else { continue }
-            record(match, range: restOfFileRange)
+            guard let (match, scope) = ruleStatusDirectiveMatch(in: comment) else { continue }
+            // `:next` scopes the directive to this single node; bare lone-line extends to EOF.
+            record(match, range: scope == .next ? nodeRange : restOfFileRange)
         }
 
         for token in node.tokens(viewMode: .sourceAccurate) {
@@ -181,7 +186,7 @@ private final class RuleStatusCollectionVisitor: SyntaxVisitor {
             // on a struct member would leak up to the enclosing type, etc.
             if isInsideDescendantItem(token, of: node) { continue }
             for comment in trailingLineComments(in: token.trailingTrivia) {
-                guard let match = ruleStatusDirectiveMatch(in: comment) else { continue }
+                guard let (match, _) = ruleStatusDirectiveMatch(in: comment) else { continue }
                 record(match, range: nodeRange)
             }
         }
@@ -211,11 +216,17 @@ private final class RuleStatusCollectionVisitor: SyntaxVisitor {
         }
     }
 
+    /// Scope of a matched directive.
+    enum DirectiveScope { case eof, next }
+
     /// Checks if a comment containing the given text matches a rule status directive. When it does
-    /// match, its contents (e.g. list of rule names) are returned.
-    private func ruleStatusDirectiveMatch(in text: String) -> RuleStatusDirectiveMatch? {
+    /// match, its contents (rule names and scope) are returned.
+    private func ruleStatusDirectiveMatch(
+        in text: String
+    ) -> (match: RuleStatusDirectiveMatch, scope: DirectiveScope)? {
         guard let match = text.firstMatch(of: Self.ignoreRegex) else { return nil }
-        guard let matchedRuleNames = match.output.ruleNames else { return .all }
+        let scope: DirectiveScope = match.output.scope != nil ? .next : .eof
+        guard let matchedRuleNames = match.output.ruleNames else { return (.all, scope) }
 
         let rules = matchedRuleNames.split(separator: ",").compactMap { segment -> String? in
             let name = segment.trimmingCharacters(in: .whitespaces)
@@ -227,7 +238,7 @@ private final class RuleStatusCollectionVisitor: SyntaxVisitor {
             // Resolve custom keys (e.g. SortImports → "imports" not "sortImports")
             return ConfigurationRegistry.typeNameToKey[derived] ?? derived
         }
-        return .subset(ruleNames: rules)
+        return (.subset(ruleNames: rules), scope)
     }
 
     /// Returns the list of line comments in the given trivia that are on a line by themselves

Tests/SwiftiomaticTests/Core/RuleMaskTests.swift

@@ -351,6 +351,76 @@ struct RuleMaskTests {
     #expect(mask.ruleState("anyRule", at: location(ofLine: 12, in: converter)) == .disabled)
   }
 
+  // MARK: - `:next` directive: applies only to the next statement.
+
+  @Test func nextDirectiveAppliesOnlyToNextStatement() {
+    let text =
+      """
+      let a = 123
+      // sm:ignore:next rule1
+      let b = 456
+      let c = 789
+      """
+
+    let (mask, converter) = createMask(sourceText: text)
+
+    #expect(mask.ruleState("rule1", at: location(ofLine: 1, in: converter)) == .default)
+    #expect(mask.ruleState("rule1", at: location(ofLine: 3, in: converter)) == .disabled)
+    #expect(mask.ruleState("rule1", at: location(ofLine: 4, in: converter)) == .default)
+  }
+
+  @Test func bareNextDirectiveAppliesOnlyToNextStatement() {
+    let text =
+      """
+      let a = 123
+      // sm:ignore:next
+      let b = 456
+      let c = 789
+      """
+
+    let (mask, converter) = createMask(sourceText: text)
+
+    #expect(mask.ruleState("anyRule", at: location(ofLine: 1, in: converter)) == .default)
+    #expect(mask.ruleState("anyRule", at: location(ofLine: 3, in: converter)) == .disabled)
+    #expect(mask.ruleState("anyRule", at: location(ofLine: 4, in: converter)) == .default)
+  }
+
+  @Test func nextDirectiveAppliesToWholeMultiLineStatement() {
+    let text =
+      """
+      let a = 0
+      // sm:ignore:next rule1
+      if !items.contains(p) {
+        items.append(p)
+      }
+      let z = 0
+      """
+
+    let (mask, converter) = createMask(sourceText: text)
+
+    #expect(mask.ruleState("rule1", at: location(ofLine: 1, in: converter)) == .default)
+    #expect(mask.ruleState("rule1", at: location(ofLine: 3, in: converter)) == .disabled)
+    #expect(mask.ruleState("rule1", at: location(ofLine: 4, in: converter)) == .disabled)
+    #expect(mask.ruleState("rule1", at: location(ofLine: 5, in: converter)) == .disabled)
+    #expect(mask.ruleState("rule1", at: location(ofLine: 6, in: converter)) == .default)
+  }
+
+  @Test func nextDirectiveOnMember() {
+    let text =
+      """
+      struct Foo {
+        // sm:ignore:next rule1
+        var bar = 0
+        var baz = 0
+      }
+      """
+
+    let (mask, converter) = createMask(sourceText: text)
+
+    #expect(mask.ruleState("rule1", at: location(ofLine: 3, column: 3, in: converter)) == .disabled)
+    #expect(mask.ruleState("rule1", at: location(ofLine: 4, column: 3, in: converter)) == .default)
+  }
+
   // MARK: - Top-of-file named directive: file-level scope.
 
   @Test func namedDirectiveAtTopOfFileIsFileScoped() {

Tests/SwiftiomaticTests/Rules/Wrap/WrapTernaryBranchesTests.swift

@@ -107,6 +107,31 @@ struct WrapTernaryBranchesTests: RuleTesting {
   /// but whose `?` and `:` both sit on a short final line — the rule must not fire.
   /// Repros from issue: `[wrapTernaryBranches] wrap ternary branch onto a new line` warning
   /// emitted at `) != nil ? valueRange : nil` even though that line easily fits.
+  /// Bug repro: a ternary whose condition is `a || b.c` where the `||` has wrapped, putting
+  /// `?` and `:` on the same short line as `.isEmpty ? .top(...) : .all(...)`. Both operators
+  /// live on a line that fits, so the rule must not fire.
+  @Test func ternaryWithMultiLineDisjunctionConditionDoesNotWrapWhenOperatorLineFits() {
+    assertFormatting(
+      WrapTernaryBranches.self,
+      input: """
+        view
+            .fieldStyle(
+                corners: isValidQuery || !matches
+                    .isEmpty ? .top(cornerRadius + 2) : .all(cornerRadius + 2),
+                isFocused: isFocused,
+            )
+        """,
+      expected: """
+        view
+            .fieldStyle(
+                corners: isValidQuery || !matches
+                    .isEmpty ? .top(cornerRadius + 2) : .all(cornerRadius + 2),
+                isFocused: isFocused,
+            )
+        """,
+      findings: [])
+  }
+
   @Test func ternaryAfterMultiLineConditionDoesNotWrapWhenOperatorLineFits() {
     assertFormatting(
       WrapTernaryBranches.self,