wit-parser 0.253.0

Tooling for parsing `*.wit` files and working with their contents.
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

//! Verifies that `ResolveError` and `ParseError` are downcastable from the
//! `anyhow::Error` returned by `Resolve`'s public `push_*` methods and
//! `UnresolvedPackageGroup::parse_dir`.

use wit_parser::{
    ParseError, ParseErrorKind, Resolve, ResolveError, ResolveErrorKind, UnresolvedPackageGroup,
};

fn resolve_error(err: &anyhow::Error) -> &ResolveError {
    err.downcast_ref::<ResolveError>()
        .expect("expected error to downcast to ResolveError")
}

fn parse_error(err: &anyhow::Error) -> &ParseError {
    err.downcast_ref::<ParseError>()
        .expect("expected error to downcast to ParseError")
}

#[test]
fn push_str_returns_downcastable_error() {
    let mut resolve = Resolve::new();
    let err = resolve
        .push_str(
            "test.wit",
            "package foo:foo;\nworld w { import some:dependency/iface; }",
        )
        .expect_err("expected resolve to fail");
    let re = resolve_error(&err);
    assert!(
        matches!(re.kind(), ResolveErrorKind::PackageNotFound { .. }),
        "expected PackageNotFound, got: {:?}",
        re.kind()
    );
}

#[test]
fn push_file_returns_downcastable_error() {
    let mut resolve = Resolve::new();
    let err = resolve
        .push_file("tests/ui/parse-fail/unresolved-interface4.wit")
        .expect_err("expected resolve to fail");
    let re = resolve_error(&err);
    assert!(
        matches!(re.kind(), ResolveErrorKind::PackageNotFound { .. }),
        "expected PackageNotFound, got: {:?}",
        re.kind()
    );
}

#[test]
fn push_dir_returns_downcastable_error() {
    let mut resolve = Resolve::new();
    let err = resolve
        .push_dir("tests/ui/parse-fail/bad-pkg6")
        .expect_err("expected resolve to fail");
    let re = resolve_error(&err);
    assert!(
        matches!(re.kind(), ResolveErrorKind::PackageNotFound { .. }),
        "expected PackageNotFound, got: {:?}",
        re.kind()
    );
}

#[test]
fn push_str_parse_error_is_downcastable() {
    let mut resolve = Resolve::new();
    let err = resolve
        .push_str("test.wit", "package foo:foo;\nworld w { not-a-keyword }")
        .expect_err("expected parse to fail");
    let pe = parse_error(&err);
    // Spans must be valid against `resolve.source_map` after the failure-path
    // merge, so rendering against it should not panic and should include
    // the file and line.
    let rendered = pe.render(&resolve.source_map);
    assert!(
        rendered.contains("test.wit:2:"),
        "expected rendered error to reference test.wit:2:..., got:\n{rendered}"
    );
    assert!(
        matches!(pe.kind(), ParseErrorKind::Syntax { .. }),
        "expected Syntax, got: {:?}",
        pe.kind()
    );
}

#[test]
fn parse_error_spans_are_adjusted_after_earlier_pushes() {
    let mut resolve = Resolve::new();
    resolve
        .push_str(
            "first.wit",
            "package foo:first;\n\ninterface i {\n    f: func();\n}\n",
        )
        .expect("first package should parse");
    let err = resolve
        .push_str(
            "second.wit",
            "package foo:second;\nworld w { not-a-keyword }",
        )
        .expect_err("expected parse to fail");
    let pe = parse_error(&err);
    // The failing package's sources land at a nonzero offset in
    // `resolve.source_map` because `first.wit` was merged before it, so this
    // only points at the right file and line if the error's spans were
    // adjusted during the failure-path merge.
    let rendered = pe.render(&resolve.source_map);
    assert!(
        rendered.contains("second.wit:2:"),
        "expected rendered error to reference second.wit:2:..., got:\n{rendered}"
    );
    assert!(
        rendered.contains("not-a-keyword"),
        "expected snippet to show the offending line, got:\n{rendered}"
    );
}

#[test]
fn push_file_parse_error_is_downcastable() {
    let mut resolve = Resolve::new();
    let err = resolve
        .push_file("tests/ui/parse-fail/bad-function.wit")
        .expect_err("expected parse to fail");
    parse_error(&err);
}

#[test]
fn parse_dir_parse_error_is_downcastable() {
    let err = UnresolvedPackageGroup::parse_dir("tests/ui/parse-fail/multi-file-missing-delimiter")
        .expect_err("expected parse to fail");
    parse_error(&err);
    // The source map is discarded on failure, but the rendered location must
    // be preserved in the error's message.
    assert!(
        format!("{err}").contains("observe.wit:6:"),
        "expected rendered location in Display, got:\n{err}"
    );
}