worry about tuple types a bit

frontend/src/ast.rs

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

frontend/src/ast_visitor.rs

···
         TypeKind::Unit => mir::Ty::Unit,
         TypeKind::Alloc(kind, _) => match kind {
             // TODO: resolve tuple tys
-            AllocKind::Tuple => mir::Ty::Tuple(vec![]),
+            AllocKind::Tuple(tys) => {
+                let tys = tys.iter().map(|t| ast_type_to_mir_type(&t)).collect();
+
+                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)
···
                         let ty = ast_type_to_mir_type(&ty.node);
                         mir::RValue::Alloc(mir::AllocKind::Array(ty), ops)
                     }
-                    AllocKind::Tuple => mir::RValue::Alloc(mir::AllocKind::Tuple, ops),
-                    AllocKind::DynArray(_ty) => {
-                        todo!()
+                    AllocKind::Tuple(tys) => {
+                        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);
+                        mir::RValue::Alloc(mir::AllocKind::DynArray(ty), ops)
                     }
                 }
             }

frontend/src/mir/mod.rs

···
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum AllocKind {
     Array(Ty),
-    Tuple,
+    DynArray(Ty),
+    Tuple(Vec<Ty>),
 }
 
 impl Display for AllocKind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             AllocKind::Array(ty) => write!(f, "array<{}>", ty),
-            AllocKind::Tuple => write!(f, "tuple"),
+            AllocKind::Tuple(tys) => {
+                let ty_str = tys
+                    .iter()
+                    .map(|t| t.to_string())
+                    .collect::<Vec<String>>()
+                    .join(" * ");
+
+                write!(f, "{}", ty_str)
+            }
+            AllocKind::DynArray(ty) => write!(f, "dyn_array<{}>", ty),
         }
     }
 }

frontend/src/parse.rs

···
 
                 Ok(Spanned::new(
                     ExprKind::Allocation {
-                        kind: AllocKind::Tuple,
+                        // filled in during typechecking
+                        kind: AllocKind::Tuple(vec![]),
                         elements: exprs,
                         region: None,
                     },
···
 
 #[cfg(test)]
 mod tests {
-    use std::clone;
-
     use super::*;
-    use crate::{
-        ast::{Type, UserDefinedType},
-        ctx::Symbol,
-        lex,
-    };
+    use crate::{ast::UserDefinedType, ctx::Symbol, lex};
 
     fn tokenify(s: &str) -> (Ctx, VecDeque<SpannedToken>) {
         let mut ctx = Ctx::new();
···
         let ExprKind::Allocation { kind, elements, .. } = &expr.node else {
             panic!("expected allocation")
         };
-        assert!(matches!(kind, AllocKind::Tuple));
+        // types have not been resolved since we did not provide them
+        assert_eq!(*kind, AllocKind::Tuple(vec![]));
         assert_eq!(elements.len(), 3);
     }
 }

frontend/src/typecheck.rs

···
                 // TODO: implement region handling
                 // regions should be resolved by the time we get here
                 let region_handle = region.unwrap_or(Region::Local);
-                Type::synthetic(TypeKind::Alloc(kind.clone(), region_handle))
+                let kind = match kind {
+                    AllocKind::Tuple(tys) => {
+                        let mut types = Vec::new();
+                        for elem in elements {
+                            types.push(elem.resolve_type(ctx).node);
+                        }
+
+                        if tys.len() != 0 && tys.len() != types.len() && *tys != types {
+                            panic!("expected tuple types to be equal");
+                        }
+
+                        // here we resolve the tuple types if they were not provided by a type hint
+                        AllocKind::Tuple(types)
+                    }
+                    _ => kind.clone(),
+                };
+
+                Type::synthetic(TypeKind::Alloc(kind, region_handle))
             }
         }
     }