use std::fmt::Write as FmtWrite;
use std::path::{Path, PathBuf};
use anyhow::{anyhow, Context, Result};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use crate::workspace;
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(tag = "op", rename_all = "snake_case")]
pub enum Operation {
Apply {
profile_path: PathBuf,
},
Instrument,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct LintFileEntry {
pub file: PathBuf,
pub sha256_before: String,
pub content_before: String,
pub sha256_after: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct LintRunManifest {
pub version: u32,
pub operation: Operation,
pub files: Vec<LintFileEntry>,
}
pub fn default_apply_manifest_path(workspace_root: &Path) -> PathBuf {
workspace_root
.join("target")
.join("captrack-pgo")
.join("last-apply.json")
}
pub fn default_instrument_manifest_path(workspace_root: &Path) -> PathBuf {
workspace_root
.join("target")
.join("captrack-pgo")
.join("last-instrument.json")
}
#[allow(dead_code)]
pub fn legacy_lint_manifest_path(workspace_root: &Path) -> PathBuf {
workspace_root
.join("target")
.join("captrack-pgo")
.join("last-lint-apply.json")
}
pub fn latest_manifest_path(workspace_root: &Path) -> Option<PathBuf> {
let candidates = [
default_apply_manifest_path(workspace_root),
default_instrument_manifest_path(workspace_root),
];
candidates
.into_iter()
.filter(|p| p.is_file())
.max_by_key(|p| {
p.metadata()
.and_then(|m| m.modified())
.ok()
.unwrap_or(std::time::SystemTime::UNIX_EPOCH)
})
}
pub(crate) fn check_cargo_dylint_available() -> Result<()> {
let status = std::process::Command::new("cargo")
.args(["dylint", "--version"])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status();
match status {
Ok(s) if s.success() => Ok(()),
_ => Err(anyhow!(
"cargo dylint is not installed or not in PATH.\n\
Install with: cargo install cargo-dylint dylint-link\n\
(requires a nightly toolchain for the CDylib build step)"
)),
}
}
pub(crate) fn check_lint_path(lint_path: &Path) -> Result<()> {
let cargo_toml = lint_path.join("Cargo.toml");
if !cargo_toml.is_file() {
return Err(anyhow!(
"lint-path '{}' does not contain a Cargo.toml",
lint_path.display()
));
}
let body = std::fs::read_to_string(&cargo_toml)
.with_context(|| format!("read {}", cargo_toml.display()))?;
if !body.contains("captrack-pgo-lint") {
return Err(anyhow!(
"Cargo.toml at '{}' does not appear to be the captrack-pgo-lint package \
(missing 'captrack-pgo-lint' in package name)",
lint_path.display()
));
}
Ok(())
}
pub fn resolve_default_lint_path() -> Result<PathBuf> {
let cwd = std::env::current_dir().context("get cwd")?;
for candidate in [
cwd.join("captrack-pgo-lint"),
cwd.parent()
.map(|p| p.join("captrack-pgo-lint"))
.unwrap_or_default(),
] {
if candidate.join("Cargo.toml").is_file() {
return Ok(candidate);
}
}
Err(anyhow!(
"could not find captrack-pgo-lint/ as a sibling of the current directory '{}'. \
Pass --lint-path explicitly.",
cwd.display()
))
}
pub(crate) fn hex_sha256(bytes: &[u8]) -> String {
let digest = Sha256::digest(bytes);
let mut s = String::with_capacity(64);
for b in digest {
let _ = write!(s, "{b:02x}");
}
s
}
pub(crate) fn snapshot_rs_files(workspace_root: &Path) -> Result<Vec<(PathBuf, String, String)>> {
let mut out = Vec::new();
for file in workspace::walk_rust_files(workspace_root) {
let content = std::fs::read_to_string(&file)
.with_context(|| format!("snapshot read {}", file.display()))?;
let sha = hex_sha256(content.as_bytes());
out.push((file, sha, content));
}
Ok(out)
}
pub(crate) fn diff_snapshots(
before_snapshots: &[(PathBuf, String, String)],
) -> (Vec<LintFileEntry>, i64) {
let mut changed_files: Vec<LintFileEntry> = Vec::new();
let mut total_bytes_changed: i64 = 0;
for (path, sha_before, content_before) in before_snapshots {
let content_after = match std::fs::read_to_string(path) {
Ok(c) => c,
Err(e) => {
eprintln!(
"captrack-pgo: warning: could not re-read {} after dylint ({e}); skipping",
path.display()
);
continue;
}
};
let sha_after = hex_sha256(content_after.as_bytes());
if sha_after != *sha_before {
total_bytes_changed += content_after.len() as i64 - content_before.len() as i64;
changed_files.push(LintFileEntry {
file: path.clone(),
sha256_before: sha_before.clone(),
content_before: content_before.clone(),
sha256_after: sha_after,
});
}
}
(changed_files, total_bytes_changed)
}
pub(crate) fn write_manifest(manifest: &LintRunManifest, manifest_path: &Path) -> Result<()> {
if let Some(parent) = manifest_path.parent() {
std::fs::create_dir_all(parent)
.with_context(|| format!("create dir {}", parent.display()))?;
}
let json = serde_json::to_string_pretty(manifest)?;
std::fs::write(manifest_path, &json)
.with_context(|| format!("write manifest {}", manifest_path.display()))?;
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum HasherChoice {
#[default]
None,
Fx,
AHash,
FoldHash,
}
impl HasherChoice {
pub fn env_value(self) -> Option<&'static str> {
match self {
HasherChoice::None => None,
HasherChoice::Fx => Some("fx"),
HasherChoice::AHash => Some("ahash"),
HasherChoice::FoldHash => Some("foldhash"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CapFromChoice {
Max,
Mean,
Median,
#[default]
P95,
P99,
}
impl CapFromChoice {
pub fn env_value(self) -> Option<&'static str> {
match self {
CapFromChoice::Max => Some("max"),
CapFromChoice::Mean => Some("mean"),
CapFromChoice::Median => Some("median"),
CapFromChoice::P95 => None, CapFromChoice::P99 => Some("p99"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CapRoundChoice {
#[default]
Pow2,
To8,
Exact,
}
impl CapRoundChoice {
pub fn env_value(self) -> Option<&'static str> {
match self {
CapRoundChoice::Pow2 => None, CapRoundChoice::To8 => Some("to8"),
CapRoundChoice::Exact => Some("exact"),
}
}
}
pub struct LintApplyArgs {
pub profile_path: PathBuf,
pub lint_path: PathBuf,
pub workspace_root: PathBuf,
pub dry_run: bool,
pub allow_dirty: bool,
pub hasher: HasherChoice,
pub cap_from: CapFromChoice,
pub cap_mul: f64,
pub cap_round: CapRoundChoice,
pub force: bool,
}
pub fn run_lint_apply(args: LintApplyArgs) -> Result<()> {
if !args.profile_path.is_file() {
return Err(anyhow!(
"profile '{}' does not exist or is not a file",
args.profile_path.display()
));
}
{
let raw = std::fs::read_to_string(&args.profile_path)
.with_context(|| format!("read profile {}", args.profile_path.display()))?;
let v: serde_json::Value = serde_json::from_str(&raw)
.with_context(|| format!("parse profile JSON {}", args.profile_path.display()))?;
if !v.is_object() {
return Err(anyhow!(
"profile '{}' is not a JSON object (expected captrack dump format)",
args.profile_path.display()
));
}
}
check_lint_path(&args.lint_path)?;
if !args.dry_run {
check_cargo_dylint_available()?;
}
let workspace_cargo_toml = args.workspace_root.join("Cargo.toml");
if !workspace_cargo_toml.is_file() {
return Err(anyhow!(
"workspace root '{}' does not contain a Cargo.toml",
args.workspace_root.display()
));
}
crate::staleness::check_staleness(&args.workspace_root, args.force)
.context("staleness check")?;
let before_snapshots =
snapshot_rs_files(&args.workspace_root).context("snapshot workspace before dylint")?;
let converted_profile_path: PathBuf = {
use crate::profile::captrack::CaptrackProfile;
use crate::profile::Profile as _;
let backend = CaptrackProfile::new(&args.profile_path);
let site_stats = backend
.sites()
.with_context(|| format!("convert captrack dump {}", args.profile_path.display()))?;
let stem = args
.profile_path
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("profile");
let converted_name = format!("{}-converted.json", stem);
let converted_path = args
.profile_path
.parent()
.unwrap_or_else(|| std::path::Path::new("."))
.join(&converted_name);
let json =
serde_json::to_string_pretty(&site_stats).context("serialize converted SiteStats")?;
std::fs::write(&converted_path, json.as_bytes())
.with_context(|| format!("write converted profile {}", converted_path.display()))?;
println!(
"captrack-pgo: converted {} sites to {} for lint plugin",
site_stats.len(),
converted_path.display()
);
converted_path
};
let abs_profile = converted_profile_path.canonicalize().with_context(|| {
format!(
"canonicalize converted profile path {}",
converted_profile_path.display()
)
})?;
let mut cmd = std::process::Command::new("cargo");
cmd.arg("dylint");
cmd.arg("--path");
cmd.arg(&args.lint_path);
if !args.dry_run {
cmd.arg("--fix");
}
cmd.arg("--");
cmd.arg("--manifest-path");
cmd.arg(&workspace_cargo_toml);
cmd.arg("--all-targets");
if args.allow_dirty {
cmd.arg("--allow-dirty");
}
cmd.env("CAPTRACK_PGO_PROFILE", &abs_profile);
cmd.env_remove("CAPTRACK_PGO_INSTRUMENT");
match args.hasher.env_value() {
Some(v) => {
cmd.env("CAPTRACK_PGO_HASHER", v);
}
None => {
cmd.env_remove("CAPTRACK_PGO_HASHER");
}
}
match args.cap_from.env_value() {
Some(v) => {
cmd.env("CAPTRACK_PGO_CAP_FROM", v);
}
None => {
cmd.env_remove("CAPTRACK_PGO_CAP_FROM");
}
}
if (args.cap_mul - 1.0).abs() > f64::EPSILON {
cmd.env("CAPTRACK_PGO_CAP_MUL", args.cap_mul.to_string());
} else {
cmd.env_remove("CAPTRACK_PGO_CAP_MUL");
}
match args.cap_round.env_value() {
Some(v) => {
cmd.env("CAPTRACK_PGO_CAP_ROUND", v);
}
None => {
cmd.env_remove("CAPTRACK_PGO_CAP_ROUND");
}
}
cmd.stdin(std::process::Stdio::null());
if args.dry_run {
println!("captrack-pgo: dry-run — would run:");
let hasher_env = args
.hasher
.env_value()
.map(|v| format!(" CAPTRACK_PGO_HASHER={v}"))
.unwrap_or_default();
let cap_from_env = args
.cap_from
.env_value()
.map(|v| format!(" CAPTRACK_PGO_CAP_FROM={v}"))
.unwrap_or_default();
let cap_mul_env = if (args.cap_mul - 1.0).abs() > f64::EPSILON {
format!(" CAPTRACK_PGO_CAP_MUL={}", args.cap_mul)
} else {
String::new()
};
let cap_round_env = args
.cap_round
.env_value()
.map(|v| format!(" CAPTRACK_PGO_CAP_ROUND={v}"))
.unwrap_or_default();
println!(
" CAPTRACK_PGO_PROFILE={}{hasher_env}{cap_from_env}{cap_mul_env}{cap_round_env} \
cargo dylint --path {} -- --manifest-path {}",
abs_profile.display(),
args.lint_path.display(),
workspace_cargo_toml.display()
);
println!("(files not modified, manifest not written)");
let raw = std::fs::read_to_string(&args.profile_path)?;
let v: serde_json::Value = serde_json::from_str(&raw)?;
let count = v
.get("stats")
.and_then(|s| s.as_array())
.map(|a| a.len())
.unwrap_or(0);
println!(
"would inspect {} profile site{} (matches depend on source scan)",
count,
if count == 1 { "" } else { "s" }
);
return Ok(());
}
let status = cmd
.status()
.context("spawn cargo dylint — is cargo-dylint installed?")?;
if !status.success() {
return Err(anyhow!(
"cargo dylint exited with non-zero status: {:?}\n\
Files NOT modified; manifest NOT written.",
status.code()
));
}
let (changed_files, total_bytes_changed) = diff_snapshots(&before_snapshots);
let manifest = LintRunManifest {
version: 1,
operation: Operation::Apply {
profile_path: abs_profile,
},
files: changed_files.clone(),
};
let manifest_path = default_apply_manifest_path(&args.workspace_root);
write_manifest(&manifest, &manifest_path)?;
let n = changed_files.len();
println!(
"apply: modified {} file{}, net {} byte{} changed",
n,
if n == 1 { "" } else { "s" },
total_bytes_changed,
if total_bytes_changed.abs() == 1 {
""
} else {
"s"
}
);
println!(" manifest: {}", manifest_path.display());
println!(
" undo with: captrack-pgo undo --manifest {}",
manifest_path.display()
);
if let Some(hasher_val) = args.hasher.env_value() {
let dep_name = match hasher_val {
"fx" => "fxhash",
"ahash" => "ahash",
"foldhash" => "foldhash",
_ => hasher_val,
};
eprintln!(
"captrack-pgo: note: --hasher {hasher_val} was used. \
Remember to add `{dep_name}` to your Cargo.toml if not already present."
);
}
Ok(())
}
pub fn read_manifest(path: &Path) -> Result<LintRunManifest> {
let raw = std::fs::read_to_string(path).map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
anyhow!(
"no manifest found at {}; nothing to uninstrument",
path.display()
)
} else {
anyhow!("read manifest {}: {e}", path.display())
}
})?;
serde_json::from_str::<LintRunManifest>(&raw)
.with_context(|| format!("parse manifest {}", path.display()))
}
pub fn undo_lint_apply(manifest_path: &Path) -> Result<usize> {
let raw = std::fs::read_to_string(manifest_path)
.with_context(|| format!("read lint manifest {}", manifest_path.display()))?;
let manifest: LintRunManifest = serde_json::from_str(&raw)
.with_context(|| format!("parse lint manifest {}", manifest_path.display()))?;
if manifest.version != 1 {
return Err(anyhow!(
"unsupported lint manifest version {}: only v1 supported",
manifest.version
));
}
for entry in &manifest.files {
let current = std::fs::read_to_string(&entry.file)
.with_context(|| format!("read {} for undo", entry.file.display()))?;
let cur_sha = hex_sha256(current.as_bytes());
if cur_sha != entry.sha256_after {
return Err(anyhow!(
"file modified since lint-apply: {}\n \
expected sha256 {}\n current sha256 {}\n \
resolve via git first",
entry.file.display(),
entry.sha256_after,
cur_sha
));
}
}
let mut count = 0usize;
for entry in &manifest.files {
atomic_write(&entry.file, entry.content_before.as_bytes())?;
count += 1;
}
Ok(count)
}
fn atomic_write(file: &Path, bytes: &[u8]) -> Result<()> {
let parent = file.parent().unwrap_or_else(|| Path::new("."));
let mut tmp = tempfile::NamedTempFile::new_in(parent)?;
std::io::Write::write_all(&mut tmp, bytes)?;
tmp.persist(file)
.map_err(|e| anyhow!("persist tempfile: {e}"))?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hex_sha256_is_64_hex_chars_and_deterministic() {
let h1 = hex_sha256(b"hello");
let h2 = hex_sha256(b"hello");
assert_eq!(h1, h2);
assert_eq!(h1.len(), 64);
assert!(h1.chars().all(|c| c.is_ascii_hexdigit()));
}
#[test]
fn lint_run_manifest_apply_round_trips_json() {
let m = LintRunManifest {
version: 1,
operation: Operation::Apply {
profile_path: PathBuf::from("/tmp/profile.json"),
},
files: vec![LintFileEntry {
file: PathBuf::from("/tmp/src/lib.rs"),
sha256_before: "a".repeat(64),
content_before: "fn old() {}".to_string(),
sha256_after: "b".repeat(64),
}],
};
let json = serde_json::to_string(&m).unwrap();
let back: LintRunManifest = serde_json::from_str(&json).unwrap();
assert_eq!(m, back);
}
#[test]
fn lint_run_manifest_instrument_round_trips_json() {
let m = LintRunManifest {
version: 1,
operation: Operation::Instrument,
files: vec![],
};
let json = serde_json::to_string(&m).unwrap();
let back: LintRunManifest = serde_json::from_str(&json).unwrap();
assert_eq!(m, back);
}
#[test]
fn default_apply_manifest_path_is_inside_target() {
let p = default_apply_manifest_path(Path::new("/ws"));
assert!(p.to_string_lossy().contains("captrack-pgo"));
assert!(p.to_string_lossy().contains("last-apply.json"));
}
#[test]
fn default_instrument_manifest_path_is_inside_target() {
let p = default_instrument_manifest_path(Path::new("/ws"));
assert!(p.to_string_lossy().contains("captrack-pgo"));
assert!(p.to_string_lossy().contains("last-instrument.json"));
}
#[test]
fn undo_lint_apply_fails_on_modified_file() {
let tmp = tempfile::tempdir().unwrap();
let src = tmp.path().join("foo.rs");
let before = "fn old() {}";
let after = "fn new() {}";
std::fs::write(&src, after).unwrap();
let manifest = LintRunManifest {
version: 1,
operation: Operation::Apply {
profile_path: PathBuf::from("/tmp/p.json"),
},
files: vec![LintFileEntry {
file: src.clone(),
sha256_before: hex_sha256(before.as_bytes()),
content_before: before.to_string(),
sha256_after: "x".repeat(64),
}],
};
let mpath = tmp.path().join("m.json");
std::fs::write(&mpath, serde_json::to_string(&manifest).unwrap()).unwrap();
let err = undo_lint_apply(&mpath).unwrap_err();
assert!(
err.to_string().contains("modified since lint-apply"),
"got: {err}"
);
}
#[test]
fn undo_lint_apply_restores_content() {
let tmp = tempfile::tempdir().unwrap();
let src = tmp.path().join("bar.rs");
let before = "fn original() {}";
let after_content = "fn modified() {}";
std::fs::write(&src, after_content).unwrap();
let sha_after = hex_sha256(after_content.as_bytes());
let manifest = LintRunManifest {
version: 1,
operation: Operation::Instrument,
files: vec![LintFileEntry {
file: src.clone(),
sha256_before: hex_sha256(before.as_bytes()),
content_before: before.to_string(),
sha256_after: sha_after,
}],
};
let mpath = tmp.path().join("m.json");
std::fs::write(&mpath, serde_json::to_string(&manifest).unwrap()).unwrap();
let n = undo_lint_apply(&mpath).unwrap();
assert_eq!(n, 1);
let restored = std::fs::read_to_string(&src).unwrap();
assert_eq!(restored, before);
}
#[test]
fn undo_lint_apply_rejects_wrong_version() {
let tmp = tempfile::tempdir().unwrap();
let mpath = tmp.path().join("m.json");
std::fs::write(
&mpath,
r#"{"version":99,"operation":{"op":"instrument"},"files":[]}"#,
)
.unwrap();
let err = undo_lint_apply(&mpath).unwrap_err();
assert!(err.to_string().contains("version"), "got: {err}");
}
#[test]
fn latest_manifest_path_prefers_newer_file() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let dir = root.join("target").join("captrack-pgo");
std::fs::create_dir_all(&dir).unwrap();
let apply_path = dir.join("last-apply.json");
let instr_path = dir.join("last-instrument.json");
std::fs::write(&apply_path, "{}").unwrap();
std::fs::write(&instr_path, "{}").unwrap();
let found = latest_manifest_path(root);
assert!(found.is_some(), "expected some manifest path");
}
}