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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
pub mod expr;
use expr::*;
pub type Recipe<'a> = Vec<RecipeStmt<'a>>;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RecipeStmt<'a> {
BodyStmt(BodyStmt<'a>),
Fetch {
name: Ident<'a>,
body: Body<'a>,
},
Task {
name: Ident<'a>,
params: Vec<FuncParam<'a>>,
body: Body<'a>,
},
}
impl<'a> RecipeStmt<'a> {
pub fn validate(&self) -> Result<(), ValidationError> {
match self {
RecipeStmt::BodyStmt(stmt) => stmt.validate(),
RecipeStmt::Fetch { name: _, body } => body.validate(),
RecipeStmt::Task {
name: _,
params: _,
body,
} => {
// TODO: Validate params?
body.validate()
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Body<'a>(pub Vec<BodyStmt<'a>>);
impl<'a> Body<'a> {
pub fn validate(&self) -> Result<(), ValidationError> {
for stmt in &self.0 {
stmt.validate()?;
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BodyStmt<'a> {
Assign {
dest: Box<TypedExpr<'a>>,
expr: Box<Expr<'a>>,
},
Expr {
expr: Box<Expr<'a>>,
},
Empty,
}
impl<'a> BodyStmt<'a> {
pub(crate) fn assign(
dest: TypedExpr<'a>,
op: Option<OpBinary>,
swapped: bool,
expr: Expr<'a>,
) -> Self {
let expr = match op {
Some(op) => {
let dest_expr = dest.expr.clone();
if swapped {
Expr::binary(expr, op, dest_expr)
} else {
Expr::binary(dest_expr, op, expr)
}
}
None => expr,
};
BodyStmt::Assign {
dest: Box::new(dest),
expr: Box::new(expr),
}
}
pub fn validate(&self) -> Result<(), ValidationError> {
match self {
BodyStmt::Assign { dest, expr } => {
// TODO: Extend destination validation
dest.expr.validate()?;
expr.validate()
}
BodyStmt::Expr { expr } => expr.validate(),
BodyStmt::Empty => Ok(()),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TypedExpr<'a> {
pub expr: Expr<'a>,
pub typ: Option<Expr<'a>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FuncParam<'a> {
pub name: Ident<'a>,
pub typ: Expr<'a>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Path<'a> {
pub components: Vec<Ident<'a>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Ident<'a> {
pub name: &'a str,
}
#[derive(Debug, Clone, Copy)]
pub enum ValidationError {
DuplicateKey,
NeedsParens,
}
|
