Grcov report - expand.rs

1

use conjure_cp_essence_parser::parser::ParseContext;

2

use conjure_cp_essence_parser::util::node_is_expression;

3

use conjure_cp_essence_parser::{

4

    diagnostics::source_map::SourceMap,

5

    expression::parse_expression,

6

    util::{get_tree, query_toplevel},

7

};

8

use polyquine::Quine;

9

use proc_macro2::{TokenStream, TokenTree};

10

use quote::{ToTokens, quote};

11

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

12

use tree_sitter::Node;

13

14

227

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

15

227

    let src = to_src(essence);

16

227

    let (tree, source_code) =

17

227

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

18

227

    let root = tree.root_node();

19

20

    // Get top level expressions

21

227

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

22

227

    let expr_node = query

23

227

        .next()

24

227

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

25

26

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

27

227

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

28

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

29

        return Err(Error::new(

30

            essence.span(),

31

            format!(

32

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

33

),

34

));

35

227

36

37

    // Parse expression and build the token stream

38

227

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

39

227

    Ok(expr)

40

227

41

42

1

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

43

1

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

44

1

    let src = to_src(tt);

45

1

    let (tree, source_code) =

46

1

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

47

1

    let root = tree.root_node();

48

49

1

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

50

2

    for expr_node in query {

51

2

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

52

2

        ans.push(expr);

53

54

1

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

55

1

56

57

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

58

229

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

59

229

    let mut errors = Vec::new();

60

229

    let mut source_map = SourceMap::default();

61

229

    let mut ctx = ParseContext::new(src, root, None, &mut errors, &mut source_map);

62

229

    match parse_expression(&mut ctx, node) {

63

229

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

64

        Ok(None) => {

65

            // Recoverable error occurred - get the error message from the errors vector

66

            let error_message = if let Some(err) = ctx.errors.first() {

67

                format!("Recoverable parse error: {}", err)

68

            } else {

69

                "Parse error: Unknown error occurred".to_string()

70

};

71

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

72

73

        Err(err) => Err(Error::new(tt.span(), err.to_string())),

74

75

229

76

77

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

78

228

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

79

228

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

80

65

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

81

163

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

82

83

228