adopt rust's array syntax

frontend/src/ast.rs

···
 pub enum AllocKind {
     // this should always be a ComptimeInt by the time we get to MIR lowering
     Array(Box<TypeKind>, Box<ComptimeValue>),
-    DynArray(Box<TypeKind>),
     Record(Vec<RecordField>),
     Str(String),
     Tuple(Vec<TypeKind>),
···
     pub fn fill_type(&mut self, ty: TypeKind) {
         match self {
             AllocKind::Array(ty_, _) => *ty_ = Box::new(ty),
-            AllocKind::DynArray(ty_) => *ty_ = Box::new(ty),
             _ => {}
         }
     }
···
         kind: AllocKind,
         // some allocations may not have elements, we just leave this empty
         elements: Vec<Expr>,
+        // for [expr; n] syntax - the default element to repeat n times
+        default_elem: Option<Box<Expr>>,
         // without a region, this is allocated in the function's implicit contextual region
         region: Option<Region>,
     },

frontend/src/ast_typecheck/tests.rs

···
+#![cfg(test)]
+
+use super::*;
+
+use std::collections::VecDeque;
+
+use crate::{ast::TypeKind, ctx::Ctx, lex, parse, span::Spanned};
+
+fn tokenify(s: &str) -> (Ctx, VecDeque<Spanned<crate::lex::Token>>) {
+    let mut ctx = Ctx::default();
+    let tokens = lex::tokenize(&mut ctx, s).map(|t| t.unwrap()).collect();
+    (ctx, tokens)
+}
+
+fn parseify(ctx: &mut Ctx, tokens: VecDeque<Spanned<crate::lex::Token>>) -> Module {
+    parse::parse(ctx, tokens).unwrap()
+}
+
+fn typecheck_src(src: &str) -> (Ctx, TypecheckResult<Module>) {
+    let (mut ctx, tokens) = tokenify(src);
+    let mut module = parseify(&mut ctx, tokens);
+    let result = typecheck(&mut ctx, &mut module);
+    (ctx, result)
+}
+
+#[test]
+fn test_typecheck_simple_procedure() {
+    let src = "foo :: (x: int): int { y : int = x }";
+    let (_, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_infers_val_type() {
+    let src = "foo :: (x: int): int { y := x }";
+    let (_, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
+        panic!("expected procedure");
+    };
+
+    let StmtKind::ValDec { ty, .. } = &block.node.stmts[0].node else {
+        panic!("expected val dec");
+    };
+
+    assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
+}
+
+#[test]
+fn test_typecheck_binop_expression() {
+    let src = "foo :: (x: int, y: int): int { z : int = x + y }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_assignment() {
+    let src = "foo :: (x: int): int { y : int = x \n y = x + 1 }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_if_else() {
+    let src = "foo :: (x: int): int { if x { y : int = 1 } else { z : int = 2 } }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_constant() {
+    let src = "MY_CONST :: 42";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Constant { ty, .. } = &module.declarations[0].node else {
+        panic!("expected constant");
+    };
+
+    assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
+}
+
+#[test]
+fn test_typecheck_function_call() {
+    let src = "bar :: (x: int): int { y : int = 1 } \n foo :: (a: int): int { bar(1) }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_function_call_with_return() {
+    let src =
+        "bar :: (x: int): int { y : int = 1 } \n foo :: (a: int): int { result : int = bar(1) }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_error_unknown_symbol_in_ident() {
+    let src = "foo :: (): int { y : int = unknown }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
+}
+
+#[test]
+fn test_typecheck_error_unknown_symbol_in_assignment() {
+    let src = "foo :: (): int { y : int = 1 \n y = unknown }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
+}
+
+#[test]
+fn test_typecheck_error_unknown_function() {
+    let src = "foo :: (): int { unknown_func(1) }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_err());
+
+    let err = result.unwrap_err();
+    assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
+}
+
+#[test]
+fn test_typecheck_nested_if() {
+    let src = "foo :: (x: int): int { if 1 { if 1 { y : int = 1 } } }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_multiple_params() {
+    let src = "foo :: (a: int, b: int, c: int): int { sum : int = 1 + 2 + 3 }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_procedure_infers_fn_type() {
+    let src = "foo :: (x: int): int { y : int = 1 }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Procedure { fn_ty, sig, .. } = &module.declarations[0].node else {
+        panic!("expected procedure");
+    };
+
+    assert!(fn_ty.is_some());
+    let TypeKind::Fn(fn_sig) = &fn_ty.as_ref().unwrap().node else {
+        panic!("expected fn type");
+    };
+    assert_eq!(**fn_sig, sig.node);
+}
+
+#[test]
+fn test_typecheck_multiple_declarations() {
+    let src =
+        "CONST :: 10 \n bar :: (x: int): int { y : int = 1 } \n foo :: (a: int): int { bar(1) }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    assert_eq!(module.declarations.len(), 3);
+}
+
+#[test]
+fn test_typecheck_constant_with_type_annotation() {
+    let src = "MY_CONST : int : 42";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Constant { ty, .. } = &module.declarations[0].node else {
+        panic!("expected constant");
+    };
+
+    assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
+}
+
+#[test]
+fn test_typecheck_constant_with_binop() {
+    let src = "MY_CONST :: 1 + 2 * 3";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Constant { ty, .. } = &module.declarations[0].node else {
+        panic!("expected constant");
+    };
+
+    assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
+}
+
+#[test]
+fn test_typecheck_empty_procedure() {
+    let src = "foo :: () {}";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_procedure_with_return_type() {
+    let src = "foo :: (): int {}";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Procedure { sig, .. } = &module.declarations[0].node else {
+        panic!("expected procedure");
+    };
+
+    assert_eq!(
+        sig.node.return_ty.as_ref().map(|t| &t.node),
+        Some(&TypeKind::Int)
+    );
+}
+
+#[test]
+fn test_typecheck_val_dec_infers_int_from_literal() {
+    let src = "foo :: (): int { y := 42 }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
+        panic!("expected procedure");
+    };
+
+    let StmtKind::ValDec { ty, .. } = &block.node.stmts[0].node else {
+        panic!("expected val dec");
+    };
+
+    assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
+}
+
+#[test]
+fn test_typecheck_multiple_val_decs() {
+    let src = "foo :: (): int { a : int = 1 \n b : int = 2 \n c : int = 3 }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_val_dec_uses_previous_val() {
+    let src = "foo :: (): int { a : int = 1 \n b : int = a }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_assignment_to_declared_var() {
+    let src = "foo :: (): int { a : int = 1 \n a = 2 }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_typecheck_error_assignment_to_undeclared_var() {
+    let src = "foo :: (): int { a = 1 }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_err());
+
+    let err = result.unwrap_err();
+    assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
+}
+
+#[test]
+fn test_typecheck_variant_type() {
+    let src = "foo :: (): int { x := .None }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
+        panic!("expected procedure");
+    };
+
+    let StmtKind::ValDec { expr, .. } = &block.node.stmts[0].node else {
+        panic!("expected val dec");
+    };
+
+    assert!(matches!(
+        &expr.node,
+        ExprKind::Allocation {
+            kind: AllocKind::Variant(variant_name),
+            elements,..
+
+        } if *variant_name == Symbol(2) && elements.is_empty()
+    ));
+}
+
+#[test]
+fn test_typecheck_variant_type_with_args() {
+    let src = "foo :: (): int { x : .Some(int) | .None = .Some(1) }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+
+    let module = result.unwrap();
+    let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
+        panic!("expected procedure");
+    };
+
+    let StmtKind::ValDec { expr, .. } = &block.node.stmts[0].node else {
+        panic!("expected val dec");
+    };
+
+    assert!(matches!(
+        &expr.node,
+        ExprKind::Allocation {
+            kind: AllocKind::Variant(variant_name),
+            elements,..
+
+        } if *variant_name == Symbol(2) && elements.len() == 1 && elements[0].node == ExprKind::Value(ValueKind::Int(1))
+    ));
+}
+
+#[test]
+fn test_typecheck_subtyping_record() {
+    let src = "foo :: () { x : { a: int } = { a := 1, b := 2 } }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_comptime_constant_evaluation() {
+    let src = "MY_CONST :: 1 + 2 * 3";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_comptime_bool_evaluation() {
+    let src = "TRUE_CONST :: true and false";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_monomorphization_basic_comptime_type() {
+    let src = "identity :: (comptime T: type, x: T): T { return x }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+    let module = result.unwrap();
+
+    let proc = module
+        .declarations
+        .iter()
+        .find(|d| matches!(&d.node, DeclKind::Procedure { .. }))
+        .expect("generic function not found");
+
+    if let DeclKind::Procedure {
+        sig, monomorph_of, ..
+    } = &proc.node
+    {
+        assert!(
+            monomorph_of.is_none(),
+            "Original should not have monomorph_of"
+        );
+        let params = &sig.node.params.params;
+        assert_eq!(params.len(), 2);
+        assert!(params[0].is_comptime);
+        assert!(matches!(params[0].ty.node, TypeKind::Type));
+    }
+}
+
+#[test]
+fn test_monomorphization_multiple_comptime_params() {
+    let src = "first :: (comptime T: type, comptime U: type, a: T, b: U): T { return a }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+    let module = result.unwrap();
+
+    let proc = module
+        .declarations
+        .iter()
+        .find(|d| matches!(&d.node, DeclKind::Procedure { .. }))
+        .expect("generic function not found");
+
+    if let DeclKind::Procedure { sig, .. } = &proc.node {
+        let params = &sig.node.params.params;
+        assert_eq!(params.len(), 4);
+        assert!(params[0].is_comptime);
+        assert!(params[1].is_comptime);
+        assert!(!params[2].is_comptime);
+        assert!(!params[3].is_comptime);
+    }
+}
+
+#[test]
+fn test_monomorphization_mixed_params() {
+    let src = "wrap :: (comptime T: type, x: T, y: int): T { return x }";
+    let (_ctx, result) = typecheck_src(src);
+    assert!(result.is_ok());
+    let module = result.unwrap();
+
+    let proc = module
+        .declarations
+        .iter()
+        .find(|d| matches!(&d.node, DeclKind::Procedure { .. }))
+        .expect("generic function not found");
+
+    if let DeclKind::Procedure { sig, .. } = &proc.node {
+        let params = &sig.node.params.params;
+        assert_eq!(params.len(), 3);
+        assert!(params[0].is_comptime);
+        assert!(!params[1].is_comptime);
+        assert!(!params[2].is_comptime);
+    }
+}
+
+#[test]
+fn test_monomorphization_basic() {
+    let src = "identity :: (comptime T: type, x: T): T { return x } \n main :: () { y : int = identity(int, 42) }";
+    let (ctx, result) = typecheck_src(src);
+    assert!(result.is_ok(), "typechecking failed: {:?}", result);
+    let module = result.unwrap();
+
+    let monomorph_decl = module.declarations.iter().find(|d| {
+        if let DeclKind::Procedure { name, .. } = &d.node {
+            ctx.resolve(name.node).starts_with("identity_TInt")
+        } else {
+            false
+        }
+    });
+    assert!(
+        monomorph_decl.is_some(),
+        "monomorphized identity_TInt not found"
+    );
+
+    let monomorph = monomorph_decl.unwrap();
+    if let DeclKind::Procedure {
+        sig, monomorph_of, ..
+    } = &monomorph.node
+    {
+        assert!(monomorph_of.is_some(), "monomorph_of should be set");
+        let params = &sig.node.params.params;
+        assert_eq!(params.len(), 1);
+        assert!(!params[0].is_comptime, "x param should remain runtime");
+        assert_eq!(params[0].ty.node, TypeKind::Int);
+    }
+}

frontend/src/lib.rs

···
 mod ast;
-mod to_mir;
+mod ast_typecheck;
 mod ast_visitor;
 mod ctx;
 mod lex;
···
 pub mod mir;
 mod parse;
 mod span;
-mod typecheck;
+mod to_mir;
 
 pub use ctx::{Ctx, Symbol};
 pub use lex::BinOp;
 pub use mir::{Function, visualize};
 pub use span::{Diagnostic, SourceMap, Span, SpanExt, Spanned};
 
-use to_mir::AstToMIR;
 use ast_visitor::AstVisitor;
+use to_mir::AstToMIR;
 
 use std::collections::VecDeque;
 use std::fs::File;
···
 
     let mut module = parse::parse(&mut ctx, tokens).map_err(|e| e.format(&source_map))?;
 
-    typecheck::typecheck(&mut ctx, &mut module).map_err(|e| e.format(&source_map))?;
+    ast_typecheck::typecheck(&mut ctx, &mut module).map_err(|e| e.format(&source_map))?;
 
     let mut ast_visitor = AstToMIR::new(&ctx);
     ast_visitor.visit_module(module);

frontend/src/parse/mod.rs

···
         if let ExprKind::Allocation {
             kind: _,
             elements: _,
+            default_elem: _,
             region,
         } = &mut expr.node
         {
···
             ExprKind::Allocation {
                 kind: AllocKind::Variant(variant_name),
                 elements: args,
+                default_elem: None,
                 region: None,
             },
             span,
···
             ExprKind::Allocation {
                 kind: AllocKind::Variant(variant_name),
                 elements: vec![],
+                default_elem: None,
                 region: None,
             },
             span,
···
             ExprKind::Allocation {
                 kind: AllocKind::Str(s),
                 elements: vec![],
+                default_elem: None,
                 region: None,
             },
             token.span,
···
             parse_variant_expr(ctx, variant_name, span, tokens)
         }
 
+        // array expr
         Token::LBracket => {
             let start_span = token.span;
-            let next_tok = tokens.pop_front().ok_or_else(ParseError::eof)?;
 
-            let mut alloc_kind = match next_tok.node {
-                Token::RBracket => AllocKind::DynArray(TypeKind::Int.into()),
-                Token::Int(i) => {
-                    expect_next(tokens, Token::RBracket)?;
-                    AllocKind::Array(TypeKind::Any.into(), ComptimeValue::Int(i as i128).into())
-                }
-                Token::Identifier(name) => {
-                    expect_next(tokens, Token::RBracket)?;
-                    // assuming comptime identifier that will be resolved during typechecking
-                    AllocKind::Array(TypeKind::Any.into(), ComptimeValue::Ident(name).into())
-                }
-                _ => {
-                    return Err(ParseError::new(
-                        ParseErrorKind::ExpectedExpression,
-                        next_tok.span,
-                    ));
-                }
-            };
-
-            let Some(array_ty) = parse_type(ctx, tokens)? else {
-                return Err(ParseError::new(
-                    ParseErrorKind::ExpectedType,
-                    peek_span(tokens).unwrap_or(start_span),
+            // Handle empty list []
+            if let Some(Token::RBracket) = peek_token(tokens) {
+                let end_span = expect_next(tokens, Token::RBracket)?;
+                return Ok(Spanned::new(
+                    ExprKind::Allocation {
+                        kind: AllocKind::Array(TypeKind::Any.into(), ComptimeValue::Int(0).into()),
+                        elements: vec![],
+                        default_elem: None,
+                        region: None,
+                    },
+                    start_span.merge(&end_span),
                 ));
-            };
+            }
 
-            alloc_kind.fill_type(array_ty.node);
+            // Parse first expression
+            let first_expr = parse_expr(ctx, tokens)?;
 
-            expect_next(tokens, Token::LBrace)?;
-
-            let mut exprs = Vec::new();
+            match peek_token(tokens) {
+                // [expr; size] - default array syntax
+                Some(Token::SemiColon) => {
+                    tokens.pop_front(); // consume ;
+                    let size_expr = parse_expr(ctx, tokens)?;
+                    let size_cv = match &size_expr.node {
+                        ExprKind::Value(ValueKind::Int(i)) => ComptimeValue::Int(*i as i128),
+                        ExprKind::Value(ValueKind::Ident(name)) => ComptimeValue::Ident(*name),
+                        _ => {
+                            return Err(ParseError::new(
+                                ParseErrorKind::ExpectedExpression,
+                                size_expr.span,
+                            ));
+                        }
+                    };
+                    expect_next(tokens, Token::RBracket)?;
+                    let region = check_region_type_annotation(ctx, tokens)?;
+                    let span = start_span.merge(&size_expr.span);
 
-            loop {
-                if let Some(Token::RBrace) = peek_token(tokens) {
-                    break;
+                    Ok(Spanned::new(
+                        ExprKind::Allocation {
+                            kind: AllocKind::Array(TypeKind::Any.into(), size_cv.into()),
+                            elements: vec![],
+                            default_elem: Some(Box::new(first_expr)),
+                            region,
+                        },
+                        span,
+                    ))
                 }
 
-                exprs.push(parse_expr(ctx, tokens)?);
+                // [expr, expr, ...] or [expr] - list literal syntax
+                Some(Token::Comma) | Some(Token::RBracket) => {
+                    let mut exprs = vec![first_expr];
+
+                    while let Some(Token::Comma) = peek_token(tokens) {
+                        tokens.pop_front(); // consume ,
+                        if let Some(Token::RBracket) = peek_token(tokens) {
+                            break; // trailing comma
+                        }
+                        exprs.push(parse_expr(ctx, tokens)?);
+                    }
+
+                    let end_span = expect_next(tokens, Token::RBracket)?;
+                    let span = start_span.merge(&end_span);
 
-                if let Some(Token::Comma) = peek_token(tokens) {
-                    tokens.pop_front();
+                    Ok(Spanned::new(
+                        ExprKind::Allocation {
+                            kind: AllocKind::Array(
+                                TypeKind::Any.into(),
+                                ComptimeValue::Int(exprs.len() as i128).into(),
+                            ),
+                            elements: exprs,
+                            default_elem: None,
+                            region: None,
+                        },
+                        span,
+                    ))
                 }
-            }
 
-            let end_span = expect_next(tokens, Token::RBrace)?;
-            let span = start_span.merge(&end_span);
-
-            Ok(Spanned::new(
-                ExprKind::Allocation {
-                    kind: alloc_kind,
-                    elements: exprs,
-                    region: None,
-                },
-                span,
-            ))
+                _ => Err(ParseError::new(
+                    ParseErrorKind::ExpectedExpression,
+                    peek_span(tokens).unwrap_or(start_span),
+                )),
+            }
         }
 
+        // Token::LBracket => {
+        //     let start_span = token.span;
+        //
+        //     let is_default_array = match peek_token(tokens) {
+        //         Some(Token::SemiColon) => true,
+        //         Some(Token::Int(_) | Token::Identifier(_) | Token::Keyword(_)) => {
+        //             let mut temp_tokens = tokens.clone();
+        //             let _ = parse_expr(ctx, &mut temp_tokens);
+        //             matches!(peek_token(&temp_tokens), Some(Token::SemiColon))
+        //         }
+        //         _ => false,
+        //     };
+        //
+        //     if is_default_array {
+        //         let expr = parse_expr(ctx, tokens)?;
+        //         let _ = expect_next(tokens, Token::SemiColon)?;
+        //         let default_elem = Box::new(expr);
+        //
+        //         let size_expr = parse_expr(ctx, tokens)?;
+        //         let size_cv = match &size_expr.node {
+        //             ExprKind::Value(ValueKind::Int(i)) => ComptimeValue::Int(*i as i128),
+        //             ExprKind::Value(ValueKind::Ident(name)) => ComptimeValue::Ident(*name),
+        //             _ => {
+        //                 return Err(ParseError::new(
+        //                     ParseErrorKind::ExpectedExpression,
+        //                     size_expr.span,
+        //                 ));
+        //             }
+        //         };
+        //         expect_next(tokens, Token::RBracket)?;
+        //
+        //         let region = check_region_type_annotation(ctx, tokens)?;
+        //
+        //         let span = start_span.merge(&size_expr.span);
+        //
+        //         Ok(Spanned::new(
+        //             ExprKind::Allocation {
+        //                 kind: AllocKind::Array(TypeKind::Any.into(), size_cv.into()),
+        //                 elements: vec![],
+        //                 default_elem: Some(default_elem),
+        //                 region,
+        //             },
+        //             span,
+        //         ))
+        //     } else {
+        //         let next_tok = tokens.pop_front().ok_or_else(ParseError::eof)?;
+        //
+        //         let mut alloc_kind = match next_tok.node {
+        //             Token::RBracket => AllocKind::DynArray(TypeKind::Int.into()),
+        //             Token::Int(i) => {
+        //                 expect_next(tokens, Token::RBracket)?;
+        //                 AllocKind::Array(TypeKind::Any.into(), ComptimeValue::Int(i as i128).into())
+        //             }
+        //             Token::Identifier(name) => {
+        //                 expect_next(tokens, Token::RBracket)?;
+        //                 AllocKind::Array(TypeKind::Any.into(), ComptimeValue::Ident(name).into())
+        //             }
+        //             _ => {
+        //                 return Err(ParseError::new(
+        //                     ParseErrorKind::ExpectedExpression,
+        //                     next_tok.span,
+        //                 ));
+        //             }
+        //         };
+        //
+        //         let Some(array_ty) = parse_type(ctx, tokens)? else {
+        //             return Err(ParseError::new(
+        //                 ParseErrorKind::ExpectedType,
+        //                 peek_span(tokens).unwrap_or(start_span),
+        //             ));
+        //         };
+        //
+        //         alloc_kind.fill_type(array_ty.node);
+        //
+        //         expect_next(tokens, Token::LBrace)?;
+        //
+        //         let mut exprs = Vec::new();
+        //
+        //         loop {
+        //             if let Some(Token::RBrace) = peek_token(tokens) {
+        //                 break;
+        //             }
+        //
+        //             exprs.push(parse_expr(ctx, tokens)?);
+        //
+        //             if let Some(Token::Comma) = peek_token(tokens) {
+        //                 tokens.pop_front();
+        //             }
+        //         }
+        //
+        //         let end_span = expect_next(tokens, Token::RBrace)?;
+        //         let span = start_span.merge(&end_span);
+        //
+        //         Ok(Spanned::new(
+        //             ExprKind::Allocation {
+        //                 kind: alloc_kind,
+        //                 elements: exprs,
+        //                 default_elem: None,
+        //                 region: None,
+        //             },
+        //             span,
+        //         ))
+        //     }
+        // }
         Token::LParen => {
             let start_span = token.span;
             let expr = parse_expr(ctx, tokens)?;
···
                         // filled in during typechecking
                         kind: AllocKind::Tuple(vec![]),
                         elements: exprs,
+                        default_elem: None,
                         region: None,
                     },
                     span,
···
                 ExprKind::Allocation {
                     kind: AllocKind::Record(fields),
                     elements: exprs,
+                    default_elem: None,
                     region: None,
                 },
                 span,
···
         }
         Some(Token::LBracket) => {
             let start_span = tokens.pop_front().unwrap().span;
-            let next_tok = tokens.pop_front().ok_or_else(ParseError::eof)?;
-
-            expect_next(tokens, Token::RBracket)?;
 
             let arr_ty = match parse_type(ctx, tokens)? {
                 Some(ty) => ty,
···
                 }
             };
 
+            expect_next(tokens, Token::SemiColon)?;
+
+            let next_tok = tokens.pop_front().ok_or_else(ParseError::eof)?;
             let alloc_kind = match next_tok.node {
                 Token::Int(i) => {
                     AllocKind::Array(arr_ty.node.into(), ComptimeValue::Int(i as i128).into())
···
                     ));
                 }
             };
+
+            expect_next(tokens, Token::RBracket)?;
 
             let span = start_span.merge(&arr_ty.span);
 

frontend/src/parse/tests.rs

···
 }
 
 #[test]
-fn parse_array_and_dyn_array() {
+fn parse_array() {
     let decs = expect_parse_ok(
         "foo :: () { 
-                x := [3]int{1, 2, 3}
-                y := []int{1, 2, 3}
+                x := [1, 2, 3]
             }",
         1,
     );
···
     let DeclKind::Procedure { block, .. } = &decs[0].node else {
         unreachable!()
     };
-    assert_eq!(block.node.stmts.len(), 2);
+    assert_eq!(block.node.stmts.len(), 1);
 
     // Verify first is Array, second is DynArray
     let StmtKind::ValDec { expr: expr1, .. } = &block.node.stmts[0].node else {
···
         &expr1.node,
         ExprKind::Allocation {
             kind: AllocKind::Array(_, _),
-            ..
-        }
-    ));
-
-    let StmtKind::ValDec { expr: expr2, .. } = &block.node.stmts[1].node else {
-        unreachable!()
-    };
-    assert!(matches!(
-        &expr2.node,
-        ExprKind::Allocation {
-            kind: AllocKind::DynArray(_),
             ..
         }
     ));
···
 fn parse_region_alloc() {
     let decs = expect_parse_ok(
         "foo :: (comptime R: region) { 
-            x := [2]int{ 1, 2 } @ local
+            x := [ 1, 2 ] @ local
             y := (1, false) @ R
         }",
         1,
···
 
     assert_eq!(
         *kind,
-        AllocKind::Array(TypeKind::Int.into(), ComptimeValue::Int(2).into())
+        AllocKind::Array(TypeKind::Any.into(), ComptimeValue::Int(2).into())
     );
     assert_eq!(*region, Some(Region::Local));
 

frontend/src/to_mir/mod.rs

···
                 monomorph_of: _,
                 is_comptime,
             } => {
-                let name_ = self.ctx.resolve(name.node).to_string();
                 if *is_comptime {
-                    println!("skipping {name_}");
                     return;
                 }
-                println!("compiling {name_}");
 
                 let name_sym = name.node;
                 // TODO: we do not use function types yet
···
                 self.function_sigs.insert(name_sym, sig.clone());
 
                 let sig_inner = &sig.node;
-                eprintln!("\t{sig_inner:?}");
                 let return_ty = sig_inner
                     .return_ty
                     .as_ref()
···
             ExprKind::Allocation {
                 kind,
                 elements,
+                default_elem,
                 region: _,
             } => {
                 let mut ops = Vec::new();
                 let mut elem_types = Vec::new();
-                for elem in elements {
-                    let elem = self.visit_expr(elem);
-                    let (op, ty) = match elem {
+
+                if let Some(default_elem) = default_elem {
+                    let default_mir = self.visit_expr(*default_elem);
+                    let (op, ty) = match default_mir {
                         mir::RValue::Use(mir::Operand::Copy(place)) => {
                             let local_ty = self.local_types.get(&place.local).unwrap().clone();
                             (mir::Operand::Copy(place), local_ty)
···
                             let elem_local = self.new_local(&TypeKind::Int);
                             self.get_current_block()
                                 .stmts
-                                .push(mir::Statement::Assign(elem_local, elem));
+                                .push(mir::Statement::Assign(elem_local, default_mir));
 
                             let place = mir::Place::new(elem_local, mir::PlaceKind::Deref);
                             let local_ty = self.local_types.get(&elem_local).unwrap().clone();
                             (mir::Operand::Copy(place), local_ty)
                         }
                     };
-                    ops.push(op);
-                    elem_types.push(ty);
+
+                    let array_size = match kind {
+                        AllocKind::Array(_, ref size) => match size.as_ref() {
+                            ComptimeValue::Int(i) => *i as usize,
+                            ComptimeValue::Ident(_) => {
+                                panic!("comptime identifier should be resolved by typechecker")
+                            }
+                            _ => panic!("unexpected comptime value for array size"),
+                        },
+                        _ => panic!("expected array allocation"),
+                    };
+
+                    for _ in 0..array_size {
+                        ops.push(op.clone());
+                        elem_types.push(ty.clone());
+                    }
+                } else {
+                    for elem in elements {
+                        let elem = self.visit_expr(elem);
+                        let (op, ty) = match elem {
+                            mir::RValue::Use(mir::Operand::Copy(place)) => {
+                                let local_ty = self.local_types.get(&place.local).unwrap().clone();
+                                (mir::Operand::Copy(place), local_ty)
+                            }
+                            mir::RValue::Use(mir::Operand::Constant(c)) => {
+                                let local_ty = Self::type_of_constant(&c);
+                                (mir::Operand::Constant(c), local_ty)
+                            }
+                            _ => {
+                                let elem_local = self.new_local(&TypeKind::Int);
+                                self.get_current_block()
+                                    .stmts
+                                    .push(mir::Statement::Assign(elem_local, elem));
+
+                                let place = mir::Place::new(elem_local, mir::PlaceKind::Deref);
+                                let local_ty = self.local_types.get(&elem_local).unwrap().clone();
+                                (mir::Operand::Copy(place), local_ty)
+                            }
+                        };
+                        ops.push(op);
+                        elem_types.push(ty);
+                    }
                 }
 
                 match kind {
···
                         let tys = tys.into_iter().map(|t| ast_type_to_mir_type(&t)).collect();
 
                         mir::RValue::Alloc(mir::AllocKind::Tuple(tys), ops)
-                    }
-
-                    AllocKind::DynArray(ty) => {
-                        let ty = ast_type_to_mir_type(&ty);
-                        mir::RValue::Alloc(mir::AllocKind::DynArray(ty), ops)
                     }
                     AllocKind::Record(_fields) => {
                         let tys = elem_types
···
                 let local_id = self.new_local(&ty.node);
 
                 self.symbol_table.insert(name.node, local_id);
+
+                // println!(
+                //     "assigning to {}: {:?}\n\t{:?}",
+                //     self.ctx.resolve(name.node),
+                //     ty,
+                //     expr.node
+                // );
 
                 self.in_assign_expr = true;
                 let rvalue = self.visit_expr(expr);
···
                 mir::Ty::Tuple(tys)
             }
 
-            AllocKind::DynArray(ty) => mir::Ty::DynArray(Box::new(ast_type_to_mir_type(ty))),
             AllocKind::Array(ty, len) => {
                 if let ComptimeValue::Int(len) = **len {
                     mir::Ty::Array(Box::new(ast_type_to_mir_type(ty)), len as usize)

frontend/src/typecheck.rs frontend/src/ast_typecheck/mod.rs

···
-#![allow(unused)]
+mod tests;
 
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 use crate::{
     Ctx,
···
 }
 
 #[derive(Debug)]
+#[allow(unused)]
 pub enum TypeErrorKind {
     ArraySizeMismatch {
         expected: ComptimeValue,
···
                     .map(|cv| self.type_of_comptime_value(cv))
                     .collect();
                 if tys.is_empty() {
-                    TypeKind::Alloc(AllocKind::DynArray(Box::new(TypeKind::Unit)), Region::Stack)
+                    TypeKind::Alloc(
+                        AllocKind::Array(Box::new(TypeKind::Unit), ComptimeValue::Int(0).into()),
+                        Region::Stack,
+                    )
                 } else {
                     let ty = tys.first().unwrap();
                     assert!(tys.iter().all(|t| t == ty));
-                    TypeKind::Alloc(AllocKind::DynArray(Box::new(ty.clone())), Region::Stack)
+                    TypeKind::Alloc(
+                        AllocKind::Array(
+                            Box::new(ty.clone()),
+                            ComptimeValue::Int(tys.len() as i128).into(),
+                        ),
+                        Region::Stack,
+                    )
                 }
             }
             ComptimeValue::Bool(_) => TypeKind::Bool,
···
             AllocKind::Array(ty, size) => AllocKind::Array(
                 self.substitute_type(ty, subs).into(),
                 match **size {
-                    ComptimeValue::Int(i) => size.clone(),
+                    ComptimeValue::Int(_) => size.clone(),
                     ComptimeValue::Ident(sym) => {
                         let cv = subs.get(&sym).cloned().unwrap().cv;
                         assert!(matches!(cv, ComptimeValue::Int(_)));
···
                         .iter()
                         .map(|a| self.substitute_expr(a, subs))
                         .collect(),
-                    returned_ty: call.returned_ty.clone(),
+                    returned_ty: call
+                        .returned_ty
+                        .as_ref()
+                        .map(|t| Spanned::new(self.substitute_type(&t.node, subs), t.span.clone())),
                 }),
                 expr.span.clone(),
             ),
···
                     ExprKind::Value(ValueKind::Int(*i as i32)),
                     expr.span.clone(),
                 ),
-                ComptimeValue::Ident(ident) => {
+                ComptimeValue::Ident(_ident) => {
                     todo!()
                 }
                 _ => todo!(),
···
             ExprKind::Allocation {
                 kind,
                 elements,
+                default_elem,
                 region,
             } => {
                 let sub_kind = self.substitute_alloc_kind(kind, subs);
+                let sub_default_elem = default_elem
+                    .as_ref()
+                    .map(|e| self.substitute_expr(e, subs).into());
                 Spanned::new(
                     ExprKind::Allocation {
                         kind: sub_kind,
···
                             .iter()
                             .map(|e| self.substitute_expr(e, subs))
                             .collect(),
+                        default_elem: sub_default_elem,
                         region: *region,
                     },
                     expr.span.clone(),
···
                 kind,
                 region,
                 elements,
+                default_elem,
             } => {
                 let mut elem_vals = Vec::new();
-                for elem in elements {
-                    elem_vals.push(self.analyze_expr(elem)?);
+
+                if let Some(default_elem) = default_elem {
+                    let default_val = self.analyze_expr(default_elem)?;
+                    elem_vals.push(default_val);
+                } else {
+                    for elem in elements {
+                        elem_vals.push(self.analyze_expr(elem)?);
+                    }
                 }
 
                 let region_handle = region.unwrap_or(Region::Stack);
···
                                         expr.span.clone(),
                                     ));
                                 }
+
                                 Box::new(elem_vals[0].ty.clone())
                             }
                             _ => {
···
                     }
                     _ => kind.clone(),
                 };
+
+                *kind = resolved_kind.clone();
                 Ok(TypedValue::runtime(TypeKind::Alloc(
                     resolved_kind,
                     region_handle,
···
             .map(|arg| self.analyze_expr(arg))
             .collect::<Result<_, _>>()?;
 
-        let (callee_sig, span) = self.resolve_callee_signature(&call.callee)?;
+        let (callee_sig, _) = self.resolve_callee_signature(&call.callee)?;
 
         let params = &callee_sig.node.params.params;
         let expected_count = params.len();
···
         if !comptime_args.is_empty()
             && let ExprKind::Value(ValueKind::Ident(fn_name)) = &call.callee.node
         {
-            println!("here: {comptime_args:?}");
             let monomorphized_decl = self.monomorphize(*fn_name, comptime_args)?;
             if let DeclKind::Procedure { name, sig, .. } = monomorphized_decl.node {
                 return_ty = sig
···
                 };
                 Ok((sig.clone(), callee.span.clone()))
             }
-            ExprKind::FieldAccess(receiver, method_name) => {
+            ExprKind::FieldAccess(_receiver, method_name) => {
                 let Some(sig) = self.function_sigs.get(method_name) else {
                     return Err(TypeError::new(
                         TypeErrorKind::UnknownMethod(*method_name),
···
                     ));
                 }
             }
+            (TypeKind::Alloc(AllocKind::Str(_), _), TypeKind::Alloc(AllocKind::Str(_), _)) => {}
             (TypeKind::Alloc(AllocKind::Str(_), _), TypeKind::Ptr(c))
                 if (**c) == TypeKind::Char => {}
             _ => {
···
         self.check_entry_point()
     }
 
+    #[allow(unused)]
+    // found_main is used but rust analyzer complains
     fn check_entry_point(&mut self) -> Result<(), TypeError> {
         let mut found_main = false;
         for function in self.function_sigs.keys() {
···
                     }
 
                     if param.is_comptime {
-                        println!("{}", self.front_ctx.resolve(name.node));
                         *is_comptime = true;
                     }
                 }
···
                     let expr_val = self.analyze_expr(expr)?;
                     self.structural_typecheck(&expr_val.ty, &ret_ty.node, expr.span.clone())?;
                 }
+
+                // we must reinsert the decl here after mutation
+                // this is critical for type inference, otherwise, when functions are monomorphized,
+                // they monomorphize the uninferred statements
+                self.module_decls.insert(name.node, decl.node.clone());
                 Ok(())
             }
         }
···
                         ));
                     }
                 }
+
+                let name_ = self.front_ctx.resolve(name.node).to_string();
+                println!(
+                    "inferred type for {}: {:?}\n\t{:?}",
+                    name_, inferred_ty, expr.node
+                );
                 *ty = Some(inferred_ty.clone());
                 self.type_map.insert(name.node, inferred_ty);
                 Ok(())
···
 
                 let val = self.analyze_expr(expr)?;
 
-                if location_val.ty != val.ty {
-                    return Err(TypeError::new(
-                        TypeErrorKind::ExpectedType {
-                            expected: location_val.ty.clone(),
-                            found: val.ty,
-                        },
-                        expr.span.clone(),
-                    ));
-                }
+                self.structural_typecheck(&location_val.ty, &val.ty, expr.span.clone())?;
                 Ok(())
             }
             StmtKind::IfElse(if_else) => {
···
                 let scrutinee_val = self.analyze_expr(scrutinee)?;
                 for arm in arms {
                     match &arm.pat.node {
-                        PatKind::Symbol(name) => {
+                        PatKind::Symbol(_) => {
                             self.bind_pattern(&arm.pat, &Type::synthetic(scrutinee_val.ty.clone()));
                         }
                         PatKind::Variant { name, bindings } => {
···
                             }
                         }
                         PatKind::Record(fields) => {
-                            let TypeKind::Record(scru_fields) = &scrutinee_val.ty else {
+                            let TypeKind::Record(_scru_fields) = &scrutinee_val.ty else {
                                 return Err(TypeError::new(
                                     TypeErrorKind::ExpectedRecord,
                                     scrutinee.span.clone(),
···
     }
 }
 
-pub fn typecheck(ctx: &mut Ctx, module: &mut Module) -> TypecheckResult<Module> {
+pub fn typecheck(ctx: &mut Ctx, module: &mut Module) -> TypecheckResult<()> {
     let mut analyzer = Analyzer::new(ctx);
     analyzer.typecheck_module(module)?;
-    Ok(module.clone())
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::VecDeque;
-
-    use crate::{
-        ast::{Pat, PatKind, TypeKind},
-        ctx::Ctx,
-        lex, parse,
-        span::Spanned,
-    };
-
-    use super::*;
-
-    fn tokenify(s: &str) -> (Ctx, VecDeque<Spanned<crate::lex::Token>>) {
-        let mut ctx = Ctx::default();
-        let tokens = lex::tokenize(&mut ctx, s).map(|t| t.unwrap()).collect();
-        (ctx, tokens)
-    }
-
-    fn parseify(ctx: &mut Ctx, tokens: VecDeque<Spanned<crate::lex::Token>>) -> Module {
-        parse::parse(ctx, tokens).unwrap()
-    }
-
-    fn typecheck_src(src: &str) -> (Ctx, TypecheckResult<Module>) {
-        let (mut ctx, tokens) = tokenify(src);
-        let mut module = parseify(&mut ctx, tokens);
-        let result = typecheck(&mut ctx, &mut module);
-        (ctx, result)
-    }
-
-    #[test]
-    fn test_typecheck_simple_procedure() {
-        let src = "foo :: (x: int): int { y : int = x }";
-        let (_, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_infers_val_type() {
-        let src = "foo :: (x: int): int { y := x }";
-        let (_, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
-            panic!("expected procedure");
-        };
-
-        let StmtKind::ValDec { ty, .. } = &block.node.stmts[0].node else {
-            panic!("expected val dec");
-        };
-
-        assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
-    }
-
-    #[test]
-    fn test_typecheck_binop_expression() {
-        let src = "foo :: (x: int, y: int): int { z : int = x + y }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_assignment() {
-        let src = "foo :: (x: int): int { y : int = x \n y = x + 1 }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_if_else() {
-        let src = "foo :: (x: int): int { if x { y : int = 1 } else { z : int = 2 } }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_constant() {
-        let src = "MY_CONST :: 42";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Constant { ty, .. } = &module.declarations[0].node else {
-            panic!("expected constant");
-        };
-
-        assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
-    }
-
-    #[test]
-    fn test_typecheck_function_call() {
-        let src = "bar :: (x: int): int { y : int = 1 } \n foo :: (a: int): int { bar(1) }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_function_call_with_return() {
-        let src = "bar :: (x: int): int { y : int = 1 } \n foo :: (a: int): int { result : int = bar(1) }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_error_unknown_symbol_in_ident() {
-        let src = "foo :: (): int { y : int = unknown }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
-    }
-
-    #[test]
-    fn test_typecheck_error_unknown_symbol_in_assignment() {
-        let src = "foo :: (): int { y : int = 1 \n y = unknown }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
-    }
-
-    #[test]
-    fn test_typecheck_error_unknown_function() {
-        let src = "foo :: (): int { unknown_func(1) }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_err());
-
-        let err = result.unwrap_err();
-        assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
-    }
-
-    #[test]
-    fn test_typecheck_nested_if() {
-        let src = "foo :: (x: int): int { if 1 { if 1 { y : int = 1 } } }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_multiple_params() {
-        let src = "foo :: (a: int, b: int, c: int): int { sum : int = 1 + 2 + 3 }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_procedure_infers_fn_type() {
-        let src = "foo :: (x: int): int { y : int = 1 }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Procedure { fn_ty, sig, .. } = &module.declarations[0].node else {
-            panic!("expected procedure");
-        };
-
-        assert!(fn_ty.is_some());
-        let TypeKind::Fn(fn_sig) = &fn_ty.as_ref().unwrap().node else {
-            panic!("expected fn type");
-        };
-        assert_eq!(**fn_sig, sig.node);
-    }
-
-    #[test]
-    fn test_typecheck_multiple_declarations() {
-        let src = "CONST :: 10 \n bar :: (x: int): int { y : int = 1 } \n foo :: (a: int): int { bar(1) }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        assert_eq!(module.declarations.len(), 3);
-    }
-
-    #[test]
-    fn test_typecheck_constant_with_type_annotation() {
-        let src = "MY_CONST : int : 42";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Constant { ty, .. } = &module.declarations[0].node else {
-            panic!("expected constant");
-        };
-
-        assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
-    }
-
-    #[test]
-    fn test_typecheck_constant_with_binop() {
-        let src = "MY_CONST :: 1 + 2 * 3";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Constant { ty, .. } = &module.declarations[0].node else {
-            panic!("expected constant");
-        };
-
-        assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
-    }
-
-    #[test]
-    fn test_typecheck_empty_procedure() {
-        let src = "foo :: () {}";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_procedure_with_return_type() {
-        let src = "foo :: (): int {}";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Procedure { sig, .. } = &module.declarations[0].node else {
-            panic!("expected procedure");
-        };
-
-        assert_eq!(
-            sig.node.return_ty.as_ref().map(|t| &t.node),
-            Some(&TypeKind::Int)
-        );
-    }
-
-    #[test]
-    fn test_typecheck_val_dec_infers_int_from_literal() {
-        let src = "foo :: (): int { y := 42 }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
-            panic!("expected procedure");
-        };
-
-        let StmtKind::ValDec { ty, .. } = &block.node.stmts[0].node else {
-            panic!("expected val dec");
-        };
-
-        assert_eq!(ty.as_ref().map(|t| &t.node), Some(&TypeKind::Int));
-    }
-
-    #[test]
-    fn test_typecheck_multiple_val_decs() {
-        let src = "foo :: (): int { a : int = 1 \n b : int = 2 \n c : int = 3 }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_val_dec_uses_previous_val() {
-        let src = "foo :: (): int { a : int = 1 \n b : int = a }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_assignment_to_declared_var() {
-        let src = "foo :: (): int { a : int = 1 \n a = 2 }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_typecheck_error_assignment_to_undeclared_var() {
-        let src = "foo :: (): int { a = 1 }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_err());
-
-        let err = result.unwrap_err();
-        assert!(matches!(err.kind, TypeErrorKind::UnknownSymbol(_)));
-    }
-
-    #[test]
-    fn test_typecheck_variant_type() {
-        let src = "foo :: (): int { x := .None }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
-            panic!("expected procedure");
-        };
-
-        let StmtKind::ValDec { expr, .. } = &block.node.stmts[0].node else {
-            panic!("expected val dec");
-        };
-
-        assert!(matches!(
-            &expr.node,
-            ExprKind::Allocation {
-                kind: AllocKind::Variant(variant_name),
-                elements,..
-
-            } if *variant_name == Symbol(2) && elements.is_empty()
-        ));
-    }
-
-    #[test]
-    fn test_typecheck_variant_type_with_args() {
-        let src = "foo :: (): int { x : .Some(int) | .None = .Some(1) }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-
-        let module = result.unwrap();
-        let DeclKind::Procedure { block, .. } = &module.declarations[0].node else {
-            panic!("expected procedure");
-        };
-
-        let StmtKind::ValDec { expr, .. } = &block.node.stmts[0].node else {
-            panic!("expected val dec");
-        };
-
-        assert!(matches!(
-            &expr.node,
-            ExprKind::Allocation {
-                kind: AllocKind::Variant(variant_name),
-                elements,..
-
-            } if *variant_name == Symbol(2) && elements.len() == 1 && elements[0].node == ExprKind::Value(ValueKind::Int(1))
-        ));
-    }
-
-    #[test]
-    fn test_typecheck_subtyping_record() {
-        let src = "foo :: () { x : { a: int } = { a := 1, b := 2 } }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_comptime_constant_evaluation() {
-        let src = "MY_CONST :: 1 + 2 * 3";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_comptime_bool_evaluation() {
-        let src = "TRUE_CONST :: true and false";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_monomorphization_basic_comptime_type() {
-        let src = "identity :: (comptime T: type, x: T): T { return x }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-        let module = result.unwrap();
-
-        let proc = module
-            .declarations
-            .iter()
-            .find(|d| matches!(&d.node, DeclKind::Procedure { .. }))
-            .expect("generic function not found");
-
-        if let DeclKind::Procedure {
-            sig, monomorph_of, ..
-        } = &proc.node
-        {
-            assert!(
-                monomorph_of.is_none(),
-                "Original should not have monomorph_of"
-            );
-            let params = &sig.node.params.params;
-            assert_eq!(params.len(), 2);
-            assert!(params[0].is_comptime);
-            assert!(matches!(params[0].ty.node, TypeKind::Type));
-        }
-    }
-
-    #[test]
-    fn test_monomorphization_multiple_comptime_params() {
-        let src = "first :: (comptime T: type, comptime U: type, a: T, b: U): T { return a }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-        let module = result.unwrap();
-
-        let proc = module
-            .declarations
-            .iter()
-            .find(|d| matches!(&d.node, DeclKind::Procedure { .. }))
-            .expect("generic function not found");
-
-        if let DeclKind::Procedure { sig, .. } = &proc.node {
-            let params = &sig.node.params.params;
-            assert_eq!(params.len(), 4);
-            assert!(params[0].is_comptime);
-            assert!(params[1].is_comptime);
-            assert!(!params[2].is_comptime);
-            assert!(!params[3].is_comptime);
-        }
-    }
-
-    #[test]
-    fn test_monomorphization_mixed_params() {
-        let src = "wrap :: (comptime T: type, x: T, y: int): T { return x }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok());
-        let module = result.unwrap();
-
-        let proc = module
-            .declarations
-            .iter()
-            .find(|d| matches!(&d.node, DeclKind::Procedure { .. }))
-            .expect("generic function not found");
-
-        if let DeclKind::Procedure { sig, .. } = &proc.node {
-            let params = &sig.node.params.params;
-            assert_eq!(params.len(), 3);
-            assert!(params[0].is_comptime);
-            assert!(!params[1].is_comptime);
-            assert!(!params[2].is_comptime);
-        }
-    }
-
-    #[test]
-    fn test_monomorphization_basic() {
-        let src = "identity :: (comptime T: type, x: T): T { return x } \n main :: () { y : int = identity(int, 42) }";
-        let (ctx, result) = typecheck_src(src);
-        assert!(result.is_ok(), "typechecking failed: {:?}", result);
-        let module = result.unwrap();
-
-        let monomorph_decl = module.declarations.iter().find(|d| {
-            if let DeclKind::Procedure { name, .. } = &d.node {
-                ctx.resolve(name.node).starts_with("identity_TInt")
-            } else {
-                false
-            }
-        });
-        assert!(
-            monomorph_decl.is_some(),
-            "monomorphized identity_TInt not found"
-        );
-
-        let monomorph = monomorph_decl.unwrap();
-        if let DeclKind::Procedure {
-            sig, monomorph_of, ..
-        } = &monomorph.node
-        {
-            assert!(monomorph_of.is_some(), "monomorph_of should be set");
-            let params = &sig.node.params.params;
-            assert_eq!(params.len(), 1);
-            assert!(!params[0].is_comptime, "x param should remain runtime");
-            assert_eq!(params[0].ty.node, TypeKind::Int);
-        }
-    }
+    Ok(())
 }