Skip to content

Commit 8c9757c

Browse files
JonathanBrouwerJonathanBrouwer
authored
Merge pull request #13 from binary-banter/cleanup
Cleanup
2 parents 6a4fe77 + bc1c5a3 commit 8c9757c

File tree

3 files changed

+52
-57
lines changed

3 files changed

+52
-57
lines changed

‎compiler/src/lib.rs

+2-6
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,15 @@
11
#![allow(clippy::module_inception)]
22

3-
extern crate core;
4-
53
pub mod interpreter;
64
pub mod passes;
75
pub mod utils;
86

97
use crate::passes::parse::parse::parse_program;
10-
use miette::{NamedSource, Report};
8+
use miette::{IntoDiagnostic, NamedSource, Report};
119
use std::fs::File;
1210
use std::path::Path;
1311

1412
pub fn compile(program: &str, filename: &str, output: &Path) -> miette::Result<()> {
15-
let mut file = File::create(output).unwrap();
16-
1713
let add_source =
1814
|error| Report::with_source_code(error, NamedSource::new(filename, program.to_string()));
1915

@@ -32,7 +28,7 @@ pub fn compile(program: &str, filename: &str, output: &Path) -> miette::Result<(
3228
.patch()
3329
.conclude()
3430
.emit()
35-
.write(&mut file);
31+
.write(&mut File::create(output).into_diagnostic()?);
3632

3733
Ok(())
3834
}

‎compiler/src/passes/parse/grammar.lalrpop

+49-50
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,8 @@
11
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,
33
};
44
use crate::passes::validate::partial_type::PartialType;
55
use functor_derive::Functor;
6-
use crate::passes::parse::Spanned;
76

87
grammar;
98

@@ -93,20 +92,20 @@ pub Program: PrgParsed<'input> = {
9392
}
9493
}
9594

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 {
9897
sym,
9998
def: TypeDef::Struct { fields },
10099
},
101-
"enum" <sym:Ident> "{" <variants:Comma<(<Ident> ":" <Type>)>> "}" => Def::TypeDef {
100+
"enum" <sym:Ident> "{" <variants:Comma<(<Ident> ":" <Type>)>> "}" => DefParsed::TypeDef {
102101
sym,
103102
def: TypeDef::Enum { variants },
104103
},
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 {
106105
sym,
107106
params,
108107
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 })),
110109
},
111110
}
112111

@@ -143,76 +142,76 @@ Type: Type<Spanned<&'input str>> = {
143142
// Num/Bool/Ident
144143
Expr = ExprStmt;
145144

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 {
148147
sym,
149148
mutable: mutable.is_some(),
150149
typ,
151150
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 }))),
153152
},
154-
<stmt:Spanned<ExprInStmt>> ";" <cnt:Spanned<ExprStmt?>> => Expr::Seq {
153+
<stmt:Spanned<ExprInStmt>> ";" <cnt:Spanned<ExprStmt?>> => ExprParsed::Seq {
155154
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 }))),
157156
},
158157
ExprInStmt,
159158
}
160159

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 {
163162
sym,
164163
bnd: Box::new(bnd),
165164
},
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 {
167166
cnd: Box::new(cnd),
168167
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 }})),
170169
},
171-
"loop" "{" <bdy:Spanned<Expr>> "}" => Expr::Loop {
170+
"loop" "{" <bdy:Spanned<Expr>> "}" => ExprParsed::Loop {
172171
bdy: Box::new(bdy),
173172
},
174173
// 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 {
176175
bdy: Box::new(Meta {
177176
meta: (l, r - l),
178-
inner: Expr::If {
177+
inner: ExprParsed::If {
179178
cnd: Box::new(cnd),
180179
thn: Box::new(bdy),
181180
els: Box::new(Meta {
182181
meta: (l, r - l),
183-
inner: Expr::Seq {
182+
inner: ExprParsed::Seq {
184183
stmt: Box::new(Meta {
185184
meta: (l, r - l),
186-
inner: Expr::Break { bdy: Box::new(Meta {
185+
inner: ExprParsed::Break { bdy: Box::new(Meta {
187186
meta: (l, r - l),
188-
inner: Expr::Lit { val: Lit::Unit },
187+
inner: ExprParsed::Lit { val: Lit::Unit },
189188
})},
190189
}),
191190
cnt: Box::new(Meta {
192191
meta: (l, r - l),
193-
inner: Expr::Lit { val: Lit::Unit },
192+
inner: ExprParsed::Lit { val: Lit::Unit },
194193
}),
195194
},
196195
}),
197196
},
198197
}),
199198
},
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 {
201200
enm: Box::new(enm),
202201
arms: arms.into_iter().map(|(s1, s2, e)| (s1, s2, Box::new(e))).collect(),
203202
},
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 }))),
206205
},
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 }))),
209208
},
210-
"continue" => Expr::Continue,
209+
"continue" => ExprParsed::Continue,
211210
ExprLogicalOr<Struct>,
212211
}
213212

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 {
216215
op,
217216
exprs: [Box::new(e1), Box::new(e2)],
218217
},
@@ -251,53 +250,53 @@ UnaryOp: UnaryOp = {
251250
"!" => UnaryOp::Not,
252251
}
253252

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 {
256255
op,
257256
expr: Box::new(e),
258257
},
259258
ExprAccess<T>,
260259
}
261260

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 {
264263
strct: Box::new(strct),
265264
field,
266265
},
267266
ExprCall<T>,
268267
}
269268

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 {
272271
fun: Box::new(fun),
273272
args,
274273
},
275274
ExprAtom<T>,
276275
}
277276

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 {
280279
val: Lit::Int {
281280
val,
282281
typ: None,
283282
},
284283
},
285-
<val:i64> => Expr::Lit {
284+
<val:i64> => ExprParsed::Lit {
286285
val: Lit::Int {
287286
val: val.trim_end_matches("i64"),
288287
typ: Some(PartialType::I64),
289288
},
290289
},
291-
<val:u64> => Expr::Lit {
290+
<val:u64> => ExprParsed::Lit {
292291
val: Lit::Int {
293292
val: val.trim_end_matches("u64"),
294293
typ: Some(PartialType::U64),
295294
},
296295
},
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 {
301300
enum_sym,
302301
variant_sym,
303302
bdy: Box::new(bdy),
@@ -306,19 +305,19 @@ ExprAtom<T>: Expr<Spanned<&'input str>, Spanned<&'input str>, Lit<'input>, Span>
306305
<T>,
307306
}
308307

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 {
311310
sym,
312311
fields,
313312
},
314313
}
315314

316-
StructArg : (Spanned<&'input str>, Spanned<Expr<Spanned<&'input str>, Spanned<&'input str>, Lit<'input>, Span>>) = {
315+
StructArg : (Spanned<&'input str>, Spanned<ExprParsed<'input>>) = {
317316
<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 } })
319318
}
320319

321-
Never: Expr<Spanned<&'input str>, Spanned<&'input str>, Lit<'input>, Span> = {};
320+
Never: ExprParsed<'input> = {};
322321

323322
Ident: Spanned<&'input str> = Spanned<identifier>;
324323

‎compiler/src/passes/validate/constrain/var.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use crate::passes::validate::{CMeta, ExprConstrained};
55
use crate::utils::gen_sym::UniqueSym;
66

77
pub fn constrain_var<'p>(
8-
env: &mut Env<'_, 'p>,
8+
env: &Env<'_, 'p>,
99
span: Span,
1010
sym: Spanned<UniqueSym<'p>>,
1111
) -> Result<Meta<CMeta, ExprConstrained<'p>>, TypeError> {

0 commit comments

Comments
 (0)