m2-syn 0.7.1

Parser, typed CST, traversal and procedural macros for Macaulay2
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

//! Integration tests for storing every comment in the slot where it occurs.

use m2_syn::nodes::SourceFile;
use m2_syn::{CommentTrivia, Lex, parse_file, parse_file_recovering, parse_native};

/// Sources whose comments sit at each kind of ownership boundary.
const COMMENT_PLACEMENT_SOURCES: [&str; 14] = [
    "-- doc\n(x)",
    "(x) -- c",
    "x\n-- c",
    "-* b *- x",
    "x -* b *-",
    "{x, -- c\ny}",
    "-- a\n\n-- b\nx",
    "x\n-- c\n\ny",
    "x\n\n-- c\n",
    "-- only",
    "(-* b *-)",
    "-- d\n-* b *-\nx",
    "f(x, -- c\n  y)\n-- tail\n",
    "x := (-- c\n  1)",
];

/// The text of each outer and inner comment, independent of the parse's source.
fn comment_texts(comments: &CommentTrivia) -> [Vec<&str>; 2] {
    [comments.outer(), comments.inner()]
        .map(|comments| comments.iter().map(|comment| comment.text()).collect())
}

fn both_parsers(source: &str) -> [SourceFile; 3] {
    [
        parse_native(source).expect("the native parser accepts the source"),
        parse_file(source).expect("the tree-sitter parser accepts the source"),
        parse_file_recovering(source)
            .expect("the recovering tree-sitter parser accepts the source")
            .value,
    ]
}

#[test]
fn every_comment_survives_a_parse_and_emit_round_trip_in_place() {
    for source in COMMENT_PLACEMENT_SOURCES {
        for file in both_parsers(source) {
            assert_eq!(file.to_m2(), source, "{source:?}");
        }
    }
}

#[test]
fn the_backends_assign_every_cell_the_same_comments() {
    for source in COMMENT_PLACEMENT_SOURCES {
        let [native, sitter, recovered] = both_parsers(source);
        for other in [&sitter, &recovered] {
            assert_eq!(other.cells.len(), native.cells.len(), "{source:?}");
            for (left, right) in native.cells.iter().zip(&other.cells) {
                assert_eq!(
                    comment_texts(&left.comments()),
                    comment_texts(&right.comments()),
                    "{source:?}"
                );
            }
            assert_eq!(
                comment_texts(&other.comments()),
                comment_texts(&native.comments()),
                "{source:?}"
            );
        }
    }
}

#[test]
fn a_documentation_block_before_a_group_is_the_cells_outer_comment() {
    for file in both_parsers("-- doc\n(x)") {
        let comments = file.cells[0].comments();

        assert_eq!(comments.outer().len(), 1);
        assert_eq!(comments.outer()[0].text(), "-- doc");
        assert!(comments.inner().is_empty());
        assert_eq!(file.cells[0].leading_trivia.as_slice().len(), 1);
    }
}

#[test]
fn comments_after_the_last_token_belong_to_the_last_cell() {
    for file in both_parsers("x\n\n-- c\n") {
        assert_eq!(
            comment_texts(&file.cells[0].comments()),
            [vec![], vec!["-- c"]]
        );
        assert!(file.leading_trivia.is_empty());
    }
}

#[test]
fn a_file_without_cells_owns_its_comments() {
    for file in both_parsers("-- only") {
        assert!(file.cells.is_empty());
        assert_eq!(file.leading_trivia.as_slice().len(), 1);
        assert_eq!(comment_texts(&file.comments()), [vec![], vec!["-- only"]]);
    }
}

#[test]
fn layout_beside_a_comment_next_to_a_delimiter_survives() {
    for source in [
        "( -- c\nx)",
        "(x\n-- c\n)",
        "f(-- c\n)",
        "x = (\n  -- c\n  1)",
        "(x -- c   \n)",
    ] {
        for file in both_parsers(source) {
            assert_eq!(file.to_m2(), source, "{source:?}");
        }
    }
}

#[test]
fn layout_beside_a_comment_in_an_unclosed_group_survives_recovery() {
    for source in ["( -- c", "(-- c\n", "[\n\n-- c", "{\t-- c"] {
        let native = m2_syn::parse_native_recovering(source)
            .expect("the recovering native parser accepts the source")
            .value;
        let sitter = parse_file_recovering(source)
            .expect("the recovering tree-sitter parser accepts the source")
            .value;

        assert_eq!(native.to_m2(), source, "{source:?}");
        assert_eq!(sitter.to_m2(), source, "{source:?}");
    }
}