Grcov report - parse

1

use super::ParseContext;

2

use super::util::{get_tree, query_toplevel};

3

use crate::diagnostics::source_map::SourceMap;

4

use crate::errors::FatalParseError;

5

use crate::expression::parse_expression;

6

use crate::util::node_is_expression;

7

use conjure_cp_core::ast::{Expression, SymbolTablePtr};

8

#[allow(unused)]

9

use uniplate::Uniplate;

10

11

27

pub fn parse_expr(src: &str, symbols_ptr: SymbolTablePtr) -> Result<Expression, FatalParseError> {

12

27

    let exprs = parse_exprs(src, symbols_ptr)?;

13

27

    if exprs.len() != 1 {

14

3

        return Err(FatalParseError::internal_error(

15

3

            "Expected a single expression".to_string(),

16

3

            None,

17

3

));

18

24

19

24

    Ok(exprs[0].clone())

20

27

21

22

30

pub fn parse_exprs(

23

30

    src: &str,

24

30

    symbols_ptr: SymbolTablePtr,

25

30

) -> Result<Vec<Expression>, FatalParseError> {

26

30

    let (tree, source_code) = get_tree(src).ok_or(FatalParseError::TreeSitterError(

27

30

        "Failed to parse Essence source code".to_string(),

28

30

    ))?;

29

30

    let root = tree.root_node();

31

30

    let mut source_map = SourceMap::default();

32

30

    let mut errors = Vec::new();

33

30

    let mut ctx = ParseContext::new(

34

30

        &source_code,

35

30

        &root,

36

30

        Some(symbols_ptr),

37

30

        &mut errors,

38

30

        &mut source_map,

39

);

40

30

    let mut ans = Vec::new();

41

33

    for expr in query_toplevel(&root, &node_is_expression) {

42

33

        let Some(expr) = parse_expression(&mut ctx, expr)? else {

43

3

            continue;

44

};

45

30

        ans.push(expr);

46

47

30

    Ok(ans)

48

30

49

50

mod test {

51

    #[allow(unused)]

52

    use super::{parse_expr, parse_exprs};

53

    #[allow(unused)]

54

    use conjure_cp_core::ast::SymbolTablePtr;

55

    #[allow(unused)]

56

    use conjure_cp_core::ast::{

57

        Atom, DeclarationPtr, Domain, Expression, Literal, Metadata, Moo, Name, SymbolTable,

58

};

59

    #[allow(unused)]

60

    use std::collections::HashMap;

61

    #[allow(unused)]

62

    use std::sync::Arc;

63

    #[allow(unused)]

64

    use tree_sitter::Range;

65

66

    #[test]

67

3

    pub fn test_parse_constant() {

68

3

        let symbols = SymbolTablePtr::new();

69

70

3

        assert_eq!(

71

3

            parse_expr("42", symbols.clone()).unwrap(),

72

3

            Expression::Atomic(Metadata::new(), Atom::Literal(Literal::Int(42)))

73

);

74

3

        assert_eq!(

75

3

            parse_expr("true", symbols.clone()).unwrap(),

76

3

            Expression::Atomic(Metadata::new(), Atom::Literal(Literal::Bool(true)))

77

);

78

3

        assert_eq!(

79

3

            parse_expr("false", symbols).unwrap(),

80

3

            Expression::Atomic(Metadata::new(), Atom::Literal(Literal::Bool(false)))

81

82

3

83

84

    #[test]

85

3

    pub fn test_parse_expressions() {

86

3

        let src = "x >= 5, y = a / 2";

87

3

        let symbols = SymbolTablePtr::new();

88

3

        let x = DeclarationPtr::new_find(

89

3

            Name::User("x".into()),

90

3

            Domain::int(vec![conjure_cp_core::ast::Range::Bounded(0, 10)]),

91

);

92

93

3

        let y = DeclarationPtr::new_find(

94

3

            Name::User("y".into()),

95

3

            Domain::int(vec![conjure_cp_core::ast::Range::Bounded(0, 10)]),

96

);

97

98

3

        let a = DeclarationPtr::new_find(

99

3

            Name::User("a".into()),

100

3

            Domain::int(vec![conjure_cp_core::ast::Range::Bounded(0, 10)]),

101

);

102

103

        // Clone the Rc when inserting!

104

3

        symbols

105

3

            .write()

106

3

            .insert(x.clone())

107

3

            .expect("x should not exist in the symbol-table yet, so we should be able to add it");

108

109

3

        symbols

110

3

            .write()

111

3

            .insert(y.clone())

112

3

            .expect("y should not exist in the symbol-table yet, so we should be able to add it");

113

114

3

        symbols

115

3

            .write()

116

3

            .insert(a.clone())

117

3

            .expect("a should not exist in the symbol-table yet, so we should be able to add it");

118

119

3

        let exprs = parse_exprs(src, symbols).unwrap();

120

3

        assert_eq!(exprs.len(), 2);

121

122

3

        assert_eq!(

123

3

            exprs[0],

124

3

            Expression::Geq(

125

3

                Metadata::new(),

126

3

                Moo::new(Expression::Atomic(Metadata::new(), Atom::new_ref(x))),

127

3

                Moo::new(Expression::Atomic(Metadata::new(), 5.into()))

128

3

129

);

130

131

3

        assert_eq!(

132

3

            exprs[1],

133

3

            Expression::Eq(

134

3

                Metadata::new(),

135

3

                Moo::new(Expression::Atomic(Metadata::new(), Atom::new_ref(y))),

136

3

                Moo::new(Expression::UnsafeDiv(

137

3

                    Metadata::new(),

138

3

                    Moo::new(Expression::Atomic(Metadata::new(), Atom::new_ref(a))),

139

3

                    Moo::new(Expression::Atomic(Metadata::new(), 2.into()))

140

3

))

141

3

142

);

143

3

144