radiance · Radiance self-hosting compiler

compiler/ lib/ examples/ std/ arch/ char/ collections/ lang/ alloc/ ast/ printer.rad 23.8 KiB gen/ il/ module/ parser/ resolver/ scanner/ alloc.rad 4.3 KiB ast.rad 23.9 KiB gen.rad 507 B il.rad 15.3 KiB lower.rad 287.8 KiB module.rad 13.5 KiB package.rad 1.2 KiB parser.rad 82.9 KiB resolver.rad 407.8 KiB scanner.rad 18.3 KiB sexpr.rad 6.3 KiB strings.rad 2.2 KiB types.rad 280 B sys/ arch.rad 68 B char.rad 855 B collections.rad 39 B fmt.rad 8.1 KiB intrinsics.rad 467 B io.rad 1.3 KiB lang.rad 276 B mem.rad 2.2 KiB sys.rad 173 B testing.rad 2.4 KiB tests.rad 12.9 KiB vec.rad 1.7 KiB std.rad 281 B scripts/ seed/ sublime/ test/ vim/ .gitignore 336 B .gitsigners 112 B LICENSE 1.1 KiB Makefile 3.7 KiB README 4.8 KiB STYLE 2.5 KiB std.lib 1.2 KiB std.lib.test 347 B
lib/std/lang/ast/printer.rad 23.8 KiB raw
//! AST pretty printer using S-expression syntax.

use std::io;
use std::lang::sexpr;
use std::lang::alloc;
use std::lang::types;

/// Return the symbol for a binary operator.
fn binOpName(op: super::BinaryOp) -> *[u8] {
    match op {
        case super::BinaryOp::Add => return "+",
        case super::BinaryOp::Sub => return "-",
        case super::BinaryOp::Mul => return "*",
        case super::BinaryOp::Div => return "/",
        case super::BinaryOp::Mod => return "%",
        case super::BinaryOp::BitAnd => return "&",
        case super::BinaryOp::BitOr => return "|",
        case super::BinaryOp::BitXor => return "^",
        case super::BinaryOp::Shl => return "<<",
        case super::BinaryOp::Shr => return ">>",
        case super::BinaryOp::Eq => return "==",
        case super::BinaryOp::Ne => return "<>",
        case super::BinaryOp::Lt => return "<",
        case super::BinaryOp::Gt => return ">",
        case super::BinaryOp::Lte => return "<=",
        case super::BinaryOp::Gte => return ">=",
        case super::BinaryOp::And => return "and",
        case super::BinaryOp::Or => return "or",
        case super::BinaryOp::Xor => return "xor",
    }
}

/// Return the symbol for a unary operator.
fn unOpName(op: super::UnaryOp) -> *[u8] {
    match op {
        case super::UnaryOp::Not => return "not",
        case super::UnaryOp::Neg => return "-",
        case super::UnaryOp::BitNot => return "~",
    }
}

/// Return the name for a builtin.
fn builtinName(kind: super::Builtin) -> *[u8] {
    match kind {
        case super::Builtin::SizeOf => return "@sizeOf",
        case super::Builtin::AlignOf => return "@alignOf",
        case super::Builtin::SliceOf => return "@sliceOf",
    }
}

/// Return the name for an integer type.
fn intTypeName(width: u8, sign: super::Signedness) -> *[u8] {
    if let case super::Signedness::Signed = sign {
        match width {
            case 1 => return "i8",
            case 2 => return "i16",
            case 4 => return "i32",
            case 8 => return "i64",
            else => panic,
        }
    } else {
        match width {
            case 1 => return "u8",
            case 2 => return "u16",
            case 4 => return "u32",
            case 8 => return "u64",
            else => panic,
        }
    }
}

/// Return the S-expression head for a pointer class.
fn pointerClassHead(
    class: types::PointerClass,
    ownedHead: *[u8],
    refHead: *[u8],
    unsafeHead: *[u8],
) -> *[u8] {
    match class {
        case types::PointerClass::Owned => return ownedHead,
        case types::PointerClass::Ref => return refHead,
        case types::PointerClass::Unsafe => return unsafeHead,
    }
}

/// Convert a type signature to an S-expression.
fn typeSigToExpr(a: *mut alloc::Arena, sig: super::TypeSig) -> sexpr::Expr {
    match sig {
        case super::TypeSig::Void => return sexpr::sym("void"),
        case super::TypeSig::Opaque => return sexpr::sym("opaque"),
        case super::TypeSig::Bool => return sexpr::sym("bool"),
        case super::TypeSig::Integer { width, sign } => return sexpr::sym(intTypeName(width, sign)),
        case super::TypeSig::Array { itemType, length } =>
            return sexpr::list(a, "array", &[toExpr(a, itemType), toExpr(a, length)]),
        case super::TypeSig::Slice { class, itemType, mutable } => {
            let head = pointerClassHead(class, "slice", "slice-ref", "unsafe-slice");
            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, itemType)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, itemType)]);
        }
        case super::TypeSig::Pointer { class, valueType, mutable } => {
            let head = pointerClassHead(class, "ptr", "ref", "unsafe-ptr");
            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, valueType)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, valueType)]);
        }
        case super::TypeSig::Optional { valueType } =>
            return sexpr::list(a, "?", &[toExpr(a, valueType)]),
        case super::TypeSig::Nominal(name) => return toExpr(a, name),
        case super::TypeSig::Record { fields, .. } =>
            return sexpr::list(a, "record", nodeListToExprs(a, &fields[..])),
        case super::TypeSig::Fn(sig) => {
            let mut ret = sexpr::sym("void");
            if let rt = sig.returnType {
                set ret = toExpr(a, rt);
            }
            return sexpr::list(a, "fn", &[sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..])), ret]);
        }
        case super::TypeSig::TraitObject { class, traitName, mutable } => {
            let head = pointerClassHead(class, "obj", "obj-ref", "unsafe-obj");
            return sexpr::list(a, head, &[sexpr::sym("mut"), toExpr(a, traitName)]) if mutable
                else sexpr::list(a, head, &[toExpr(a, traitName)]);
        }
    }
}

/// Convert a node slice to a slice of expressions.
fn nodeListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {
        set buf[i] = toExpr(a, node);
    }
    return buf;
}

/// Convert optional attributes to an attribute list expression.
fn attributesToExpr(a: *mut alloc::Arena, attrs: ?super::Attributes) -> sexpr::Expr {
    let mut exprs: *[sexpr::Expr] = &[];
    if let list = attrs {
        set exprs = nodeListToExprs(a, &list.list[..]);
    }
    return sexpr::list(a, "attrs", exprs);
}

/// Convert an optional node to an expression, or return placeholder.
fn toExprOpt(a: *mut alloc::Arena, opt: ?*super::Node) -> sexpr::Expr {
    if let n = opt {
        return toExpr(a, n);
    }
    return sexpr::sym("_");
}

/// Convert an optional node to an expression, or return `Null`.
fn toExprOrNull(a: *mut alloc::Arena, opt: ?*super::Node) -> sexpr::Expr {
    if let n = opt {
        return toExpr(a, n);
    }
    return sexpr::Expr::Null;
}

/// Convert an optional guard.
fn guardExpr(a: *mut alloc::Arena, guard: ?*super::Node) -> sexpr::Expr {
    if let g = guard {
        return sexpr::list(a, "guard", &[toExpr(a, g)]);
    }
    return sexpr::Expr::Null;
}

/// Convert a list of match prongs to expressions.
fn prongListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for prong, i in nodes {
        match prong.value {
            case super::NodeValue::MatchProng(p) => {
                set buf[i] = prongToExpr(a, p);
            }
            else => {
                set buf[i] = sexpr::sym("<invalid>");
            }
        }
    }
    return buf;
}

/// Convert a match prong to an S-expression.
fn prongToExpr(a: *mut alloc::Arena, p: super::MatchProng) -> sexpr::Expr {
    match p.arm {
        case super::ProngArm::Case(patterns) => {
            return sexpr::block(a, "case", &[
                sexpr::list(a, "patterns", nodeListToExprs(a, &patterns[..])),
                guardExpr(a, p.guard)
            ], &[toExpr(a, p.body)]);
        }
        case super::ProngArm::Else => {
            return sexpr::block(a, "else", &[guardExpr(a, p.guard)], &[toExpr(a, p.body)]);
        }
        case super::ProngArm::Binding(pat) => {
            if let g = p.guard {
                return sexpr::block(a, "let", &[toExpr(a, pat), guardExpr(a, p.guard)], &[toExpr(a, p.body)]);
            }
            return sexpr::block(a, "bind", &[toExpr(a, pat)], &[toExpr(a, p.body)]);
        }
    }
}

/// Convert a record field declaration to an S-expression.
fn fieldToExpr(
    a: *mut alloc::Arena,
    field: ?*super::Node,
    type: *super::Node,
    value: ?*super::Node
) -> sexpr::Expr {
    return sexpr::list(a, ":", &[toExprOpt(a, field), toExpr(a, type), toExprOrNull(a, value)]);
}

/// Convert a list of record fields to expressions.
fn fieldListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {
        match node.value {
            case super::NodeValue::RecordField { field, type, value } => {
                set buf[i] = fieldToExpr(a, field, type, value);
            }
            else => {
                set buf[i] = sexpr::sym("<invalid>");
            }
        }
    }
    return buf;
}

/// Convert a union variant to an S-expression.
fn variantToExpr(a: *mut alloc::Arena, name: *super::Node, type: ?*super::Node) -> sexpr::Expr {
    return sexpr::list(a, "variant", &[toExpr(a, name), toExprOrNull(a, type)]);
}

/// Convert a list of union variants to expressions.
fn variantListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {
    if nodes.len == 0 {
        return &[];
    }
    let buf = try! sexpr::allocExprs(a, nodes.len as u32);
    for node, i in nodes {
        match node.value {
            case super::NodeValue::UnionDeclVariant(v) => {
                set buf[i] = variantToExpr(a, v.name, v.type);
            }
            else => {
                set buf[i] = sexpr::sym("<invalid>");
            }
        }
    }
    return buf;
}

/// Convert an AST node to an S-expression.
export fn toExpr(a: *mut alloc::Arena, node: *super::Node) -> sexpr::Expr {
    match node.value {
        case super::NodeValue::Placeholder => return sexpr::sym("_"),
        case super::NodeValue::Nil => return sexpr::sym("nil"),
        case super::NodeValue::Undef => return sexpr::sym("undefined"),
        case super::NodeValue::Bool(v) => {
            if v {
                return sexpr::sym("true");
            }
            return sexpr::sym("false");
        }
        case super::NodeValue::Char(c) => return sexpr::Expr::Char(c),
        case super::NodeValue::String(s) => return sexpr::Expr::Str(s),
        case super::NodeValue::Ident(name) => return sexpr::sym(name),
        case super::NodeValue::Number(lit) => return sexpr::sym(lit.text),
        case super::NodeValue::Super => return sexpr::sym("super"),
        case super::NodeValue::Break => return sexpr::list(a, "break", &[]),
        case super::NodeValue::Continue => return sexpr::list(a, "continue", &[]),
        case super::NodeValue::Range(r) =>
            return sexpr::list(a, "range", &[toExprOpt(a, r.start), toExprOpt(a, r.end)]),
        case super::NodeValue::BinOp(b) =>
            return sexpr::list(a, binOpName(b.op), &[toExpr(a, b.left), toExpr(a, b.right)]),
        case super::NodeValue::UnOp(u) =>
            return sexpr::list(a, unOpName(u.op), &[toExpr(a, u.value)]),
        case super::NodeValue::Call(c) => {
            let buf = try! sexpr::allocExprs(a, c.args.len as u32 + 1);
            set buf[0] = toExpr(a, c.callee);
            for arg, i in c.args { set buf[i + 1] = toExpr(a, arg); }
            return sexpr::Expr::List { head: "call", tail: buf, multiline: false };
        }
        case super::NodeValue::BuiltinCall { kind, args } =>
            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),
        case super::NodeValue::Subscript { container, index } =>
            return sexpr::list(a, "[]", &[toExpr(a, container), toExpr(a, index)]),
        case super::NodeValue::GenericApply(app) => {
            let buf = try! sexpr::allocExprs(a, app.args.len as u32 + 1);
            set buf[0] = toExpr(a, app.target);
            for arg, i in app.args { set buf[i + 1] = toExpr(a, arg); }
            return sexpr::Expr::List { head: "apply", tail: buf, multiline: false };
        }
        case super::NodeValue::FieldAccess(acc) =>
            return sexpr::list(a, ".", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
        case super::NodeValue::ScopeAccess(acc) =>
            return sexpr::list(a, "::", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
        case super::NodeValue::AddressOf(addr) =>
            return sexpr::list(a, "&mut", &[toExpr(a, addr.target)]) if addr.mutable
                else sexpr::list(a, "&", &[toExpr(a, addr.target)]),
        case super::NodeValue::Deref(target) =>
            return sexpr::list(a, "deref", &[toExpr(a, target)]),
        case super::NodeValue::As(cast) =>
            return sexpr::list(a, "as", &[toExpr(a, cast.value), toExpr(a, cast.type)]),
        case super::NodeValue::ArrayLit(elems) =>
            return sexpr::list(a, "array", nodeListToExprs(a, &elems[..])),
        case super::NodeValue::ArrayRepeatLit(rep) =>
            return sexpr::list(a, "array-repeat", &[toExpr(a, rep.item), toExpr(a, rep.count)]),
        case super::NodeValue::RecordLit(lit) => {
            let mut total: u32 = lit.fields.len as u32;
            if let _ = lit.typeName {
                set total += 1;
            }
            let buf = try! sexpr::allocExprs(a, total);
            let mut idx: u32 = 0;
            if let tn = lit.typeName {
                set buf[idx] = toExpr(a, tn); set idx = idx + 1;
            }
            for field, i in lit.fields {
                set buf[idx + i] = toExpr(a, field);
            }
            return sexpr::Expr::List { head: "record-lit", tail: buf, multiline: lit.fields.len > 2 };
        }
        case super::NodeValue::RecordLitField(f) =>
            return sexpr::list(a, "field", &[toExprOpt(a, f.label), toExpr(a, f.value)]),
        case super::NodeValue::TypeSig(sig) => return typeSigToExpr(a, sig),
        case super::NodeValue::FnParam(p) =>
            return sexpr::list(a, "param", &[toExpr(a, p.name), toExpr(a, p.type)]),
        case super::NodeValue::Attribute(attr) => {
            match attr {
                case super::Attribute::Export => return sexpr::sym("@export"),
                case super::Attribute::Default => return sexpr::sym("@default"),
                case super::Attribute::Extern => return sexpr::sym("@extern"),
                case super::Attribute::Test => return sexpr::sym("@test"),
                case super::Attribute::Intrinsic => return sexpr::sym("@intrinsic"),
                case super::Attribute::Unsafe => return sexpr::sym("@unsafe"),
            }
        }
        case super::NodeValue::Try(t) => {
            let mut head = "try";
            if t.shouldPanic { set head = "try!"; }
            if t.catches.len > 0 {
                let catches = nodeListToExprs(a, &t.catches[..]);
                return sexpr::list(a, head, &[toExpr(a, t.expr), sexpr::block(a, "catches", &[], catches)]);
            }
            return sexpr::list(a, head, &[toExpr(a, t.expr)]);
        }
        case super::NodeValue::CatchClause(clause) => {
            let mut head = "catch";
            let mut children: [sexpr::Expr; 3] = undefined;
            let mut len: u32 = 0;
            if let b = clause.binding {
                set children[len] = toExpr(a, b);
                set len += 1;
            }
            if let t = clause.typeNode {
                set children[len] = toExpr(a, t);
                set len += 1;
            }
            set children[len] = toExpr(a, clause.body);
            set len += 1;
            return sexpr::list(a, head, &children[..len]);
        }
        case super::NodeValue::Block(blk) => {
            let children = nodeListToExprs(a, &blk.statements[..]);
            return sexpr::block(a, "block", &[], children);
        }
        case super::NodeValue::Let(decl) => {
            let mut head = "let";
            if decl.mutable { set head = "let-mut"; }
            return sexpr::list(a, head, &[
                toExpr(a, decl.ident),
                toExprOrNull(a, decl.type),
                toExpr(a, decl.value)
            ]);
        }
        case super::NodeValue::ConstDecl(decl) =>
            return sexpr::list(a, "constant", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
        case super::NodeValue::StaticDecl(decl) =>
            return sexpr::list(a, "static", &[toExpr(a, decl.ident), toExpr(a, decl.type), toExpr(a, decl.value)]),
        case super::NodeValue::Assign(a_) =>
            return sexpr::list(a, "assign", &[toExpr(a, a_.left), toExpr(a, a_.right)]),
        case super::NodeValue::Return { value } =>
            return sexpr::list(a, "return", &[toExprOrNull(a, value)]),
        case super::NodeValue::Throw { expr } =>
            return sexpr::list(a, "throw", &[toExpr(a, expr)]),
        case super::NodeValue::Panic { message } =>
            return sexpr::list(a, "panic", &[toExprOrNull(a, message)]),
        case super::NodeValue::Assert { condition, message } =>
            return sexpr::list(a, "assert", &[toExpr(a, condition), toExprOrNull(a, message)]),
        case super::NodeValue::If(c) =>
            return sexpr::block(a, "if", &[toExpr(a, c.condition)],
                &[toExpr(a, c.thenBranch), toExprOrNull(a, c.elseBranch)]),
        case super::NodeValue::IfLet(c) => {
            let label = "if-let-mut" if c.pattern.mutable else "if-let";
            return sexpr::block(a, label, &[
                toExpr(a, c.pattern.pattern),
                toExpr(a, c.pattern.scrutinee),
                guardExpr(a, c.pattern.guard)
            ], &[
                toExpr(a, c.thenBranch),
                toExprOrNull(a, c.elseBranch)
            ]);
        }
        case super::NodeValue::LetElse(l) => {
            let label = "let-mut-else" if l.pattern.mutable else "let-else";
            return sexpr::block(a, label, &[
                toExpr(a, l.pattern.pattern),
                toExpr(a, l.pattern.scrutinee),
                guardExpr(a, l.pattern.guard)
            ], &[toExpr(a, l.elseBranch)]);
        }
        case super::NodeValue::While(w) =>
            return sexpr::block(a, "while", &[
                toExpr(a, w.condition)
            ], &[
                toExpr(a, w.body),
                toExprOrNull(a, w.elseBranch)
            ]),
        case super::NodeValue::WhileLet(w) => {
            let label = "while-let-mut" if w.pattern.mutable else "while-let";
            return sexpr::block(a, label, &[
                toExpr(a, w.pattern.pattern),
                toExpr(a, w.pattern.scrutinee),
                guardExpr(a, w.pattern.guard)
            ], &[
                toExpr(a, w.body),
                toExprOrNull(a, w.elseBranch)
            ]);
        }
        case super::NodeValue::For(f) =>
            return sexpr::block(a, "for", &[
                toExpr(a, f.binding),
                toExprOrNull(a, f.index),
                toExpr(a, f.iterable)
            ], &[toExpr(a, f.body), toExprOrNull(a, f.elseBranch)]),
        case super::NodeValue::Loop { body } =>
            return sexpr::block(a, "loop", &[], &[toExpr(a, body)]),
        case super::NodeValue::Match(m) => {
            let children = prongListToExprs(a, &m.prongs[..]);
            return sexpr::block(a, "match", &[toExpr(a, m.subject)], children);
        }
        case super::NodeValue::MatchProng(p) => {
            return prongToExpr(a, p);
        }
        case super::NodeValue::FnDecl(f) => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params[..]));
            let ret = toExprOrNull(a, f.sig.returnType);
            if f.params.len > 0 {
                let generics = sexpr::list(a, "generics", nodeListToExprs(a, &f.params[..]));
                if let body = f.body {
                    return sexpr::block(a, "fn", &[toExpr(a, f.name), generics, params, ret], &[toExpr(a, body)]);
                }
                return sexpr::list(a, "fn", &[toExpr(a, f.name), generics, params, ret]);
            }
            if let body = f.body {
                return sexpr::block(a, "fn", &[toExpr(a, f.name), params, ret], &[toExpr(a, body)]);
            }
            return sexpr::list(a, "fn", &[toExpr(a, f.name), params, ret]);
        }
        case super::NodeValue::Mod(m) => return sexpr::list(a, "mod", &[toExpr(a, m.name)]),
        case super::NodeValue::Use(u_) => return sexpr::list(a, "use", &[toExpr(a, u_.path)]),
        case super::NodeValue::RecordDecl(r) => {
            let children = fieldListToExprs(a, &r.fields[..]);
            if r.params.len > 0 {
                let generics = sexpr::list(a, "generics", nodeListToExprs(a, &r.params[..]));
                return sexpr::block(a, "record", &[toExpr(a, r.name), generics], children);
            }
            return sexpr::block(a, "record", &[toExpr(a, r.name)], children);
        }
        case super::NodeValue::RecordField { field, type, value } => {
            return fieldToExpr(a, field, type, value);
        }
        case super::NodeValue::UnionDecl(u_) => {
            let children = variantListToExprs(a, &u_.variants[..]);
            if u_.params.len > 0 {
                let generics = sexpr::list(a, "generics", nodeListToExprs(a, &u_.params[..]));
                return sexpr::block(a, "union", &[toExpr(a, u_.name), generics], children);
            }
            return sexpr::block(a, "union", &[toExpr(a, u_.name)], children);
        }
        case super::NodeValue::UnionDeclVariant(v) => {
            return variantToExpr(a, v.name, v.type);
        }
        case super::NodeValue::ExprStmt(e) => return toExpr(a, e),
        case super::NodeValue::GenericParam(param) => {
            match param {
                case super::GenericParam::Type { name, bounds } => {
                    let boundExpr = sexpr::list(a, "bounds", nodeListToExprs(a, &bounds[..]));
                    return sexpr::list(a, "type-param", &[toExpr(a, name), boundExpr]);
                }
                case super::GenericParam::Const { name, type } =>
                    return sexpr::list(a, "const-param", &[toExpr(a, name), toExpr(a, type)]),
            }
        }
        case super::NodeValue::Instantiate(applications) =>
            return sexpr::list(a, "instantiate", nodeListToExprs(a, &applications[..])),
        case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
            let children = nodeListToExprs(a, &methods[..]);
            let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
            return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
        }
        case super::NodeValue::TraitMethodSig { name, receiver, sig, attrs } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            let ret = toExprOrNull(a, sig.returnType);
            let attributes = attributesToExpr(a, attrs);
            return sexpr::list(
                a,
                "methodSig",
                &[attributes, toExpr(a, receiver), toExpr(a, name), params, ret],
            );
        }
        case super::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            let children = nodeListToExprs(a, &methods[..]);
            return sexpr::block(a, "instance", &[toExpr(a, traitName), toExpr(a, targetType)], children);
        }
        case super::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, attrs,
        } => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &sig.params[..]));
            let ret = toExprOrNull(a, sig.returnType);
            let attributes = attributesToExpr(a, attrs);
            return sexpr::block(
                a,
                "method",
                &[
                    attributes,
                    toExpr(a, receiverType),
                    toExpr(a, receiverName),
                    toExpr(a, name),
                    params,
                    ret,
                ],
                &[toExpr(a, body)],
            );
        }
        else => return sexpr::sym("?"),
    }
}

/// Dump the tree rooted at `root`, using the provided arena for allocation.
export fn printTree(root: *super::Node, arena: *mut alloc::Arena) {
    match root.value {
        case super::NodeValue::Block(blk) => {
            for stmt, i in blk.statements {
                sexpr::print(toExpr(arena, stmt), 0);
                if i < blk.statements.len - 1 { io::print("\n\n"); }
            }
            io::print("\n");
        }
        else => {
            sexpr::print(toExpr(arena, root), 0);
            io::print("\n");
        }
    }
}