Grcov report - parse

1

use crate::errors::{ConjureParseError, EssenceParseError};

2

use crate::parse_expr;

3

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

4

#[allow(unused)]

5

use uniplate::Uniplate;

6

7

6

pub fn parse_literal(src: &str) -> Result<Literal, EssenceParseError> {

8

    // HACK: Create a dummy symbol table - don't need it for parsing literals

9

6

    let symbol_table = SymbolTablePtr::new();

10

6

    let expr = parse_expr(src, symbol_table)?;

11

5

    match expr {

12

4

        Expression::Atomic(_metadata, atom) => match atom {

13

4

            Atom::Literal(lit) => Ok(lit),

14

            _ => {

15

                Err(ConjureParseError::Parse(format!("Expected a literal, got '{atom:?}'")).into())

16

17

},

18

1

        _ => Err(ConjureParseError::Parse(format!("Expected a literal, got '{expr:?}'")).into()),

19

20

6

21

22

mod test {

23

    #[allow(unused)]

24

    use super::parse_literal;

25

    #[allow(unused)]

26

    use conjure_cp_core::ast::Metadata;

27

    #[allow(unused)]

28

    use conjure_cp_core::ast::{

29

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

30

};

31

    #[allow(unused)]

32

    use std::collections::HashMap;

33

    #[allow(unused)]

34

    use std::sync::Arc;

35

    #[allow(unused)]

36

    use std::{cell::RefCell, rc::Rc};

37

    #[allow(unused)]

38

    use tree_sitter::Range;

39

40

    #[test]

41

1

    pub fn test_parse_bool() {

42

1

        let src_true = "true";

43

1

        let src_false = "false";

44

1

        let literal_true = parse_literal(src_true).unwrap();

45

1

        let literal_false = parse_literal(src_false).unwrap();

46

1

        assert_eq!(literal_true, Literal::Bool(true));

47

1

        assert_eq!(literal_false, Literal::Bool(false));

48

1

49

50

    #[test]

51

1

    pub fn test_parse_int() {

52

1

        let src_int = "42";

53

1

        let literal_int = parse_literal(src_int).unwrap();

54

1

        assert_eq!(literal_int, Literal::Int(42));

55

1

56

57

    #[test]

58

1

    pub fn test_parse_neg_int() {

59

1

        let src_int = "-42";

60

1

        let literal_int = parse_literal(src_int).unwrap();

61

1

        assert_eq!(literal_int, Literal::Int(-42));

62

1

63

64

    #[test]

65

1

    pub fn test_bad() {

66

1

        let src_bad = "bad";

67

1

        let src_expr = "2 + 2";

68

1

        let literal_bad = parse_literal(src_bad);

69

1

        let literal_expr = parse_literal(src_expr);

70

1

        assert!(literal_bad.is_err());

71

1

        assert!(literal_expr.is_err());

72

1

73