harn-lint 0.8.121

Linter for the Harn programming language
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! HARN-LNT-054..057 — ambient fs/env/random/net builtins now route
//! through `harness.{fs,env,random,net}.*`. Direct lint fixes run only
//! when a Harness binding is already in scope; `harn fix` owns broader
//! migration planning.

use super::*;

#[test]
fn ambient_fs_call_inside_main_rewrites_to_harness_fs() {
    let source =
        "fn main(harness: Harness) {\n  let body = read_file(\"path.txt\")\n  harness.stdio.println(body)\n}\n";
    let diags = lint_source(source);
    assert_eq!(
        count_rule(&diags, "ambient-fs-builtin"),
        1,
        "expected one ambient-fs lint, got: {diags:?}"
    );
    let fixed = apply_fixes(source, &diags);
    assert!(
        fixed.contains("harness.fs.read_text(\"path.txt\")"),
        "expected rewrite to harness.fs.read_text, got: {fixed}"
    );
}

#[test]
fn ambient_fs_mkdtemp_inside_main_rewrites_to_harness_fs() {
    let source = "fn main(harness: Harness) {\n  let dir = mkdtemp(\"harn-\")\n}\n";
    let diags = lint_source(source);
    assert_eq!(count_rule(&diags, "ambient-fs-builtin"), 1);
    let fixed = apply_fixes(source, &diags);
    assert!(
        fixed.contains("harness.fs.mkdtemp(\"harn-\")"),
        "expected rewrite to harness.fs.mkdtemp, got: {fixed}"
    );
}

#[test]
fn ambient_fs_lints_full_surface_inside_main() {
    let source = r#"fn main(harness: Harness) {
  read_file("a")
  write_file("b", "x")
  file_exists("c")
  delete_file("d")
  append_file("e", "y")
  list_dir("f")
  mkdir("g")
  copy_file("h", "i")
  temp_dir()
  mkdtemp("tmp-")
  stat("j")
  move_file("k", "l")
  read_lines("m")
  walk_dir("n")
  glob("o")
}
"#;
    let diags = lint_source(source);
    assert_eq!(
        count_rule(&diags, "ambient-fs-builtin"),
        15,
        "expected one lint per ambient fs call, got: {diags:?}"
    );
}

#[test]
fn ambient_env_call_rewrites_to_harness_env() {
    let source =
        "fn main(harness: Harness) {\n  let v = env(\"HOME\")\n  harness.stdio.println(v)\n}\n";
    let diags = lint_source(source);
    assert_eq!(
        count_rule(&diags, "ambient-env-builtin"),
        1,
        "expected one ambient-env lint, got: {diags:?}"
    );
    let fixed = apply_fixes(source, &diags);
    assert!(
        fixed.contains("harness.env.get(\"HOME\")"),
        "expected rewrite to harness.env.get, got: {fixed}"
    );
}

#[test]
fn ambient_env_or_rewrites_to_harness_env_get_or() {
    let source = "fn main(harness: Harness) {\n  let v = env_or(\"X\", \"default\")\n}\n";
    let diags = lint_source(source);
    assert_eq!(count_rule(&diags, "ambient-env-builtin"), 1);
    let fixed = apply_fixes(source, &diags);
    assert!(fixed.contains("harness.env.get_or(\"X\", \"default\")"));
}

#[test]
fn ambient_random_call_rewrites_to_harness_random() {
    let source =
        "fn main(harness: Harness) {\n  let n = random_int(0, 10)\n  harness.stdio.println(n)\n}\n";
    let diags = lint_source(source);
    assert_eq!(
        count_rule(&diags, "ambient-random-builtin"),
        1,
        "expected one ambient-random lint, got: {diags:?}"
    );
    let fixed = apply_fixes(source, &diags);
    assert!(
        fixed.contains("harness.random.gen_range(0, 10)"),
        "expected rewrite to harness.random.gen_range, got: {fixed}"
    );
}

#[test]
fn explicit_seeded_random_calls_are_not_ambient_host_random() {
    let source = r#"fn main(harness: Harness) {
  let rng = rng_seed(42)
  random(rng)
  random_int(rng, 0, 10)
  random_choice(rng, ["a", "b"])
  random_shuffle(rng, [1, 2])
}
"#;
    let diags = lint_source(source);
    assert_eq!(
        count_rule(&diags, "ambient-random-builtin"),
        0,
        "seeded Rng calls should stay on the deterministic Rng surface: {diags:?}"
    );
}

#[test]
fn ambient_net_call_rewrites_to_harness_net() {
    let source =
        "fn main(harness: Harness) {\n  let r = http_get(\"https://example.test\")\n  harness.stdio.println(r)\n}\n";
    let diags = lint_source(source);
    assert_eq!(
        count_rule(&diags, "ambient-net-builtin"),
        1,
        "expected one ambient-net lint, got: {diags:?}"
    );
    let fixed = apply_fixes(source, &diags);
    assert!(
        fixed.contains("harness.net.get(\"https://example.test\")"),
        "expected rewrite to harness.net.get, got: {fixed}"
    );
}

#[test]
fn ambient_capability_lint_without_harness_param_keeps_no_fix() {
    let source = "fn helper() {\n  let _ = read_file(\"x\")\n}\n";
    let diags = lint_source(source);
    let entry = diags
        .iter()
        .find(|d| d.rule == "ambient-fs-builtin")
        .expect("ambient-fs lint should fire even without harness in scope");
    assert!(
        entry.fix.is_none(),
        "should not auto-fix without harness in scope, got: {:?}",
        entry.fix
    );
    let suggestion = entry
        .suggestion
        .as_deref()
        .expect("lint must carry a suggestion");
    assert!(
        suggestion.contains("--harness-threading thread-params")
            && suggestion.contains("VM-level `harness`"),
        "suggestion should describe both Harness migration modes, got: {suggestion}"
    );
}