feat(coverage): add xccov-json coverage format parser (#2568)

## Summary

- Add new `XccovJson` parser for Apple's xccov JSON format
- Support coverage reports produced by `xcrun xccov view --json
path/to/file.xccovarchive`
- Add `xccov-json` to the `Formats` enum with Display, FromStr, and
parser_for implementations

## Details

The xccov JSON format has a root object mapping file paths to arrays of
line coverage objects:
```json
{
  "/path/to/File.swift": [
    { "isExecutable": false, "line": 1 },
    { "isExecutable": true, "line": 2, "executionCount": 5 }
  ]
}
```

The parser maps:
- `isExecutable: false` -> hits = -1 (non-executable line)
- `isExecutable: true` -> hits = executionCount

Usage: `qlty coverage publish --report-format=xccov-json coverage.json`

## Test plan

- [x] Unit tests for basic file parsing
- [x] Unit tests for multiple files
- [x] Unit tests for empty reports
- [x] Unit tests for all non-executable lines
- [x] Unit tests for sparse line numbers
- [x] Unit tests for zero execution count
- [x] Unit tests for subranges (ignored, using line-level count)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: brynary

docs/licenses/xccov2lcov.txt

@@ -0,0 +1,11 @@
+https://github.com/StanfordBDHG/xccov2lcov
+
+MIT License
+
+Copyright (c) 2025 Stanford University and the project authors (see CONTRIBUTORS.md)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

qlty-coverage/src/formats.rs

@@ -17,6 +17,7 @@ pub enum Formats {
     Lcov,
     Jacoco,
     Qlty,
+    XccovJson,
 }
 
 impl std::fmt::Display for Formats {
@@ -30,6 +31,7 @@ impl std::fmt::Display for Formats {
             Formats::Lcov => write!(f, "lcov"),
             Formats::Jacoco => write!(f, "jacoco"),
             Formats::Qlty => write!(f, "qlty"),
+            Formats::XccovJson => write!(f, "xccov-json"),
         }
     }
 }
@@ -81,6 +83,7 @@ impl FromStr for Formats {
             "lcov" => Ok(Formats::Lcov),
             "jacoco" => Ok(Formats::Jacoco),
             "qlty" => Ok(Formats::Qlty),
+            "xccov-json" => Ok(Formats::XccovJson),
             _ => bail!("Unsupported coverage report format: {}", s),
         }
     }
@@ -96,6 +99,7 @@ pub fn parser_for(&format: &Formats) -> Box<dyn Parser> {
         Formats::Lcov => Box::new(parser::Lcov::new()),
         Formats::Jacoco => Box::new(parser::Jacoco::new()),
         Formats::Qlty => Box::new(parser::Qlty::new()),
+        Formats::XccovJson => Box::new(parser::XccovJson::new()),
     }
 }
 

qlty-coverage/src/parser.rs

@@ -10,6 +10,7 @@ mod jacoco;
 mod lcov;
 mod qlty;
 mod simplecov;
+mod xccov;
 
 pub use clover::Clover;
 pub use cobertura::Cobertura;
@@ -19,6 +20,7 @@ pub use jacoco::Jacoco;
 pub use lcov::Lcov;
 pub use qlty::Qlty;
 pub use simplecov::Simplecov;
+pub use xccov::XccovJson;
 
 pub trait Parser {
     fn parse_file(&self, path: &Path) -> Result<Vec<FileCoverage>> {

qlty-coverage/src/parser/xccov.rs

@@ -0,0 +1,215 @@
+use crate::Parser;
+use anyhow::{Context, Result};
+use qlty_types::tests::v1::FileCoverage;
+use serde::Deserialize;
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize)]
+struct XccovLine {
+    line: i64,
+    #[serde(rename = "isExecutable")]
+    is_executable: bool,
+    #[serde(rename = "executionCount")]
+    execution_count: Option<i64>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct XccovJson {}
+
+impl XccovJson {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl Parser for XccovJson {
+    fn parse_text(&self, text: &str) -> Result<Vec<FileCoverage>> {
+        let report: HashMap<String, Vec<XccovLine>> =
+            serde_json::from_str(text).with_context(|| "Failed to parse XCCov JSON")?;
+
+        let mut file_coverages: Vec<FileCoverage> = Vec::new();
+        let mut sorted_paths: Vec<_> = report.keys().collect();
+        sorted_paths.sort();
+
+        for path in sorted_paths {
+            let lines = &report[path];
+            let max_line = lines.iter().map(|l| l.line).max().unwrap_or(0);
+            let mut hits: Vec<i64> = vec![-1; max_line as usize];
+
+            for line_data in lines {
+                if line_data.line > 0 {
+                    let index = (line_data.line - 1) as usize;
+                    if index < hits.len() {
+                        hits[index] = if line_data.is_executable {
+                            line_data.execution_count.unwrap_or(0)
+                        } else {
+                            -1
+                        };
+                    }
+                }
+            }
+
+            file_coverages.push(FileCoverage {
+                path: path.clone(),
+                hits,
+                ..Default::default()
+            });
+        }
+
+        Ok(file_coverages)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn basic_file() {
+        let input = r#"
+        {
+            "/path/to/File.swift": [
+                { "isExecutable": false, "line": 1 },
+                { "isExecutable": false, "line": 2 },
+                { "isExecutable": true, "line": 3, "executionCount": 5 },
+                { "isExecutable": true, "line": 4, "executionCount": 0 },
+                { "isExecutable": false, "line": 5 }
+            ]
+        }
+        "#;
+
+        let results = XccovJson::new().parse_text(input).unwrap();
+        insta::assert_yaml_snapshot!(results, @r#"
+        - path: /path/to/File.swift
+          hits:
+            - "-1"
+            - "-1"
+            - "5"
+            - "0"
+            - "-1"
+        "#);
+    }
+
+    #[test]
+    fn multiple_files() {
+        let input = r#"
+        {
+            "/path/to/First.swift": [
+                { "isExecutable": true, "line": 1, "executionCount": 1 },
+                { "isExecutable": true, "line": 2, "executionCount": 2 }
+            ],
+            "/path/to/Second.swift": [
+                { "isExecutable": true, "line": 1, "executionCount": 3 },
+                { "isExecutable": false, "line": 2 }
+            ]
+        }
+        "#;
+
+        let results = XccovJson::new().parse_text(input).unwrap();
+        insta::assert_yaml_snapshot!(results, @r#"
+        - path: /path/to/First.swift
+          hits:
+            - "1"
+            - "2"
+        - path: /path/to/Second.swift
+          hits:
+            - "3"
+            - "-1"
+        "#);
+    }
+
+    #[test]
+    fn empty_report() {
+        let input = r#"{}"#;
+        let results = XccovJson::new().parse_text(input).unwrap();
+        assert!(results.is_empty());
+    }
+
+    #[test]
+    fn all_non_executable() {
+        let input = r#"
+        {
+            "/path/to/File.swift": [
+                { "isExecutable": false, "line": 1 },
+                { "isExecutable": false, "line": 2 },
+                { "isExecutable": false, "line": 3 }
+            ]
+        }
+        "#;
+
+        let results = XccovJson::new().parse_text(input).unwrap();
+        insta::assert_yaml_snapshot!(results, @r#"
+        - path: /path/to/File.swift
+          hits:
+            - "-1"
+            - "-1"
+            - "-1"
+        "#);
+    }
+
+    #[test]
+    fn sparse_line_numbers() {
+        let input = r#"
+        {
+            "/path/to/File.swift": [
+                { "isExecutable": true, "line": 5, "executionCount": 1 },
+                { "isExecutable": true, "line": 10, "executionCount": 2 }
+            ]
+        }
+        "#;
+
+        let results = XccovJson::new().parse_text(input).unwrap();
+        insta::assert_yaml_snapshot!(results, @r#"
+        - path: /path/to/File.swift
+          hits:
+            - "-1"
+            - "-1"
+            - "-1"
+            - "-1"
+            - "1"
+            - "-1"
+            - "-1"
+            - "-1"
+            - "-1"
+            - "2"
+        "#);
+    }
+
+    #[test]
+    fn zero_execution_count() {
+        let input = r#"
+        {
+            "/path/to/File.swift": [
+                { "isExecutable": true, "line": 1, "executionCount": 0 },
+                { "isExecutable": true, "line": 2, "executionCount": 0 }
+            ]
+        }
+        "#;
+
+        let results = XccovJson::new().parse_text(input).unwrap();
+        insta::assert_yaml_snapshot!(results, @r#"
+        - path: /path/to/File.swift
+          hits:
+            - "0"
+            - "0"
+        "#);
+    }
+
+    #[test]
+    fn with_subranges() {
+        let input = r#"
+        {
+            "/path/to/File.swift": [
+                { "isExecutable": true, "line": 1, "executionCount": 4, "subranges": [{"column": 36, "executionCount": 2, "length": 0}] }
+            ]
+        }
+        "#;
+
+        let results = XccovJson::new().parse_text(input).unwrap();
+        insta::assert_yaml_snapshot!(results, @r#"
+        - path: /path/to/File.swift
+          hits:
+            - "4"
+        "#);
+    }
+}