WIP: resolve match_same_arms warnings in preprocess.rs

.hermes/conveyor/work-3d8d9b32/adr.md

@@ -0,0 +1,60 @@
+# ADR-0013: Close Issue #289 — Severity::Info Already Maps to "info"
+
+## Status
+Accepted
+
+## Context
+
+Issue #289 reported that `checkstyle.rs` had `Severity::Info` and `Severity::Warn` both mapping to the string `"warning"`, causing a `clippy::match_same_arms` warning and making the Info arm dead code.
+
+However, prior investigation found that:
+- The bug was already fixed in PR #460 (commit b31d836)
+- The current code at `checkstyle.rs:71-75` correctly maps all three severities
+- All 28 checkstyle tests pass
+- Clippy is clean with no warnings
+
+The issue remains OPEN on GitHub despite the fix being merged.
+
+## Decision
+
+**No code changes are needed.** Issue #289 should be closed as "Already resolved" referencing PR #460.
+
+The current implementation is correct:
+```rust
+let severity_str = match f.severity {
+    Severity::Error => "error",
+    Severity::Warn => "warning",
+    Severity::Info => "info",  // ← Correct
+};
+```
+
+## Consequences
+
+### Tradeoffs
+
+| Alternative | Why Rejected |
+|-------------|--------------|
+| Create new PR with identical fix | Duplicates PR #460, wastes review time, risks new bugs |
+| Leave issue open | Misleads contributors, suggests bug still exists |
+| Modify working code | Unnecessary churn, no benefit |
+
+### Benefits
+- No risk of introducing regressions
+- Preserves existing test coverage (`info_maps_to_info` test)
+- Issue closure provides clear signal to contributors
+
+### Risks
+- Issue #289 must be closed on GitHub to prevent confusion
+- If future refactoring moves the severity mapping, regression tests must catch it
+
+## Alternatives Considered
+
+1. **Create duplicate PR** — Rejected: PR #460 already contains the correct fix
+2. **Do nothing** — Rejected: Open issue misleads contributors
+3. **Modify working code** — Rejected: No benefit, introduces risk
+
+## References
+
+- Issue #289: `checkstyle.rs:50-51: Severity::Info and Severity::Warn produce identical "warning"`
+- PR #460: `fix(checkstyle): Severity::Info maps to 'info' not 'warning'`
+- Commit `b31d836`: Merge commit that applied the fix

.hermes/conveyor/work-3d8d9b32/specs.md

@@ -0,0 +1,35 @@
+# Spec — work-3d8d9b32: Close Issue #289 (Already Resolved)
+
+## Feature/Behavior Description
+
+This work item concerns closing GitHub issue #289 which reports a bug in `checkstyle.rs` where `Severity::Info` and `Severity::Warn` produce identical `"warning"` strings. Investigation reveals the bug was already fixed in PR #460. No code changes are needed.
+
+## Acceptance Criteria
+
+1. **Issue Closure** — Issue #289 on GitHub is closed with resolution "Already resolved" and reference to PR #460 as the fix.
+
+2. **No Code Changes** — No modifications are made to `checkstyle.rs` or any other source files, since the bug was already fixed in PR #460.
+
+3. **Existing Tests Pass** — All 28 checkstyle-related tests continue to pass, ensuring no regression.
+
+## Non-Goals
+
+- No new code, tests, or functionality is being added
+- No changes to severity mapping logic (already correct)
+- No modifications to output format (already correct per checkstyle.org schema)
+
+## Dependencies
+
+- PR #460 must remain merged (contains the fix)
+- Existing `info_maps_to_info` test in `checkstyle.rs` must remain (prevents regression)
+
+## Current State Verification
+
+| Aspect | Status |
+|--------|--------|
+| `Severity::Error` → `"error"` | ✓ Correct |
+| `Severity::Warn` → `"warning"` | ✓ Correct |
+| `Severity::Info` → `"info"` | ✓ Correct |
+| Clippy `match_same_arms` | ✓ No warning |
+| Checkstyle tests | ✓ All 28 pass |
+| Module documentation | ✓ Matches implementation |

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Windows target triple detection for MSYS/MINGW environments
   - Concurrency control on SARIF upload to prevent race conditions across workflow runs
   - Improved error handling with user-visible warning messages for fallback installation paths
+- **`parse_unified_diff` now requires explicit Result handling** — Added `#[must_use]` to `parse_unified_diff` so the compiler warns when callers ignore the `Result`. This prevents silent parse failures where malformed diffs are silently ignored. Callers must now explicitly handle the `Result` or use `let _ = ...` to indicate intentional ignore. Closes #329.
 
 ### Changed
 

adr.md

@@ -0,0 +1,68 @@
+# ADR-334a49bf: Resolve match_same_arms Warnings in preprocess.rs
+
+## Status
+Proposed
+
+## Context
+
+Clippy's `match_same_arms` lint flags two genuine redundancies in `Language::comment_syntax()` and `Language::string_syntax()` in `preprocess.rs`:
+
+1. **`comment_syntax()` lines 71 and 81**: Both return `CommentSyntax::Hash` — two separate match arms with identical bodies that should be merged:
+   ```rust
+   Language::Python | Language::Ruby | Language::Shell => CommentSyntax::Hash,  // line 71
+   Language::Yaml | Language::Toml => CommentSyntax::Hash,                     // line 81
+   ```
+
+2. **`string_syntax()` line 107**: `Language::Yaml | Language::Toml | Language::Json => StringSyntax::CStyle` is literally identical to the wildcard `_ => StringSyntax::CStyle` on line 109 — the explicit arm should be removed.
+
+**What is NOT redundant** (must be preserved):
+- `Language::Xml => CommentSyntax::Xml` — triggers XML `<!-- -->` block comment handling (distinct from CStyle)
+- `Language::Php => CommentSyntax::Php` — triggers PHP-specific `#` comment handling (CStyle doesn't handle `#`)
+- `Language::Php => StringSyntax::Php` — produces `Mode::NormalString` for single-quoted strings; CStyle produces `Mode::Char` for single quotes — these are NOT identical
+- `Language::Xml => StringSyntax::Xml` — handled distinctly downstream
+
+The prior research misidentified singleton arms (`Language::Xml`, `Language::Php`) as "redundant." They are not redundant — they produce distinct enum values with genuinely different downstream processing.
+
+## Decision
+
+1. **Merge the two `CommentSyntax::Hash` arms** in `comment_syntax()` into a single arm:
+   ```rust
+   // Python, Ruby, Shell, YAML, and TOML all use # comments
+   Language::Python | Language::Ruby | Language::Shell | Language::Yaml | Language::Toml => CommentSyntax::Hash,
+   ```
+
+2. **Remove the redundant `Yaml|Toml|Json` arm** from `string_syntax()` (line 107) entirely. These languages fall through to the wildcard `CStyle` already.
+
+3. **Preserve all singleton arms** (`Language::Xml`, `Language::Php`) — they are not flagged by clippy because their bodies are genuinely distinct from the wildcard.
+
+## Consequences
+
+**Benefits:**
+- Resolves 2 genuine clippy `match_same_arms` warnings
+- Reduces code duplication in a well-traveled code path
+- Clarifies the distinction between "truly redundant" (identical bodies) and "singleton but necessary" (different bodies with different behavior)
+
+**Tradeoffs:**
+- None — the fix is purely cosmetic, no behavioral change
+
+**Risks:**
+- None identified — existing tests verify all language preprocessing behavior
+
+## Alternatives Considered
+
+### Alternative 1: Remove singleton arms entirely
+Remove `Language::Php => StringSyntax::Php` and let PHP fall to CStyle wildcard.
+
+**Rejected because:**
+- `StringSyntax::Php` produces `Mode::NormalString` for single-quoted strings
+- `StringSyntax::CStyle` produces `Mode::Char` for single-quoted strings
+- PHP single-quoted strings would be incorrectly processed as char literals
+- This would introduce a regression in PHP string preprocessing
+
+### Alternative 2: Suppress clippy lint with `#[allow(clippy::match_same_arms)]`
+Keep the duplicate arms and suppress the warning.
+
+**Rejected because:**
+- The warnings represent genuine code duplication
+- Suppressing warnings creates technical debt and warning fatigue
+- The fix is trivial and risk-free

crates/diffguard-analytics/Cargo.toml

@@ -23,3 +23,4 @@ diffguard-types = { version = "0.2", path = "../diffguard-types" }
 
 [dev-dependencies]
 proptest.workspace = true
+insta.workspace = true