ripex 0.2.0

Multi-language structural parsing and fact extraction.
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

mod fixtures;

use crate::go::facts::extract_facts;
use crate::go::lexer::{Lexer, TokenKind};
use crate::go::parser::parse_program;
use fixtures::*;

#[test]
fn test_lexer_basic_tokens() {
    let src = "package main\nfunc main() {}";
    let (tokens, errors) = Lexer::new(src).tokenize();
    assert!(errors.is_empty());
    let kinds: Vec<TokenKind> = tokens.iter().map(|t| t.kind).collect();
    assert_eq!(
        kinds,
        vec![
            TokenKind::Package,
            TokenKind::Ident,
            TokenKind::Func,
            TokenKind::Ident,
            TokenKind::LParen,
            TokenKind::RParen,
            TokenKind::LBrace,
            TokenKind::RBrace,
            TokenKind::Eof,
        ]
    );
    assert_eq!(tokens[1].value, "main");
    assert_eq!(tokens[3].value, "main");
}

#[test]
fn test_parse_empty() {
    let (program, errors) = parse_program("");
    assert!(errors.is_empty());
    assert!(program.decls.is_empty());
}

#[test]
fn test_parse_imports() {
    for (name, source) in &ALL_FIXTURES[..2] {
        let (program, errors) = parse_program(source);
        assert!(errors.is_empty(), "{} produced errors: {:?}", name, errors);
        let facts = extract_facts(&program);
        assert!(
            !facts.imports.is_empty(),
            "expected imports from '{}'",
            name
        );
    }
}

#[test]
fn test_parse_functions() {
    for (name, source) in &ALL_FIXTURES[2..5] {
        let (program, errors) = parse_program(source);
        assert!(errors.is_empty(), "{} produced errors: {:?}", name, errors);
        let facts = extract_facts(&program);
        assert!(
            !facts.symbols.is_empty(),
            "expected symbols from '{}'",
            name
        );
    }
}

#[test]
fn test_parse_types() {
    for (name, source) in &ALL_FIXTURES[5..8] {
        let (program, errors) = parse_program(source);
        assert!(errors.is_empty(), "{} produced errors: {:?}", name, errors);
        let facts = extract_facts(&program);
        assert!(
            !facts.symbols.is_empty(),
            "expected symbols from '{}'",
            name
        );
    }
}

#[test]
fn test_parse_variables() {
    let (program, errors) = parse_program(VAR_DECL);
    assert!(errors.is_empty(), "var decl produced errors: {:?}", errors);
    let facts = extract_facts(&program);
    assert!(
        !facts.variables.is_empty(),
        "expected variables from var decl"
    );

    let (program, errors) = parse_program(CONST_DECL);
    assert!(
        errors.is_empty(),
        "const decl produced errors: {:?}",
        errors
    );
    let facts = extract_facts(&program);
    assert!(
        !facts.variables.is_empty(),
        "expected variables from const decl"
    );
}

#[test]
fn test_parse_all_fixtures() {
    for (name, source) in ALL_FIXTURES {
        let (program, errors) = parse_program(source);
        assert!(
            errors.is_empty(),
            "fixture '{}' produced errors: {:?}",
            name,
            errors
        );
        // Facts extraction must not panic
        let _facts = extract_facts(&program);
    }
}