Grcov report - expand.rs

1

use conjure_cp_essence_parser::util::node_is_expression;

2

use conjure_cp_essence_parser::{

3

    EssenceParseError,

4

    expression::parse_expression,

5

    util::{get_tree, query_toplevel},

6

};

7

use polyquine::Quine;

8

use proc_macro2::{TokenStream, TokenTree};

9

use quote::{ToTokens, quote};

10

use syn::{Error, LitStr, Result};

11

use tree_sitter::Node;

12

13

192

pub fn expand_expr(essence: &TokenTree) -> Result<TokenStream> {

14

192

    let src = to_src(essence);

15

192

    let (tree, source_code) =

16

192

        get_tree(&src).ok_or(Error::new(essence.span(), "Could not parse Essence AST"))?;

17

192

    let root = tree.root_node();

18

19

    // Get top level expressions

20

192

    let mut query = query_toplevel(&root, &node_is_expression);

21

192

    let expr_node = query

22

192

        .next()

23

192

        .ok_or(Error::new(essence.span(), "Expected an Essence expression"))?;

24

25

    // We only expect one expression, error if that's not the case

26

192

    if let Some(expr) = query.next() {

27

        let tokens = &source_code[expr.start_byte()..expr.end_byte()];

28

        return Err(Error::new(

29

            essence.span(),

30

            format!(

31

                "Unexpected tokens: `{tokens}`. Expected a single Essence expression. Perhaps you meant `essence_vec!`?"

32

),

33

));

34

192

35

36

    // Parse expression and build the token stream

37

192

    let expr = mk_expr(expr_node, &source_code, &root, essence)?;

38

192

    Ok(expr)

39

192

40

41

1

pub fn expand_expr_vec(tt: &TokenTree) -> Result<TokenStream> {

42

1

    let mut ans: Vec<TokenStream> = Vec::new();

43

1

    let src = to_src(tt);

44

1

    let (tree, source_code) =

45

1

        get_tree(&src).ok_or(Error::new(tt.span(), "Could not parse Essence AST"))?;

46

1

    let root = tree.root_node();

47

48

1

    let query = query_toplevel(&root, &node_is_expression);

49

2

    for expr_node in query {

50

2

        let expr = mk_expr(expr_node, &source_code, &root, tt)?;

51

2

        ans.push(expr);

52

53

1

    Ok(quote! { vec![#(#ans),*] })

54

1

55

56

/// Parse a single expression or make a compile time error

57

194

fn mk_expr(node: Node, src: &str, root: &Node, tt: &TokenTree) -> Result<TokenStream> {

58

194

    match parse_expression(node, src, root, None) {

59

194

        Ok(expr) => Ok(expr.ctor_tokens()),

60

        Err(err) => {

61

            let error_message = match err {

62

                EssenceParseError::SyntaxError {

63

                    msg,

64

                    range: Some(rng),

65

                } => {

66

                    let lines: Vec<&str> = src.lines().collect();

67

                    let start_line = rng.start_point.row;

68

                    let mut start_col = rng.start_point.column;

69

70

                    let mut line_content = lines

71

                        .get(start_line)

72

                        .unwrap_or(&"<line not found>")

73

                        .trim()

74

                        .to_string();

75

                    let pref = "_FRAGMENT_EXPRESSION";

76

                    if line_content.starts_with(pref) {

77

                        let len = pref.len();

78

                        line_content = line_content[len..].trim_start().to_string();

79

                        start_col -= len;

80

81

82

                    format!(

83

                        "Syntax error: {}\n{}\n{}^-- Error here",

84

                        msg,

85

                        line_content,

86

                        " ".repeat(start_col)

87

88

89

                _ => err.to_string(),

90

};

91

92

            Err(Error::new(tt.span(), error_message))

93

94

95

194

96

97

/// Parse string literals (gets rid of ""), otherwise use tokens as is

98

193

fn to_src(tt: &TokenTree) -> String {

99

193

    match syn::parse::<LitStr>(tt.to_token_stream().into()) {

100

20

        Ok(src) => src.value(),

101

173

        Err(_) => tt.to_string(),

102

103

193