"type check" arrays a bit

frontend/src/ast.rs

···
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum AllocKind {
-    DynArray(Box<Type>),
-    Array(Box<Type>, usize),
+    DynArray(Box<TypeKind>),
+    Array(Box<TypeKind>, usize),
     Tuple(Vec<TypeKind>),
 }
 

frontend/src/ast_visitor.rs

···
                 mir::Ty::Tuple(tys)
             }
 
-            AllocKind::DynArray(ty) => mir::Ty::DynArray(Box::new(ast_type_to_mir_type(&ty.node))),
-            AllocKind::Array(ty, len) => {
-                mir::Ty::Array(Box::new(ast_type_to_mir_type(&ty.node)), *len)
-            }
+            AllocKind::DynArray(ty) => mir::Ty::DynArray(Box::new(ast_type_to_mir_type(&ty))),
+            AllocKind::Array(ty, len) => mir::Ty::Array(Box::new(ast_type_to_mir_type(&ty)), *len),
         },
         _ => todo!(),
     }
···
 
                 match kind {
                     AllocKind::Array(ty, _) => {
-                        let ty = ast_type_to_mir_type(&ty.node);
+                        let ty = ast_type_to_mir_type(&ty);
                         mir::RValue::Alloc(mir::AllocKind::Array(ty), ops)
                     }
                     AllocKind::Tuple(tys) => {
-                        let tys = tys
-                            .into_iter()
-                            .map(|t| ast_type_to_mir_type(&t))
-                            .collect();
+                        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.node);
+                        let ty = ast_type_to_mir_type(&ty);
                         mir::RValue::Alloc(mir::AllocKind::DynArray(ty), ops)
                     }
                 }

frontend/src/mir/visualize.rs

···
                 rhs.visualize(indent);
             }
             RValue::Alloc(kind, ops) => {
-                print!("alloc {} {{", kind);
+                print!("alloc({}) {{", kind);
                 for (i, op) in ops.iter().enumerate() {
                     op.visualize(indent);
                     if i != ops.len() - 1 {
                         print!(", ");
                     }
                 }
-                println!("}}");
+                print!("}}");
             }
         }
     }

frontend/src/parse.rs

···
             let next_tok = tokens.pop_front().ok_or_else(ParseError::eof)?;
 
             let alloc_kind = match next_tok.node {
-                Token::RBracket => AllocKind::DynArray(Type::synthetic(TypeKind::Unit).into()),
+                Token::RBracket => AllocKind::DynArray(TypeKind::Int.into()),
                 Token::Int(i) => {
                     expect_next(tokens, Token::RBracket)?;
-                    AllocKind::Array(Type::synthetic(TypeKind::Int).into(), i as usize)
+                    AllocKind::Array(TypeKind::Int.into(), i as usize)
                 }
                 _ => {
                     return Err(ParseError::new(

frontend/src/typecheck.rs

···
                 Ok(())
             }
             ExprKind::Call(c) => type_check_call(c, ctx),
-            ExprKind::Allocation { elements, .. } => {
-                for e in elements {
+            ExprKind::Allocation { elements, kind, .. } => {
+                for e in &mut *elements {
                     e.typecheck(ctx)?;
+                }
+
+                match kind {
+                    AllocKind::Tuple(tys) => {
+                        let mut types = Vec::new();
+                        for elem in elements {
+                            types.push(elem.resolve_type(ctx).node);
+                        }
+
+                        if !tys.is_empty() && tys.len() != types.len() && *tys != types {
+                            panic!("expected tuple types to be equal");
+                        }
+
+                        *tys = types;
+                    }
+                    AllocKind::Array(ty_kind, size) => {
+                        assert_eq!(*size, elements.len());
+
+                        assert!(
+                            elements
+                                .iter()
+                                .all(|e| e.resolve_type(ctx).node == **ty_kind)
+                        );
+                    }
+                    AllocKind::DynArray(ty_kind) => {
+                        assert!(
+                            elements
+                                .iter()
+                                .all(|e| e.resolve_type(ctx).node == **ty_kind)
+                        );
+                    }
                 }
                 Ok(())
             }

tests/working_subset.nm

···
     untyped_int := 1
     typed_int : int = 2
     array := [2]{ 1, 2 }
-    // dyn_array := [] { 1, 2 }
+    dyn_array := [] { 1, 2 }
+    tuple := (1, 2)
 
     println(untyped_int)
 }