vyre-conform 0.1.0

Conformance suite for vyre backends — proves byte-identical output to CPU reference
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

//! Category B Round 2: `enum_dispatch` must **not** be treated as a Category B violation.

mod support;

use std::fs;
use std::sync::atomic::{AtomicU64, Ordering};

use vyre_conform::enforce::category::check_category_b_tripwire;

static COUNTER: AtomicU64 = AtomicU64::new(0);

fn temp_vyre_root() -> support::TempDir {
    let p = std::env::temp_dir().join(format!(
        "vyre-conform-catb-r2-enum-dispatch-{}-{}",
        std::process::id(),
        COUNTER.fetch_add(1, Ordering::SeqCst)
    ));
    fs::create_dir_all(p.join("runtime")).expect("mkdir runtime");
    support::TempDir { path: p }
}

#[test]
fn enum_dispatch_attribute_does_not_false_positive() {
    let root = temp_vyre_root();
    let source = r#"#[enum_dispatch::enum_dispatch]
pub trait Plugin {
    fn id(&self) -> u32;
}

pub enum Plugins {
    A(u32),
}

impl Plugin for Plugins {
    fn id(&self) -> u32 {
        0
    }
}
"#;
    let path = root.join("runtime").join("enum_dispatch_fixture.rs");
    fs::write(&path, source).expect("write fixture");

    let findings = check_category_b_tripwire(&root);
    assert!(
        findings.is_empty(),
        "enum_dispatch expands to static dispatch; must not trip Cat-B: {findings:?}"
    );
}

#[test]
fn plain_box_dyn_in_same_file_is_still_reported() {
    let root = temp_vyre_root();
    let source = r#"#[enum_dispatch::enum_dispatch]
pub trait Plugin {
    fn id(&self) -> u32;
}

pub enum Plugins {
    A(u32),
}

impl Plugin for Plugins {
    fn id(&self) -> u32 {
        0
    }
}

pub fn use_dyn(_: Box<dyn Plugin>) {}
"#;
    let path = root.join("runtime").join("enum_dispatch_with_dyn.rs");
    fs::write(&path, source).expect("write fixture");
    let want_line = support::line_of(source, "Box<dyn Plugin>");

    let findings = check_category_b_tripwire(&root);
    support::assert_located(&findings, "trait object (`dyn Trait`)", want_line);
}

#[test]
fn plain_enum_without_macro_is_clean() {
    let root = temp_vyre_root();
    let source = r#"pub enum Kind {
    Fast,
    Slow,
}

pub fn tag(k: Kind) -> u8 {
    match k {
        Kind::Fast => 1,
        Kind::Slow => 2,
    }
}
"#;
    let path = root.join("runtime").join("plain_enum.rs");
    fs::write(&path, source).expect("write fixture");

    let findings = check_category_b_tripwire(&root);
    assert!(
        findings.is_empty(),
        "plain enum must stay clean: {findings:?}"
    );
}