conlang: deprecate the AST

libconlang/src/ast.rs

@@ -7,7 +7,7 @@
 //! [`Identifier`]` := `[`IDENTIFIER`](crate::token::token_type::Type::Identifier)
 //!
 //! See [statement], [literal], and [expression] for more information.
-
+#![deprecated]
 pub mod preamble {
     #![allow(deprecated)]
     //! Common imports for working with the [ast](super)
@@ -123,12 +123,30 @@ pub mod statement {
         /// # Syntax
         /// [`Fn`](Stmt::Fn) := `"fn"` [`Identifier`] `'('` `Args...` `')'` [`Block`]
         Fn(FnDecl),
+        /// Contains a module declaration
+        /// # Syntax
+        /// [`Mod`](Stmt::Mod) := `"mod"` [`Identifier`] `'{'`
+        ///
+        /// `'}'`
         /// Contains an expression statement
         /// # Syntax
         /// [`Expr`](Stmt::Expr) := [`Expr`] `;`
         Expr(Expr),
     }
 
+    /// Contains the declarations allowed in a module
+    ///
+    /// # Syntax
+    /// [Mod](Module::Mod) := "mod" [Identifier] '{' [Module] '}'
+    /// [`Let`](Module::Let) := `"let"` [`Identifier`] (`:` `Type`)? (`=` [`Expr`])? `;`
+    #[derive(Clone, Debug)]
+    pub enum Module {
+        Struct(StructDecl),
+        Mod(ModuleDecl),
+        Let(Let),
+        Fn(FnDecl),
+    }
+
     /// Contains a variable declaration
     /// # Syntax
     /// [`Let`] := `let` [`Identifier`] (`:`) `Type`)? (`=` [`Expr`])? `;`
@@ -160,7 +178,22 @@ pub mod statement {
         pub ty: Option<TypeExpr>,
     }
 
+    /// Contains the name and declaration
+    #[derive(Clone, Debug)]
+    pub struct ModuleDecl {}
+
     // TODO: Create closure, transmute fndecl into a name and closure
+    /// Contains the name and field information for a struct
+    ///
+    /// # Syntax
+    /// [`StructDecl`]` := "struct" `[`Identifier`]` '{'
+    /// (`[`Identifier`]` ':' `[`TypeExpr`]`),*
+    /// '}'`
+    #[derive(Clone, Debug)]
+    pub struct StructDecl {
+        pub name: Identifier,
+        pub data: Vec<(Identifier, TypeExpr)>,
+    }
 }
 
 pub mod path {
@@ -324,6 +357,10 @@ pub mod expression {
             pub callee: Box<Primary>,
             pub args: Vec<Tuple>,
         }
+        #[allow(non_snake_case)]
+        pub fn FnCall(callee: Box<Primary>, args: Vec<Tuple>) -> FnCall {
+            FnCall { callee, args }
+        }
     }
 
     pub mod tuple {
@@ -762,6 +799,16 @@ pub mod todo {
         //! traits, modules, etc.
     }
 
+    pub mod module {
+        //! Module support
+        //! - [ ] Add Module Declaration type : ModDecl = "mod" Identifier '{' Module '}' ;
+        //! - [ ] Change Program to Module : Module = (ModDecl | FnDecl | Let)*
+        //!   - [ ] Implementer's note: Modules must be traversed breadth-first, with no
+        //!     alpha-renaming
+        //!   - [ ] Blocks should probably also be traversed breadth-first, and Let declarations
+        //!     hoisted up, leaving initialization assignments in-place
+    }
+
     pub mod structure {
         //! Struct support
         //! - [ ] Add struct declaration expression (returns a struct declaration)

libconlang/src/parser.rs

@@ -1,5 +1,6 @@
 //! Parses [tokens](super::token) into an [AST](super::ast)
-
+#![deprecated]
+#![allow(deprecated)]
 use super::{ast::preamble::*, lexer::Lexer, token::preamble::*};
 use error::{Error, *};
 

libconlang/src/pretty_printer.rs

@@ -1,5 +1,6 @@
 //! A [Printer] pretty-prints a Conlang [syntax tree](crate::ast)
-
+#![deprecated]
+#![allow(deprecated)]
 use super::ast::preamble::*;
 use std::{
     fmt::Display,

libconlang/src/resolver.rs

@@ -3,8 +3,6 @@
 //! This will hopefully become a fully fledged static resolution pass in the future
 use std::collections::HashMap;
 
-use crate::ast::preamble::*;
-
 use scopeguard::Scoped;
 pub mod scopeguard {
     //! Implements a generic RAII scope-guard
@@ -488,362 +486,374 @@ pub trait Resolve {
         Ok(Type::Empty)
     }
 }
-
+mod ast1 {
-impl Resolve for Start {
+    #![allow(deprecated)]
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+    use super::*;
-        let Self(program) = self;
+    use crate::ast::preamble::*;
-        program.resolve(resolver)
+    impl Resolve for Start {
-    }
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-}
+            let Self(program) = self;
-impl Resolve for Program {
+            program.resolve(resolver)
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let Self(module) = self;
-        for decl in module {
-            decl.resolve(resolver)?;
-        }
-        // TODO: record the number of module-level assignments into the AST
-        Ok(Type::Empty)
-    }
-}
-impl Resolve for Stmt {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        match self {
-            Stmt::Let(value) => value.resolve(resolver),
-            Stmt::Fn(value) => value.resolve(resolver),
-            Stmt::Expr(value) => value.resolve(resolver),
         }
     }
-}
+    impl Resolve for Program {
-impl Resolve for Let {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Self(module) = self;
-        let Let { name: Name { symbol: Identifier { name, index }, mutable, ty: _ }, init } = self;
+            for decl in module {
-        debugln!("ty> let {name} ...");
+                decl.resolve(resolver)?;
-        if let Some(init) = init {
-            let ty = init.resolve(resolver)?;
-            *index = Some(resolver.insert_scope(name, *mutable)?);
-            resolver.get_mut(name)?.assign(name, &ty)?;
-        } else {
-            resolver.insert_scope(name, *mutable)?;
-        }
-        Ok(Type::Empty)
-    }
-}
-impl Resolve for FnDecl {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let FnDecl { name: Name { symbol: Identifier { name, index }, .. }, args, body } = self;
-        debugln!("ty> fn {name} ...");
-        // register the name at module scope
-        *index = Some(resolver.insert_module(name, false)?);
-        // create a new lexical scope
-        let scopes = std::mem::take(&mut resolver.scopes);
-        // type-check the function body
-        let out = {
-            let mut resolver = resolver.frame();
-            let mut evaluated_args = vec![];
-            for arg in args {
-                evaluated_args.push(arg.resolve(&mut resolver)?)
             }
-            let fn_decl = Type::Fn { args: evaluated_args.clone(), ret: Box::new(Type::Empty) };
+            // TODO: record the number of module-level assignments into the AST
-            resolver.get_mut(name)?.assign(name, &fn_decl)?;
+            Ok(Type::Empty)
-            module!(resolver, name, { body.resolve(&mut resolver) })
-        };
-        let _ = std::mem::replace(&mut resolver.scopes, scopes);
-        out
-    }
-}
-impl Resolve for Name {
-    fn resolve(&mut self, _resolver: &mut Resolver) -> TyResult<Type> {
-        Ok(Type::Empty)
-    }
-}
-impl Resolve for Block {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let Block { let_count: _, statements, expr } = self;
-        let mut resolver = resolver.frame();
-        for stmt in statements {
-            stmt.resolve(&mut resolver)?;
         }
-        expr.resolve(&mut resolver)
     }
-}
+    impl Resolve for Stmt {
-impl Resolve for Expr {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            match self {
-        let Expr(expr) = self;
+                Stmt::Let(value) => value.resolve(resolver),
-        expr.resolve(resolver)
+                Stmt::Fn(value) => value.resolve(resolver),
+                Stmt::Expr(value) => value.resolve(resolver),
+            }
+        }
+    }
+    impl Resolve for Let {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Let { name: Name { symbol: Identifier { name, index }, mutable, ty: _ }, init } =
+                self;
+            debugln!("ty> let {name} ...");
+            if let Some(init) = init {
+                let ty = init.resolve(resolver)?;
+                *index = Some(resolver.insert_scope(name, *mutable)?);
+                resolver.get_mut(name)?.assign(name, &ty)?;
+            } else {
+                resolver.insert_scope(name, *mutable)?;
+            }
+            Ok(Type::Empty)
+        }
+    }
+    impl Resolve for FnDecl {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let FnDecl { name: Name { symbol: Identifier { name, index }, .. }, args, body } = self;
+            debugln!("ty> fn {name} ...");
+            // register the name at module scope
+            *index = Some(resolver.insert_module(name, false)?);
+            // create a new lexical scope
+            let scopes = std::mem::take(&mut resolver.scopes);
+            // type-check the function body
+            let out = {
+                let mut resolver = resolver.frame();
+                let mut evaluated_args = vec![];
+                for arg in args {
+                    evaluated_args.push(arg.resolve(&mut resolver)?)
+                }
+                let fn_decl = Type::Fn { args: evaluated_args.clone(), ret: Box::new(Type::Empty) };
+                resolver.get_mut(name)?.assign(name, &fn_decl)?;
+                module!(resolver, name, { body.resolve(&mut resolver) })
+            };
+            let _ = std::mem::replace(&mut resolver.scopes, scopes);
+            out
+        }
+    }
+    impl Resolve for Name {
+        fn resolve(&mut self, _resolver: &mut Resolver) -> TyResult<Type> {
+            Ok(Type::Empty)
+        }
+    }
+    impl Resolve for Block {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Block { let_count: _, statements, expr } = self;
+            let mut resolver = resolver.frame();
+            for stmt in statements {
+                stmt.resolve(&mut resolver)?;
+            }
+            expr.resolve(&mut resolver)
+        }
+    }
+    impl Resolve for Expr {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Expr(expr) = self;
+            expr.resolve(resolver)
+        }
     }
-}
 
-impl Resolve for Operation {
+    impl Resolve for Operation {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        match self {
+            match self {
-            Operation::Assign(value) => value.resolve(resolver),
+                Operation::Assign(value) => value.resolve(resolver),
-            Operation::Binary(value) => value.resolve(resolver),
+                Operation::Binary(value) => value.resolve(resolver),
-            Operation::Unary(value) => value.resolve(resolver),
+                Operation::Unary(value) => value.resolve(resolver),
-            Operation::Call(value) => value.resolve(resolver),
+                Operation::Call(value) => value.resolve(resolver),
+            }
         }
     }
-}
+    impl Resolve for Assign {
-impl Resolve for Assign {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Assign { target, operator, init } = self;
-        let Assign { target, operator, init } = self;
+            // Evaluate the initializer expression
-        // Evaluate the initializer expression
+            let ty = init.resolve(resolver)?;
-        let ty = init.resolve(resolver)?;
+            // Resolve the variable
-        // Resolve the variable
+            match (operator, resolver.get_mut(&target.name)?) {
-        match (operator, resolver.get_mut(&target.name)?) {
+                (
-            (
+                    operator::Assign::Assign,
-                operator::Assign::Assign,
+                    Variable { status: Status::Initialized(_), mutable: false, index },
-                Variable { status: Status::Initialized(_), mutable: false, index },
+                ) => Err(Error::ImmutableAssign(target.name.clone(), *index)),
-            ) => Err(Error::ImmutableAssign(target.name.clone(), *index)),
+                // TODO: make typing more expressive for modifying assignment
-            // TODO: make typing more expressive for modifying assignment
+                (_, variable) => variable
-            (_, variable) => variable
+                    .modify_assign(&target.name, &ty)
-                .modify_assign(&target.name, &ty)
+                    .map(|_| Type::Empty),
-                .map(|_| Type::Empty),
+            }
         }
     }
-}
 
-impl Resolve for Binary {
+    impl Resolve for Binary {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let Binary { first, other } = self;
+            let Binary { first, other } = self;
 
-        let mut first = first.resolve(resolver)?;
+            let mut first = first.resolve(resolver)?;
-        for (op, other) in other {
+            for (op, other) in other {
-            let other = other.resolve(resolver)?;
+                let other = other.resolve(resolver)?;
-            first = resolver.resolve_binary_operator(first, other, op)?;
+                first = resolver.resolve_binary_operator(first, other, op)?;
-        }
+            }
-        Ok(first)
-    }
-}
-impl Resolve for Unary {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let Unary { operators, operand } = self;
-        let mut operand = operand.resolve(resolver)?;
-        for op in operators {
-            operand = resolver.resolve_unary_operator(operand, op)?;
-        }
-        Ok(operand)
-    }
-}
-/// Resolve [operator]s
-impl Resolver {
-    fn resolve_binary_operator(
-        &mut self,
-        first: Type,
-        other: Type,
-        op: &operator::Binary,
-    ) -> TyResult<Type> {
-        // TODO: check type compatibility for binary ops
-        // TODO: desugar binary ops into function calls, when member functions are a thing
-        eprintln!("Resolve binary operators {first} {op:?} {other}");
-        if first != other {
-            Err(Error::TypeMismatch { want: first, got: other })
-        } else {
             Ok(first)
         }
     }
-    fn resolve_unary_operator(&mut self, operand: Type, op: &operator::Unary) -> TyResult<Type> {
+    impl Resolve for Unary {
-        // TODO: Allow more expressive unary operator type conversions
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        todo!("Resolve unary operators {op:?} {operand}")
+            let Unary { operators, operand } = self;
-    }
+            let mut operand = operand.resolve(resolver)?;
-}
+            for op in operators {
-impl Resolve for Call {
+                operand = resolver.resolve_unary_operator(operand, op)?;
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            }
-        match self {
+            Ok(operand)
-            Call::FnCall(value) => value.resolve(resolver),
-            Call::Primary(value) => value.resolve(resolver),
         }
     }
-}
+    /// Resolve [operator]s
-impl Resolve for FnCall {
+    impl Resolver {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+        fn resolve_binary_operator(
-        let FnCall { callee, args } = self;
+            &mut self,
-        let mut callee = callee.resolve(resolver)?;
+            first: Type,
-        for argset in args {
+            other: Type,
-            // arguments should always be a tuple here
+            op: &operator::Binary,
-            let arguments = argset.resolve(resolver)?;
+        ) -> TyResult<Type> {
-            let Type::Tuple(arguments) = arguments else {
+            // TODO: check type compatibility for binary ops
-                Err(Error::TypeMismatch {
+            // TODO: desugar binary ops into function calls, when member functions are a thing
-                    want: Type::Tuple(vec![Type::ManyInferred]),
+            eprintln!("Resolve binary operators {first} {op:?} {other}");
-                    got: arguments,
+            if first != other {
-                })?
+                Err(Error::TypeMismatch { want: first, got: other })
-            };
+            } else {
-            // Verify that the callee is a function, and the arguments match.
+                Ok(first)
-            // We need the arguments
+            }
-            let Type::Fn { args, ret } = callee else {
+        }
-                return Err(Error::TypeMismatch {
+        fn resolve_unary_operator(
-                    want: Type::Fn { args: arguments, ret: Type::Inferred.into() },
+            &mut self,
-                    got: callee,
+            operand: Type,
-                })?;
+            op: &operator::Unary,
-            };
+        ) -> TyResult<Type> {
-            for (want, got) in args.iter().zip(&arguments) {
+            // TODO: Allow more expressive unary operator type conversions
-                // TODO: verify generics
+            todo!("Resolve unary operators {op:?} {operand}")
-                if let Type::Generic(_) = want {
+        }
-                    continue;
+    }
-                }
+    impl Resolve for Call {
-                if want != got {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            match self {
+                Call::FnCall(value) => value.resolve(resolver),
+                Call::Primary(value) => value.resolve(resolver),
+            }
+        }
+    }
+    impl Resolve for FnCall {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let FnCall { callee, args } = self;
+            let mut callee = callee.resolve(resolver)?;
+            for argset in args {
+                // arguments should always be a tuple here
+                let arguments = argset.resolve(resolver)?;
+                let Type::Tuple(arguments) = arguments else {
+                    Err(Error::TypeMismatch {
+                        want: Type::Tuple(vec![Type::ManyInferred]),
+                        got: arguments,
+                    })?
+                };
+                // Verify that the callee is a function, and the arguments match.
+                // We need the arguments
+                let Type::Fn { args, ret } = callee else {
                     return Err(Error::TypeMismatch {
                         want: Type::Fn { args: arguments, ret: Type::Inferred.into() },
-                        got: Type::Fn { args, ret },
+                        got: callee,
                     })?;
+                };
+                for (want, got) in args.iter().zip(&arguments) {
+                    // TODO: verify generics
+                    if let Type::Generic(_) = want {
+                        continue;
+                    }
+                    if want != got {
+                        return Err(Error::TypeMismatch {
+                            want: Type::Fn { args: arguments, ret: Type::Inferred.into() },
+                            got: Type::Fn { args, ret },
+                        })?;
+                    }
                 }
+                callee = *ret;
             }
-            callee = *ret;
+            Ok(callee)
         }
-        Ok(callee)
     }
-}
+    impl Resolve for Primary {
-impl Resolve for Primary {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            match self {
-        match self {
+                Primary::Identifier(value) => value.resolve(resolver),
-            Primary::Identifier(value) => value.resolve(resolver),
+                Primary::Literal(value) => value.resolve(resolver),
-            Primary::Literal(value) => value.resolve(resolver),
+                Primary::Block(value) => value.resolve(resolver),
-            Primary::Block(value) => value.resolve(resolver),
+                Primary::Group(value) => value.resolve(resolver),
-            Primary::Group(value) => value.resolve(resolver),
+                Primary::Branch(value) => value.resolve(resolver),
-            Primary::Branch(value) => value.resolve(resolver),
+            }
+        }
+    }
+
+    impl Resolve for Group {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            match self {
+                Group::Tuple(tuple) => tuple.resolve(resolver),
+                Group::Single(expr) => expr.resolve(resolver),
+                Group::Empty => Ok(Type::Empty),
+            }
+        }
+    }
+
+    impl Resolve for Tuple {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Tuple { elements } = self;
+            let mut types = vec![];
+            for expr in elements.iter_mut() {
+                types.push(expr.resolve(resolver)?);
+            }
+            Ok(Type::Tuple(types))
+        }
+    }
+
+    impl Resolve for Identifier {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Identifier { name, index: id_index } = self;
+            let Variable { index, status, .. } = resolver.get(name)?;
+            *id_index = Some(*index);
+            let ty = match status {
+                Status::Initialized(t) => t,
+                _ => Err(Error::Uninitialized(name.to_owned(), *index))?,
+            };
+            debugln!("ty> Resolved {} #{index}: {ty}", name);
+            Ok(ty.to_owned())
+        }
+    }
+    impl Resolve for Literal {
+        fn resolve(&mut self, _resolver: &mut Resolver) -> TyResult<Type> {
+            Ok(match self {
+                Literal::String(_) => Type::String,
+                Literal::Char(_) => Type::Char,
+                Literal::Bool(_) => Type::Bool,
+                Literal::Float(_) => Type::Float,
+                Literal::Int(_) => Type::Int,
+            })
+        }
+    }
+
+    impl Resolve for Flow {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            // TODO: Finish this
+            match self {
+                Flow::While(value) => value.resolve(resolver),
+                Flow::If(value) => value.resolve(resolver),
+                Flow::For(value) => value.resolve(resolver),
+                Flow::Continue(value) => value.resolve(resolver),
+                Flow::Return(value) => value.resolve(resolver),
+                Flow::Break(value) => value.resolve(resolver),
+            }
+        }
+    }
+    impl Resolve for While {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            // TODO: Finish this
+            // Visit else first, save that to a break-pattern stack in the Resolver,
+            // and check it inside Break::resolve()
+            let While { cond, body, else_ } = self;
+            cond.resolve(resolver)?; // must be Type::Bool
+            body.resolve(resolver)?; // discard
+            else_.resolve(resolver) // compare with returns inside body
+        }
+    }
+    impl Resolve for If {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let If { cond, body, else_ } = self;
+            let cond = cond.resolve(resolver)?;
+            if Type::Bool != cond {
+                return Err(Error::TypeMismatch { want: Type::Bool, got: cond });
+            }
+            let body_ty = body.resolve(resolver)?;
+            let else_ty = else_.resolve(resolver)?;
+            if body_ty == else_ty {
+                Ok(body_ty)
+            } else {
+                Err(Error::TypeMismatch { want: body_ty, got: else_ty })
+            }
+        }
+    }
+
+    impl Resolve for For {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let For { var: Identifier { name, index }, iter, body, else_ } = self;
+            debugln!("> for {name} in ...");
+            // Visit the iter expression and get its type
+            let range = iter.resolve(resolver)?;
+            let ty = match range {
+                Type::Range(t) => t,
+                got => Err(Error::TypeMismatch { want: Type::Range(Type::Inferred.into()), got })?,
+            };
+            let body_ty = {
+                let mut resolver = resolver.frame();
+                // bind the variable in the loop scope
+                *index = Some(resolver.insert_scope(name, false)?);
+                resolver.get_mut(name)?.assign(name, &ty)?;
+                body.resolve(&mut resolver)
+            }?;
+            // visit the else block
+            let else_ty = else_.resolve(resolver)?;
+            if body_ty != else_ty {
+                Err(Error::TypeMismatch { want: body_ty, got: else_ty })
+            } else {
+                Ok(body_ty)
+            }
+        }
+    }
+    impl Resolve for Else {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            let Else { expr } = self;
+            expr.resolve(resolver)
+        }
+    }
+
+    impl Resolve for Continue {
+        fn resolve(&mut self, _resolver: &mut Resolver) -> TyResult<Type> {
+            // TODO: Finish control flow
+            Ok(Type::Never)
+        }
+    }
+    impl Resolve for Break {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            // TODO: Finish control flow
+            let Break { expr } = self;
+            expr.resolve(resolver)
+        }
+    }
+    impl Resolve for Return {
+        fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
+            // TODO: Finish control flow
+            let Return { expr } = self;
+            expr.resolve(resolver)
         }
     }
 }
 
-impl Resolve for Group {
+mod ast2 {}
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        match self {
-            Group::Tuple(tuple) => tuple.resolve(resolver),
-            Group::Single(expr) => expr.resolve(resolver),
-            Group::Empty => Ok(Type::Empty),
-        }
-    }
-}
 
-impl Resolve for Tuple {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let Tuple { elements } = self;
-        let mut types = vec![];
-        for expr in elements.iter_mut() {
-            types.push(expr.resolve(resolver)?);
-        }
-        Ok(Type::Tuple(types))
-    }
-}
-
-impl Resolve for Identifier {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let Identifier { name, index: id_index } = self;
-        let Variable { index, status, .. } = resolver.get(name)?;
-        *id_index = Some(*index);
-        let ty = match status {
-            Status::Initialized(t) => t,
-            _ => Err(Error::Uninitialized(name.to_owned(), *index))?,
-        };
-        debugln!("ty> Resolved {} #{index}: {ty}", name);
-        Ok(ty.to_owned())
-    }
-}
-impl Resolve for Literal {
-    fn resolve(&mut self, _resolver: &mut Resolver) -> TyResult<Type> {
-        Ok(match self {
-            Literal::String(_) => Type::String,
-            Literal::Char(_) => Type::Char,
-            Literal::Bool(_) => Type::Bool,
-            Literal::Float(_) => Type::Float,
-            Literal::Int(_) => Type::Int,
-        })
-    }
-}
-
-impl Resolve for Flow {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        // TODO: Finish this
-        match self {
-            Flow::While(value) => value.resolve(resolver),
-            Flow::If(value) => value.resolve(resolver),
-            Flow::For(value) => value.resolve(resolver),
-            Flow::Continue(value) => value.resolve(resolver),
-            Flow::Return(value) => value.resolve(resolver),
-            Flow::Break(value) => value.resolve(resolver),
-        }
-    }
-}
-impl Resolve for While {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        // TODO: Finish this
-        // Visit else first, save that to a break-pattern stack in the Resolver,
-        // and check it inside Break::resolve()
-        let While { cond, body, else_ } = self;
-        cond.resolve(resolver)?; // must be Type::Bool
-        body.resolve(resolver)?; // discard
-        else_.resolve(resolver) // compare with returns inside body
-    }
-}
-impl Resolve for If {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let If { cond, body, else_ } = self;
-        let cond = cond.resolve(resolver)?;
-        if Type::Bool != cond {
-            return Err(Error::TypeMismatch { want: Type::Bool, got: cond });
-        }
-        let body_ty = body.resolve(resolver)?;
-        let else_ty = else_.resolve(resolver)?;
-        if body_ty == else_ty {
-            Ok(body_ty)
-        } else {
-            Err(Error::TypeMismatch { want: body_ty, got: else_ty })
-        }
-    }
-}
-
-impl Resolve for For {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let For { var: Identifier { name, index }, iter, body, else_ } = self;
-        debugln!("> for {name} in ...");
-        // Visit the iter expression and get its type
-        let range = iter.resolve(resolver)?;
-        let ty = match range {
-            Type::Range(t) => t,
-            got => Err(Error::TypeMismatch { want: Type::Range(Type::Inferred.into()), got })?,
-        };
-        let body_ty = {
-            let mut resolver = resolver.frame();
-            // bind the variable in the loop scope
-            *index = Some(resolver.insert_scope(name, false)?);
-            resolver.get_mut(name)?.assign(name, &ty)?;
-            body.resolve(&mut resolver)
-        }?;
-        // visit the else block
-        let else_ty = else_.resolve(resolver)?;
-        if body_ty != else_ty {
-            Err(Error::TypeMismatch { want: body_ty, got: else_ty })
-        } else {
-            Ok(body_ty)
-        }
-    }
-}
-impl Resolve for Else {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        let Else { expr } = self;
-        expr.resolve(resolver)
-    }
-}
-
-impl Resolve for Continue {
-    fn resolve(&mut self, _resolver: &mut Resolver) -> TyResult<Type> {
-        // TODO: Finish control flow
-        Ok(Type::Never)
-    }
-}
-impl Resolve for Break {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        // TODO: Finish control flow
-        let Break { expr } = self;
-        expr.resolve(resolver)
-    }
-}
-impl Resolve for Return {
-    fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {
-        // TODO: Finish control flow
-        let Return { expr } = self;
-        expr.resolve(resolver)
-    }
-}
 // heakc yea man, generics
 impl<T: Resolve> Resolve for Option<T> {
     fn resolve(&mut self, resolver: &mut Resolver) -> TyResult<Type> {