fix SimplifyGenericConstraints diagnostic location; preserve link reference definitions in ReflowComments

Author: Jason-Abbott

.issues/8/83k-hv9--wrapternarybranches-fires-on-ternary-that-fits-on.md

@@ -0,0 +1,52 @@
+---
+# 83k-hv9
+title: wrapTernaryBranches fires on ternary that fits on one line
+status: completed
+type: bug
+priority: normal
+created_at: 2026-05-01T21:49:13Z
+updated_at: 2026-05-01T21:54:32Z
+sync:
+    github:
+        issue_number: "614"
+        synced_at: "2026-05-01T23:12:04Z"
+---
+
+## Repro
+
+```swift
+var urlEncoded: String {
+    isEmpty ? "" : "?"
+        + map { key, value in "\(key)=\(value.description.urlEncoded)" }
+        .joined(separator: "&")
+}
+```
+
+Xcode shows a `wrapTernaryBranches` warning on the `isEmpty ? "" : "?"` line: "wrap ternary branch onto a new line". The ternary itself (`isEmpty ? "" : "?"`) fits comfortably on one line — the rule should not fire.
+
+The likely confusion is that the ternary is the **left operand** of a `+` expression whose right operand is a multi-line chain. The rule may be looking at the enclosing expression's wrapped state rather than the ternary expression itself, or measuring the ternary's containing line including the trailing `+ map { … }` continuation.
+
+## Expected
+
+`wrapTernaryBranches` should only fire when the ternary expression's *own* operands (condition / then / else) cause it to overflow the print width on a single line. `isEmpty ? "" : "?"` is well under width and should be left alone.
+
+## Files
+
+- `Sources/SwiftiomaticKit/Rules/Wrap/WrapTernaryBranches.swift`
+- Look at how the rule measures fit and whether it considers the ternary in isolation or as part of the enclosing infix expression.
+
+## Test plan
+
+- Add a fixture with a ternary used as one operand of a multi-line infix expression where the ternary itself is short — assert no finding.
+- Existing wrap-when-overflowing case stays green.
+
+
+
+## Summary of Changes
+
+- `Sources/SwiftiomaticKit/Rules/Wrap/WrapTernaryBranches.swift` — added a short-circuit before the collapsed-length calculation: if the source lines that already host `?` and `:` both fit within `lineLength`, skip the wrap. New helper `sourceLineLength(at:converter:)` measures actual source-line length via `SourceLocationConverter.position(ofLine:column:)`.
+- `Tests/SwiftiomaticTests/Rules/Wrap/WrapTernaryBranchesTests.swift` — added `ternaryWithMultiLineRHSOperandNotWrapped` covering the user's exact `isEmpty ? "" : "?" + map { … }.joined(...)` pattern.
+
+## Root cause
+
+Ternary `?:` precedence is lower than `+` in Swift, so `cond ? a : b + chain` parses as `cond ? a : (b + chain)`. When the `+ chain` part was a multi-line method chain, the ternary's `else` branch span included all of it, and `singleLineLength(of:)` (which collapses internal whitespace) measured the whole ternary as a single huge string that overflowed `lineLength`. The fix bypasses that calculation when both operator lines already fit in source — the operands' wrapping is independent and not the ternary's concern.

.issues/s/slg-5gh--simplifygenericconstraints-diagnostics-anchor-to-w.md

@@ -0,0 +1,43 @@
+---
+# slg-5gh
+title: SimplifyGenericConstraints diagnostics anchor to wrong source line
+status: completed
+type: bug
+priority: normal
+created_at: 2026-05-01T21:58:31Z
+updated_at: 2026-05-01T22:14:40Z
+sync:
+    github:
+        issue_number: "615"
+        synced_at: "2026-05-01T23:12:04Z"
+---
+
+The rule's `transform` extracts the where-clause `conformance` node from `visited` (the rewritten subtree) and calls `Self.diagnose(on: conformance, ...)`. The static `emitFinding` helper resolves the source location via `node.startLocation(converter: context.sourceLocationConverter)` — but the converter is built from the original source while `conformance`'s absolute byte offset reflects its position inside the detached rewritten subtree. Result: when a triggering decl is preceded by other source content, the finding lands on whatever original-source line shares that byte offset (typealiases, doc comments, URLs above the decl).
+
+## Reproduction
+
+A file like:
+
+```
+typealias MoveRowHandler = (IndexSet, Int) -> Void
+
+/// doc
+/// comment
+struct OutlineList<Data, RowContent>: View where Data: RecursiveCollection, RowContent: View { ... }
+```
+
+…produces `simplifyGenericConstraints` warnings on the typealias and doc-comment lines instead of on the `where` clause.
+
+## Tasks
+
+- [x] Add a failing test that places the triggering struct after preceding content and asserts the finding line/column lands on the original `where` clause
+- [x] Fix `SimplifyGenericConstraints.simplifyConstraints` to diagnose against the original (not the rewritten) node
+- [x] Re-run the SimplifyGenericConstraints test suite
+
+
+
+## Summary of Changes
+
+`Sources/SwiftiomaticKit/Rules/Generics/SimplifyGenericConstraints.swift`: thread the `original` decl through `simplifyConstraints`, look up the matching `GenericRequirementSyntax` in the original where clause by the same enumeration index, and pass that attached node as the diagnose anchor. `original` carries correct positions because it is the node passed to the parent rewriter's `visit(_:)` while the tree is still attached, whereas `visited` (the result of `super.visit(node)`) is a detached subtree whose `position` is offset relative to its own root.
+
+Verified end-to-end against `OutlineList.swift` (the user's repro). Before: warnings landed on lines 4, 6, 22. After: warnings land on lines 23 and 79, correctly anchored to each `where` clause. Full test suite passes (3161 tests).

.issues/t/t8p-jfj--doc-comment-reflow-merges-markdown-footnote-defini.md

@@ -0,0 +1,52 @@
+---
+# t8p-jfj
+title: Doc-comment reflow merges Markdown footnote definitions into prose
+status: completed
+type: bug
+priority: normal
+created_at: 2026-05-01T22:14:55Z
+updated_at: 2026-05-01T23:10:52Z
+sync:
+    github:
+        issue_number: "613"
+        synced_at: "2026-05-01T23:12:04Z"
+---
+
+The doc-comment reflow rule treats a footnote/link reference definition as a regular continuation paragraph and reflows it onto the previous line, breaking the Markdown.
+
+## Reproduction
+
+Input:
+
+```
+/// Text view for [iOS][uiv] or [MacOS][nsv]
+///
+/// [uiv]: https://developer.apple.com/documentation/uikit/uitextview
+/// [nsv]: https://developer.apple.com/documentation/appkit/nstextview
+```
+
+Output:
+
+```
+/// Text view for [iOS][uiv] or [MacOS][nsv]
+///
+/// [uiv]: https://developer.apple.com/documentation/uikit/uitextview [nsv]:
+/// https://developer.apple.com/documentation/appkit/nstextview
+```
+
+The reflow joins the two `[name]: url` definitions into a single line, which makes them invalid Markdown link references. Footnote/reference definitions of the form `[label]: url` (with optional title) must remain on their own line.
+
+## Tasks
+
+- [x] Find the doc-comment reflow rule and locate where paragraph wrapping decides what counts as a continuation line
+- [x] Add a failing test that exercises the `[label]: url` line pattern across two adjacent definition lines and asserts no reflow
+- [x] Treat `^\s*\[[^\]]+\]:\s` (CommonMark link/reference definition) as a hard break — never merge into the previous or next line, never wrap mid-URL
+- [x] Re-run the reflow rule's test suite and full suite
+
+
+
+## Summary of Changes
+
+`Sources/SwiftiomaticKit/Rules/Comments/CommentReflowEngine.swift`: added `isLinkReferenceDefinition(_:)` that recognizes a CommonMark link reference definition (optional 0–3 leading spaces, `[label]: dest`). `parseBlocks` now (a) emits such a line as a `.verbatim` block at the top-level dispatch, and (b) breaks paragraph collection when one is encountered, so adjacent definitions can never be folded into a single paragraph and reflowed.
+
+Added regression test `preservesAdjacentLinkReferenceDefinitions` in `Tests/SwiftiomaticTests/Rules/ReflowCommentsTests.swift` covering the exact reproduction (two `[uiv]:` / `[nsv]:` lines after a paragraph). Full suite passes (3162 tests).

CHANGELOG.md

@@ -43,6 +43,9 @@
 
 ### 🐞 Fixes
 
+- `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))
 - `wrapTernary`; skip ternaries inside single-line string interpolations to avoid producing invalid Swift ([#602](https://github.com/toba/swiftiomatic/issues/602))
 - `PreferIfElseChain`; rewrite guard-return + trailing return to `if/else` expression in implicit-return positions ([#563](https://github.com/toba/swiftiomatic/issues/563))
 - `extension` where-clause; apply continuation indent when `where` wraps to its own line

Sources/SwiftiomaticKit/Rules/Comments/CommentReflowEngine.swift

@@ -137,6 +137,13 @@ package enum CommentReflowEngine {
                 i += 1
                 continue
             }
+            // CommonMark link reference definition (`[label]: url`). Preserve verbatim — wrapping
+            // the URL or merging adjacent definitions onto one line breaks the Markdown.
+            if isLinkReferenceDefinition(line) {
+                blocks.append(.verbatim(line: line))
+                i += 1
+                continue
+            }
             // Block quote: contiguous lines starting with ">".
             if line.hasPrefix(">") {
                 var quoted: [String] = []
@@ -167,6 +174,7 @@ package enum CommentReflowEngine {
                 if l.hasPrefix(">") { break }
                 if listMarker(l) != nil { break }
                 if fenceOpener(l) != nil { break }
+                if isLinkReferenceDefinition(l) { break }
                 paraLines.append(l.trimmingCharacters(in: .whitespaces))
                 i += 1
             }
@@ -175,6 +183,34 @@ package enum CommentReflowEngine {
         return blocks
     }
 
+    /// Returns `true` if `line` is a CommonMark link reference definition of the form
+    /// `[label]: destination`, allowing up to 3 leading spaces of indent. These lines must remain
+    /// on their own — wrapping the destination or merging an adjacent definition into the previous
+    /// line invalidates the reference.
+    private static func isLinkReferenceDefinition(_ line: String) -> Bool {
+        var idx = line.startIndex
+        var leading = 0
+
+        while idx < line.endIndex, line[idx] == " ", leading < 3 {
+            idx = line.index(after: idx)
+            leading += 1
+        }
+        guard idx < line.endIndex, line[idx] == "[" else { return false }
+        let afterOpen = line.index(after: idx)
+        guard let closeBracket = line[afterOpen...].firstIndex(of: "]") else { return false }
+        // Label must be non-empty and contain no `[` (CommonMark forbids unescaped brackets).
+        guard closeBracket > afterOpen,
+              !line[afterOpen..<closeBracket].contains("[") else { return false }
+        let afterClose = line.index(after: closeBracket)
+        guard afterClose < line.endIndex, line[afterClose] == ":" else { return false }
+        // Must be followed by whitespace (or end of line in lazy parsers — but we require non-empty
+        // destination on the same line, which is the common case in Swift docs).
+        let afterColon = line.index(after: afterClose)
+        guard afterColon < line.endIndex, line[afterColon] == " " else { return false }
+        let dest = line[afterColon...].drop(while: { $0 == " " })
+        return !dest.isEmpty
+    }
+
     /// Returns the fence string (e.g. "` ` ` " or "~~~") if ` line` opens a fenced code block.
     private static func fenceOpener(_ line: String) -> String? {
         let trimmed = line.drop(while: { $0 == " " })

Sources/SwiftiomaticKit/Rules/Generics/SimplifyGenericConstraints.swift

@@ -18,12 +18,13 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
 
     static func transform(
         _ visited: FunctionDeclSyntax,
-        original _: FunctionDeclSyntax,
+        original: FunctionDeclSyntax,
         parent _: Syntax?,
         context: Context
     ) -> DeclSyntax {
         var result = simplifyConstraints(
             visited,
+            original: original,
             genericParamsKeyPath: \.genericParameterClause,
             whereClauseKeyPath: \.genericWhereClause,
             context: context
@@ -38,13 +39,14 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
 
     static func transform(
         _ visited: StructDeclSyntax,
-        original _: StructDeclSyntax,
+        original: StructDeclSyntax,
         parent _: Syntax?,
         context: Context
     ) -> DeclSyntax {
         DeclSyntax(
             simplifyConstraints(
                 visited,
+                original: original,
                 genericParamsKeyPath: \.genericParameterClause,
                 whereClauseKeyPath: \.genericWhereClause,
                 context: context
@@ -53,13 +55,14 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
 
     static func transform(
         _ visited: ClassDeclSyntax,
-        original _: ClassDeclSyntax,
+        original: ClassDeclSyntax,
         parent _: Syntax?,
         context: Context
     ) -> DeclSyntax {
         DeclSyntax(
             simplifyConstraints(
                 visited,
+                original: original,
                 genericParamsKeyPath: \.genericParameterClause,
                 whereClauseKeyPath: \.genericWhereClause,
                 context: context
@@ -68,13 +71,14 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
 
     static func transform(
         _ visited: EnumDeclSyntax,
-        original _: EnumDeclSyntax,
+        original: EnumDeclSyntax,
         parent _: Syntax?,
         context: Context
     ) -> DeclSyntax {
         DeclSyntax(
             simplifyConstraints(
                 visited,
+                original: original,
                 genericParamsKeyPath: \.genericParameterClause,
                 whereClauseKeyPath: \.genericWhereClause,
                 context: context
@@ -83,13 +87,14 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
 
     static func transform(
         _ visited: ActorDeclSyntax,
-        original _: ActorDeclSyntax,
+        original: ActorDeclSyntax,
         parent _: Syntax?,
         context: Context
     ) -> DeclSyntax {
         DeclSyntax(
             simplifyConstraints(
                 visited,
+                original: original,
                 genericParamsKeyPath: \.genericParameterClause,
                 whereClauseKeyPath: \.genericWhereClause,
                 context: context
@@ -98,6 +103,7 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
 
     private static func simplifyConstraints<D>(
         _ decl: D,
+        original: D,
         genericParamsKeyPath: WritableKeyPath<D, GenericParameterClauseSyntax?>,
         whereClauseKeyPath: WritableKeyPath<D, GenericWhereClauseSyntax?>,
         context: Context
@@ -113,7 +119,12 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
                 .map { $0.name.text }
         )
 
-        // Identify constraints to inline
+        // Identify constraints to inline. The diagnostic is anchored to the *original* (attached)
+        // conformance node so its source location maps through `context.sourceLocationConverter`
+        // (which is built from the original tree) to the correct line/column. Anchoring on the
+        // visited (rewritten) subtree gives a position relative to the detached subtree's root,
+        // which floats up to whatever earlier source line shares that byte offset.
+        let originalRequirements: [GenericRequirementSyntax] = (original[keyPath: whereClauseKeyPath]?.requirements).map(Array.init) ?? []
         var consumedIndices: Set<Int> = []
         var inlineMap: [String: TypeSyntax] = [:]
 
@@ -129,9 +140,12 @@ final class SimplifyGenericConstraints: StaticFormatRule<BasicRuleValue>, @unche
             inlineMap[leftIdent.name.text] = conformance.rightType
             consumedIndices.insert(index)
 
+            let anchor = originalRequirements.indices.contains(index)
+                ? Syntax(originalRequirements[index].requirement)
+                : Syntax(conformance)
             Self.diagnose(
                 .simplifyGenericConstraint(param: leftIdent.name.text),
-                on: conformance,
+                on: anchor,
                 context: context
             )
         }