valkyrie-ast 0.1.12

Strong typed abstract syntax tree of valkyrie 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

use super::*;
use core::fmt::Debug;

impl Debug for StatementKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Nothing => f.write_str("Statement::Nothing"),
            Self::Document(node) => Debug::fmt(node, f),
            Self::Annotation(node) => Debug::fmt(node, f),
            Self::Namespace(node) => Debug::fmt(node, f),
            Self::Import(node) => Debug::fmt(node, f),
            Self::Class(node) => Debug::fmt(node, f),
            Self::Union(node) => Debug::fmt(node, f),
            Self::Enumerate(node) => Debug::fmt(node, f),
            Self::Trait(node) => Debug::fmt(node, f),
            Self::Extends(node) => Debug::fmt(node, f),
            Self::Function(node) => Debug::fmt(node, f),
            Self::Variable(node) => Debug::fmt(node, f),
            Self::While(node) => Debug::fmt(node, f),
            Self::For(node) => Debug::fmt(node, f),
            Self::Guard(node) => Debug::fmt(node, f),
            Self::Control(node) => Debug::fmt(node, f),
            Self::Expression(node) => Debug::fmt(&node.body, f),
        }
    }
}

#[cfg(feature = "pretty-print")]
impl PrettyPrint for StatementKind {
    fn pretty(&self, theme: &PrettyProvider) -> PrettyTree {
        match self {
            Self::Nothing => ";;".into(),
            Self::Annotation(node) => node.pretty(theme),
            Self::Namespace(node) => node.pretty(theme),
            Self::Import(node) => node.pretty(theme),
            Self::Class(node) => node.pretty(theme),
            Self::Tagged(node) => node.pretty(theme),
            Self::Variant(node) => node.pretty(theme),
            Self::Union(node) => node.pretty(theme),
            Self::UnionField(node) => node.pretty(theme),
            Self::Enumerate(node) => node.pretty(theme),
            Self::EnumerateField(node) => node.pretty(theme),
            Self::Function(node) => node.pretty(theme),
            Self::While(node) => node.pretty(theme),
            Self::For(node) => node.pretty(theme),
            Self::Expression(node) => node.pretty(theme),
            Self::Control(node) => node.pretty(theme),
            Self::Document(node) => node.pretty(theme),
            Self::Variable(node) => node.pretty(theme),
            Self::Guard(node) => node.pretty(theme),
            Self::Flags(node) => node.pretty(theme),
            Self::Trait(node) => node.pretty(theme),
            Self::Extends(node) => node.pretty(theme),
        }
    }
}

#[cfg(feature = "lispify")]
impl Lispify for StatementKind {
    type Output = Lisp;

    fn lispify(&self) -> Self::Output {
        match self {
            Self::Nothing => Lisp::default(),
            Self::Namespace(v) => v.lispify(),
            Self::Import(v) => todo!(),
            Self::While(v) => v.lispify(),
            Self::For(v) => v.lispify(),
            Self::Class(v) => v.lispify(),
            Self::Expression(v) => v.lispify(),
            Self::Function(v) => v.lispify(),
            Self::Control(v) => todo!(),
            Self::Document(v) => todo!(),
            Self::Variable(v) => todo!(),
            Self::Guard(v) => v.lispify(),
            Self::Flags(v) => v.lispify(),
            Self::EnumerateField(v) => todo!(),
            Self::Tagged(v) => todo!(),
            Self::Variant(v) => todo!(),
            Self::Union(v) => v.lispify(),
            Self::Enumerate(v) => todo!(),
            Self::UnionField(v) => todo!(),
            Self::Annotation(v) => todo!(),
            Self::Trait(v) => v.lispify(),
            Self::Extends(v) => v.lispify(),
        }
    }
}