harn-lint 0.10.166

Linter for the Harn programming language
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

//! `HARN-LNT-029` must see a boundary call in either spelling.
//!
//! Reading a field straight off an unvalidated model response or tool result
//! is the same risk whether the source calls `llm_call(...)` or the
//! `harness.llm.call(...)` that replaced it. The list of boundary sources
//! is owned by `harn_parser::builtin_signatures`, shared with the
//! typechecker's `HARN-OWN-004`, so the two rules cannot drift apart.

use super::*;

#[test]
fn untyped_dict_access_reports_the_ambient_spelling() {
    let diagnostics = lint_source(
        r#"
pipeline main(harness: Harness) {
  const body = llm_call("rate this", "system").data
  harness.stdio.log(body)
}
"#,
    );

    assert_eq!(count_rule(&diagnostics, "untyped-dict-access"), 1);
}

#[test]
fn untyped_dict_access_reports_the_harness_spelling() {
    let diagnostics = lint_source(
        r#"
pipeline main(harness: Harness) {
  const body = harness.llm.call("rate this", "system").data
  harness.stdio.log(body)
}
"#,
    );

    assert_eq!(
        count_rule(&diagnostics, "untyped-dict-access"),
        1,
        "migrating the call site must not silence the rule: {diagnostics:?}"
    );
}

#[test]
fn untyped_dict_access_reports_a_harness_subscript() {
    let diagnostics = lint_source(
        r#"
pipeline main(harness: Harness) {
  const body = harness.llm.call("rate this", "system")["data"]
  harness.stdio.log(body)
}
"#,
    );

    assert_eq!(
        count_rule(&diagnostics, "untyped-dict-access"),
        1,
        "subscript access is the same risk as property access: {diagnostics:?}"
    );
}

#[test]
fn untyped_dict_access_ignores_a_get_method_on_another_receiver() {
    let diagnostics = lint_source(
        r#"
pipeline main(harness: Harness) {
  const proxy = {llm: {call: { prompt, system -> {data: prompt} }}}
  const body = proxy.llm.call("rate this", "system").data
  harness.stdio.log(body)
}
"#,
    );

    assert!(
        !has_rule(&diagnostics, "untyped-dict-access"),
        "`llm.call` on a plain value is not the harness method: {diagnostics:?}"
    );
}

#[test]
fn untyped_dict_access_names_the_spelling_the_source_used() {
    let diagnostics = lint_source(
        r#"
pipeline main(harness: Harness) {
  const body = harness.llm.call("rate this", "system").data
  harness.stdio.log(body)
}
"#,
    );

    let message = &diagnostics
        .iter()
        .find(|diagnostic| diagnostic.rule == "untyped-dict-access")
        .expect("expected an untyped-dict-access diagnostic")
        .message;
    assert!(
        message.contains("harness.llm.call()"),
        "the diagnostic should quote the call as written, got: {message}"
    );
}

/// `mcp_call` was in the linter's list but not the typechecker's, and
/// `host_tool_call` was the reverse. Both now resolve from the one list, in
/// both spellings.
#[test]
fn untyped_dict_access_covers_the_previously_divergent_names() {
    let diagnostics = lint_source(
        r#"
pipeline main(harness: Harness) {
  const a = host_tool_call("read_file", {path: "x"}).content
  const b = harness.tools.mcp_call(nil, "srv::tool", {}).content
  harness.stdio.log("${a} ${b}")
}
"#,
    );

    assert_eq!(
        count_rule(&diagnostics, "untyped-dict-access"),
        2,
        "both previously one-sided names should report: {diagnostics:?}"
    );
}

/// A buffered HTTP response is the closed `HTTP_RESPONSE` record, so reading
/// its envelope is typed access, not a boundary read.
#[test]
fn untyped_dict_access_ignores_the_typed_http_envelope() {
    let diagnostics = lint_source(
        r#"
pipeline main(harness: Harness) {
  const response = harness.net.get("https://example.com")
  harness.stdio.log("${response.status} ${response.body}")
}
"#,
    );

    assert!(
        !has_rule(&diagnostics, "untyped-dict-access"),
        "a typed response envelope is not an untyped boundary: {diagnostics:?}"
    );
}