weirflow 0.1.0

GPU-first dataflow analysis primitives for Vyre and Santh compiler pipelines.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Feature-gate contract tests.
//!
//! Verify that optional capabilities are strictly behind their feature flags.

use std::fs;
use std::path::Path;

fn lib_rs_source() -> String {
    fs::read_to_string(
        Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("src")
            .join("lib.rs"),
    )
    .expect("src/lib.rs should be readable")
}

#[test]
fn cpu_parity_gates_all_cpu_oracle_code() {
    let lib_rs = lib_rs_source();
    let lines: Vec<&str> = lib_rs.lines().collect();

    // CPU oracle modules must be behind cpu-parity in lib.rs
    let required_gated_modules = ["bitset_closure_oracle", "ifds_cpu_oracle", "oracle"];

    for module in &required_gated_modules {
        let mod_line = lines
            .iter()
            .position(|line| {
                let t = line.trim();
                t == format!("pub mod {module};") || t == format!("mod {module};")
            })
            .unwrap_or_else(|| panic!("CPU oracle module `{module}` must be declared in lib.rs"));

        let context_start = mod_line.saturating_sub(10);
        let context = lines[context_start..=mod_line].join("\n");
        assert!(
            context.contains("cfg(any(test, feature = \"cpu-parity\"))")
                || context.contains("cfg(feature = \"cpu-parity\")"),
            "CPU oracle module `{module}` must be gated by `cpu-parity` feature in lib.rs"
        );
    }
}

#[test]
fn serde_gates_all_serialization_code() {
    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
    let mut files = Vec::new();
    let mut stack = vec![manifest_dir];
    while let Some(dir) = stack.pop() {
        for entry in fs::read_dir(&dir).unwrap() {
            let entry = entry.unwrap();
            let path = entry.path();
            if path.is_dir() {
                stack.push(path);
                continue;
            }
            if path.extension().and_then(|s| s.to_str()) == Some("rs") {
                let content = fs::read_to_string(&path).unwrap();
                files.push(content);
            }
        }
    }

    let mut violations = Vec::new();
    for content in files {
        for (line_no, line) in content.lines().enumerate() {
            let trimmed = line.trim();
            if (trimmed.contains("serde::Serialize") || trimmed.contains("serde::Deserialize"))
                && !trimmed.starts_with("//")
                && !trimmed.starts_with("///")
            {
                let start = line_no.saturating_sub(3);
                let context = content.lines().collect::<Vec<_>>()[start..=line_no].join("\n");
                let gated = context.contains("cfg_attr(feature = \"serde\"")
                    || context.contains("cfg(feature = \"serde\")");
                if !gated {
                    violations.push(format!("line {}: {}", line_no + 1, trimmed));
                }
            }
        }
    }

    assert!(
        violations.is_empty(),
        "serde code must be behind `serde` feature gate:\n{}",
        violations.join("\n")
    );
}

#[test]
fn gpu_telemetry_gates_all_gpu_telemetry_code() {
    let lib_rs = lib_rs_source();

    // Any gpu-telemetry module declarations in lib.rs must be gated
    for line in lib_rs.lines() {
        let trimmed = line.trim();
        if trimmed.contains("gpu-telemetry") && trimmed.starts_with("pub mod") {
            panic!("gpu-telemetry module `{trimmed}` must be cfg-gated in lib.rs");
        }
    }

    // Verify that no unconditional gpu-telemetry fields exist in public structs in lib.rs
    assert!(
        !lib_rs.contains("pub mod telemetry")
            || lib_rs.contains("cfg(feature = \"gpu-telemetry\")"),
        "telemetry module must be behind gpu-telemetry feature gate"
    );
}

#[test]
fn simd_oracle_gates_all_simd_oracle_code() {
    let lib_rs = lib_rs_source();

    // SIMD oracle code is only in bitset_closure_oracle which is already cpu-parity gated
    // Verify no standalone simd-oracle module declarations in lib.rs
    for line in lib_rs.lines() {
        let trimmed = line.trim();
        if trimmed.contains("simd-oracle") && trimmed.starts_with("pub mod") {
            panic!("simd-oracle module `{trimmed}` must be cfg-gated in lib.rs");
        }
    }
}

#[test]
fn test_harness_gates_all_test_fixture_code() {
    let lib_rs = lib_rs_source();

    // Verify test_harness module declaration is feature-gated
    let test_harness_line = lib_rs
        .lines()
        .enumerate()
        .find(|(_, line)| line.contains("pub mod test_harness"))
        .expect("test_harness module must be declared in lib.rs");

    let start = test_harness_line.0.saturating_sub(10);
    let context = lib_rs.lines().collect::<Vec<_>>()[start..=test_harness_line.0].join("\n");
    assert!(
        context.contains("cfg(any(test, feature = \"test-harness\"))"),
        "test_harness module must be behind `test-harness` feature gate"
    );

    // Verify no unconditional test_harness re-exports in lib.rs
    assert!(
        !lib_rs.contains("pub use test_harness::")
            || lib_rs.contains("cfg(any(test, feature = \"test-harness\"))"),
        "test_harness re-exports must be behind `test-harness` feature gate"
    );
}