Grcov report - parse

1

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

2

use crate::parse_expr;

3

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

4

#[allow(unused)]

5

use uniplate::Uniplate;

6

7

12

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

8

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

9

12

    let symbol_table = SymbolTablePtr::new();

10

12

    let expr = parse_expr(src, symbol_table)?;

11

10

    match expr {

12

8

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

13

8

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

14

            _ => {

15

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

16

17

},

18

2

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

19

20

12

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

2

    pub fn test_parse_bool() {

42

2

        let src_true = "true";

43

2

        let src_false = "false";

44

2

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

45

2

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

46

2

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

47

2

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

48

2

49

50

    #[test]

51

2

    pub fn test_parse_int() {

52

2

        let src_int = "42";

53

2

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

54

2

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

55

2

56

57

    #[test]

58

2

    pub fn test_parse_neg_int() {

59

2

        let src_int = "-42";

60

2

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

61

2

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

62

2

63

64

    #[test]

65

2

    pub fn test_bad() {

66

2

        let src_bad = "bad";

67

2

        let src_expr = "2 + 2";

68

2

        let literal_bad = parse_literal(src_bad);

69

2

        let literal_expr = parse_literal(src_expr);

70

2

        assert!(literal_bad.is_err());

71

2

        assert!(literal_expr.is_err());

72

2

73