harn-cli 0.10.92

CLI for the Harn programming language — run, test, REPL, format, and lint
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

use std::cell::Cell;

use super::*;

fn diagnostic(
    file: &str,
    code: Code,
    repair_id: &str,
    expected_type: Option<TypeExpr>,
) -> RepairCandidate {
    RepairCandidate {
        file: file.to_string(),
        source: "test",
        severity: "warning",
        code,
        message: "test diagnostic".to_string(),
        unresolved_name: None,
        expected_type,
        span: Some(Span::with_offsets(4, 8, 1, 5)),
        repair: Repair {
            id: harn_parser::RepairId::from_owned(repair_id.to_string()),
            summary: "test repair".to_string(),
            safety: RepairSafety::ScopeLocal,
        },
        impact: RepairImpactWire::generic(),
        edits: Vec::new(),
    }
}

#[test]
fn diagnostic_index_normalizes_each_relevant_file_once() {
    let diagnostics = vec![
        diagnostic(
            "a.harn",
            Code::LintAmbientFsBuiltin,
            "bindings/thread-harness-fs",
            None,
        ),
        diagnostic(
            "a.harn",
            Code::ArgumentTypeMismatch,
            "bindings/prepend-capability-argument",
            Some(TypeExpr::Named("HarnessFs".to_string())),
        ),
        diagnostic(
            "b.harn",
            Code::LintAmbientClockBuiltin,
            "bindings/thread-harness-clock",
            None,
        ),
        diagnostic(
            "c.harn",
            Code::FormatterWouldReformat,
            "format/reformat",
            None,
        ),
    ];
    let normalizations = Cell::new(0);

    let index = diagnostic_index_with(&diagnostics, |path| {
        normalizations.set(normalizations.get() + 1);
        path.to_path_buf()
    });

    assert_eq!(normalizations.get(), 2);
    let indexed = index.get(Path::new("a.harn")).unwrap();
    assert_eq!(indexed.ambient_spans.len(), 1);
    assert_eq!(indexed.missing_capability_arguments.len(), 1);
    assert_eq!(index[Path::new("b.harn")].ambient_spans.len(), 1);
    assert!(!index.contains_key(Path::new("c.harn")));
}

#[test]
fn capability_carrier_alias_resolution_stops_at_cycles() {
    let aliases = BTreeMap::from([
        ("First".to_string(), TypeExpr::Named("Second".to_string())),
        ("Second".to_string(), TypeExpr::Named("First".to_string())),
    ]);

    assert_eq!(
        capability_carrier_kind(
            &TypeExpr::Named("First".to_string()),
            &aliases,
            &mut BTreeSet::new(),
        ),
        None
    );
}