aver/ir/mir/
dump.rs

1//! Textual dump for Core MIR.
2//!
3//! Phase 2b of #252. Renders `MirProgram` / `MirFn` / `MirExpr` /
4//! `MirPattern` as a structured text view suitable for snapshot
5//! tests, pass reports, and the future `aver compile
6//! --emit-ir-after=mir` flag (the flag itself lands together with
7//! Phase 3's first lowering wave — there's no source-of-`MirProgram`
8//! until then).
9//!
10//! Format philosophy:
11//! - **Stable order**: functions sorted by `FnId`, fields by their
12//!   declared order, locals by introduction order. Snapshot tests
13//!   only stay green if every walker visits the same nodes in the
14//!   same sequence.
15//! - **Identity visible**: `FnId`, `TypeId`, `CtorId`, `LocalId`
16//!   all appear in the dump so a reviewer can tell whether the
17//!   lowerer wired references through the identity layer or fell
18//!   back to a string lookup.
19//! - **One concept per line**: each `Let`, each `Match` arm, each
20//!   constructor / record field gets its own line. Wide
21//!   expressions still wrap, but the structural skeleton stays
22//!   line-oriented so `diff` reads cleanly.
23//! - **No span noise by default**: source line numbers would
24//!   churn the snapshots whenever a fixture moves by one line.
25//!   When a future diagnostic consumer needs span output, it can
26//!   call into a richer formatter; the `Display` impl stays
27//!   span-free.
28
29use std::collections::BTreeMap;
30use std::fmt;
31
32use crate::ast::Spanned;
33
34use super::expr::{
35    MirBinOp, MirCall, MirCallee, MirConstruct, MirEffectAnnotation, MirExpr,
36    MirIndependentProduct, MirLet, MirMatch, MirMatchArm, MirPattern, MirProject, MirRecordCreate,
37    MirRecordField, MirRecordUpdate, MirStrPart, MirTailCall,
38};
39use super::program::{MirFn, MirParam, MirProgram};
40
41impl fmt::Display for MirProgram {
42    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
43        writeln!(f, "MirProgram {{")?;
44        // Sort by FnId so dump order is independent of HashMap
45        // iteration order (which would otherwise drift across
46        // platforms + Rust versions).
47        let sorted: BTreeMap<_, _> = self.fns.iter().collect();
48        for (fn_id, mir_fn) in sorted {
49            writeln!(f, "  // FnId({})", fn_id.0)?;
50            write_fn(f, mir_fn, "  ")?;
51        }
52        if !self.modules.is_empty() {
53            writeln!(f, "  modules: [")?;
54            for m in &self.modules {
55                writeln!(f, "    ModuleId({})", m.0)?;
56            }
57            writeln!(f, "  ]")?;
58        }
59        writeln!(f, "}}")
60    }
61}
62
63impl fmt::Display for MirFn {
64    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
65        write_fn(f, self, "")
66    }
67}
68
69fn write_fn(f: &mut fmt::Formatter<'_>, mir_fn: &MirFn, indent: &str) -> fmt::Result {
70    write!(f, "{indent}fn {}(", mir_fn.name)?;
71    for (i, p) in mir_fn.params.iter().enumerate() {
72        if i > 0 {
73            write!(f, ", ")?;
74        }
75        write_param(f, p)?;
76    }
77    writeln!(f, ") -> {} {{", mir_fn.return_type)?;
78    if !mir_fn.effects.is_empty() {
79        write!(f, "{indent}  effects: [")?;
80        for (i, e) in mir_fn.effects.iter().enumerate() {
81            if i > 0 {
82                write!(f, ", ")?;
83            }
84            write_effect(f, e)?;
85        }
86        writeln!(f, "]")?;
87    }
88    write!(f, "{indent}  ")?;
89    write_expr(f, &mir_fn.body, &format!("{indent}  "))?;
90    writeln!(f)?;
91    writeln!(f, "{indent}}}")
92}
93
94fn write_param(f: &mut fmt::Formatter<'_>, p: &MirParam) -> fmt::Result {
95    write!(f, "{}{}: {}", p.local, p.name, p.ty)
96}
97
98fn write_effect(f: &mut fmt::Formatter<'_>, e: &MirEffectAnnotation) -> fmt::Result {
99    write!(f, "{}", e.name)
100}
101
102fn write_expr(f: &mut fmt::Formatter<'_>, expr: &Spanned<MirExpr>, indent: &str) -> fmt::Result {
103    match &expr.node {
104        MirExpr::Literal(lit) => write!(f, "{:?}", lit.node),
105        MirExpr::Local(local) => write!(f, "{}", local.node),
106        MirExpr::FnValue(name) => write!(f, "fn_value({name})"),
107        MirExpr::Let(spanned) => write_let(f, &spanned.node, indent),
108        MirExpr::Call(spanned) => write_call(f, &spanned.node, indent),
109        MirExpr::TailCall(spanned) => write_tail_call(f, &spanned.node, indent),
110        MirExpr::BinOp(spanned) => write_bin_op(f, &spanned.node, indent),
111        MirExpr::Neg(inner) => {
112            write!(f, "-(")?;
113            write_expr(f, inner, indent)?;
114            write!(f, ")")
115        }
116        MirExpr::Match(spanned) => write_match(f, &spanned.node, indent),
117        MirExpr::IfThenElse(spanned) => {
118            let ite = &spanned.node;
119            write!(f, "if ")?;
120            write_expr(f, &ite.cond, indent)?;
121            write!(f, " then ")?;
122            write_expr(f, &ite.then_branch, indent)?;
123            write!(f, " else ")?;
124            write_expr(f, &ite.else_branch, indent)
125        }
126        MirExpr::Construct(spanned) => write_construct(f, &spanned.node, indent),
127        MirExpr::RecordCreate(spanned) => write_record_create(f, &spanned.node, indent),
128        MirExpr::RecordUpdate(spanned) => write_record_update(f, &spanned.node, indent),
129        MirExpr::Project(spanned) => write_project(f, &spanned.node, indent),
130        MirExpr::Try(inner) => {
131            write_expr(f, inner, indent)?;
132            write!(f, "?")
133        }
134        MirExpr::List(items) => write_list_or_tuple(f, "List", items, indent),
135        MirExpr::Tuple(items) => write_list_or_tuple(f, "Tuple", items, indent),
136        MirExpr::MapLiteral(pairs) => write_map_literal(f, pairs, indent),
137        MirExpr::InterpolatedStr(parts) => write_interp_str(f, parts, indent),
138        MirExpr::IndependentProduct(spanned) => write_independent_product(f, &spanned.node, indent),
139        MirExpr::Return(inner) => {
140            write!(f, "return ")?;
141            write_expr(f, inner, indent)
142        }
143    }
144}
145
146fn write_let(f: &mut fmt::Formatter<'_>, let_node: &MirLet, indent: &str) -> fmt::Result {
147    writeln!(f, "let {} =", let_node.binding)?;
148    let inner = format!("{indent}  ");
149    write!(f, "{inner}")?;
150    write_expr(f, &let_node.value, &inner)?;
151    writeln!(f)?;
152    write!(f, "{indent}in ")?;
153    write_expr(f, &let_node.body, indent)
154}
155
156fn write_call(f: &mut fmt::Formatter<'_>, call: &MirCall, indent: &str) -> fmt::Result {
157    match &call.callee {
158        MirCallee::Fn(id) => write!(f, "FnId({}).call(", id.0)?,
159        MirCallee::Builtin(id) => write!(f, "Builtin(#{}).call(", id.0)?,
160        MirCallee::Intrinsic(i) => write!(f, "Intrinsic({i:?}).call(")?,
161        MirCallee::LocalSlot { slot, name, .. } => write!(f, "slot({slot}, {name}).call(")?,
162    }
163    write_args(f, &call.args, indent)?;
164    write!(f, ")")
165}
166
167fn write_tail_call(f: &mut fmt::Formatter<'_>, tc: &MirTailCall, indent: &str) -> fmt::Result {
168    write!(f, "tail FnId({}).call(", tc.target.0)?;
169    write_args(f, &tc.args, indent)?;
170    write!(f, ")")
171}
172
173fn write_args(f: &mut fmt::Formatter<'_>, args: &[Spanned<MirExpr>], indent: &str) -> fmt::Result {
174    for (i, a) in args.iter().enumerate() {
175        if i > 0 {
176            write!(f, ", ")?;
177        }
178        write_expr(f, a, indent)?;
179    }
180    Ok(())
181}
182
183fn write_bin_op(f: &mut fmt::Formatter<'_>, op: &MirBinOp, indent: &str) -> fmt::Result {
184    write!(f, "(")?;
185    write_expr(f, &op.lhs, indent)?;
186    write!(f, " {:?} ", op.op)?;
187    write_expr(f, &op.rhs, indent)?;
188    write!(f, ")")
189}
190
191fn write_match(f: &mut fmt::Formatter<'_>, m: &MirMatch, indent: &str) -> fmt::Result {
192    write!(f, "match ")?;
193    write_expr(f, &m.subject, indent)?;
194    writeln!(f, " {{")?;
195    let arm_indent = format!("{indent}  ");
196    for arm in &m.arms {
197        write_arm(f, arm, &arm_indent)?;
198    }
199    write!(f, "{indent}}}")
200}
201
202fn write_arm(f: &mut fmt::Formatter<'_>, arm: &MirMatchArm, indent: &str) -> fmt::Result {
203    write!(f, "{indent}")?;
204    write_pattern(f, &arm.pattern)?;
205    write!(f, " => ")?;
206    write_expr(f, &arm.body, indent)?;
207    writeln!(f, ",")
208}
209
210fn write_pattern(f: &mut fmt::Formatter<'_>, p: &MirPattern) -> fmt::Result {
211    match p {
212        MirPattern::Wildcard => write!(f, "_"),
213        MirPattern::Literal(lit) => write!(f, "{lit:?}"),
214        MirPattern::Bind(local, _name) => write!(f, "{local}"),
215        MirPattern::EmptyList => write!(f, "[]"),
216        MirPattern::Cons { head, tail, .. } => write!(f, "[{head}, ..{tail}]"),
217        MirPattern::Tuple(items) => {
218            write!(f, "(")?;
219            for (i, sub) in items.iter().enumerate() {
220                if i > 0 {
221                    write!(f, ", ")?;
222                }
223                write_pattern(f, sub)?;
224            }
225            write!(f, ")")
226        }
227        MirPattern::Ctor { ctor, bindings, .. } => {
228            write_ctor(f, *ctor)?;
229            write!(f, "(")?;
230            for (i, b) in bindings.iter().enumerate() {
231                if i > 0 {
232                    write!(f, ", ")?;
233                }
234                write!(f, "{b}")?;
235            }
236            write!(f, ")")
237        }
238    }
239}
240
241fn write_construct(f: &mut fmt::Formatter<'_>, c: &MirConstruct, indent: &str) -> fmt::Result {
242    write_ctor(f, c.ctor)?;
243    write!(f, "(")?;
244    write_args(f, &c.args, indent)?;
245    write!(f, ")")
246}
247
248fn write_ctor(f: &mut fmt::Formatter<'_>, ctor: super::MirCtor) -> fmt::Result {
249    match ctor {
250        super::MirCtor::User(id) => write!(f, "CtorId({})", id.0),
251        super::MirCtor::Builtin(b) => match b {
252            super::BuiltinCtor::ResultOk => write!(f, "Result.Ok"),
253            super::BuiltinCtor::ResultErr => write!(f, "Result.Err"),
254            super::BuiltinCtor::OptionSome => write!(f, "Option.Some"),
255            super::BuiltinCtor::OptionNone => write!(f, "Option.None"),
256        },
257    }
258}
259
260fn write_record_create(
261    f: &mut fmt::Formatter<'_>,
262    r: &MirRecordCreate,
263    indent: &str,
264) -> fmt::Result {
265    match r.type_id {
266        Some(id) => write!(f, "TypeId({}) {{ ", id.0)?,
267        None => write!(f, "{} {{ ", r.type_name)?,
268    }
269    write_fields(f, &r.fields, indent)?;
270    write!(f, " }}")
271}
272
273fn write_record_update(
274    f: &mut fmt::Formatter<'_>,
275    r: &MirRecordUpdate,
276    indent: &str,
277) -> fmt::Result {
278    match r.type_id {
279        Some(id) => write!(f, "TypeId({}).update(", id.0)?,
280        None => write!(f, "{}.update(", r.type_name)?,
281    }
282    write_expr(f, &r.base, indent)?;
283    write!(f, ", ")?;
284    write_fields(f, &r.updates, indent)?;
285    write!(f, ")")
286}
287
288fn write_fields(
289    f: &mut fmt::Formatter<'_>,
290    fields: &[MirRecordField],
291    indent: &str,
292) -> fmt::Result {
293    for (i, field) in fields.iter().enumerate() {
294        if i > 0 {
295            write!(f, ", ")?;
296        }
297        write!(f, "{} = ", field.name)?;
298        write_expr(f, &field.value, indent)?;
299    }
300    Ok(())
301}
302
303fn write_project(f: &mut fmt::Formatter<'_>, p: &MirProject, indent: &str) -> fmt::Result {
304    write_expr(f, &p.base, indent)?;
305    write!(f, ".{}", p.field)
306}
307
308fn write_list_or_tuple(
309    f: &mut fmt::Formatter<'_>,
310    tag: &str,
311    items: &[Spanned<MirExpr>],
312    indent: &str,
313) -> fmt::Result {
314    write!(f, "{tag}[")?;
315    write_args(f, items, indent)?;
316    write!(f, "]")
317}
318
319fn write_map_literal(
320    f: &mut fmt::Formatter<'_>,
321    pairs: &[(Spanned<MirExpr>, Spanned<MirExpr>)],
322    indent: &str,
323) -> fmt::Result {
324    write!(f, "Map{{")?;
325    for (i, (k, v)) in pairs.iter().enumerate() {
326        if i > 0 {
327            write!(f, ", ")?;
328        }
329        write_expr(f, k, indent)?;
330        write!(f, " => ")?;
331        write_expr(f, v, indent)?;
332    }
333    write!(f, "}}")
334}
335
336fn write_interp_str(f: &mut fmt::Formatter<'_>, parts: &[MirStrPart], indent: &str) -> fmt::Result {
337    write!(f, "\"")?;
338    for part in parts {
339        match part {
340            MirStrPart::Literal(s) => write!(f, "{}", s.replace('"', "\\\""))?,
341            MirStrPart::Expr(e) => {
342                write!(f, "{{")?;
343                write_expr(f, e, indent)?;
344                write!(f, "}}")?;
345            }
346        }
347    }
348    write!(f, "\"")
349}
350
351fn write_independent_product(
352    f: &mut fmt::Formatter<'_>,
353    ip: &MirIndependentProduct,
354    indent: &str,
355) -> fmt::Result {
356    write!(f, "(")?;
357    write_args(f, &ip.items, indent)?;
358    if ip.unwrap_results {
359        write!(f, ")?!")
360    } else {
361        write!(f, ")!")
362    }
363}
364
365// `LocalId`'s `Display` impl lives in `program.rs` — search for it
366// there. The format (`%N`) is shared by both this dump and any
367// future pass-report code that consumes the same IDs.
aver/ir/mir/dump.rs

aver/ir/mir/
dump.rs
