conlang: Move all cl-libs into the compiler directory

compiler/cl-ast/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "cl-ast"
+repository.workspace = true
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]
+cl-structures = { path = "../cl-structures" }

compiler/cl-ast/src/ast.rs

@@ -0,0 +1,543 @@
+//! # The Abstract Syntax Tree
+//! Contains definitions of Conlang AST Nodes.
+//!
+//! # Notable nodes
+//! - [Item] and [ItemKind]: Top-level constructs
+//! - [Stmt] and [StmtKind]: Statements
+//! - [Expr] and [ExprKind]: Expressions
+//!   - [Assign], [Binary], and [Unary] expressions
+//!   - [AssignKind], [BinaryKind], and [UnaryKind] operators
+//! - [Ty] and [TyKind]: Type qualifiers
+//! - [Path]: Path expressions
+use cl_structures::span::*;
+
+/// Whether a binding ([Static] or [Let]) or reference is mutable or not
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum Mutability {
+    #[default]
+    Not,
+    Mut,
+}
+
+/// Whether an [Item] is visible outside of the current [Module]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum Visibility {
+    #[default]
+    Private,
+    Public,
+}
+
+// TODO: Capture token?
+/// A name
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Identifier(pub String);
+
+/// A [Literal]: 0x42, 1e123, 2.4, "Hello"
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Literal {
+    Bool(bool),
+    Char(char),
+    Int(u128),
+    String(String),
+}
+
+/// A list of [Item]s
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct File {
+    pub items: Vec<Item>,
+}
+
+// Metadata decorators
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct Attrs {
+    pub meta: Vec<Meta>,
+}
+
+/// A metadata decorator
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Meta {
+    pub name: Identifier,
+    pub kind: MetaKind,
+}
+
+/// Information attached to [Meta]data
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum MetaKind {
+    Plain,
+    Equals(Literal),
+    Func(Vec<Literal>),
+}
+
+// Items
+/// Anything that can appear at the top level of a [File]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Item {
+    pub extents: Span,
+    pub attrs: Attrs,
+    pub vis: Visibility,
+    pub kind: ItemKind,
+}
+
+/// What kind of [Item] is this?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum ItemKind {
+    // TODO: Import declaration ("use") item
+    // TODO: Trait declaration ("trait") item?
+    /// A [module](Module)
+    Module(Module),
+    /// A [type alias](Alias)
+    Alias(Alias),
+    /// An [enumerated type](Enum), with a discriminant and optional data
+    Enum(Enum),
+    /// A [structure](Struct)
+    Struct(Struct),
+    /// A [constant](Const)
+    Const(Const),
+    /// A [static](Static) variable
+    Static(Static),
+    /// A [function definition](Function)
+    Function(Function),
+    /// An [implementation](Impl)
+    Impl(Impl),
+}
+
+/// An alias to another [Ty]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Alias {
+    pub to: Identifier,
+    pub from: Option<Box<Ty>>,
+}
+
+/// A compile-time constant
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Const {
+    pub name: Identifier,
+    pub ty: Box<Ty>,
+    pub init: Box<Expr>,
+}
+
+/// A `static` variable
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Static {
+    pub mutable: Mutability,
+    pub name: Identifier,
+    pub ty: Box<Ty>,
+    pub init: Box<Expr>,
+}
+
+/// An ordered collection of [Items](Item)
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Module {
+    pub name: Identifier,
+    pub kind: ModuleKind,
+}
+
+/// The contents of a [Module], if they're in the same file
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum ModuleKind {
+    Inline(File),
+    Outline,
+}
+
+/// Code, and the interface to that code
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Function {
+    pub name: Identifier,
+    pub sign: TyFn,
+    pub bind: Vec<Param>,
+    pub body: Option<Block>,
+}
+
+/// A single parameter for a [Function]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Param {
+    pub mutability: Mutability,
+    pub name: Identifier,
+}
+
+/// A user-defined product type
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Struct {
+    pub name: Identifier,
+    pub kind: StructKind,
+}
+
+/// Either a [Struct]'s [StructMember]s or tuple [Ty]pes, if present.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum StructKind {
+    Empty,
+    Tuple(Vec<Ty>),
+    Struct(Vec<StructMember>),
+}
+
+/// The [Visibility], [Identifier], and [Ty]pe of a single [Struct] member
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct StructMember {
+    pub vis: Visibility,
+    pub name: Identifier,
+    pub ty: Ty,
+}
+
+/// A user-defined sum type
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Enum {
+    pub name: Identifier,
+    pub kind: EnumKind,
+}
+
+/// An [Enum]'s [Variant]s, if it has a variant block
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum EnumKind {
+    /// Represents an enum with no variants
+    NoVariants,
+    Variants(Vec<Variant>),
+}
+
+/// A single [Enum] variant
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Variant {
+    pub name: Identifier,
+    pub kind: VariantKind,
+}
+
+/// Whether the [Variant] has a C-like constant value, a tuple, or [StructMember]s
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum VariantKind {
+    Plain,
+    CLike(u128),
+    Tuple(Ty),
+    Struct(Vec<StructMember>),
+}
+
+/// Sub-[items](Item) (associated functions, etc.) for a [Ty]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Impl {
+    pub target: ImplKind,
+    pub body: File,
+}
+
+// TODO: `impl` Trait for <Target> { }
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum ImplKind {
+    Type(Ty),
+    Trait { impl_trait: Path, for_type: Box<Ty> },
+}
+
+/// A type expression
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Ty {
+    pub extents: Span,
+    pub kind: TyKind,
+}
+
+/// Information about a [Ty]pe expression
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum TyKind {
+    Never,
+    Empty,
+    SelfTy,
+    Path(Path),
+    Tuple(TyTuple),
+    Ref(TyRef),
+    Fn(TyFn),
+    // TODO: slice, array types
+}
+
+/// A tuple of [Ty]pes
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TyTuple {
+    pub types: Vec<TyKind>,
+}
+
+/// A [Ty]pe-reference expression as (number of `&`, [Path])
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TyRef {
+    pub mutable: Mutability,
+    pub count: u16,
+    pub to: Path,
+}
+
+/// The args and return value for a function pointer [Ty]pe
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TyFn {
+    pub args: Box<TyKind>,
+    pub rety: Option<Box<Ty>>,
+}
+
+/// A path to an [Item] in the [Module] tree
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Path {
+    pub absolute: bool,
+    pub parts: Vec<PathPart>,
+}
+
+/// A single component of a [Path]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum PathPart {
+    SuperKw,
+    SelfKw,
+    Ident(Identifier),
+}
+
+/// An abstract statement, and associated metadata
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Stmt {
+    pub extents: Span,
+    pub kind: StmtKind,
+    pub semi: Semi,
+}
+
+/// Whether the [Stmt] is a [Let], [Item], or [Expr] statement
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum StmtKind {
+    Empty,
+    Local(Let),
+    Item(Box<Item>),
+    Expr(Box<Expr>),
+}
+
+/// Whether or not a [Stmt] is followed by a semicolon
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Semi {
+    Terminated,
+    Unterminated,
+}
+
+/// A local variable declaration [Stmt]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Let {
+    pub mutable: Mutability,
+    pub name: Identifier,
+    pub ty: Option<Box<Ty>>,
+    pub init: Option<Box<Expr>>,
+}
+
+/// An expression, the beating heart of the language
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Expr {
+    pub extents: Span,
+    pub kind: ExprKind,
+}
+
+/// Any of the different [Expr]essions
+#[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
+pub enum ExprKind {
+    /// An empty expression: `(` `)`
+    #[default]
+    Empty,
+    /// An [Assign]ment expression: [`Expr`] ([`AssignKind`] [`Expr`])\+
+    Assign(Assign),
+    /// A [Binary] expression: [`Expr`] ([`BinaryKind`] [`Expr`])\+
+    Binary(Binary),
+    /// A [Unary] expression: [`UnaryKind`]\* [`Expr`]
+    Unary(Unary),
+    /// An Array [Index] expression: a[10, 20, 30]
+    Index(Index),
+    /// A [path expression](Path): `::`? [PathPart] (`::` [PathPart])*
+    Path(Path),
+    /// A [Literal]: 0x42, 1e123, 2.4, "Hello"
+    Literal(Literal),
+    /// An [Array] literal: `[` [`Expr`] (`,` [`Expr`])\* `]`
+    Array(Array),
+    /// An Array literal constructed with [repeat syntax](ArrayRep)
+    /// `[` [Expr] `;` [Literal] `]`
+    ArrayRep(ArrayRep),
+    /// An address-of expression: `&` `mut`? [`Expr`]
+    AddrOf(AddrOf),
+    /// A [Block] expression: `{` [`Stmt`]\* [`Expr`]? `}`
+    Block(Block),
+    /// A [Grouping](Group) expression `(` [`Expr`] `)`
+    Group(Group),
+    /// A [Tuple] expression: `(` [`Expr`] (`,` [`Expr`])+ `)`
+    Tuple(Tuple),
+    /// A [Loop] expression: `loop` [`Block`]
+    Loop(Loop),
+    /// A [While] expression: `while` [`Expr`] [`Block`] [`Else`]?
+    While(While),
+    /// An [If] expression: `if` [`Expr`] [`Block`] [`Else`]?
+    If(If),
+    /// A [For] expression: `for` Pattern `in` [`Expr`] [`Block`] [`Else`]?
+    For(For),
+    /// A [Break] expression: `break` [`Expr`]?
+    Break(Break),
+    /// A [Return] expression `return` [`Expr`]?
+    Return(Return),
+    /// A continue expression: `continue`
+    Continue(Continue),
+}
+
+/// An [Assign]ment expression: [`Expr`] ([`AssignKind`] [`Expr`])\+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Assign {
+    pub kind: AssignKind,
+    pub parts: Box<(ExprKind, ExprKind)>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AssignKind {
+    /// Standard Assignment with no read-back
+    Plain,
+    And,
+    Or,
+    Xor,
+    Shl,
+    Shr,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Rem,
+}
+
+/// A [Binary] expression: [`Expr`] ([`BinaryKind`] [`Expr`])\+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Binary {
+    pub kind: BinaryKind,
+    pub parts: Box<(ExprKind, ExprKind)>,
+}
+
+/// A [Binary] operator
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum BinaryKind {
+    Lt,
+    LtEq,
+    Equal,
+    NotEq,
+    GtEq,
+    Gt,
+    RangeExc,
+    RangeInc,
+    LogAnd,
+    LogOr,
+    LogXor,
+    BitAnd,
+    BitOr,
+    BitXor,
+    Shl,
+    Shr,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Rem,
+    Dot,
+    Call,
+}
+
+/// A [Unary] expression: [`UnaryKind`]\* [`Expr`]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Unary {
+    pub kind: UnaryKind,
+    pub tail: Box<ExprKind>,
+}
+
+/// A [Unary] operator
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum UnaryKind {
+    Deref,
+    Neg,
+    Not,
+    /// Unused
+    At,
+    /// Unused
+    Tilde,
+}
+/// A repeated [Index] expression: a[10, 20, 30][40, 50, 60]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Index {
+    pub head: Box<ExprKind>,
+    pub indices: Vec<Expr>,
+}
+
+/// An [Array] literal: `[` [`Expr`] (`,` [`Expr`])\* `]`
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Array {
+    pub values: Vec<Expr>,
+}
+
+/// An Array literal constructed with [repeat syntax](ArrayRep)
+/// `[` [Expr] `;` [Literal] `]`
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ArrayRep {
+    pub value: Box<ExprKind>,
+    pub repeat: Box<ExprKind>,
+}
+
+/// An address-of expression: `&` `mut`? [`Expr`]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct AddrOf {
+    pub count: usize,
+    pub mutable: Mutability,
+    pub expr: Box<ExprKind>,
+}
+
+/// A [Block] expression: `{` [`Stmt`]\* [`Expr`]? `}`
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Block {
+    pub stmts: Vec<Stmt>,
+}
+
+/// A [Grouping](Group) expression `(` [`Expr`] `)`
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Group {
+    pub expr: Box<ExprKind>,
+}
+
+/// A [Tuple] expression: `(` [`Expr`] (`,` [`Expr`])+ `)`
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Tuple {
+    pub exprs: Vec<Expr>,
+}
+
+/// A [Loop] expression: `loop` [`Block`]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Loop {
+    pub body: Box<Expr>,
+}
+
+/// A [While] expression: `while` [`Expr`] [`Block`] [`Else`]?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct While {
+    pub cond: Box<Expr>,
+    pub pass: Box<Block>,
+    pub fail: Else,
+}
+
+/// An [If] expression: `if` [`Expr`] [`Block`] [`Else`]?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct If {
+    pub cond: Box<Expr>,
+    pub pass: Box<Block>,
+    pub fail: Else,
+}
+
+/// A [For] expression: `for` Pattern `in` [`Expr`] [`Block`] [`Else`]?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct For {
+    pub bind: Identifier, // TODO: Patterns?
+    pub cond: Box<Expr>,
+    pub pass: Box<Block>,
+    pub fail: Else,
+}
+
+/// The (optional) `else` clause of a [While], [If], or [For] expression
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Else {
+    pub body: Option<Box<Expr>>,
+}
+
+/// A [Break] expression: `break` [`Expr`]?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Break {
+    pub body: Option<Box<Expr>>,
+}
+
+/// A [Return] expression `return` [`Expr`]?
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Return {
+    pub body: Option<Box<Expr>>,
+}
+
+/// A continue expression: `continue`
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub struct Continue;

compiler/cl-ast/src/ast_impl.rs

@@ -0,0 +1,731 @@
+//! Implementations of AST nodes and traits
+use super::*;
+
+mod display {
+    //! Implements [Display] for [AST](super::super) Types
+
+    use super::*;
+    use format::{delimiters::*, *};
+    use std::{
+        borrow::Borrow,
+        fmt::{Display, Write},
+    };
+
+    fn separate<I: Display, W: Write>(
+        iterable: impl IntoIterator<Item = I>,
+        sep: &'static str,
+    ) -> impl FnOnce(W) -> std::fmt::Result {
+        move |mut f| {
+            for (idx, item) in iterable.into_iter().enumerate() {
+                if idx > 0 {
+                    f.write_str(sep)?;
+                }
+                write!(f, "{item}")?;
+            }
+            Ok(())
+        }
+    }
+
+    impl Display for Mutability {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Mutability::Not => Ok(()),
+                Mutability::Mut => "mut ".fmt(f),
+            }
+        }
+    }
+
+    impl Display for Visibility {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Visibility::Private => Ok(()),
+                Visibility::Public => "pub ".fmt(f),
+            }
+        }
+    }
+
+    impl Display for Identifier {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl Display for Literal {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Literal::Bool(v) => v.fmt(f),
+                Literal::Char(v) => write!(f, "'{v}'"),
+                Literal::Int(v) => v.fmt(f),
+                Literal::String(v) => write!(f, "\"{v}\""),
+            }
+        }
+    }
+
+    impl Display for File {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            separate(&self.items, "\n\n")(f)
+        }
+    }
+
+    impl Display for Attrs {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { meta } = self;
+            if meta.is_empty() {
+                return Ok(());
+            }
+            "#".fmt(f)?;
+            separate(meta, ", ")(&mut f.delimit(INLINE_SQUARE))?;
+            "\n".fmt(f)
+        }
+    }
+
+    impl Display for Meta {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { name, kind } = self;
+            write!(f, "{name}{kind}")
+        }
+    }
+
+    impl Display for MetaKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                MetaKind::Plain => Ok(()),
+                MetaKind::Equals(v) => write!(f, " = {v}"),
+                MetaKind::Func(args) => separate(args, ", ")(f.delimit(INLINE_PARENS)),
+            }
+        }
+    }
+
+    impl Display for Item {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { extents: _, attrs, vis, kind } = self;
+            attrs.fmt(f)?;
+            vis.fmt(f)?;
+            kind.fmt(f)
+        }
+    }
+
+    impl Display for ItemKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                ItemKind::Alias(v) => v.fmt(f),
+                ItemKind::Const(v) => v.fmt(f),
+                ItemKind::Static(v) => v.fmt(f),
+                ItemKind::Module(v) => v.fmt(f),
+                ItemKind::Function(v) => v.fmt(f),
+                ItemKind::Struct(v) => v.fmt(f),
+                ItemKind::Enum(v) => v.fmt(f),
+                ItemKind::Impl(v) => v.fmt(f),
+            }
+        }
+    }
+
+    impl Display for Alias {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { to, from } = self;
+            match from {
+                Some(from) => write!(f, "type {to} = {from};"),
+                None => write!(f, "type {to};"),
+            }
+        }
+    }
+
+    impl Display for Const {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { name, ty, init } = self;
+            write!(f, "const {name}: {ty} = {init}")
+        }
+    }
+
+    impl Display for Static {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { mutable, name, ty, init } = self;
+            write!(f, "static {mutable}{name}: {ty} = {init}")
+        }
+    }
+
+    impl Display for Module {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { name, kind } = self;
+            write!(f, "mod {name}{kind}")
+        }
+    }
+
+    impl Display for ModuleKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                ModuleKind::Inline(items) => {
+                    ' '.fmt(f)?;
+                    write!(f.delimit(BRACES), "{items}")
+                }
+                ModuleKind::Outline => ';'.fmt(f),
+            }
+        }
+    }
+
+    impl Display for Function {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { name, sign: sign @ TyFn { args, rety }, bind, body } = self;
+            let types = match **args {
+                TyKind::Tuple(TyTuple { ref types }) => types.as_slice(),
+                TyKind::Empty => Default::default(),
+                _ => {
+                    write!(f, "Invalid function signature: {sign}")?;
+                    Default::default()
+                }
+            };
+
+            debug_assert_eq!(bind.len(), types.len());
+            write!(f, "fn {name} ")?;
+            {
+                let mut f = f.delimit(INLINE_PARENS);
+                for (idx, (arg, ty)) in bind.iter().zip(types.iter()).enumerate() {
+                    if idx != 0 {
+                        f.write_str(", ")?;
+                    }
+                    write!(f, "{arg}: {ty}")?;
+                }
+            }
+            if let Some(rety) = rety {
+                write!(f, " -> {rety}")?;
+            }
+            match body {
+                Some(body) => write!(f, " {body}"),
+                None => ';'.fmt(f),
+            }
+        }
+    }
+
+    impl Display for Param {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { mutability, name } = self;
+            write!(f, "{mutability}{name}")
+        }
+    }
+
+    impl Display for Struct {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { name, kind } = self;
+            write!(f, "struct {name}{kind}")
+        }
+    }
+
+    impl Display for StructKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                StructKind::Empty => ';'.fmt(f),
+                StructKind::Tuple(v) => separate(v, ", ")(f.delimit(INLINE_PARENS)),
+                StructKind::Struct(v) => separate(v, ",\n")(f.delimit(SPACED_BRACES)),
+            }
+        }
+    }
+
+    impl Display for StructMember {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { vis, name, ty } = self;
+            write!(f, "{vis}{name}: {ty}")
+        }
+    }
+
+    impl Display for Enum {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { name, kind } = self;
+            write!(f, "enum {name}{kind}")
+        }
+    }
+
+    impl Display for EnumKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                EnumKind::NoVariants => ';'.fmt(f),
+                EnumKind::Variants(v) => separate(v, ",\n")(f.delimit(SPACED_BRACES)),
+            }
+        }
+    }
+
+    impl Display for Variant {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { name, kind } = self;
+            write!(f, "{name}{kind}")
+        }
+    }
+
+    impl Display for VariantKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                VariantKind::Plain => Ok(()),
+                VariantKind::CLike(n) => write!(f, " = {n}"),
+                VariantKind::Tuple(v) => v.fmt(f),
+                VariantKind::Struct(v) => separate(v, ", ")(f.delimit(INLINE_BRACES)),
+            }
+        }
+    }
+
+    impl Display for Impl {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { target, body } = self;
+            write!(f, "impl {target} ")?;
+            write!(f.delimit(BRACES), "{body}")
+        }
+    }
+
+    impl Display for ImplKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                ImplKind::Type(t) => t.fmt(f),
+                ImplKind::Trait { impl_trait, for_type } => {
+                    write!(f, "{impl_trait} for {for_type}")
+                }
+            }
+        }
+    }
+
+    impl Display for Ty {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.kind.fmt(f)
+        }
+    }
+
+    impl Display for TyKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                TyKind::Never => "!".fmt(f),
+                TyKind::Empty => "()".fmt(f),
+                TyKind::SelfTy => "Self".fmt(f),
+                TyKind::Path(v) => v.fmt(f),
+                TyKind::Tuple(v) => v.fmt(f),
+                TyKind::Ref(v) => v.fmt(f),
+                TyKind::Fn(v) => v.fmt(f),
+            }
+        }
+    }
+
+    impl Display for TyTuple {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            separate(&self.types, ", ")(f.delimit(INLINE_PARENS))
+        }
+    }
+
+    impl Display for TyRef {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let &Self { count, mutable, ref to } = self;
+            for _ in 0..count {
+                f.write_char('&')?;
+            }
+            write!(f, "{mutable}{to}")
+        }
+    }
+
+    impl Display for TyFn {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { args, rety } = self;
+            write!(f, "fn {args}")?;
+            match rety {
+                Some(v) => write!(f, " -> {v}"),
+                None => Ok(()),
+            }
+        }
+    }
+
+    impl Display for Path {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { absolute, parts } = self;
+            if *absolute {
+                "::".fmt(f)?;
+            }
+            separate(parts, "::")(f)
+        }
+    }
+
+    impl Display for PathPart {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                PathPart::SuperKw => "super".fmt(f),
+                PathPart::SelfKw => "self".fmt(f),
+                PathPart::Ident(id) => id.fmt(f),
+            }
+        }
+    }
+
+    impl Display for Stmt {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Stmt { extents: _, kind, semi } = self;
+            write!(f, "{kind}{semi}")
+        }
+    }
+
+    impl Display for StmtKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                StmtKind::Empty => Ok(()),
+                StmtKind::Local(v) => v.fmt(f),
+                StmtKind::Item(v) => v.fmt(f),
+                StmtKind::Expr(v) => v.fmt(f),
+            }
+        }
+    }
+
+    impl Display for Semi {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Semi::Terminated => ';'.fmt(f),
+                Semi::Unterminated => Ok(()),
+            }
+        }
+    }
+
+    impl Display for Let {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { mutable, name, ty, init } = self;
+            write!(f, "let {mutable}{name}")?;
+            if let Some(value) = ty {
+                write!(f, ": {value}")?;
+            }
+            if let Some(value) = init {
+                write!(f, " = {value}")?;
+            }
+            Ok(())
+        }
+    }
+
+    impl Display for Expr {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.kind.fmt(f)
+        }
+    }
+
+    impl Display for ExprKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                ExprKind::Empty => "()".fmt(f),
+                ExprKind::Assign(v) => v.fmt(f),
+                ExprKind::Binary(v) => v.fmt(f),
+                ExprKind::Unary(v) => v.fmt(f),
+                ExprKind::Index(v) => v.fmt(f),
+                ExprKind::Path(v) => v.fmt(f),
+                ExprKind::Literal(v) => v.fmt(f),
+                ExprKind::Array(v) => v.fmt(f),
+                ExprKind::ArrayRep(v) => v.fmt(f),
+                ExprKind::AddrOf(v) => v.fmt(f),
+                ExprKind::Block(v) => v.fmt(f),
+                ExprKind::Group(v) => v.fmt(f),
+                ExprKind::Tuple(v) => v.fmt(f),
+                ExprKind::Loop(v) => v.fmt(f),
+                ExprKind::While(v) => v.fmt(f),
+                ExprKind::If(v) => v.fmt(f),
+                ExprKind::For(v) => v.fmt(f),
+                ExprKind::Break(v) => v.fmt(f),
+                ExprKind::Return(v) => v.fmt(f),
+                ExprKind::Continue(_) => "continue".fmt(f),
+            }
+        }
+    }
+
+    impl Display for Assign {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { kind, parts } = self;
+            write!(f, "{} {kind} {}", parts.0, parts.1)
+        }
+    }
+
+    impl Display for AssignKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                AssignKind::Plain => "=",
+                AssignKind::Mul => "*=",
+                AssignKind::Div => "/=",
+                AssignKind::Rem => "%=",
+                AssignKind::Add => "+=",
+                AssignKind::Sub => "-=",
+                AssignKind::And => "&=",
+                AssignKind::Or => "|=",
+                AssignKind::Xor => "^=",
+                AssignKind::Shl => "<<=",
+                AssignKind::Shr => ">>=",
+            }
+            .fmt(f)
+        }
+    }
+
+    impl Display for Binary {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { kind, parts } = self;
+            let (head, tail) = parts.borrow();
+            match kind {
+                BinaryKind::Dot => write!(f, "{head}{kind}{tail}"),
+                BinaryKind::Call => write!(f, "{head}{tail}"),
+                _ => write!(f, "{head} {kind} {tail}"),
+            }
+        }
+    }
+
+    impl Display for BinaryKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                BinaryKind::Lt => "<",
+                BinaryKind::LtEq => "<=",
+                BinaryKind::Equal => "==",
+                BinaryKind::NotEq => "!=",
+                BinaryKind::GtEq => ">=",
+                BinaryKind::Gt => ">",
+                BinaryKind::RangeExc => "..",
+                BinaryKind::RangeInc => "..=",
+                BinaryKind::LogAnd => "&&",
+                BinaryKind::LogOr => "||",
+                BinaryKind::LogXor => "^^",
+                BinaryKind::BitAnd => "&",
+                BinaryKind::BitOr => "|",
+                BinaryKind::BitXor => "^",
+                BinaryKind::Shl => "<<",
+                BinaryKind::Shr => ">>",
+                BinaryKind::Add => "+",
+                BinaryKind::Sub => "-",
+                BinaryKind::Mul => "*",
+                BinaryKind::Div => "/",
+                BinaryKind::Rem => "%",
+                BinaryKind::Dot => ".",
+                BinaryKind::Call => "()",
+            }
+            .fmt(f)
+        }
+    }
+
+    impl Display for Unary {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { kind, tail } = self;
+            write!(f, "{kind}{tail}")
+        }
+    }
+
+    impl Display for UnaryKind {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                UnaryKind::Deref => "*",
+                UnaryKind::Neg => "-",
+                UnaryKind::Not => "!",
+                UnaryKind::At => "@",
+                UnaryKind::Tilde => "~",
+            }
+            .fmt(f)
+        }
+    }
+
+    impl Display for Index {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { head, indices } = self;
+            write!(f, "{head}")?;
+            separate(indices, ", ")(f.delimit(INLINE_SQUARE))
+        }
+    }
+
+    impl Display for Array {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            separate(&self.values, ", ")(f.delimit(INLINE_SQUARE))
+        }
+    }
+
+    impl Display for ArrayRep {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { value, repeat } = self;
+            write!(f, "[{value}; {repeat}]")
+        }
+    }
+
+    impl Display for AddrOf {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { count, mutable, expr } = self;
+            for _ in 0..*count {
+                f.write_char('&')?;
+            }
+            write!(f, "{mutable}{expr}")
+        }
+    }
+
+    impl Display for Block {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            separate(&self.stmts, "\n")(f.delimit(BRACES))
+        }
+    }
+
+    impl Display for Group {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "({})", self.expr)
+        }
+    }
+
+    impl Display for Tuple {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            separate(&self.exprs, ", ")(f.delimit(INLINE_PARENS))
+        }
+    }
+
+    impl Display for Loop {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { body } = self;
+            write!(f, "loop {body}")
+        }
+    }
+
+    impl Display for While {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { cond, pass, fail } = self;
+            write!(f, "while {cond} {pass}{fail}")
+        }
+    }
+
+    impl Display for If {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { cond, pass, fail } = self;
+            write!(f, "if {cond} {pass}{fail}")
+        }
+    }
+
+    impl Display for For {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            let Self { bind, cond, pass, fail } = self;
+            write!(f, "for {bind} in {cond} {pass}{fail}")
+        }
+    }
+
+    impl Display for Else {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match &self.body {
+                Some(body) => write!(f, " else {body}"),
+                _ => Ok(()),
+            }
+        }
+    }
+
+    impl Display for Break {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "break")?;
+            match &self.body {
+                Some(body) => write!(f, " {body}"),
+                _ => Ok(()),
+            }
+        }
+    }
+
+    impl Display for Return {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "return")?;
+            match &self.body {
+                Some(body) => write!(f, " {body}"),
+                _ => Ok(()),
+            }
+        }
+    }
+
+    impl Display for Continue {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            "continue".fmt(f)
+        }
+    }
+}
+
+mod convert {
+    //! Converts between major enums and enum variants
+    use super::*;
+
+    impl<T: AsRef<str>> From<T> for Identifier {
+        fn from(value: T) -> Self {
+            Identifier(value.as_ref().into())
+        }
+    }
+    impl<T: AsRef<str>> From<T> for PathPart {
+        fn from(value: T) -> Self {
+            match value.as_ref() {
+                "Self" => PathPart::SelfKw,
+                "super" => PathPart::SuperKw,
+                ident => PathPart::Ident(ident.into()),
+            }
+        }
+    }
+
+    macro impl_from ($(impl From for $T:ty {$($from:ty => $to:expr),*$(,)?})*) {$($(
+        impl From<$from> for $T {
+            fn from(value: $from) -> Self {
+                $to(value.into()) // Uses *tuple constructor*
+            }
+        }
+        impl From<Box<$from>> for $T {
+            fn from(value: Box<$from>) -> Self {
+                $to((*value).into())
+            }
+        }
+    )*)*}
+
+    impl_from! {
+        impl From for ItemKind {
+            Alias => ItemKind::Alias,
+            Const => ItemKind::Const,
+            Static => ItemKind::Static,
+            Module => ItemKind::Module,
+            Function => ItemKind::Function,
+            Struct => ItemKind::Struct,
+            Enum => ItemKind::Enum,
+            Impl => ItemKind::Impl,
+        }
+        impl From for StructKind {
+            Vec<Ty> => StructKind::Tuple,
+            // TODO: Struct members in struct
+        }
+        impl From for EnumKind {
+            Vec<Variant> => EnumKind::Variants,
+        }
+        impl From for VariantKind {
+            u128 => VariantKind::CLike,
+            Ty => VariantKind::Tuple,
+            // TODO: enum struct variants
+        }
+        impl From for TyKind {
+            Path => TyKind::Path,
+            TyTuple => TyKind::Tuple,
+            TyRef => TyKind::Ref,
+            TyFn => TyKind::Fn,
+        }
+        impl From for StmtKind {
+            Let => StmtKind::Local,
+            Item => StmtKind::Item,
+            Expr => StmtKind::Expr,
+        }
+        impl From for ExprKind {
+            Assign => ExprKind::Assign,
+            Binary => ExprKind::Binary,
+            Unary => ExprKind::Unary,
+            Index => ExprKind::Index,
+            Path => ExprKind::Path,
+            Literal => ExprKind::Literal,
+            Array => ExprKind::Array,
+            ArrayRep => ExprKind::ArrayRep,
+            AddrOf => ExprKind::AddrOf,
+            Block => ExprKind::Block,
+            Group => ExprKind::Group,
+            Tuple => ExprKind::Tuple,
+            Loop => ExprKind::Loop,
+            While => ExprKind::While,
+            If => ExprKind::If,
+            For => ExprKind::For,
+            Break => ExprKind::Break,
+            Return => ExprKind::Return,
+            Continue => ExprKind::Continue,
+        }
+        impl From for Literal {
+            bool => Literal::Bool,
+            char => Literal::Char,
+            u128 => Literal::Int,
+            String => Literal::String,
+        }
+    }
+
+    impl From<Option<Expr>> for Else {
+        fn from(value: Option<Expr>) -> Self {
+            Self { body: value.map(Into::into) }
+        }
+    }
+    impl From<Expr> for Else {
+        fn from(value: Expr) -> Self {
+            Self { body: Some(value.into()) }
+        }
+    }
+}

compiler/cl-ast/src/ast_visitor.rs

@@ -0,0 +1,8 @@
+//! Contains an [immutable visitor](Visit) and an [owned folder](Fold) trait,
+//! with default implementations across the entire AST
+
+pub mod fold;
+pub mod visit;
+
+pub use fold::Fold;
+pub use visit::Visit;

compiler/cl-ast/src/ast_visitor/fold.rs

@@ -0,0 +1,493 @@
+//! A folder (implementer of the [Fold] trait) maps ASTs to ASTs
+
+use crate::ast::*;
+use cl_structures::span::Span;
+
+/// Deconstructs the entire AST, and reconstructs it from scratch.
+///
+/// Each method acts as a customization point.
+///
+/// There are a set of default implementations for enums
+/// under the name [`or_fold_`*](or_fold_expr_kind),
+/// provided for ease of use.
+///
+/// For all other nodes, traversal is *explicit*.
+pub trait Fold {
+    fn fold_span(&mut self, extents: Span) -> Span {
+        extents
+    }
+    fn fold_mutability(&mut self, mutability: Mutability) -> Mutability {
+        mutability
+    }
+    fn fold_visibility(&mut self, visibility: Visibility) -> Visibility {
+        visibility
+    }
+    fn fold_identifier(&mut self, ident: Identifier) -> Identifier {
+        ident
+    }
+    fn fold_literal(&mut self, lit: Literal) -> Literal {
+        or_fold_literal(self, lit)
+    }
+    fn fold_bool(&mut self, b: bool) -> bool {
+        b
+    }
+    fn fold_char(&mut self, c: char) -> char {
+        c
+    }
+    fn fold_int(&mut self, i: u128) -> u128 {
+        i
+    }
+    fn fold_string(&mut self, s: String) -> String {
+        s
+    }
+    fn fold_file(&mut self, f: File) -> File {
+        let File { items } = f;
+        File { items: items.into_iter().map(|i| self.fold_item(i)).collect() }
+    }
+    fn fold_attrs(&mut self, a: Attrs) -> Attrs {
+        let Attrs { meta } = a;
+        Attrs { meta: meta.into_iter().map(|m| self.fold_meta(m)).collect() }
+    }
+    fn fold_meta(&mut self, m: Meta) -> Meta {
+        let Meta { name, kind } = m;
+        Meta { name: self.fold_identifier(name), kind: self.fold_meta_kind(kind) }
+    }
+    fn fold_meta_kind(&mut self, kind: MetaKind) -> MetaKind {
+        or_fold_meta_kind(self, kind)
+    }
+    fn fold_item(&mut self, i: Item) -> Item {
+        let Item { extents, attrs, vis, kind } = i;
+        Item {
+            extents: self.fold_span(extents),
+            attrs: self.fold_attrs(attrs),
+            vis: self.fold_visibility(vis),
+            kind: self.fold_item_kind(kind),
+        }
+    }
+    fn fold_item_kind(&mut self, kind: ItemKind) -> ItemKind {
+        or_fold_item_kind(self, kind)
+    }
+    fn fold_alias(&mut self, a: Alias) -> Alias {
+        let Alias { to, from } = a;
+        Alias { to: self.fold_identifier(to), from: from.map(|from| Box::new(self.fold_ty(*from))) }
+    }
+    fn fold_const(&mut self, c: Const) -> Const {
+        let Const { name, ty, init } = c;
+        Const {
+            name: self.fold_identifier(name),
+            ty: Box::new(self.fold_ty(*ty)),
+            init: Box::new(self.fold_expr(*init)),
+        }
+    }
+    fn fold_static(&mut self, s: Static) -> Static {
+        let Static { mutable, name, ty, init } = s;
+        Static {
+            mutable: self.fold_mutability(mutable),
+            name: self.fold_identifier(name),
+            ty: Box::new(self.fold_ty(*ty)),
+            init: Box::new(self.fold_expr(*init)),
+        }
+    }
+    fn fold_module(&mut self, m: Module) -> Module {
+        let Module { name, kind } = m;
+        Module { name: self.fold_identifier(name), kind: self.fold_module_kind(kind) }
+    }
+    fn fold_module_kind(&mut self, m: ModuleKind) -> ModuleKind {
+        match m {
+            ModuleKind::Inline(f) => ModuleKind::Inline(self.fold_file(f)),
+            ModuleKind::Outline => ModuleKind::Outline,
+        }
+    }
+    fn fold_function(&mut self, f: Function) -> Function {
+        let Function { name, sign, bind, body } = f;
+        Function {
+            name: self.fold_identifier(name),
+            sign: self.fold_ty_fn(sign),
+            bind: bind.into_iter().map(|p| self.fold_param(p)).collect(),
+            body: body.map(|b| self.fold_block(b)),
+        }
+    }
+    fn fold_param(&mut self, p: Param) -> Param {
+        let Param { mutability, name } = p;
+        Param { mutability: self.fold_mutability(mutability), name: self.fold_identifier(name) }
+    }
+    fn fold_struct(&mut self, s: Struct) -> Struct {
+        let Struct { name, kind } = s;
+        Struct { name: self.fold_identifier(name), kind: self.fold_struct_kind(kind) }
+    }
+    fn fold_struct_kind(&mut self, kind: StructKind) -> StructKind {
+        match kind {
+            StructKind::Empty => StructKind::Empty,
+            StructKind::Tuple(tys) => {
+                StructKind::Tuple(tys.into_iter().map(|t| self.fold_ty(t)).collect())
+            }
+            StructKind::Struct(mem) => StructKind::Struct(
+                mem.into_iter()
+                    .map(|m| self.fold_struct_member(m))
+                    .collect(),
+            ),
+        }
+    }
+    fn fold_struct_member(&mut self, m: StructMember) -> StructMember {
+        let StructMember { vis, name, ty } = m;
+        StructMember {
+            vis: self.fold_visibility(vis),
+            name: self.fold_identifier(name),
+            ty: self.fold_ty(ty),
+        }
+    }
+    fn fold_enum(&mut self, e: Enum) -> Enum {
+        let Enum { name, kind } = e;
+        Enum { name: self.fold_identifier(name), kind: self.fold_enum_kind(kind) }
+    }
+    fn fold_enum_kind(&mut self, kind: EnumKind) -> EnumKind {
+        or_fold_enum_kind(self, kind)
+    }
+    fn fold_variant(&mut self, v: Variant) -> Variant {
+        let Variant { name, kind } = v;
+
+        Variant { name: self.fold_identifier(name), kind: self.fold_variant_kind(kind) }
+    }
+    fn fold_variant_kind(&mut self, kind: VariantKind) -> VariantKind {
+        or_fold_variant_kind(self, kind)
+    }
+    fn fold_impl(&mut self, i: Impl) -> Impl {
+        let Impl { target, body } = i;
+        Impl { target: self.fold_impl_kind(target), body: self.fold_file(body) }
+    }
+    fn fold_impl_kind(&mut self, kind: ImplKind) -> ImplKind {
+        or_fold_impl_kind(self, kind)
+    }
+    fn fold_ty(&mut self, t: Ty) -> Ty {
+        let Ty { extents, kind } = t;
+        Ty { extents: self.fold_span(extents), kind: self.fold_ty_kind(kind) }
+    }
+    fn fold_ty_kind(&mut self, kind: TyKind) -> TyKind {
+        or_fold_ty_kind(self, kind)
+    }
+    fn fold_ty_tuple(&mut self, t: TyTuple) -> TyTuple {
+        let TyTuple { types } = t;
+        TyTuple {
+            types: types
+                .into_iter()
+                .map(|kind| self.fold_ty_kind(kind))
+                .collect(),
+        }
+    }
+    fn fold_ty_ref(&mut self, t: TyRef) -> TyRef {
+        let TyRef { mutable, count, to } = t;
+        TyRef { mutable: self.fold_mutability(mutable), count, to: self.fold_path(to) }
+    }
+    fn fold_ty_fn(&mut self, t: TyFn) -> TyFn {
+        let TyFn { args, rety } = t;
+        TyFn {
+            args: Box::new(self.fold_ty_kind(*args)),
+            rety: rety.map(|t| Box::new(self.fold_ty(*t))),
+        }
+    }
+    fn fold_path(&mut self, p: Path) -> Path {
+        let Path { absolute, parts } = p;
+        Path { absolute, parts: parts.into_iter().map(|p| self.fold_path_part(p)).collect() }
+    }
+    fn fold_path_part(&mut self, p: PathPart) -> PathPart {
+        match p {
+            PathPart::SuperKw => PathPart::SuperKw,
+            PathPart::SelfKw => PathPart::SelfKw,
+            PathPart::Ident(i) => PathPart::Ident(self.fold_identifier(i)),
+        }
+    }
+    fn fold_stmt(&mut self, s: Stmt) -> Stmt {
+        let Stmt { extents, kind, semi } = s;
+        Stmt {
+            extents: self.fold_span(extents),
+            kind: self.fold_stmt_kind(kind),
+            semi: self.fold_semi(semi),
+        }
+    }
+    fn fold_stmt_kind(&mut self, kind: StmtKind) -> StmtKind {
+        or_fold_stmt_kind(self, kind)
+    }
+    fn fold_semi(&mut self, s: Semi) -> Semi {
+        s
+    }
+    fn fold_let(&mut self, l: Let) -> Let {
+        let Let { mutable, name, ty, init } = l;
+        Let {
+            mutable: self.fold_mutability(mutable),
+            name: self.fold_identifier(name),
+            ty: ty.map(|t| Box::new(self.fold_ty(*t))),
+            init: init.map(|e| Box::new(self.fold_expr(*e))),
+        }
+    }
+    fn fold_expr(&mut self, e: Expr) -> Expr {
+        let Expr { extents, kind } = e;
+        Expr { extents: self.fold_span(extents), kind: self.fold_expr_kind(kind) }
+    }
+    fn fold_expr_kind(&mut self, kind: ExprKind) -> ExprKind {
+        or_fold_expr_kind(self, kind)
+    }
+    fn fold_assign(&mut self, a: Assign) -> Assign {
+        let Assign { kind, parts } = a;
+        let (head, tail) = *parts;
+        Assign {
+            kind: self.fold_assign_kind(kind),
+            parts: Box::new((self.fold_expr_kind(head), self.fold_expr_kind(tail))),
+        }
+    }
+    fn fold_assign_kind(&mut self, kind: AssignKind) -> AssignKind {
+        kind
+    }
+    fn fold_binary(&mut self, b: Binary) -> Binary {
+        let Binary { kind, parts } = b;
+        let (head, tail) = *parts;
+        Binary {
+            kind: self.fold_binary_kind(kind),
+            parts: Box::new((self.fold_expr_kind(head), self.fold_expr_kind(tail))),
+        }
+    }
+    fn fold_binary_kind(&mut self, kind: BinaryKind) -> BinaryKind {
+        kind
+    }
+    fn fold_unary(&mut self, u: Unary) -> Unary {
+        let Unary { kind, tail } = u;
+        Unary { kind: self.fold_unary_kind(kind), tail: Box::new(self.fold_expr_kind(*tail)) }
+    }
+    fn fold_unary_kind(&mut self, kind: UnaryKind) -> UnaryKind {
+        kind
+    }
+    fn fold_index(&mut self, i: Index) -> Index {
+        let Index { head, indices } = i;
+        Index {
+            head: Box::new(self.fold_expr_kind(*head)),
+            indices: indices.into_iter().map(|e| self.fold_expr(e)).collect(),
+        }
+    }
+    fn fold_array(&mut self, a: Array) -> Array {
+        let Array { values } = a;
+        Array { values: values.into_iter().map(|e| self.fold_expr(e)).collect() }
+    }
+    fn fold_array_rep(&mut self, a: ArrayRep) -> ArrayRep {
+        let ArrayRep { value, repeat } = a;
+        ArrayRep {
+            value: Box::new(self.fold_expr_kind(*value)),
+            repeat: Box::new(self.fold_expr_kind(*repeat)),
+        }
+    }
+    fn fold_addrof(&mut self, a: AddrOf) -> AddrOf {
+        let AddrOf { count, mutable, expr } = a;
+        AddrOf {
+            count,
+            mutable: self.fold_mutability(mutable),
+            expr: Box::new(self.fold_expr_kind(*expr)),
+        }
+    }
+    fn fold_block(&mut self, b: Block) -> Block {
+        let Block { stmts } = b;
+        Block { stmts: stmts.into_iter().map(|s| self.fold_stmt(s)).collect() }
+    }
+    fn fold_group(&mut self, g: Group) -> Group {
+        let Group { expr } = g;
+        Group { expr: Box::new(self.fold_expr_kind(*expr)) }
+    }
+    fn fold_tuple(&mut self, t: Tuple) -> Tuple {
+        let Tuple { exprs } = t;
+        Tuple { exprs: exprs.into_iter().map(|e| self.fold_expr(e)).collect() }
+    }
+    fn fold_loop(&mut self, l: Loop) -> Loop {
+        let Loop { body } = l;
+        Loop { body: Box::new(self.fold_expr(*body)) }
+    }
+    fn fold_while(&mut self, w: While) -> While {
+        let While { cond, pass, fail } = w;
+        While {
+            cond: Box::new(self.fold_expr(*cond)),
+            pass: Box::new(self.fold_block(*pass)),
+            fail: self.fold_else(fail),
+        }
+    }
+    fn fold_if(&mut self, i: If) -> If {
+        let If { cond, pass, fail } = i;
+        If {
+            cond: Box::new(self.fold_expr(*cond)),
+            pass: Box::new(self.fold_block(*pass)),
+            fail: self.fold_else(fail),
+        }
+    }
+    fn fold_for(&mut self, f: For) -> For {
+        let For { bind, cond, pass, fail } = f;
+        For {
+            bind: self.fold_identifier(bind),
+            cond: Box::new(self.fold_expr(*cond)),
+            pass: Box::new(self.fold_block(*pass)),
+            fail: self.fold_else(fail),
+        }
+    }
+    fn fold_else(&mut self, e: Else) -> Else {
+        let Else { body } = e;
+        Else { body: body.map(|e| Box::new(self.fold_expr(*e))) }
+    }
+    fn fold_break(&mut self, b: Break) -> Break {
+        let Break { body } = b;
+        Break { body: body.map(|e| Box::new(self.fold_expr(*e))) }
+    }
+    fn fold_return(&mut self, r: Return) -> Return {
+        let Return { body } = r;
+        Return { body: body.map(|e| Box::new(self.fold_expr(*e))) }
+    }
+    fn fold_continue(&mut self, c: Continue) -> Continue {
+        let Continue = c;
+        Continue
+    }
+}
+
+#[inline]
+/// Folds a [Literal] in the default way
+pub fn or_fold_literal<F: Fold + ?Sized>(folder: &mut F, lit: Literal) -> Literal {
+    match lit {
+        Literal::Bool(b) => Literal::Bool(folder.fold_bool(b)),
+        Literal::Char(c) => Literal::Char(folder.fold_char(c)),
+        Literal::Int(i) => Literal::Int(folder.fold_int(i)),
+        Literal::String(s) => Literal::String(folder.fold_string(s)),
+    }
+}
+
+#[inline]
+/// Folds a [MetaKind] in the default way
+pub fn or_fold_meta_kind<F: Fold + ?Sized>(folder: &mut F, kind: MetaKind) -> MetaKind {
+    match kind {
+        MetaKind::Plain => MetaKind::Plain,
+        MetaKind::Equals(l) => MetaKind::Equals(folder.fold_literal(l)),
+        MetaKind::Func(lits) => {
+            MetaKind::Func(lits.into_iter().map(|l| folder.fold_literal(l)).collect())
+        }
+    }
+}
+
+#[inline]
+/// Folds an [ItemKind] in the default way
+pub fn or_fold_item_kind<F: Fold + ?Sized>(folder: &mut F, kind: ItemKind) -> ItemKind {
+    match kind {
+        ItemKind::Module(m) => ItemKind::Module(folder.fold_module(m)),
+        ItemKind::Alias(a) => ItemKind::Alias(folder.fold_alias(a)),
+        ItemKind::Enum(e) => ItemKind::Enum(folder.fold_enum(e)),
+        ItemKind::Struct(s) => ItemKind::Struct(folder.fold_struct(s)),
+        ItemKind::Const(c) => ItemKind::Const(folder.fold_const(c)),
+        ItemKind::Static(s) => ItemKind::Static(folder.fold_static(s)),
+        ItemKind::Function(f) => ItemKind::Function(folder.fold_function(f)),
+        ItemKind::Impl(i) => ItemKind::Impl(folder.fold_impl(i)),
+    }
+}
+
+#[inline]
+/// Folds a [ModuleKind] in the default way
+pub fn or_fold_module_kind<F: Fold + ?Sized>(folder: &mut F, kind: ModuleKind) -> ModuleKind {
+    match kind {
+        ModuleKind::Inline(f) => ModuleKind::Inline(folder.fold_file(f)),
+        ModuleKind::Outline => ModuleKind::Outline,
+    }
+}
+
+#[inline]
+/// Folds a [StructKind] in the default way
+pub fn or_fold_struct_kind<F: Fold + ?Sized>(folder: &mut F, kind: StructKind) -> StructKind {
+    match kind {
+        StructKind::Empty => StructKind::Empty,
+        StructKind::Tuple(tys) => {
+            StructKind::Tuple(tys.into_iter().map(|t| folder.fold_ty(t)).collect())
+        }
+        StructKind::Struct(mem) => StructKind::Struct(
+            mem.into_iter()
+                .map(|m| folder.fold_struct_member(m))
+                .collect(),
+        ),
+    }
+}
+
+#[inline]
+/// Folds an [EnumKind] in the default way
+pub fn or_fold_enum_kind<F: Fold + ?Sized>(folder: &mut F, kind: EnumKind) -> EnumKind {
+    match kind {
+        EnumKind::NoVariants => EnumKind::NoVariants,
+        EnumKind::Variants(v) => {
+            EnumKind::Variants(v.into_iter().map(|v| folder.fold_variant(v)).collect())
+        }
+    }
+}
+
+#[inline]
+/// Folds a [VariantKind] in the default way
+pub fn or_fold_variant_kind<F: Fold + ?Sized>(folder: &mut F, kind: VariantKind) -> VariantKind {
+    match kind {
+        VariantKind::Plain => VariantKind::Plain,
+        VariantKind::CLike(n) => VariantKind::CLike(n),
+        VariantKind::Tuple(t) => VariantKind::Tuple(folder.fold_ty(t)),
+        VariantKind::Struct(mem) => VariantKind::Struct(
+            mem.into_iter()
+                .map(|m| folder.fold_struct_member(m))
+                .collect(),
+        ),
+    }
+}
+
+#[inline]
+/// Folds an [ImplKind] in the default way
+pub fn or_fold_impl_kind<F: Fold + ?Sized>(folder: &mut F, kind: ImplKind) -> ImplKind {
+    match kind {
+        ImplKind::Type(t) => ImplKind::Type(folder.fold_ty(t)),
+        ImplKind::Trait { impl_trait, for_type } => ImplKind::Trait {
+            impl_trait: folder.fold_path(impl_trait),
+            for_type: Box::new(folder.fold_ty(*for_type)),
+        },
+    }
+}
+
+#[inline]
+/// Folds a [TyKind] in the default way
+pub fn or_fold_ty_kind<F: Fold + ?Sized>(folder: &mut F, kind: TyKind) -> TyKind {
+    match kind {
+        TyKind::Never => TyKind::Never,
+        TyKind::Empty => TyKind::Empty,
+        TyKind::SelfTy => TyKind::SelfTy,
+        TyKind::Path(p) => TyKind::Path(folder.fold_path(p)),
+        TyKind::Tuple(t) => TyKind::Tuple(folder.fold_ty_tuple(t)),
+        TyKind::Ref(t) => TyKind::Ref(folder.fold_ty_ref(t)),
+        TyKind::Fn(t) => TyKind::Fn(folder.fold_ty_fn(t)),
+    }
+}
+
+#[inline]
+/// Folds a [StmtKind] in the default way
+pub fn or_fold_stmt_kind<F: Fold + ?Sized>(folder: &mut F, kind: StmtKind) -> StmtKind {
+    match kind {
+        StmtKind::Empty => StmtKind::Empty,
+        StmtKind::Local(l) => StmtKind::Local(folder.fold_let(l)),
+        StmtKind::Item(i) => StmtKind::Item(Box::new(folder.fold_item(*i))),
+        StmtKind::Expr(e) => StmtKind::Expr(Box::new(folder.fold_expr(*e))),
+    }
+}
+#[inline]
+/// Folds an [ExprKind] in the default way
+pub fn or_fold_expr_kind<F: Fold + ?Sized>(folder: &mut F, kind: ExprKind) -> ExprKind {
+    match kind {
+        ExprKind::Empty => ExprKind::Empty,
+        ExprKind::Assign(a) => ExprKind::Assign(folder.fold_assign(a)),
+        ExprKind::Binary(b) => ExprKind::Binary(folder.fold_binary(b)),
+        ExprKind::Unary(u) => ExprKind::Unary(folder.fold_unary(u)),
+        ExprKind::Index(i) => ExprKind::Index(folder.fold_index(i)),
+        ExprKind::Path(p) => ExprKind::Path(folder.fold_path(p)),
+        ExprKind::Literal(l) => ExprKind::Literal(folder.fold_literal(l)),
+        ExprKind::Array(a) => ExprKind::Array(folder.fold_array(a)),
+        ExprKind::ArrayRep(a) => ExprKind::ArrayRep(folder.fold_array_rep(a)),
+        ExprKind::AddrOf(a) => ExprKind::AddrOf(folder.fold_addrof(a)),
+        ExprKind::Block(b) => ExprKind::Block(folder.fold_block(b)),
+        ExprKind::Group(g) => ExprKind::Group(folder.fold_group(g)),
+        ExprKind::Tuple(t) => ExprKind::Tuple(folder.fold_tuple(t)),
+        ExprKind::Loop(l) => ExprKind::Loop(folder.fold_loop(l)),
+        ExprKind::While(w) => ExprKind::While(folder.fold_while(w)),
+        ExprKind::If(i) => ExprKind::If(folder.fold_if(i)),
+        ExprKind::For(f) => ExprKind::For(folder.fold_for(f)),
+        ExprKind::Break(b) => ExprKind::Break(folder.fold_break(b)),
+        ExprKind::Return(r) => ExprKind::Return(folder.fold_return(r)),
+        ExprKind::Continue(c) => ExprKind::Continue(folder.fold_continue(c)),
+    }
+}

compiler/cl-ast/src/ast_visitor/visit.rs

@@ -0,0 +1,411 @@
+//! A [visitor](Visit) (implementer of the [Visit] trait) walks the immutable AST, mutating itself.
+
+use crate::ast::*;
+use cl_structures::span::Span;
+
+/// Immutably walks the entire AST
+///
+/// Each method acts as a customization point.
+///
+/// There are a set of default implementations for enums
+/// under the name [`or_visit_`*](or_visit_expr_kind),
+/// provided for ease of use.
+///
+/// For all other nodes, traversal is *explicit*.
+pub trait Visit<'a>: Sized {
+    fn visit_span(&mut self, _extents: &'a Span) {}
+    fn visit_mutability(&mut self, _mutable: &'a Mutability) {}
+    fn visit_visibility(&mut self, _vis: &'a Visibility) {}
+    fn visit_identifier(&mut self, _name: &'a Identifier) {}
+    fn visit_literal(&mut self, l: &'a Literal) {
+        or_visit_literal(self, l)
+    }
+    fn visit_bool(&mut self, _b: &'a bool) {}
+    fn visit_char(&mut self, _c: &'a char) {}
+    fn visit_int(&mut self, _i: &'a u128) {}
+    fn visit_string(&mut self, _s: &'a str) {}
+    fn visit_file(&mut self, f: &'a File) {
+        let File { items } = f;
+        items.iter().for_each(|i| self.visit_item(i));
+    }
+    fn visit_attrs(&mut self, a: &'a Attrs) {
+        let Attrs { meta } = a;
+        meta.iter().for_each(|m| self.visit_meta(m));
+    }
+    fn visit_meta(&mut self, m: &'a Meta) {
+        let Meta { name, kind } = m;
+        self.visit_identifier(name);
+        self.visit_meta_kind(kind);
+    }
+    fn visit_meta_kind(&mut self, kind: &'a MetaKind) {
+        or_visit_meta_kind(self, kind)
+    }
+    fn visit_item(&mut self, i: &'a Item) {
+        let Item { extents, attrs, vis, kind } = i;
+        self.visit_span(extents);
+        self.visit_attrs(attrs);
+        self.visit_visibility(vis);
+        self.visit_item_kind(kind);
+    }
+    fn visit_item_kind(&mut self, kind: &'a ItemKind) {
+        or_visit_item_kind(self, kind)
+    }
+    fn visit_alias(&mut self, a: &'a Alias) {
+        let Alias { to, from } = a;
+        self.visit_identifier(to);
+        if let Some(t) = from {
+            self.visit_ty(t)
+        }
+    }
+    fn visit_const(&mut self, c: &'a Const) {
+        let Const { name, ty, init } = c;
+        self.visit_identifier(name);
+        self.visit_ty(ty);
+        self.visit_expr(init);
+    }
+    fn visit_static(&mut self, s: &'a Static) {
+        let Static { mutable, name, ty, init } = s;
+        self.visit_mutability(mutable);
+        self.visit_identifier(name);
+        self.visit_ty(ty);
+        self.visit_expr(init);
+    }
+    fn visit_module(&mut self, m: &'a Module) {
+        let Module { name, kind } = m;
+        self.visit_identifier(name);
+        self.visit_module_kind(kind);
+    }
+    fn visit_module_kind(&mut self, kind: &'a ModuleKind) {
+        or_visit_module_kind(self, kind)
+    }
+    fn visit_function(&mut self, f: &'a Function) {
+        let Function { name, sign, bind, body } = f;
+        self.visit_identifier(name);
+        self.visit_ty_fn(sign);
+        bind.iter().for_each(|p| self.visit_param(p));
+        if let Some(b) = body {
+            self.visit_block(b)
+        }
+    }
+    fn visit_param(&mut self, p: &'a Param) {
+        let Param { mutability, name } = p;
+        self.visit_mutability(mutability);
+        self.visit_identifier(name);
+    }
+    fn visit_struct(&mut self, s: &'a Struct) {
+        let Struct { name, kind } = s;
+        self.visit_identifier(name);
+        self.visit_struct_kind(kind);
+    }
+    fn visit_struct_kind(&mut self, kind: &'a StructKind) {
+        or_visit_struct_kind(self, kind)
+    }
+    fn visit_struct_member(&mut self, m: &'a StructMember) {
+        let StructMember { vis, name, ty } = m;
+        self.visit_visibility(vis);
+        self.visit_identifier(name);
+        self.visit_ty(ty);
+    }
+    fn visit_enum(&mut self, e: &'a Enum) {
+        let Enum { name, kind } = e;
+        self.visit_identifier(name);
+        self.visit_enum_kind(kind);
+    }
+    fn visit_enum_kind(&mut self, kind: &'a EnumKind) {
+        or_visit_enum_kind(self, kind)
+    }
+    fn visit_variant(&mut self, v: &'a Variant) {
+        let Variant { name, kind } = v;
+        self.visit_identifier(name);
+        self.visit_variant_kind(kind);
+    }
+    fn visit_variant_kind(&mut self, kind: &'a VariantKind) {
+        or_visit_variant_kind(self, kind)
+    }
+    fn visit_impl(&mut self, i: &'a Impl) {
+        let Impl { target, body } = i;
+        self.visit_impl_kind(target);
+        self.visit_file(body)
+    }
+    fn visit_impl_kind(&mut self, target: &'a ImplKind) {
+        or_visit_impl_kind(self, target)
+    }
+    fn visit_ty(&mut self, t: &'a Ty) {
+        let Ty { extents, kind } = t;
+        self.visit_span(extents);
+        self.visit_ty_kind(kind);
+    }
+    fn visit_ty_kind(&mut self, kind: &'a TyKind) {
+        or_visit_ty_kind(self, kind)
+    }
+    fn visit_ty_tuple(&mut self, t: &'a TyTuple) {
+        let TyTuple { types } = t;
+        types.iter().for_each(|kind| self.visit_ty_kind(kind))
+    }
+    fn visit_ty_ref(&mut self, t: &'a TyRef) {
+        let TyRef { mutable, count: _, to } = t;
+        self.visit_mutability(mutable);
+        self.visit_path(to);
+    }
+    fn visit_ty_fn(&mut self, t: &'a TyFn) {
+        let TyFn { args, rety } = t;
+        self.visit_ty_kind(args);
+        if let Some(rety) = rety {
+            self.visit_ty(rety);
+        }
+    }
+    fn visit_path(&mut self, p: &'a Path) {
+        let Path { absolute: _, parts } = p;
+        parts.iter().for_each(|p| self.visit_path_part(p))
+    }
+    fn visit_path_part(&mut self, p: &'a PathPart) {
+        match p {
+            PathPart::SuperKw => {}
+            PathPart::SelfKw => {}
+            PathPart::Ident(i) => self.visit_identifier(i),
+        }
+    }
+    fn visit_stmt(&mut self, s: &'a Stmt) {
+        let Stmt { extents, kind, semi } = s;
+        self.visit_span(extents);
+        self.visit_stmt_kind(kind);
+        self.visit_semi(semi);
+    }
+    fn visit_stmt_kind(&mut self, kind: &'a StmtKind) {
+        or_visit_stmt_kind(self, kind)
+    }
+    fn visit_semi(&mut self, _s: &'a Semi) {}
+    fn visit_let(&mut self, l: &'a Let) {
+        let Let { mutable, name, ty, init } = l;
+        self.visit_mutability(mutable);
+        self.visit_identifier(name);
+        if let Some(ty) = ty {
+            self.visit_ty(ty);
+        }
+        if let Some(init) = init {
+            self.visit_expr(init)
+        }
+    }
+    fn visit_expr(&mut self, e: &'a Expr) {
+        let Expr { extents, kind } = e;
+        self.visit_span(extents);
+        self.visit_expr_kind(kind)
+    }
+    fn visit_expr_kind(&mut self, e: &'a ExprKind) {
+        or_visit_expr_kind(self, e)
+    }
+    fn visit_assign(&mut self, a: &'a Assign) {
+        let Assign { kind, parts } = a;
+        let (head, tail) = parts.as_ref();
+        self.visit_assign_kind(kind);
+        self.visit_expr_kind(head);
+        self.visit_expr_kind(tail);
+    }
+    fn visit_assign_kind(&mut self, _kind: &'a AssignKind) {}
+    fn visit_binary(&mut self, b: &'a Binary) {
+        let Binary { kind, parts } = b;
+        let (head, tail) = parts.as_ref();
+        self.visit_binary_kind(kind);
+        self.visit_expr_kind(head);
+        self.visit_expr_kind(tail);
+    }
+    fn visit_binary_kind(&mut self, _kind: &'a BinaryKind) {}
+    fn visit_unary(&mut self, u: &'a Unary) {
+        let Unary { kind, tail } = u;
+        self.visit_unary_kind(kind);
+        self.visit_expr_kind(tail);
+    }
+    fn visit_unary_kind(&mut self, _kind: &'a UnaryKind) {}
+    fn visit_index(&mut self, i: &'a Index) {
+        let Index { head, indices } = i;
+        self.visit_expr_kind(head);
+        indices.iter().for_each(|e| self.visit_expr(e));
+    }
+    fn visit_array(&mut self, a: &'a Array) {
+        let Array { values } = a;
+        values.iter().for_each(|e| self.visit_expr(e))
+    }
+    fn visit_array_rep(&mut self, a: &'a ArrayRep) {
+        let ArrayRep { value, repeat } = a;
+        self.visit_expr_kind(value);
+        self.visit_expr_kind(repeat);
+    }
+    fn visit_addrof(&mut self, a: &'a AddrOf) {
+        let AddrOf { count: _, mutable, expr } = a;
+        self.visit_mutability(mutable);
+        self.visit_expr_kind(expr);
+    }
+    fn visit_block(&mut self, b: &'a Block) {
+        let Block { stmts } = b;
+        stmts.iter().for_each(|s| self.visit_stmt(s));
+    }
+    fn visit_group(&mut self, g: &'a Group) {
+        let Group { expr } = g;
+        self.visit_expr_kind(expr)
+    }
+    fn visit_tuple(&mut self, t: &'a Tuple) {
+        let Tuple { exprs } = t;
+        exprs.iter().for_each(|e| self.visit_expr(e))
+    }
+    fn visit_loop(&mut self, l: &'a Loop) {
+        let Loop { body } = l;
+        self.visit_expr(body)
+    }
+    fn visit_while(&mut self, w: &'a While) {
+        let While { cond, pass, fail } = w;
+        self.visit_expr(cond);
+        self.visit_block(pass);
+        self.visit_else(fail);
+    }
+    fn visit_if(&mut self, i: &'a If) {
+        let If { cond, pass, fail } = i;
+        self.visit_expr(cond);
+        self.visit_block(pass);
+        self.visit_else(fail);
+    }
+    fn visit_for(&mut self, f: &'a For) {
+        let For { bind, cond, pass, fail } = f;
+        self.visit_identifier(bind);
+        self.visit_expr(cond);
+        self.visit_block(pass);
+        self.visit_else(fail);
+    }
+    fn visit_else(&mut self, e: &'a Else) {
+        let Else { body } = e;
+        if let Some(body) = body {
+            self.visit_expr(body)
+        }
+    }
+    fn visit_break(&mut self, b: &'a Break) {
+        let Break { body } = b;
+        if let Some(body) = body {
+            self.visit_expr(body)
+        }
+    }
+    fn visit_return(&mut self, r: &'a Return) {
+        let Return { body } = r;
+        if let Some(body) = body {
+            self.visit_expr(body)
+        }
+    }
+    fn visit_continue(&mut self, c: &'a Continue) {
+        let Continue = c;
+    }
+}
+
+pub fn or_visit_literal<'a, V: Visit<'a>>(visitor: &mut V, l: &'a Literal) {
+    match l {
+        Literal::Bool(b) => visitor.visit_bool(b),
+        Literal::Char(c) => visitor.visit_char(c),
+        Literal::Int(i) => visitor.visit_int(i),
+        Literal::String(s) => visitor.visit_string(s),
+    }
+}
+
+pub fn or_visit_meta_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a MetaKind) {
+    match kind {
+        MetaKind::Plain => {}
+        MetaKind::Equals(l) => visitor.visit_literal(l),
+        MetaKind::Func(lits) => lits.iter().for_each(|l| visitor.visit_literal(l)),
+    }
+}
+
+pub fn or_visit_item_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a ItemKind) {
+    match kind {
+        ItemKind::Module(m) => visitor.visit_module(m),
+        ItemKind::Alias(a) => visitor.visit_alias(a),
+        ItemKind::Enum(e) => visitor.visit_enum(e),
+        ItemKind::Struct(s) => visitor.visit_struct(s),
+        ItemKind::Const(c) => visitor.visit_const(c),
+        ItemKind::Static(s) => visitor.visit_static(s),
+        ItemKind::Function(f) => visitor.visit_function(f),
+        ItemKind::Impl(i) => visitor.visit_impl(i),
+    }
+}
+
+pub fn or_visit_module_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a ModuleKind) {
+    match kind {
+        ModuleKind::Inline(f) => visitor.visit_file(f),
+        ModuleKind::Outline => {}
+    }
+}
+
+pub fn or_visit_struct_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a StructKind) {
+    match kind {
+        StructKind::Empty => {}
+        StructKind::Tuple(ty) => ty.iter().for_each(|t| visitor.visit_ty(t)),
+        StructKind::Struct(m) => m.iter().for_each(|m| visitor.visit_struct_member(m)),
+    }
+}
+
+pub fn or_visit_enum_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a EnumKind) {
+    match kind {
+        EnumKind::NoVariants => {}
+        EnumKind::Variants(variants) => variants.iter().for_each(|v| visitor.visit_variant(v)),
+    }
+}
+
+pub fn or_visit_variant_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a VariantKind) {
+    match kind {
+        VariantKind::Plain => {}
+        VariantKind::CLike(_) => {}
+        VariantKind::Tuple(t) => visitor.visit_ty(t),
+        VariantKind::Struct(m) => m.iter().for_each(|m| visitor.visit_struct_member(m)),
+    }
+}
+
+pub fn or_visit_impl_kind<'a, V: Visit<'a>>(visitor: &mut V, target: &'a ImplKind) {
+    match target {
+        ImplKind::Type(t) => visitor.visit_ty(t),
+        ImplKind::Trait { impl_trait, for_type } => {
+            visitor.visit_path(impl_trait);
+            visitor.visit_ty(for_type)
+        }
+    }
+}
+
+pub fn or_visit_ty_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a TyKind) {
+    match kind {
+        TyKind::Never => {}
+        TyKind::Empty => {}
+        TyKind::SelfTy => {}
+        TyKind::Path(p) => visitor.visit_path(p),
+        TyKind::Tuple(t) => visitor.visit_ty_tuple(t),
+        TyKind::Ref(t) => visitor.visit_ty_ref(t),
+        TyKind::Fn(t) => visitor.visit_ty_fn(t),
+    }
+}
+
+pub fn or_visit_stmt_kind<'a, V: Visit<'a>>(visitor: &mut V, kind: &'a StmtKind) {
+    match kind {
+        StmtKind::Empty => {}
+        StmtKind::Local(l) => visitor.visit_let(l),
+        StmtKind::Item(i) => visitor.visit_item(i),
+        StmtKind::Expr(e) => visitor.visit_expr(e),
+    }
+}
+
+pub fn or_visit_expr_kind<'a, V: Visit<'a>>(visitor: &mut V, e: &'a ExprKind) {
+    match e {
+        ExprKind::Empty => {}
+        ExprKind::Assign(a) => visitor.visit_assign(a),
+        ExprKind::Binary(b) => visitor.visit_binary(b),
+        ExprKind::Unary(u) => visitor.visit_unary(u),
+        ExprKind::Index(i) => visitor.visit_index(i),
+        ExprKind::Path(p) => visitor.visit_path(p),
+        ExprKind::Literal(l) => visitor.visit_literal(l),
+        ExprKind::Array(a) => visitor.visit_array(a),
+        ExprKind::ArrayRep(a) => visitor.visit_array_rep(a),
+        ExprKind::AddrOf(a) => visitor.visit_addrof(a),
+        ExprKind::Block(b) => visitor.visit_block(b),
+        ExprKind::Group(g) => visitor.visit_group(g),
+        ExprKind::Tuple(t) => visitor.visit_tuple(t),
+        ExprKind::Loop(l) => visitor.visit_loop(l),
+        ExprKind::While(w) => visitor.visit_while(w),
+        ExprKind::If(i) => visitor.visit_if(i),
+        ExprKind::For(f) => visitor.visit_for(f),
+        ExprKind::Break(b) => visitor.visit_break(b),
+        ExprKind::Return(r) => visitor.visit_return(r),
+        ExprKind::Continue(c) => visitor.visit_continue(c),
+    }
+}

compiler/cl-ast/src/desugar.rs

@@ -0,0 +1,5 @@
+//! Desugaring passes for Conlang
+
+pub mod while_else;
+
+pub mod squash_groups;

compiler/cl-ast/src/desugar/squash_groups.rs

@@ -0,0 +1,14 @@
+//! Squashes group expressions
+use crate::{ast::*, ast_visitor::fold::*};
+
+/// Squashes group expressions
+pub struct SquashGroups;
+
+impl Fold for SquashGroups {
+    fn fold_expr_kind(&mut self, kind: ExprKind) -> ExprKind {
+        match kind {
+            ExprKind::Group(Group { expr }) => self.fold_expr_kind(*expr),
+            _ => or_fold_expr_kind(self, kind),
+        }
+    }
+}

compiler/cl-ast/src/desugar/while_else.rs

@@ -0,0 +1,34 @@
+//! Desugars `while {...} else` expressions
+//! into `loop if {...} else break` expressions
+
+use crate::{ast::*, ast_visitor::fold::Fold};
+use cl_structures::span::Span;
+
+/// Desugars while-else expressions
+/// into loop-if-else-break expressions
+pub struct WhileElseDesugar;
+
+impl Fold for WhileElseDesugar {
+    fn fold_expr(&mut self, e: Expr) -> Expr {
+        let Expr { extents, kind } = e;
+        let kind = desugar_while(extents, kind);
+        Expr { extents: self.fold_span(extents), kind: self.fold_expr_kind(kind) }
+    }
+}
+
+/// Desugars while(-else) expressions into loop-if-else-break expressions
+fn desugar_while(extents: Span, kind: ExprKind) -> ExprKind {
+    match kind {
+        // work backwards: fail -> break -> if -> loop
+        ExprKind::While(While { cond, pass, fail: Else { body } }) => {
+            // Preserve the else-expression's extents, if present, or use the parent's extents
+            let fail_span = body.as_ref().map(|body| body.extents).unwrap_or(extents);
+            let break_expr = Expr { extents: fail_span, kind: ExprKind::Break(Break { body }) };
+
+            let loop_body = If { cond, pass, fail: Else { body: Some(Box::new(break_expr)) } };
+            let loop_body = Expr { extents, kind: ExprKind::If(loop_body) };
+            ExprKind::Loop(Loop { body: Box::new(loop_body) })
+        }
+        _ => kind,
+    }
+}

compiler/cl-ast/src/format.rs

@@ -0,0 +1,78 @@
+
+use delimiters::Delimiters;
+use std::fmt::Write;
+
+impl<W: Write + ?Sized> FmtAdapter for W {}
+pub trait FmtAdapter: Write {
+    fn indent(&mut self) -> Indent<Self> {
+        Indent { f: self }
+    }
+    fn delimit(&mut self, delim: Delimiters) -> Delimit<Self> {
+        Delimit::new(self, delim)
+    }
+}
+
+/// Pads text with leading indentation after every newline
+pub struct Indent<'f, F: Write + ?Sized> {
+    f: &'f mut F,
+}
+
+impl<'f, F: Write + ?Sized> Write for Indent<'f, F> {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        for s in s.split_inclusive('\n') {
+            self.f.write_str(s)?;
+            if s.ends_with('\n') {
+                self.f.write_str("    ")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Prints [Delimiters] around anything formatted with this. Implies [Indent]
+pub struct Delimit<'f, F: Write + ?Sized> {
+    f: Indent<'f, F>,
+    delim: Delimiters,
+}
+impl<'f, F: Write + ?Sized> Delimit<'f, F> {
+    pub fn new(f: &'f mut F, delim: Delimiters) -> Self {
+        let mut f = f.indent();
+        let _ = f.write_str(delim.open);
+        Self { f, delim }
+    }
+}
+impl<'f, F: Write + ?Sized> Drop for Delimit<'f, F> {
+    fn drop(&mut self) {
+        let Self { f: Indent { f, .. }, delim } = self;
+        let _ = f.write_str(delim.close);
+    }
+}
+
+impl<'f, F: Write + ?Sized> Write for Delimit<'f, F> {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.f.write_str(s)
+    }
+}
+
+pub mod delimiters {
+    #![allow(dead_code)]
+    #[derive(Clone, Copy, Debug)]
+    pub struct Delimiters {
+        pub open: &'static str,
+        pub close: &'static str,
+    }
+    /// Delimits with braces decorated with spaces  `" {\n"`, ..., `"\n}"`
+    pub const SPACED_BRACES: Delimiters = Delimiters { open: " {\n", close: "\n}" };
+    /// Delimits with braces on separate lines `{\n`, ..., `\n}`
+    pub const BRACES: Delimiters = Delimiters { open: "{\n", close: "\n}" };
+    /// Delimits with parentheses on separate lines `{\n`, ..., `\n}`
+    pub const PARENS: Delimiters = Delimiters { open: "(\n", close: "\n)" };
+    /// Delimits with square brackets on separate lines `{\n`, ..., `\n}`
+    pub const SQUARE: Delimiters = Delimiters { open: "[\n", close: "\n]" };
+    /// Delimits with braces on the same line `{ `, ..., ` }`
+    pub const INLINE_BRACES: Delimiters = Delimiters { open: "{ ", close: " }" };
+    /// Delimits with parentheses on the same line `( `, ..., ` )`
+    pub const INLINE_PARENS: Delimiters = Delimiters { open: "(", close: ")" };
+    /// Delimits with square brackets on the same line `[ `, ..., ` ]`
+    pub const INLINE_SQUARE: Delimiters = Delimiters { open: "[", close: "]" };
+}

compiler/cl-ast/src/lib.rs

@@ -0,0 +1,21 @@
+//! # The Abstract Syntax Tree
+//! Contains definitions of Conlang AST Nodes.
+//!
+//! # Notable nodes
+//! - [Item] and [ItemKind]: Top-level constructs
+//! - [Stmt] and [StmtKind]: Statements
+//! - [Expr] and [ExprKind]: Expressions
+//!   - [Assign], [Binary], and [Unary] expressions
+//!   - [AssignKind], [BinaryKind], and [UnaryKind] operators
+//! - [Ty] and [TyKind]: Type qualifiers
+//! - [Path]: Path expressions
+#![warn(clippy::all)]
+#![feature(decl_macro)]
+
+pub use ast::*;
+
+pub mod ast;
+pub mod ast_impl;
+pub mod ast_visitor;
+pub mod desugar;
+pub mod format;