1use crate::syntax::*;
5use std::fmt::Write;
6
7pub fn print_program(program: &Program) -> String {
8 let mut p = Printer::new();
9 p.program(program);
10 p.out
11}
12
13struct Printer {
14 out: String,
15 indent: usize,
16}
17
18impl Printer {
19 fn new() -> Self { Self { out: String::new(), indent: 0 } }
20
21 fn write_indent(&mut self) {
22 for _ in 0..self.indent {
23 self.out.push_str(" ");
24 }
25 }
26
27 fn nl(&mut self) {
28 self.out.push('\n');
29 }
30
31 fn program(&mut self, p: &Program) {
32 for (i, item) in p.items.iter().enumerate() {
33 if i > 0 { self.nl(); }
34 self.item(item);
35 }
36 if !p.items.is_empty() {
37 self.nl();
38 }
39 }
40
41 fn item(&mut self, item: &Item) {
42 match item {
43 Item::Import(i) => {
44 writeln!(self.out, "import \"{}\" as {}", i.reference, i.alias).unwrap();
45 }
46 Item::TypeDecl(td) => self.type_decl(td),
47 Item::FnDecl(fd) => self.fn_decl(fd),
48 }
49 }
50
51 fn type_decl(&mut self, td: &TypeDecl) {
52 write!(self.out, "type {}", td.name).unwrap();
53 if !td.params.is_empty() {
54 write!(self.out, "[{}]", td.params.join(", ")).unwrap();
55 }
56 write!(self.out, " = ").unwrap();
57 self.type_expr(&td.definition);
58 self.nl();
59 }
60
61 fn fn_decl(&mut self, fd: &FnDecl) {
62 write!(self.out, "fn {}", fd.name).unwrap();
63 if !fd.type_params.is_empty() {
64 write!(self.out, "[{}]", fd.type_params.join(", ")).unwrap();
65 }
66 write!(self.out, "(").unwrap();
67 for (i, p) in fd.params.iter().enumerate() {
68 if i > 0 { write!(self.out, ", ").unwrap(); }
69 write!(self.out, "{} :: ", p.name).unwrap();
70 self.type_expr(&p.ty);
71 }
72 write!(self.out, ") -> ").unwrap();
73 self.effects(&fd.effects);
74 self.type_expr(&fd.return_type);
75 write!(self.out, " ").unwrap();
76 self.block(&fd.body);
77 self.nl();
78 }
79
80 fn effects(&mut self, effects: &[Effect]) {
81 if effects.is_empty() { return; }
82 write!(self.out, "[").unwrap();
83 for (i, e) in effects.iter().enumerate() {
84 if i > 0 { write!(self.out, ", ").unwrap(); }
85 write!(self.out, "{}", e.name).unwrap();
86 if let Some(arg) = &e.arg {
87 match arg {
88 EffectArg::Str(s) => write!(self.out, "(\"{}\")", s).unwrap(),
89 EffectArg::Int(n) => write!(self.out, "({})", n).unwrap(),
90 EffectArg::Ident(s) => write!(self.out, "({})", s).unwrap(),
91 }
92 }
93 }
94 write!(self.out, "] ").unwrap();
95 }
96
97 fn type_expr(&mut self, t: &TypeExpr) {
98 match t {
99 TypeExpr::Named { name, args } => {
100 write!(self.out, "{}", name).unwrap();
101 if !args.is_empty() {
102 write!(self.out, "[").unwrap();
103 for (i, a) in args.iter().enumerate() {
104 if i > 0 { write!(self.out, ", ").unwrap(); }
105 self.type_expr(a);
106 }
107 write!(self.out, "]").unwrap();
108 }
109 }
110 TypeExpr::Record(fs) => {
111 write!(self.out, "{{ ").unwrap();
112 for (i, f) in fs.iter().enumerate() {
113 if i > 0 { write!(self.out, ", ").unwrap(); }
114 write!(self.out, "{} :: ", f.name).unwrap();
115 self.type_expr(&f.ty);
116 }
117 write!(self.out, " }}").unwrap();
118 }
119 TypeExpr::Tuple(items) => {
120 write!(self.out, "(").unwrap();
121 for (i, it) in items.iter().enumerate() {
122 if i > 0 { write!(self.out, ", ").unwrap(); }
123 self.type_expr(it);
124 }
125 write!(self.out, ")").unwrap();
126 }
127 TypeExpr::Function { params, effects, ret } => {
128 write!(self.out, "(").unwrap();
129 for (i, p) in params.iter().enumerate() {
130 if i > 0 { write!(self.out, ", ").unwrap(); }
131 self.type_expr(p);
132 }
133 write!(self.out, ") -> ").unwrap();
134 self.effects(effects);
135 self.type_expr(ret);
136 }
137 TypeExpr::Union(variants) => {
138 for (i, v) in variants.iter().enumerate() {
139 if i > 0 { write!(self.out, " | ").unwrap(); }
140 write!(self.out, "{}", v.name).unwrap();
141 if let Some(payload) = &v.payload {
142 write!(self.out, "(").unwrap();
143 self.type_expr(payload);
144 write!(self.out, ")").unwrap();
145 }
146 }
147 }
148 }
149 }
150
151 fn block(&mut self, b: &Block) {
152 write!(self.out, "{{").unwrap();
153 self.indent += 1;
154 for stmt in &b.statements {
155 self.nl();
156 self.write_indent();
157 self.statement(stmt);
158 }
159 self.nl();
160 self.write_indent();
161 self.expr(&b.result);
162 self.indent -= 1;
163 self.nl();
164 self.write_indent();
165 write!(self.out, "}}").unwrap();
166 }
167
168 fn statement(&mut self, s: &Statement) {
169 match s {
170 Statement::Let { name, ty, value } => {
171 write!(self.out, "let {}", name).unwrap();
172 if let Some(ty) = ty {
173 write!(self.out, " :: ").unwrap();
174 self.type_expr(ty);
175 }
176 write!(self.out, " := ").unwrap();
177 self.expr(value);
178 }
179 Statement::Expr(e) => self.expr(e),
180 }
181 }
182
183 fn expr(&mut self, e: &Expr) {
184 self.expr_prec(e, 0);
185 }
186
187 fn expr_prec(&mut self, e: &Expr, parent_prec: u8) {
188 match e {
189 Expr::Lit(l) => self.literal(l),
190 Expr::Var(n) => { write!(self.out, "{}", n).unwrap(); }
191 Expr::Block(b) => self.block(b),
192 Expr::Call { callee, args } => {
193 self.expr_prec(callee, 100);
194 write!(self.out, "(").unwrap();
195 for (i, a) in args.iter().enumerate() {
196 if i > 0 { write!(self.out, ", ").unwrap(); }
197 self.expr(a);
198 }
199 write!(self.out, ")").unwrap();
200 }
201 Expr::Pipe { left, right } => {
202 if parent_prec > 0 { write!(self.out, "(").unwrap(); }
203 self.expr_prec(left, 1);
204 write!(self.out, " |> ").unwrap();
205 self.expr_prec(right, 1);
206 if parent_prec > 0 { write!(self.out, ")").unwrap(); }
207 }
208 Expr::Try(inner) => {
209 self.expr_prec(inner, 100);
210 write!(self.out, "?").unwrap();
211 }
212 Expr::Field { value, field } => {
213 self.expr_prec(value, 100);
214 write!(self.out, ".{}", field).unwrap();
215 }
216 Expr::BinOp { op, lhs, rhs } => {
217 let prec = op.precedence() + 10;
218 if parent_prec > prec { write!(self.out, "(").unwrap(); }
219 self.expr_prec(lhs, prec);
220 write!(self.out, " {} ", op.as_str()).unwrap();
221 self.expr_prec(rhs, prec + 1);
222 if parent_prec > prec { write!(self.out, ")").unwrap(); }
223 }
224 Expr::UnaryOp { op, expr } => {
225 let s = match op { UnaryOp::Neg => "-", UnaryOp::Not => "not " };
226 write!(self.out, "{}", s).unwrap();
227 self.expr_prec(expr, 100);
228 }
229 Expr::If { cond, then_block, else_block } => {
230 write!(self.out, "if ").unwrap();
231 self.expr(cond);
232 write!(self.out, " ").unwrap();
233 self.block(then_block);
234 write!(self.out, " else ").unwrap();
235 self.block(else_block);
236 }
237 Expr::Match { scrutinee, arms } => {
238 write!(self.out, "match ").unwrap();
239 self.expr(scrutinee);
240 write!(self.out, " {{").unwrap();
241 self.indent += 1;
242 for arm in arms {
243 self.nl();
244 self.write_indent();
245 self.pattern(&arm.pattern);
246 write!(self.out, " => ").unwrap();
247 self.expr(&arm.body);
248 write!(self.out, ",").unwrap();
249 }
250 self.indent -= 1;
251 self.nl();
252 self.write_indent();
253 write!(self.out, "}}").unwrap();
254 }
255 Expr::RecordLit(fields) => {
256 write!(self.out, "{{ ").unwrap();
257 for (i, f) in fields.iter().enumerate() {
258 if i > 0 { write!(self.out, ", ").unwrap(); }
259 write!(self.out, "{}: ", f.name).unwrap();
260 self.expr(&f.value);
261 }
262 write!(self.out, " }}").unwrap();
263 }
264 Expr::TupleLit(items) => {
265 write!(self.out, "(").unwrap();
266 for (i, it) in items.iter().enumerate() {
267 if i > 0 { write!(self.out, ", ").unwrap(); }
268 self.expr(it);
269 }
270 write!(self.out, ")").unwrap();
271 }
272 Expr::ListLit(items) => {
273 write!(self.out, "[").unwrap();
274 for (i, it) in items.iter().enumerate() {
275 if i > 0 { write!(self.out, ", ").unwrap(); }
276 self.expr(it);
277 }
278 write!(self.out, "]").unwrap();
279 }
280 Expr::Constructor { name, args } => {
281 write!(self.out, "{}", name).unwrap();
282 if !args.is_empty() {
283 write!(self.out, "(").unwrap();
284 for (i, a) in args.iter().enumerate() {
285 if i > 0 { write!(self.out, ", ").unwrap(); }
286 self.expr(a);
287 }
288 write!(self.out, ")").unwrap();
289 }
290 }
291 Expr::Lambda(l) => {
292 write!(self.out, "fn (").unwrap();
293 for (i, p) in l.params.iter().enumerate() {
294 if i > 0 { write!(self.out, ", ").unwrap(); }
295 write!(self.out, "{} :: ", p.name).unwrap();
296 self.type_expr(&p.ty);
297 }
298 write!(self.out, ") -> ").unwrap();
299 self.effects(&l.effects);
300 self.type_expr(&l.return_type);
301 write!(self.out, " ").unwrap();
302 self.block(&l.body);
303 }
304 }
305 }
306
307 fn literal(&mut self, l: &Literal) {
308 match l {
309 Literal::Int(n) => write!(self.out, "{}", n).unwrap(),
310 Literal::Float(n) => write!(self.out, "{}", format_float(*n)).unwrap(),
311 Literal::Str(s) => write!(self.out, "\"{}\"", escape(s)).unwrap(),
312 Literal::Bytes(b) => {
313 write!(self.out, "b\"").unwrap();
314 for &c in b {
315 if c.is_ascii() && (c as char).is_ascii_graphic() && c != b'"' && c != b'\\' {
316 self.out.push(c as char);
317 } else {
318 write!(self.out, "\\x{:02x}", c).unwrap();
319 }
320 }
321 write!(self.out, "\"").unwrap();
322 }
323 Literal::Bool(b) => write!(self.out, "{}", b).unwrap(),
324 Literal::Unit => write!(self.out, "()").unwrap(),
325 }
326 }
327
328 fn pattern(&mut self, p: &Pattern) {
329 match p {
330 Pattern::Lit(l) => self.literal(l),
331 Pattern::Var(n) => { write!(self.out, "{}", n).unwrap(); }
332 Pattern::Wild => { write!(self.out, "_").unwrap(); }
333 Pattern::Constructor { name, args } => {
334 write!(self.out, "{}", name).unwrap();
335 if !args.is_empty() {
336 write!(self.out, "(").unwrap();
337 for (i, a) in args.iter().enumerate() {
338 if i > 0 { write!(self.out, ", ").unwrap(); }
339 self.pattern(a);
340 }
341 write!(self.out, ")").unwrap();
342 }
343 }
344 Pattern::Record { fields, rest: _ } => {
345 write!(self.out, "{{ ").unwrap();
346 for (i, f) in fields.iter().enumerate() {
347 if i > 0 { write!(self.out, ", ").unwrap(); }
348 write!(self.out, "{}", f.name).unwrap();
349 if let Some(p) = &f.pattern {
350 write!(self.out, ": ").unwrap();
351 self.pattern(p);
352 }
353 }
354 write!(self.out, " }}").unwrap();
355 }
356 Pattern::Tuple(items) => {
357 write!(self.out, "(").unwrap();
358 for (i, it) in items.iter().enumerate() {
359 if i > 0 { write!(self.out, ", ").unwrap(); }
360 self.pattern(it);
361 }
362 write!(self.out, ")").unwrap();
363 }
364 }
365 }
366}
367
368fn escape(s: &str) -> String {
369 let mut out = String::with_capacity(s.len());
370 for c in s.chars() {
371 match c {
372 '\\' => out.push_str("\\\\"),
373 '"' => out.push_str("\\\""),
374 '\n' => out.push_str("\\n"),
375 '\t' => out.push_str("\\t"),
376 '\r' => out.push_str("\\r"),
377 c => out.push(c),
378 }
379 }
380 out
381}
382
383fn format_float(n: f64) -> String {
384 if n.is_finite() && n == n.trunc() {
385 format!("{:.1}", n)
386 } else {
387 format!("{}", n)
388 }
389}