aufbau 0.1.2

Generalized prefix parsing for a class of context-dependent languages
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

use crate::logic::grammar::Grammar;
use crate::logic::parse::arena::{AltRange, ArenaNode, NodeStatus, Span};
use crate::logic::path::TreePath;
use crate::logic::typing::{ContextTransition, Obligations};

fn grammar_with_rule_obligations() -> Grammar {
    Grammar::load(
        r#"
        Number ::= /[0-9]+/
        Pair(pair) ::= Number[x] ',' Number[x]
        Start ::= Pair

        Γ ⊢ x : 'number'
        ----------------- (pair)
        'number'
        "#,
    )
    .unwrap()
}

#[test]
fn create_obligations_reads_rule_bindings_from_grammar() {
    let grammar = grammar_with_rule_obligations();
    let pair = grammar.nt_index("Pair").unwrap();

    let obligations = Obligations::create(&grammar, (pair, 0), TreePath::new());

    assert_eq!(obligations.len(), 1);
    assert_eq!(obligations.as_slice()[0].name, "x");
    assert_eq!(obligations.as_slice()[0].paths.len(), 2);
    assert!(obligations.root().is_empty());
}

#[test]
fn step_obligations_advances_only_matching_paths() {
    let grammar = grammar_with_rule_obligations();
    let pair = grammar.nt_index("Pair").unwrap();
    let obligations = Obligations::create(&grammar, (pair, 0), TreePath::new());

    let stepped = obligations.step(0, 0);

    assert_eq!(stepped.len(), 1);
    assert_eq!(stepped.as_slice()[0].name, "x");
    assert!(
        stepped.as_slice()[0]
            .paths
            .iter()
            .all(|path| path.is_empty())
    );
}

#[test]
fn step_seed_obligations_filters_to_seed_alternative() {
    let grammar = grammar_with_rule_obligations();
    let pair = grammar.nt_index("Pair").unwrap();
    let obligations = Obligations::create(&grammar, (pair, 0), TreePath::new());

    let seeded = obligations.for_seed(0);

    assert_eq!(seeded.len(), obligations.len());
    let other = obligations.for_seed(1);
    assert!(other.is_empty());
}

#[test]
fn resolve_nonterminal_obligations_captures_child_type() {
    let grammar = grammar_with_rule_obligations();
    let pair = grammar.nt_index("Pair").unwrap();
    let mut obligations = Obligations::create(&grammar, (pair, 0), TreePath::new());
    let node = ArenaNode {
        nt: pair,
        span: Span { start: 0, end: 1 },
        status: NodeStatus::Closed,
        ty: 7,
        ctr: Some(ContextTransition::identity()),
        bindings: Vec::new(),
        alts: AltRange { start: 0, len: 0 },
    };

    obligations.resolve_nonterminal(0, 0, &node);

    let matched = obligations.iter().find(|ob| ob.name == "x").unwrap();
    assert_eq!(matched.actual, Some(7));
    assert!(matched.value.is_some());
}

#[test]
fn constrained_productions_uses_obligation_alternative_constraints() {
    let grammar = grammar_with_rule_obligations();
    let pair = grammar.nt_index("Pair").unwrap();
    let number = grammar.nt_index("Number").unwrap();
    let obligations = Obligations::create(&grammar, (pair, 0), TreePath::new());

    let constrained = obligations.prune(number, &grammar);

    assert_eq!(constrained, vec![(number, 0)]);
}

#[test]
fn child_root_tracks_absolute_tree_position() {
    let grammar = grammar_with_rule_obligations();
    let pair = grammar.nt_index("Pair").unwrap();
    let obligations = Obligations::create(&grammar, (pair, 0), TreePath::new());

    let child = obligations.step(0, 0).at_child(0);

    assert_eq!(child.root().as_slice(), &[0]);
}