galvan-into-ast 0.0.3

CST to AST conversion for the Galvan programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use galvan_ast::{
    AccessExpression, Block, Body, ClosureParameter, ElseExpression, Expression, PostfixExpression,
    Span, YeetExpression,
};
use galvan_parse::TreeCursor;

use crate::{cursor_expect, result::CursorUtil, AstError, ReadCursor, SpanExt};

impl ReadCursor for PostfixExpression {
    fn read_cursor(cursor: &mut TreeCursor<'_>, source: &str) -> Result<Self, AstError> {
        let node = cursor_expect!(cursor, "postfix_expression");
        let span = Span::from_node(node);

        cursor.child();
        let inner = Expression::read_cursor(cursor, source)?;

        cursor.next();
        cursor_expect!(cursor, "postfix_operator");

        cursor.child();
        let res = match cursor.kind()? {
            "yeet_operator" => YeetExpression { inner, span }.into(),
            "access_operator" => {
                cursor.child();
                cursor_expect!(cursor, "bracket_open");

                cursor.next();
                let index = Expression::read_cursor(cursor, source)?;

                cursor.next();
                cursor_expect!(cursor, "bracket_close");

                cursor.goto_parent();
                AccessExpression {
                    base: inner,
                    index,
                    span,
                }
                .into()
            }
            unknown => unreachable!("Unknown postfix operator: {unknown}"),
        };
        cursor.goto_parent();

        cursor.goto_parent();
        Ok(res)
    }
}

impl ReadCursor for ElseExpression {
    fn read_cursor(cursor: &mut TreeCursor<'_>, source: &str) -> Result<Self, AstError> {
        cursor_expect!(cursor, "else_expression");

        cursor.child();
        let receiver = Expression::read_cursor(cursor, source)?.into();

        cursor.next();
        cursor_expect!(cursor, "else_keyword");

        cursor.next();
        let mut parameter = Vec::new();
        if cursor.kind()? == "pipe" {
            cursor_expect!(cursor, "pipe");
            cursor.next();
            while cursor.kind()? == "closure_argument" {
                parameter.push(ClosureParameter::read_cursor(cursor, source)?);
                cursor.next();
                while cursor.kind()? == "," {
                    cursor.next();
                }
            }

            cursor_expect!(cursor, "pipe");
        }

        cursor.next();
        let body = Body::read_cursor(cursor, source)?;
        let body_span = body.span;
        let block = Block {
            body,
            span: body_span,
        };

        cursor.goto_parent();
        Ok(ElseExpression {
            receiver,
            block,
            parameters: parameter,
        })
    }
}