matching on literals

codegen/src/llvm.rs

···
 
 struct FunctionLocalInfo<'ctx> {
     ty: BasicTypeEnum<'ctx>,
+    tk: mir::Ty,
     alloc: PointerValue<'ctx>,
     defining_block: BasicBlock<'ctx>,
 }
···
 impl<'ctx> FunctionLocalInfo<'ctx> {
     fn new(
         ty: BasicTypeEnum<'ctx>,
+        tk: mir::Ty,
         alloc: PointerValue<'ctx>,
         defining_block: BasicBlock<'ctx>,
     ) -> Self {
         Self {
             ty,
+            tk,
             alloc,
             defining_block,
         }
···
             }
             mir::Terminator::BrTable(local_id, jump_table) => {
                 let jump_local_info = self.function_locals.get(&local_id).unwrap();
+                let (jump_val, switch_type) = match jump_local_info.tk {
+                    mir::Ty::Int => {
+                        let switch_type = self.ctx().i32_type();
 
-                let jump_ptr = self.builder.build_struct_gep(
-                    jump_local_info.ty,
-                    jump_local_info.alloc,
-                    0,
-                    "jump_ptr",
-                )?;
+                        let jump_val = self
+                            .builder
+                            .build_load(switch_type, jump_local_info.alloc, "jump_val")
+                            .unwrap()
+                            .into_int_value();
+
+                        (jump_val, switch_type)
+                    }
+                    mir::Ty::TaggedUnion(_) => {
+                        let switch_type = self.ctx().i8_type();
+
+                        let jump_ptr = self.builder.build_struct_gep(
+                            jump_local_info.ty,
+                            jump_local_info.alloc,
+                            0,
+                            "jump_ptr",
+                        )?;
+
+                        let jump_val = self
+                            .builder
+                            .build_load(switch_type, jump_ptr, "jump_val")
+                            .unwrap()
+                            .into_int_value();
 
-                let jump_val = self
-                    .builder
-                    .build_load(self.ctx().i8_type(), jump_ptr, "jump_val")
-                    .unwrap()
-                    .into_int_value();
+                        (jump_val, switch_type)
+                    }
+                    _ => todo!(),
+                };
 
                 let default_bb = self.get_or_create_bb(llvm_fn, jump_table.default);
 
···
                 for (val, block_id) in jump_table.cases {
                     let bb = self.get_or_create_bb(llvm_fn, block_id);
 
-                    let val = self.ctx().i8_type().const_int(val as u64, false);
+                    let val = switch_type.const_int(val as u64, false);
                     cases.push((val, bb));
                 }
 
···
                 .builder
                 .build_alloca(local_ty, format!("x{}", local.id).as_str())?;
 
-            let local_info = FunctionLocalInfo::new(local_ty, local_alloca, entry_block);
+            let local_info =
+                FunctionLocalInfo::new(local_ty, local.ty.clone(), local_alloca, entry_block);
             self.function_locals.insert(local.id, local_info);
         }
 

frontend/src/ast_visitor.rs

···
 
     fn get_scrutinee_type_and_local(&mut self, scrutinee: Expr) -> (TypeKind, mir::LocalId) {
         let scru_rvalue = self.visit_expr(scrutinee);
-        let scru_ty = self
-            .local_types
-            .get(&scru_rvalue.place().unwrap().local)
-            .unwrap()
-            .clone();
-        let scru_local = self.ensure_local(scru_rvalue, &scru_ty);
-        (scru_ty, scru_local)
+        match &scru_rvalue.place() {
+            Some(place) => {
+                let scru_ty = self.local_types.get(&place.local).unwrap().clone();
+                let scru_local = self.ensure_local(scru_rvalue, &scru_ty);
+                (scru_ty, scru_local)
+            }
+            None => {
+                // need to load this into memory now
+                match &scru_rvalue {
+                    mir::RValue::Use(mir::Operand::Constant(cnst)) => {
+                        let scru_ty = match cnst {
+                            mir::Constant::Int(_) => TypeKind::Int,
+                            mir::Constant::Bool(_) => TypeKind::Bool,
+                        };
+
+                        let scru_local = self.new_local(&scru_ty);
+                        self.get_current_block()
+                            .stmts
+                            .push(mir::Statement::Assign(scru_local, scru_rvalue));
+                        (scru_ty, scru_local)
+                    }
+                    _ => todo!(),
+                }
+            }
+        }
     }
 
     fn get_variant_tag(&self, scrutinee_ty: &TypeKind, variant_name: Symbol) -> Option<u8> {
···
                     match &arm.pat.node {
                         PatKind::Variant { name, bindings } => {
                             if let Some(tag) = self.get_variant_tag(&scru_ty, *name) {
-                                cases.push((tag as u32, arm_block_id));
+                                cases.push((tag as i32, arm_block_id));
 
                                 if !bindings.is_empty() {
                                     let idx = self.get_variant_index(&scru_ty, *name).unwrap();
···
                             self.bind_pattern(&arm.pat, scru_local, &scru_ty);
                             default_arm_block_id = Some(arm_block_id);
                         }
-                        PatKind::Record(fields) => {
-                            for field in fields {
-                                let field_idx = self.get_record_field_index(&scru_ty, field.name);
-                                if let Some(idx) = field_idx {
-                                    let field_local = self.extract_record_field(scru_local, idx);
-                                    self.symbol_table.insert(field.name, field_local);
-                                }
+                        PatKind::Literal(lit) => match lit {
+                            ValueKind::Int(i) => {
+                                cases.push((*i, arm_block_id));
                             }
-                        }
+                            _ => todo!(),
+                        },
+                        // PatKind::Record(fields) => {
+                        //     for field in fields {
+                        //         let field_idx = self.get_record_field_index(&scru_ty, field.name);
+                        //         if let Some(idx) = field_idx {
+                        //             let field_local = self.extract_record_field(scru_local, idx);
+                        //             self.symbol_table.insert(field.name, field_local);
+                        //         }
+                        //     }
+                        // }
                         _ => {}
                     }
 

frontend/src/mir/ir.rs

···
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct JumpTable {
     pub default: BlockId,
-    pub cases: Vec<(u32, BlockId)>,
+    pub cases: Vec<(i32, BlockId)>,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]

frontend/src/typecheck.rs

···
                                 ctx.type_map.insert(field.name, field.ty.clone().unwrap());
                             }
                         }
+                        PatKind::Literal(lit) => match lit {
+                            ValueKind::Int(_) => {
+                                if scrutinee_ty.node != TypeKind::Int {
+                                    return Err(TypeError::new(
+                                        TypeErrorKind::ExpectedType {
+                                            expected: TypeKind::Int,
+                                            found: scrutinee_ty.node.clone(),
+                                        },
+                                        scrutinee_ty.span.clone(),
+                                    ));
+                                }
+                            }
+                            _ => todo!(),
+                        },
                         PatKind::Wildcard => {}
                         _ => todo!(),
                     }

tests/working_subset.nm

···
         Some(x) => { printf(fmt_string, x) }
       | None    => { printf(fmt_string, 0) }
 
+    match typed_int with
+        1 => { printf(fmt_string, 1) }
+      | 2 => { printf(fmt_string, 2) }
+      | _ => { printf(fmt_string, 999) }
+
+    match 3 with
+        1 => { printf(fmt_string, 1) }
+      | 2 => { printf(fmt_string, 2) }
+      | _ => { printf(fmt_string, 999) }
+
     // dyn_array := [] { 1, 2 }
 }