m2-syn 0.6.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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Integration tests for native cell parser.

use std::sync::Arc;

use m2_syn::{Lex, LexErrorKind, NativeCellParser, NativeCellState, NativeParseError, Spanned};

#[test]
fn a_long_function_remains_typed_until_its_block_closes() {
    let mut parser = NativeCellParser::new();

    assert_eq!(parser.push_line("f = x -> ("), NativeCellState::Incomplete);
    assert!(parser.active_syntax().is_some());

    assert_eq!(parser.push_line("y := x + 1;"), NativeCellState::Incomplete);
    assert_eq!(parser.push_line("y^2"), NativeCellState::Incomplete);
    assert_eq!(
        parser.active_syntax().unwrap().to_m2(),
        "f = x -> (\ny := x + 1;\ny^2"
    );
    assert_eq!(parser.lexer_diagnostics().len(), 1);
    assert_eq!(
        parser.lexer_diagnostics()[0].kind(),
        LexErrorKind::UnterminatedGroup
    );
    assert_eq!(parser.lexer_diagnostics()[0].expected(), Some(")"));

    assert_eq!(parser.push_line(")"), NativeCellState::Complete);
    assert_eq!(parser.active_source(), "");
    assert!(parser.active_syntax().is_none());

    let completed = parser.take_completed();
    assert_eq!(completed.len(), 1);
    assert_eq!(completed[0].source(), "f = x -> (\ny := x + 1;\ny^2\n)\n");
    assert_eq!(
        completed[0].syntax().to_m2(),
        "f = x -> (\ny := x + 1;\ny^2\n)"
    );
    assert_eq!(parser.state(), NativeCellState::Empty);
}

#[test]
fn an_operator_tail_is_incomplete_but_an_explicit_bad_boundary_is_invalid() {
    let mut parser = NativeCellParser::new();
    assert_eq!(parser.push_line("x +"), NativeCellState::Incomplete);
    assert!(matches!(
        parser.parse_error(),
        Some(NativeParseError::MissingOperand { .. })
    ));

    assert_eq!(parser.push_line("1"), NativeCellState::Complete);
    let completed = parser.take_completed();
    assert_eq!(completed[0].source(), "x +\n1\n");
    assert_eq!(completed[0].syntax().to_m2(), "x +\n1");

    let mut parser = NativeCellParser::new();
    assert_eq!(parser.push_line("x +;"), NativeCellState::Invalid);
    assert!(matches!(
        parser.parse_error(),
        Some(NativeParseError::MissingOperand { .. })
    ));
}

#[test]
fn required_control_clauses_continue_across_submitted_lines() {
    let mut parser = NativeCellParser::new();
    assert_eq!(parser.push_line("if x"), NativeCellState::Incomplete);
    assert_eq!(parser.push_line("then y"), NativeCellState::Complete);

    let completed = parser.take_completed();
    assert_eq!(completed.len(), 1);
    assert_eq!(completed[0].source(), "if x\nthen y\n");
    assert_eq!(completed[0].syntax().to_m2(), "if x\nthen y");

    let mut parser = NativeCellParser::new();
    assert_eq!(parser.push_line("1 = x"), NativeCellState::Invalid);
    assert!(matches!(
        parser.parse_error(),
        Some(NativeParseError::InvalidAssignmentTarget { .. })
    ));
}

#[test]
fn a_mismatched_closer_is_invalid_and_can_be_abandoned() {
    let mut parser = NativeCellParser::new();
    assert_eq!(parser.push_line("f("), NativeCellState::Incomplete);
    assert_eq!(parser.push_line("]"), NativeCellState::Invalid);
    assert_eq!(parser.lexer_diagnostics().len(), 1);
    assert_eq!(
        parser.lexer_diagnostics()[0].kind(),
        LexErrorKind::UnexpectedClosingDelimiter
    );

    parser.reset_active();
    assert_eq!(parser.state(), NativeCellState::Empty);
    assert_eq!(parser.active_source(), "");
}

#[test]
fn nested_unclosed_groups_report_every_required_closer() {
    let mut parser = NativeCellParser::new();
    assert_eq!(parser.push_line("f([x"), NativeCellState::Incomplete);
    assert!(parser.active_syntax().is_some());
    assert_eq!(parser.lexer_diagnostics().len(), 2);
    assert_eq!(parser.lexer_diagnostics()[0].expected(), Some("]"));
    assert_eq!(parser.lexer_diagnostics()[1].expected(), Some(")"));

    assert_eq!(parser.push_line("])"), NativeCellState::Complete);
    let completed = parser.take_completed();
    assert_eq!(completed[0].syntax().to_m2(), "f([x\n])");
}

#[test]
fn an_unterminated_block_comment_is_incomplete_until_its_closer_arrives() {
    let mut parser = NativeCellParser::new();
    assert_eq!(
        parser.push_line("x -* comment"),
        NativeCellState::Incomplete
    );
    assert_eq!(parser.lexer_diagnostics().len(), 1);
    assert_eq!(
        parser.lexer_diagnostics()[0].kind(),
        LexErrorKind::UnterminatedBlockComment
    );

    assert_eq!(parser.push_line("*-"), NativeCellState::Complete);
    let completed = parser.take_completed();
    assert_eq!(completed[0].source(), "x -* comment\n*-\n");
    assert_eq!(completed[0].syntax().to_m2(), "x -* comment\n*-");
}

#[test]
fn a_completed_prefix_is_not_rebuilt_with_the_unfinished_tail() {
    let mut parser = NativeCellParser::new();
    assert_eq!(parser.push_line("x = 1; f("), NativeCellState::Incomplete);
    assert_eq!(parser.completed().len(), 1);
    assert_eq!(parser.completed()[0].source(), "x = 1;");
    assert_eq!(parser.completed()[0].syntax().to_m2(), "x = 1;");
    assert_eq!(parser.active_source(), " f(\n");

    let source = Arc::clone(parser.completed()[0].syntax().span().source());
    assert_eq!(parser.push_line("x"), NativeCellState::Incomplete);
    assert!(Arc::ptr_eq(
        &source,
        parser.completed()[0].syntax().span().source()
    ));

    assert_eq!(parser.push_line(")"), NativeCellState::Complete);
    let completed = parser.take_completed();
    assert_eq!(completed.len(), 2);
    assert_eq!(completed[0].syntax().to_m2(), "x = 1;");
    assert_eq!(completed[1].syntax().to_m2(), "f(\nx\n)");
}