1
1
use crate::passes::parse::{
2
- BinaryOp, Def, Expr , Lit, Meta, Param, PrgParsed, Span , Type, TypeDef, UnaryOp,
2
+ BinaryOp, DefParsed, ExprParsed , Lit, Meta, Param, PrgParsed, Spanned , Type, TypeDef, UnaryOp,
3
3
};
4
4
use crate::passes::validate::partial_type::PartialType;
5
5
use functor_derive::Functor;
6
- use crate::passes::parse::Spanned;
7
6
8
7
grammar;
9
8
@@ -93,20 +92,20 @@ pub Program: PrgParsed<'input> = {
93
92
}
94
93
}
95
94
96
- Def: Def<Spanned<& 'input str>, Spanned<&'input str>, Spanned<Expr<Spanned<&'input str>, Spanned<&'input str>, Lit<'input>, Span>> > = {
97
- "struct" <sym:Ident> "{" <fields:Comma<(<Ident> ":" <Type>)>> "}" => Def ::TypeDef {
95
+ Def: DefParsed< 'input> = {
96
+ "struct" <sym:Ident> "{" <fields:Comma<(<Ident> ":" <Type>)>> "}" => DefParsed ::TypeDef {
98
97
sym,
99
98
def: TypeDef::Struct { fields },
100
99
},
101
- "enum" <sym:Ident> "{" <variants:Comma<(<Ident> ":" <Type>)>> "}" => Def ::TypeDef {
100
+ "enum" <sym:Ident> "{" <variants:Comma<(<Ident> ":" <Type>)>> "}" => DefParsed ::TypeDef {
102
101
sym,
103
102
def: TypeDef::Enum { variants },
104
103
},
105
- "fn" <sym:Ident> "(" <params:Comma<Param>> ")" <typ:("->" <Type>)?> "{" <bdy: Spanned<Expr?>> "}" => Def ::Fn {
104
+ "fn" <sym:Ident> "(" <params:Comma<Param>> ")" <typ:("->" <Type>)?> "{" <bdy: Spanned<Expr?>> "}" => DefParsed ::Fn {
106
105
sym,
107
106
params,
108
107
typ: typ.unwrap_or(Type::Unit),
109
- bdy: bdy.fmap(|bdy| bdy.unwrap_or(Expr ::Lit { val: Lit::Unit })),
108
+ bdy: bdy.fmap(|bdy| bdy.unwrap_or(ExprParsed ::Lit { val: Lit::Unit })),
110
109
},
111
110
}
112
111
@@ -143,76 +142,76 @@ Type: Type<Spanned<&'input str>> = {
143
142
// Num/Bool/Ident
144
143
Expr = ExprStmt;
145
144
146
- ExprStmt: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
147
- "let" <mutable:"mut"?> <sym:Ident> <typ:(":" <Type>)?> "=" <bnd:Spanned<ExprLogicalOr<Struct>>> ";" <bdy:Spanned<ExprStmt?>> => Expr ::Let {
145
+ ExprStmt: ExprParsed< 'input> = {
146
+ "let" <mutable:"mut"?> <sym:Ident> <typ:(":" <Type>)?> "=" <bnd:Spanned<ExprLogicalOr<Struct>>> ";" <bdy:Spanned<ExprStmt?>> => ExprParsed ::Let {
148
147
sym,
149
148
mutable: mutable.is_some(),
150
149
typ,
151
150
bnd: Box::new(bnd),
152
- bdy: Box::new(bdy.fmap(|bdy| bdy.unwrap_or(Expr ::Lit { val: Lit::Unit }))),
151
+ bdy: Box::new(bdy.fmap(|bdy| bdy.unwrap_or(ExprParsed ::Lit { val: Lit::Unit }))),
153
152
},
154
- <stmt:Spanned<ExprInStmt>> ";" <cnt:Spanned<ExprStmt?>> => Expr ::Seq {
153
+ <stmt:Spanned<ExprInStmt>> ";" <cnt:Spanned<ExprStmt?>> => ExprParsed ::Seq {
155
154
stmt: Box::new(stmt),
156
- cnt: Box::new(cnt.fmap(|cnt| cnt.unwrap_or(Expr ::Lit { val: Lit::Unit }))),
155
+ cnt: Box::new(cnt.fmap(|cnt| cnt.unwrap_or(ExprParsed ::Lit { val: Lit::Unit }))),
157
156
},
158
157
ExprInStmt,
159
158
}
160
159
161
- ExprInStmt: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
162
- <sym:Ident> "=" <bnd:Spanned<ExprLogicalOr<Struct>>> => Expr ::Assign {
160
+ ExprInStmt: ExprParsed< 'input> = {
161
+ <sym:Ident> "=" <bnd:Spanned<ExprLogicalOr<Struct>>> => ExprParsed ::Assign {
163
162
sym,
164
163
bnd: Box::new(bnd),
165
164
},
166
- "if" <cnd:Spanned<ExprLogicalOr<Never>>> "{" <thn:Spanned<Expr>> "}" <l:@L> <els:("else" "{" <Spanned<Expr>> "}")?> <r:@R> => Expr ::If {
165
+ "if" <cnd:Spanned<ExprLogicalOr<Never>>> "{" <thn:Spanned<Expr>> "}" <l:@L> <els:("else" "{" <Spanned<Expr>> "}")?> <r:@R> => ExprParsed ::If {
167
166
cnd: Box::new(cnd),
168
167
thn: Box::new(thn),
169
- els: Box::new(els.unwrap_or(Meta { meta: (l, r - l), inner: Expr ::Lit { val: Lit::Unit }})),
168
+ els: Box::new(els.unwrap_or(Meta { meta: (l, r - l), inner: ExprParsed ::Lit { val: Lit::Unit }})),
170
169
},
171
- "loop" "{" <bdy:Spanned<Expr>> "}" => Expr ::Loop {
170
+ "loop" "{" <bdy:Spanned<Expr>> "}" => ExprParsed ::Loop {
172
171
bdy: Box::new(bdy),
173
172
},
174
173
// todo: the spans in this desugaring do not make a lot sense.
175
- <l:@L> "while" <r:@R> <cnd:Spanned<ExprLogicalOr<Never>>> "{" <bdy:Spanned<Expr>> "}" => Expr ::Loop {
174
+ <l:@L> "while" <r:@R> <cnd:Spanned<ExprLogicalOr<Never>>> "{" <bdy:Spanned<Expr>> "}" => ExprParsed ::Loop {
176
175
bdy: Box::new(Meta {
177
176
meta: (l, r - l),
178
- inner: Expr ::If {
177
+ inner: ExprParsed ::If {
179
178
cnd: Box::new(cnd),
180
179
thn: Box::new(bdy),
181
180
els: Box::new(Meta {
182
181
meta: (l, r - l),
183
- inner: Expr ::Seq {
182
+ inner: ExprParsed ::Seq {
184
183
stmt: Box::new(Meta {
185
184
meta: (l, r - l),
186
- inner: Expr ::Break { bdy: Box::new(Meta {
185
+ inner: ExprParsed ::Break { bdy: Box::new(Meta {
187
186
meta: (l, r - l),
188
- inner: Expr ::Lit { val: Lit::Unit },
187
+ inner: ExprParsed ::Lit { val: Lit::Unit },
189
188
})},
190
189
}),
191
190
cnt: Box::new(Meta {
192
191
meta: (l, r - l),
193
- inner: Expr ::Lit { val: Lit::Unit },
192
+ inner: ExprParsed ::Lit { val: Lit::Unit },
194
193
}),
195
194
},
196
195
}),
197
196
},
198
197
}),
199
198
},
200
- "switch" <enm:Spanned<ExprLogicalOr<Never>>> "{" <arms:Comma<(<Ident> "(" <Ident> ")" "=>" <Spanned<Expr>> )>> "}" => Expr ::Switch {
199
+ "switch" <enm:Spanned<ExprLogicalOr<Never>>> "{" <arms:Comma<(<Ident> "(" <Ident> ")" "=>" <Spanned<Expr>> )>> "}" => ExprParsed ::Switch {
201
200
enm: Box::new(enm),
202
201
arms: arms.into_iter().map(|(s1, s2, e)| (s1, s2, Box::new(e))).collect(),
203
202
},
204
- "break" <bdy:Spanned<ExprLogicalOr<Struct>?>> => Expr ::Break {
205
- bdy: Box::new(bdy.fmap(|bdy| bdy.unwrap_or(Expr ::Lit { val: Lit::Unit }))),
203
+ "break" <bdy:Spanned<ExprLogicalOr<Struct>?>> => ExprParsed ::Break {
204
+ bdy: Box::new(bdy.fmap(|bdy| bdy.unwrap_or(ExprParsed ::Lit { val: Lit::Unit }))),
206
205
},
207
- "return" <bdy:Spanned<ExprLogicalOr<Struct>?>> => Expr ::Return {
208
- bdy: Box::new(bdy.fmap(|bdy| bdy.unwrap_or(Expr ::Lit { val: Lit::Unit }))),
206
+ "return" <bdy:Spanned<ExprLogicalOr<Struct>?>> => ExprParsed ::Return {
207
+ bdy: Box::new(bdy.fmap(|bdy| bdy.unwrap_or(ExprParsed ::Lit { val: Lit::Unit }))),
209
208
},
210
- "continue" => Expr ::Continue,
209
+ "continue" => ExprParsed ::Continue,
211
210
ExprLogicalOr<Struct>,
212
211
}
213
212
214
- BinaryOps<Op,Next>: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
215
- <e1:Spanned<BinaryOps<Op,Next>>> <op:Op> <e2:Spanned<Next>> => Expr ::BinaryOp {
213
+ BinaryOps<Op,Next>: ExprParsed< 'input> = {
214
+ <e1:Spanned<BinaryOps<Op,Next>>> <op:Op> <e2:Spanned<Next>> => ExprParsed ::BinaryOp {
216
215
op,
217
216
exprs: [Box::new(e1), Box::new(e2)],
218
217
},
@@ -251,53 +250,53 @@ UnaryOp: UnaryOp = {
251
250
"!" => UnaryOp::Not,
252
251
}
253
252
254
- ExprUnary<T>: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
255
- <op:UnaryOp> <e:Spanned<ExprUnary<T>>> => Expr ::UnaryOp {
253
+ ExprUnary<T>: ExprParsed< 'input> = {
254
+ <op:UnaryOp> <e:Spanned<ExprUnary<T>>> => ExprParsed ::UnaryOp {
256
255
op,
257
256
expr: Box::new(e),
258
257
},
259
258
ExprAccess<T>,
260
259
}
261
260
262
- ExprAccess<T>: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
263
- <strct:Spanned<ExprAccess<T>>> "." <field:Ident> => Expr ::AccessField {
261
+ ExprAccess<T>: ExprParsed< 'input> = {
262
+ <strct:Spanned<ExprAccess<T>>> "." <field:Ident> => ExprParsed ::AccessField {
264
263
strct: Box::new(strct),
265
264
field,
266
265
},
267
266
ExprCall<T>,
268
267
}
269
268
270
- ExprCall<T>: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
271
- <fun:Spanned<ExprAtom<T>>> "(" <args:Comma<Spanned<Expr>>> ")" => Expr ::Apply {
269
+ ExprCall<T>: ExprParsed< 'input> = {
270
+ <fun:Spanned<ExprAtom<T>>> "(" <args:Comma<Spanned<Expr>>> ")" => ExprParsed ::Apply {
272
271
fun: Box::new(fun),
273
272
args,
274
273
},
275
274
ExprAtom<T>,
276
275
}
277
276
278
- ExprAtom<T>: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
279
- <val:integer> => Expr ::Lit {
277
+ ExprAtom<T>: ExprParsed< 'input> = {
278
+ <val:integer> => ExprParsed ::Lit {
280
279
val: Lit::Int {
281
280
val,
282
281
typ: None,
283
282
},
284
283
},
285
- <val:i64> => Expr ::Lit {
284
+ <val:i64> => ExprParsed ::Lit {
286
285
val: Lit::Int {
287
286
val: val.trim_end_matches("i64"),
288
287
typ: Some(PartialType::I64),
289
288
},
290
289
},
291
- <val:u64> => Expr ::Lit {
290
+ <val:u64> => ExprParsed ::Lit {
292
291
val: Lit::Int {
293
292
val: val.trim_end_matches("u64"),
294
293
typ: Some(PartialType::U64),
295
294
},
296
295
},
297
- <val:Bool> => Expr ::Lit { val: Lit::Bool { val } },
298
- "unit" => Expr ::Lit { val: Lit::Unit },
299
- <sym:Ident> => Expr ::Var { sym },
300
- <enum_sym:Ident> "::" <variant_sym:Ident> "(" <bdy:Spanned<Expr>> ")" => Expr ::Variant {
296
+ <val:Bool> => ExprParsed ::Lit { val: Lit::Bool { val } },
297
+ "unit" => ExprParsed ::Lit { val: Lit::Unit },
298
+ <sym:Ident> => ExprParsed ::Var { sym },
299
+ <enum_sym:Ident> "::" <variant_sym:Ident> "(" <bdy:Spanned<Expr>> ")" => ExprParsed ::Variant {
301
300
enum_sym,
302
301
variant_sym,
303
302
bdy: Box::new(bdy),
@@ -306,19 +305,19 @@ ExprAtom<T>: Expr<Spanned<&'input str>, Spanned<&'input str>, Lit<'input>, Span>
306
305
<T>,
307
306
}
308
307
309
- Struct: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {
310
- <sym:Ident> "{" <fields:Comma<StructArg>> "}" => Expr ::Struct {
308
+ Struct: ExprParsed< 'input> = {
309
+ <sym:Ident> "{" <fields:Comma<StructArg>> "}" => ExprParsed ::Struct {
311
310
sym,
312
311
fields,
313
312
},
314
313
}
315
314
316
- StructArg : (Spanned<&'input str>, Spanned<Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span >>) = {
315
+ StructArg : (Spanned<&'input str>, Spanned<ExprParsed< 'input>>) = {
317
316
<Ident> ":" <Spanned<Expr>>,
318
- <l:@L> <sym:Ident> <r:@R> => (sym.clone(), Meta { meta: (l, r - l), inner: Expr ::Var { sym } })
317
+ <l:@L> <sym:Ident> <r:@R> => (sym.clone(), Meta { meta: (l, r - l), inner: ExprParsed ::Var { sym } })
319
318
}
320
319
321
- Never: Expr<Spanned<& 'input str>, Spanned<&'input str>, Lit<'input>, Span > = {};
320
+ Never: ExprParsed< 'input> = {};
322
321
323
322
Ident: Spanned<&'input str> = Spanned<identifier>;
324
323
0 commit comments