core/builtins: Add np_minimum/np_maximum

We will need to reuse them when implementing elementwise function
application for ndarrays.

.clippy.toml

@@ -0,0 +1 @@
+doc-valid-idents = ["NumPy", ".."]

flake.lock

@@ -2,16 +2,16 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1701389149,
-        "narHash": "sha256-rU1suTIEd5DGCaAXKW6yHoCfR1mnYjOXQFOaH7M23js=",
+        "lastModified": 1708296515,
+        "narHash": "sha256-FyF489fYNAUy7b6dkYV6rGPyzp+4tThhr80KNAaF/yY=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "5de0b32be6e85dc1a9404c75131316e4ffbc634c",
+        "rev": "b98a4e1746acceb92c509bc496ef3d0e5ad8d4aa",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.11",
+        "ref": "nixos-unstable",
         "repo": "nixpkgs",
         "type": "github"
       }

flake.nix

@@ -1,7 +1,7 @@
 {
   description = "The third-generation ARTIQ compiler";
 
-  inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-23.11;
+  inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-unstable;
 
   outputs = { self, nixpkgs }:
     let
@@ -94,8 +94,8 @@
             (pkgs.fetchFromGitHub {
               owner = "m-labs";
               repo = "artiq";
-              rev = "8b4572f9cad34ac0c2b6f6bba9382e7b59b2f93b";
-              sha256 = "sha256-O/0sUSxxXU1AL9cmT9qdzCkzdOKREBNftz22/8ouQcc=";
+              rev = "923ca3377d42c815f979983134ec549dc39d3ca0";
+              sha256 = "sha256-oJoEeNEeNFSUyh6jXG8Tzp6qHVikeHS0CzfE+mODPgw=";
             })
           ];
           buildInputs = [

nac3artiq/Cargo.toml

@@ -12,13 +12,13 @@ crate-type = ["cdylib"]
 itertools = "0.12"
 pyo3 = { version = "0.20", features = ["extension-module"] }
 parking_lot = "0.12"
-tempfile = "3.8"
+tempfile = "3.10"
 nac3parser = { path = "../nac3parser" }
 nac3core = { path = "../nac3core" }
 nac3ld = { path = "../nac3ld" }
 
 [dependencies.inkwell]
-version = "0.2"
+version = "0.4"
 default-features = false
 features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
 

nac3artiq/src/codegen.rs

@@ -1,18 +1,23 @@
 use nac3core::{
     codegen::{
         expr::gen_call,
+        llvm_intrinsics::{call_int_smax, call_stackrestore, call_stacksave},
         stmt::{gen_block, gen_with},
         CodeGenContext, CodeGenerator,
     },
     symbol_resolver::ValueEnum,
-    toplevel::{DefinitionId, GenCall},
-    typecheck::typedef::{FunSignature, FuncArg, Type, TypeEnum}
+    toplevel::{DefinitionId, GenCall, helper::PRIMITIVE_DEF_IDS},
+    typecheck::typedef::{FunSignature, FuncArg, Type, TypeEnum, VarMap}
 };
 
 use nac3parser::ast::{Expr, ExprKind, Located, Stmt, StmtKind, StrRef};
 
 use inkwell::{
-    context::Context, module::Linkage, types::IntType, values::BasicValueEnum, AddressSpace,
+    context::Context, 
+    module::Linkage, 
+    types::IntType, 
+    values::BasicValueEnum,
+    AddressSpace,
 };
 
 use pyo3::{PyObject, PyResult, Python, types::{PyDict, PyList}};
@@ -128,26 +133,18 @@ impl<'a> ArtiqCodeGenerator<'a> {
                 .unwrap()
                 .to_basic_value_enum(ctx, self, end.custom.unwrap())?;
             let now = self.timeline.emit_now_mu(ctx);
-            let smax = ctx.module.get_function("llvm.smax.i64").unwrap_or_else(|| {
-                let i64 = ctx.ctx.i64_type();
-                ctx.module.add_function(
-                    "llvm.smax.i64",
-                    i64.fn_type(&[i64.into(), i64.into()], false),
-                    None,
-                )
-            });
-            let max = ctx
-                .builder
-                .build_call(smax, &[old_end.into(), now.into()], "smax")
-                .try_as_basic_value()
-                .left()
-                .unwrap();
+            let max = call_int_smax(
+                ctx, 
+                old_end.into_int_value(), 
+                now.into_int_value(), 
+                Some("smax")
+            );
             let end_store = self.gen_store_target(
                 ctx,
                 &end,
                 store_name.map(|name| format!("{name}.addr")).as_deref())?
                 .unwrap();
-            ctx.builder.build_store(end_store, max);
+            ctx.builder.build_store(end_store, max).unwrap();
         }
 
         Ok(())
@@ -268,7 +265,7 @@ impl<'b> CodeGenerator for ArtiqCodeGenerator<'b> {
                             let start = self
                                 .gen_store_target(ctx, &start_expr, Some("start.addr"))?
                                 .unwrap();
-                            ctx.builder.build_store(start, now);
+                            ctx.builder.build_store(start, now).unwrap();
                             Ok(Some(start_expr)) as Result<_, String>
                         },
                         |v| Ok(Some(v)),
@@ -283,7 +280,7 @@ impl<'b> CodeGenerator for ArtiqCodeGenerator<'b> {
                     let end = self
                         .gen_store_target(ctx, &end_expr, Some("end.addr"))?
                         .unwrap();
-                    ctx.builder.build_store(end, now);
+                    ctx.builder.build_store(end, now).unwrap();
                     self.end = Some(end_expr);
                     self.name_counter += 1;
                     self.parallel_mode = match id.to_string().as_str() {
@@ -463,23 +460,14 @@ fn rpc_codegen_callback_fn<'ctx>(
 
     let arg_length = args.len() + usize::from(obj.is_some());
 
-    let stacksave = ctx.module.get_function("llvm.stacksave").unwrap_or_else(|| {
-        ctx.module.add_function("llvm.stacksave", ptr_type.fn_type(&[], false), None)
-    });
-    let stackrestore = ctx.module.get_function("llvm.stackrestore").unwrap_or_else(|| {
-        ctx.module.add_function(
-            "llvm.stackrestore",
-            ctx.ctx.void_type().fn_type(&[ptr_type.into()], false),
-            None,
+    let stackptr = call_stacksave(ctx, Some("rpc.stack"));
+    let args_ptr = ctx.builder
+        .build_array_alloca(
+            ptr_type,
+            ctx.ctx.i32_type().const_int(arg_length as u64, false),
+            "argptr",
         )
-    });
-
-    let stackptr = ctx.builder.build_call(stacksave, &[], "rpc.stack");
-    let args_ptr = ctx.builder.build_array_alloca(
-        ptr_type,
-        ctx.ctx.i32_type().const_int(arg_length as u64, false),
-        "argptr",
-    );
+        .unwrap();
 
     // -- rpc args handling
     let mut keys = fun.0.args.clone();
@@ -512,16 +500,16 @@ fn rpc_codegen_callback_fn<'ctx>(
 
     for (i, arg) in real_params.iter().enumerate() {
         let arg_slot = generator.gen_var_alloc(ctx, arg.get_type(), Some(&format!("rpc.arg{i}"))).unwrap();
-        ctx.builder.build_store(arg_slot, *arg);
-        let arg_slot = ctx.builder.build_bitcast(arg_slot, ptr_type, "rpc.arg");
+        ctx.builder.build_store(arg_slot, *arg).unwrap();
+        let arg_slot = ctx.builder.build_bitcast(arg_slot, ptr_type, "rpc.arg").unwrap();
         let arg_ptr = unsafe {
             ctx.builder.build_gep(
                 args_ptr,
                 &[int32.const_int(i as u64, false)],
                 &format!("rpc.arg{i}"),
             )
-        };
-        ctx.builder.build_store(arg_ptr, arg_slot);
+        }.unwrap();
+        ctx.builder.build_store(arg_ptr, arg_slot).unwrap();
     }
 
     // call
@@ -539,18 +527,16 @@ fn rpc_codegen_callback_fn<'ctx>(
             None,
         )
     });
-    ctx.builder.build_call(
-        rpc_send,
-        &[service_id.into(), tag_ptr.into(), args_ptr.into()],
-        "rpc.send",
-    );
+    ctx.builder
+        .build_call(
+            rpc_send,
+            &[service_id.into(), tag_ptr.into(), args_ptr.into()],
+            "rpc.send",
+        )
+        .unwrap();
 
     // reclaim stack space used by arguments
-    ctx.builder.build_call(
-        stackrestore,
-        &[stackptr.try_as_basic_value().unwrap_left().into()],
-        "rpc.stackrestore",
-    );
+    call_stackrestore(ctx, stackptr);
 
     // -- receive value:
     // T result = {
@@ -578,41 +564,39 @@ fn rpc_codegen_callback_fn<'ctx>(
 
     let ret_ty = ctx.get_llvm_abi_type(generator, fun.0.ret);
     let need_load = !ret_ty.is_pointer_type();
-    let slot = ctx.builder.build_alloca(ret_ty, "rpc.ret.slot");
-    let slotgen = ctx.builder.build_bitcast(slot, ptr_type, "rpc.ret.ptr");
-    ctx.builder.build_unconditional_branch(head_bb);
+    let slot = ctx.builder.build_alloca(ret_ty, "rpc.ret.slot").unwrap();
+    let slotgen = ctx.builder.build_bitcast(slot, ptr_type, "rpc.ret.ptr").unwrap();
+    ctx.builder.build_unconditional_branch(head_bb).unwrap();
     ctx.builder.position_at_end(head_bb);
 
-    let phi = ctx.builder.build_phi(ptr_type, "rpc.ptr");
+    let phi = ctx.builder.build_phi(ptr_type, "rpc.ptr").unwrap();
     phi.add_incoming(&[(&slotgen, prehead_bb)]);
     let alloc_size = ctx
         .build_call_or_invoke(rpc_recv, &[phi.as_basic_value()], "rpc.size.next")
         .unwrap()
         .into_int_value();
-    let is_done = ctx.builder.build_int_compare(
-        inkwell::IntPredicate::EQ,
-        int32.const_zero(),
-        alloc_size,
-        "rpc.done",
-    );
+    let is_done = ctx.builder
+        .build_int_compare(
+            inkwell::IntPredicate::EQ,
+            int32.const_zero(),
+            alloc_size,
+            "rpc.done",
+        )
+        .unwrap();
 
-    ctx.builder.build_conditional_branch(is_done, tail_bb, alloc_bb);
+    ctx.builder.build_conditional_branch(is_done, tail_bb, alloc_bb).unwrap();
     ctx.builder.position_at_end(alloc_bb);
 
-    let alloc_ptr = ctx.builder.build_array_alloca(ptr_type, alloc_size, "rpc.alloc");
-    let alloc_ptr = ctx.builder.build_bitcast(alloc_ptr, ptr_type, "rpc.alloc.ptr");
+    let alloc_ptr = ctx.builder.build_array_alloca(ptr_type, alloc_size, "rpc.alloc").unwrap();
+    let alloc_ptr = ctx.builder.build_bitcast(alloc_ptr, ptr_type, "rpc.alloc.ptr").unwrap();
     phi.add_incoming(&[(&alloc_ptr, alloc_bb)]);
-    ctx.builder.build_unconditional_branch(head_bb);
+    ctx.builder.build_unconditional_branch(head_bb).unwrap();
 
     ctx.builder.position_at_end(tail_bb);
 
-    let result = ctx.builder.build_load(slot, "rpc.result");
+    let result = ctx.builder.build_load(slot, "rpc.result").unwrap();
     if need_load {
-        ctx.builder.build_call(
-            stackrestore,
-            &[stackptr.try_as_basic_value().unwrap_left().into()],
-            "rpc.stackrestore",
-        );
+        call_stackrestore(ctx, stackptr);
     }
     Ok(Some(result))
 }
@@ -640,7 +624,7 @@ pub fn attributes_writeback(
             let ty = ty.unwrap();
             match &*ctx.unifier.get_ty(ty) {
                 TypeEnum::TObj { fields, obj_id, .. }
-                    if *obj_id != ctx.primitives.option.get_obj_id(&ctx.unifier) =>
+                    if *obj_id != ctx.primitives.option.obj_id(&ctx.unifier).unwrap() =>
                 {
                     // we only care about primitive attributes
                     // for non-primitive attributes, they should be in another global
@@ -683,10 +667,10 @@ pub fn attributes_writeback(
                 default_value: None
             }).collect(),
             ret: ctx.primitives.none,
-            vars: HashMap::default()
+            vars: VarMap::default()
         };
         let args: Vec<_> = values.into_iter().map(|(_, val)| (None, ValueEnum::Dynamic(val))).collect();
-        if let Err(e) = rpc_codegen_callback_fn(ctx, None, (&fun, DefinitionId(0)), args, generator) {
+        if let Err(e) = rpc_codegen_callback_fn(ctx, None, (&fun, PRIMITIVE_DEF_IDS.int32), args, generator) {
             return Ok(Err(e));
         }
         Ok(Ok(()))

nac3artiq/src/lib.rs

@@ -16,7 +16,7 @@ use inkwell::{
 use itertools::Itertools;
 use nac3core::codegen::{CodeGenLLVMOptions, CodeGenTargetMachineOptions, gen_func_impl};
 use nac3core::toplevel::builtins::get_exn_constructor;
-use nac3core::typecheck::typedef::{TypeEnum, Unifier};
+use nac3core::typecheck::typedef::{TypeEnum, Unifier, VarMap};
 use nac3parser::{
     ast::{ExprKind, Stmt, StmtKind, StrRef},
     parser::parse_program,
@@ -63,6 +63,17 @@ enum Isa {
     CortexA9,
 }
 
+impl Isa {
+    /// Returns the number of bits in `size_t` for the [`Isa`].
+    fn get_size_type(self) -> u32 {
+        if self == Isa::Host {
+            64u32
+        } else {
+            32u32
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct PrimitivePythonId {
     int: u64,
@@ -74,6 +85,7 @@ pub struct PrimitivePythonId {
     float64: u64,
     bool: u64,
     list: u64,
+    ndarray: u64,
     tuple: u64,
     typevar: u64,
     const_generic_marker: u64,
@@ -277,9 +289,11 @@ impl Nac3 {
         py: Python,
         link_fn: &dyn Fn(&Module) -> PyResult<T>,
     ) -> PyResult<T> {
+        let size_t = self.isa.get_size_type();
         let (mut composer, mut builtins_def, mut builtins_ty) = TopLevelComposer::new(
             self.builtins.clone(),
             ComposerConfig { kernel_ann: Some("Kernel"), kernel_invariant_ann: "KernelInvariant" },
+            size_t,
         );
 
         let builtins = PyModule::import(py, "builtins")?;
@@ -462,7 +476,7 @@ impl Nac3 {
             .unwrap();
 
         let fun_signature =
-            FunSignature { args: vec![], ret: self.primitive.none, vars: HashMap::new() };
+            FunSignature { args: vec![], ret: self.primitive.none, vars: VarMap::new() };
         let mut store = ConcreteTypeStore::new();
         let mut cache = HashMap::new();
         let signature =
@@ -628,7 +642,13 @@ impl Nac3 {
         let builder = context.create_builder();
         let modinit_return = main.get_function("__modinit__").unwrap().get_last_basic_block().unwrap().get_terminator().unwrap();
         builder.position_before(&modinit_return);
-        builder.build_call(main.get_function("attributes_writeback").unwrap(), &[], "attributes_writeback");
+        builder
+            .build_call(
+                main.get_function("attributes_writeback").unwrap(),
+                &[],
+                "attributes_writeback",
+            )
+            .unwrap();
 
         main.link_in_module(load_irrt(&context))
             .map_err(|err| CompileError::new_err(err.to_string()))?;
@@ -792,11 +812,11 @@ impl Nac3 {
             Isa::RiscV32IMA => &timeline::NOW_PINNING_TIME_FNS,
             Isa::CortexA9 | Isa::Host => &timeline::EXTERN_TIME_FNS,
         };
-        let primitive: PrimitiveStore = TopLevelComposer::make_primitives().0;
+        let primitive: PrimitiveStore = TopLevelComposer::make_primitives(isa.get_size_type()).0;
         let builtins = vec![
             (
                 "now_mu".into(),
-                FunSignature { args: vec![], ret: primitive.int64, vars: HashMap::new() },
+                FunSignature { args: vec![], ret: primitive.int64, vars: VarMap::new() },
                 Arc::new(GenCall::new(Box::new(move |ctx, _, _, _, _| {
                     Ok(Some(time_fns.emit_now_mu(ctx)))
                 }))),
@@ -810,7 +830,7 @@ impl Nac3 {
                         default_value: None,
                     }],
                     ret: primitive.none,
-                    vars: HashMap::new(),
+                    vars: VarMap::new(),
                 },
                 Arc::new(GenCall::new(Box::new(move |ctx, _, fun, args, generator| {
                     let arg_ty = fun.0.args[0].ty;
@@ -828,7 +848,7 @@ impl Nac3 {
                         default_value: None,
                     }],
                     ret: primitive.none,
-                    vars: HashMap::new(),
+                    vars: VarMap::new(),
                 },
                 Arc::new(GenCall::new(Box::new(move |ctx, _, fun, args, generator| {
                     let arg_ty = fun.0.args[0].ty;
@@ -842,6 +862,7 @@ impl Nac3 {
         let builtins_mod = PyModule::import(py, "builtins").unwrap();
         let id_fn = builtins_mod.getattr("id").unwrap();
         let numpy_mod = PyModule::import(py, "numpy").unwrap();
+        let numpy_typing_mod = PyModule::import(py, "numpy.typing").unwrap();
         let typing_mod = PyModule::import(py, "typing").unwrap();
         let types_mod = PyModule::import(py, "types").unwrap();
 
@@ -866,6 +887,7 @@ impl Nac3 {
             float: get_attr_id(builtins_mod, "float"),
             float64: get_attr_id(numpy_mod, "float64"),
             list: get_attr_id(builtins_mod, "list"),
+            ndarray: get_attr_id(numpy_typing_mod, "NDArray"),
             tuple: get_attr_id(builtins_mod, "tuple"),
             exception: get_attr_id(builtins_mod, "Exception"),
             option: get_id(artiq_builtins.get_item("Option").ok().flatten().unwrap()),

nac3artiq/src/symbol_resolver.rs

@@ -2,10 +2,15 @@ use inkwell::{types::BasicType, values::BasicValueEnum, AddressSpace};
 use nac3core::{
     codegen::{CodeGenContext, CodeGenerator},
     symbol_resolver::{StaticValue, SymbolResolver, SymbolValue, ValueEnum},
-    toplevel::{DefinitionId, TopLevelDef},
+    toplevel::{
+        DefinitionId, 
+        helper::PRIMITIVE_DEF_IDS, 
+        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
+        TopLevelDef,
+    },
     typecheck::{
         type_inferencer::PrimitiveStore,
-        typedef::{Type, TypeEnum, Unifier},
+        typedef::{Type, TypeEnum, Unifier, VarMap},
     },
 };
 use nac3parser::ast::{self, StrRef};
@@ -33,10 +38,15 @@ pub enum PrimitiveValue {
     Bool(bool),
 }
 
+/// An entry in the [`DeferredEvaluationStore`], containing the deferred types, a [`PyObject`]
+/// representing the `__constraints__` of the type variables, and the name of the type to be
+/// instantiated.
+type DeferredEvaluationEntry = (Vec<Type>, PyObject, String);
+
 #[derive(Clone)]
 pub struct DeferredEvaluationStore {
     needs_defer: Arc<AtomicBool>,
-    store: Arc<RwLock<Vec<(Vec<Type>, PyObject, String)>>>,
+    store: Arc<RwLock<Vec<DeferredEvaluationEntry>>>,
 }
 
 impl DeferredEvaluationStore {
@@ -48,12 +58,18 @@ impl DeferredEvaluationStore {
     }
 }
 
+/// A class field as stored in the [`InnerResolver`], represented by the ID and name of the 
+/// associated [`PythonValue`].
+type ResolverField = (u64, StrRef);
+/// A class field as stored in Python, represented by the `id()` and [`PyObject`] of the field.
+type PyFieldHandle = (u64, PyObject);
+
 pub struct InnerResolver {
     pub id_to_type: RwLock<HashMap<StrRef, Type>>,
     pub id_to_def: RwLock<HashMap<StrRef, DefinitionId>>,
     pub id_to_pyval: RwLock<HashMap<StrRef, (u64, PyObject)>>,
     pub id_to_primitive: RwLock<HashMap<u64, PrimitiveValue>>,
-    pub field_to_val: RwLock<HashMap<(u64, StrRef), Option<(u64, PyObject)>>>,
+    pub field_to_val: RwLock<HashMap<ResolverField, Option<PyFieldHandle>>>,
     pub global_value_ids: Arc<RwLock<HashMap<u64, PyObject>>>,
     pub class_names: Mutex<HashMap<StrRef, Type>>,
     pub pyid_to_def: Arc<RwLock<HashMap<u64, DefinitionId>>>,
@@ -302,6 +318,12 @@ impl InnerResolver {
             let var = unifier.get_dummy_var().0;
             let list = unifier.add_ty(TypeEnum::TList { ty: var });
             Ok(Ok((list, false)))
+        } else if ty_id == self.primitive_ids.ndarray {
+            // do not handle type var param and concrete check here
+            let var = unifier.get_dummy_var().0;
+            let ndims = unifier.get_fresh_const_generic_var(primitives.usize(), None, None).0;
+            let ndarray = make_ndarray_ty(unifier, primitives, Some(var), Some(ndims));
+            Ok(Ok((ndarray, false)))
         } else if ty_id == self.primitive_ids.tuple {
             // do not handle type var param and concrete check here
             Ok(Ok((unifier.add_ty(TypeEnum::TTuple { ty: vec![] }), false)))
@@ -446,6 +468,16 @@ impl InnerResolver {
                         )));
                     }
                 }
+                TypeEnum::TObj { obj_id, .. } if *obj_id == PRIMITIVE_DEF_IDS.ndarray => {
+                    if args.len() != 2 {
+                        return Ok(Err(format!(
+                            "type list needs exactly 2 type parameters, found {}",
+                            args.len()
+                        )));
+                    }
+
+                    todo!()
+                }
                 TypeEnum::TTuple { .. } => {
                     let args = match args
                         .iter()
@@ -498,7 +530,7 @@ impl InnerResolver {
                             .iter()
                             .zip(args.iter())
                             .map(|((id, _), ty)| (*id, *ty))
-                            .collect::<HashMap<_, _>>()
+                            .collect::<VarMap>()
                     };
                     Ok(Ok((unifier.subst(origin_ty, &subst).unwrap_or(origin_ty), true)))
                 }
@@ -607,7 +639,7 @@ impl InnerResolver {
             Err(e) => return Ok(Err(e)),
         };
         match (&*unifier.get_ty(extracted_ty), inst_check) {
-            // do the instantiation for these three types
+            // do the instantiation for these four types
             (TypeEnum::TList { ty }, false) => {
                 let len: usize = self.helper.len_fn.call1(py, (obj,))?.extract(py)?;
                 if len == 0 {
@@ -632,6 +664,40 @@ impl InnerResolver {
                     }
                 }
             }
+            (TypeEnum::TObj { obj_id, .. }, false) if *obj_id == PRIMITIVE_DEF_IDS.ndarray => {
+                let (ty, ndims) = unpack_ndarray_var_tys(unifier, extracted_ty);
+                let len: usize = self.helper.len_fn.call1(py, (obj,))?.extract(py)?;
+                if len == 0 {
+                    assert!(matches!(
+                        &*unifier.get_ty(ty),
+                        TypeEnum::TVar { fields: None, range, .. }
+                            if range.is_empty()
+                    ));
+                    Ok(Ok(extracted_ty))
+                } else {
+                    let actual_ty =
+                        self.get_list_elem_type(py, obj, len, unifier, defs, primitives)?;
+                    match actual_ty {
+                        Ok(t) => match unifier.unify(ty, t) {
+                            Ok(()) => {
+                                let ndarray_ty = make_ndarray_ty(
+                                    unifier,
+                                    primitives,
+                                    Some(ty),
+                                    Some(ndims),
+                                );
+
+                                Ok(Ok(ndarray_ty))
+                            }
+                            Err(e) => Ok(Err(format!(
+                                "type error ({}) for the ndarray",
+                                e.to_display(unifier),
+                            ))),
+                        },
+                        Err(e) => Ok(Err(e)),
+                    }
+                }
+            }
             (TypeEnum::TTuple { .. }, false) => {
                 let elements: &PyTuple = obj.downcast()?;
                 let types: Result<Result<Vec<_>, _>, _> = elements
@@ -644,7 +710,7 @@ impl InnerResolver {
             // special handling for option type since its class member layout in python side
             // is special and cannot be mapped directly to a nac3 type as below
             (TypeEnum::TObj { obj_id, params, .. }, false)
-                if *obj_id == primitives.option.get_obj_id(unifier) =>
+                if *obj_id == primitives.option.obj_id(unifier).unwrap() =>
             {
                 let Ok(field_data) = obj.getattr("_nac3_option") else {
                     unreachable!("cannot be None")
@@ -667,7 +733,7 @@ impl InnerResolver {
                             assert_eq!(*id, *id_var);
                             (*id, unifier.get_fresh_var_with_range(range, *name, *loc).0)
                         })
-                        .collect::<HashMap<_, _>>();
+                        .collect::<VarMap>();
                     return Ok(Ok(unifier.subst(primitives.option, &var_map).unwrap()))
                 }
 
@@ -679,7 +745,7 @@ impl InnerResolver {
                         )))
                     }
                 };
-                let new_var_map: HashMap<_, _> = params.iter().map(|(id, _)| (*id, ty)).collect();
+                let new_var_map: VarMap = params.iter().map(|(id, _)| (*id, ty)).collect();
                 let res = unifier.subst(extracted_ty, &new_var_map).unwrap_or(extracted_ty);
                 Ok(Ok(res))
             }
@@ -696,7 +762,7 @@ impl InnerResolver {
                         assert_eq!(*id, *id_var);
                         (*id, unifier.get_fresh_var_with_range(range, *name, *loc).0)
                     })
-                    .collect::<HashMap<_, _>>();
+                    .collect::<VarMap>();
                 let mut instantiate_obj = || {
                     // loop through non-function fields of the class to get the instantiated value
                     for field in fields {
@@ -898,6 +964,8 @@ impl InnerResolver {
             global.set_initializer(&val);
 
             Ok(Some(global.as_pointer_value().into()))
+        } else if ty_id == self.primitive_ids.ndarray {
+            todo!()
         } else if ty_id == self.primitive_ids.tuple {
             let expected_ty_enum = ctx.unifier.get_ty_immutable(expected_ty);
             let TypeEnum::TTuple { ty } = expected_ty_enum.as_ref() else {
@@ -925,7 +993,7 @@ impl InnerResolver {
         } else if ty_id == self.primitive_ids.option {
             let option_val_ty = match ctx.unifier.get_ty_immutable(expected_ty).as_ref() {
                 TypeEnum::TObj { obj_id, params, .. }
-                    if *obj_id == ctx.primitives.option.get_obj_id(&ctx.unifier) =>
+                    if *obj_id == ctx.primitives.option.obj_id(&ctx.unifier).unwrap() =>
                 {
                     *params.iter().next().unwrap().1
                 }
@@ -1064,7 +1132,6 @@ impl InnerResolver {
 impl SymbolResolver for Resolver {
     fn get_default_param_value(&self, expr: &ast::Expr) -> Option<SymbolValue> {
         let ast::ExprKind::Name { id, .. } = &expr.node else {
-
             unreachable!("only for resolving names")
         };
 

nac3artiq/src/timeline.rs

@@ -1,4 +1,5 @@
-use inkwell::{values::BasicValueEnum, AddressSpace, AtomicOrdering};
+use inkwell::{values::{BasicValueEnum, CallSiteValue}, AddressSpace, AtomicOrdering};
+use itertools::Either;
 use nac3core::codegen::CodeGenContext;
 
 /// Functions for manipulating the timeline.
@@ -26,32 +27,28 @@ impl TimeFns for NowPinningTimeFns64 {
             .module
             .get_global("now")
             .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
-        let now_hiptr =
-            ctx.builder.build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr");
-
-        let BasicValueEnum::PointerValue(now_hiptr) = now_hiptr else {
-            unreachable!()
-        };
+        let now_hiptr = ctx.builder
+            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .map(BasicValueEnum::into_pointer_value)
+            .unwrap();
 
         let now_loptr = unsafe {
             ctx.builder.build_gep(now_hiptr, &[i32_type.const_int(2, false)], "now.lo.addr")
-        };
+        }.unwrap();
 
-        let (BasicValueEnum::IntValue(now_hi), BasicValueEnum::IntValue(now_lo)) = (
-            ctx.builder.build_load(now_hiptr, "now.hi"),
-            ctx.builder.build_load(now_loptr, "now.lo"),
-        ) else {
-            unreachable!()
-        };
+        let now_hi = ctx.builder.build_load(now_hiptr, "now.hi")
+            .map(BasicValueEnum::into_int_value)
+            .unwrap();
+        let now_lo = ctx.builder.build_load(now_loptr, "now.lo")
+            .map(BasicValueEnum::into_int_value)
+            .unwrap();
 
-        let zext_hi = ctx.builder.build_int_z_extend(now_hi, i64_type, "");
-        let shifted_hi = ctx.builder.build_left_shift(
-            zext_hi,
-            i64_type.const_int(32, false),
-            "",
-        );
-        let zext_lo = ctx.builder.build_int_z_extend(now_lo, i64_type, "");
-        ctx.builder.build_or(shifted_hi, zext_lo, "now_mu").into()
+        let zext_hi = ctx.builder.build_int_z_extend(now_hi, i64_type, "").unwrap();
+        let shifted_hi = ctx.builder
+            .build_left_shift(zext_hi, i64_type.const_int(32, false), "")
+            .unwrap();
+        let zext_lo = ctx.builder.build_int_z_extend(now_lo, i64_type, "").unwrap();
+        ctx.builder.build_or(shifted_hi, zext_lo, "now_mu").map(Into::into).unwrap()
     }
 
     fn emit_at_mu<'ctx>(&self, ctx: &mut CodeGenContext<'ctx, '_>, t: BasicValueEnum<'ctx>) {
@@ -59,39 +56,36 @@ impl TimeFns for NowPinningTimeFns64 {
         let i64_type = ctx.ctx.i64_type();
 
         let i64_32 = i64_type.const_int(32, false);
-        let BasicValueEnum::IntValue(time) = t else {
-            unreachable!()
-        };
+        let time = t.into_int_value();
 
-        let time_hi = ctx.builder.build_int_truncate(
-            ctx.builder.build_right_shift(time, i64_32, false, "time.hi"),
-            i32_type,
-            "",
-        );
-        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo");
+        let time_hi = ctx.builder
+            .build_int_truncate(
+                ctx.builder.build_right_shift(time, i64_32, false, "time.hi").unwrap(),
+                i32_type,
+                "",
+            )
+            .unwrap();
+        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo").unwrap();
         let now = ctx
             .module
             .get_global("now")
             .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
-        let now_hiptr = ctx.builder.build_bitcast(
-            now,
-            i32_type.ptr_type(AddressSpace::default()),
-            "now.hi.addr",
-        );
-
-        let BasicValueEnum::PointerValue(now_hiptr) = now_hiptr else {
-            unreachable!()
-        };
+        let now_hiptr = ctx.builder
+            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .map(BasicValueEnum::into_pointer_value)
+            .unwrap();
 
         let now_loptr = unsafe {
             ctx.builder.build_gep(now_hiptr, &[i32_type.const_int(2, false)], "now.lo.addr")
-        };
+        }.unwrap();
         ctx.builder
             .build_store(now_hiptr, time_hi)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
         ctx.builder
             .build_store(now_loptr, time_lo)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
     }
@@ -107,57 +101,53 @@ impl TimeFns for NowPinningTimeFns64 {
             .module
             .get_global("now")
             .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
-        let now_hiptr =
-            ctx.builder.build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr");
-
-        let BasicValueEnum::PointerValue(now_hiptr) = now_hiptr else {
-            unreachable!()
-        };
+        let now_hiptr = ctx.builder
+            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .map(BasicValueEnum::into_pointer_value)
+            .unwrap();
 
         let now_loptr = unsafe {
             ctx.builder.build_gep(now_hiptr, &[i32_type.const_int(2, false)], "now.lo.addr")
-        };
+        }.unwrap();
 
-        let (
-            BasicValueEnum::IntValue(now_hi),
-            BasicValueEnum::IntValue(now_lo),
-            BasicValueEnum::IntValue(dt),
-        ) = (
-            ctx.builder.build_load(now_hiptr, "now.hi"),
-            ctx.builder.build_load(now_loptr, "now.lo"),
-            dt,
-        ) else {
-            unreachable!()
-        };
+        let now_hi = ctx.builder.build_load(now_hiptr, "now.hi")
+            .map(BasicValueEnum::into_int_value)
+            .unwrap();
+        let now_lo = ctx.builder.build_load(now_loptr, "now.lo")
+            .map(BasicValueEnum::into_int_value)
+            .unwrap();
+        let dt = dt.into_int_value();
 
-        let zext_hi = ctx.builder.build_int_z_extend(now_hi, i64_type, "");
-        let shifted_hi = ctx.builder.build_left_shift(
-            zext_hi,
-            i64_type.const_int(32, false),
-            "",
-        );
-        let zext_lo = ctx.builder.build_int_z_extend(now_lo, i64_type, "");
-        let now_val = ctx.builder.build_or(shifted_hi, zext_lo, "now");
+        let zext_hi = ctx.builder.build_int_z_extend(now_hi, i64_type, "").unwrap();
+        let shifted_hi = ctx.builder
+            .build_left_shift(zext_hi, i64_type.const_int(32, false), "")
+            .unwrap();
+        let zext_lo = ctx.builder.build_int_z_extend(now_lo, i64_type, "").unwrap();
+        let now_val = ctx.builder.build_or(shifted_hi, zext_lo, "now").unwrap();
 
-        let time = ctx.builder.build_int_add(now_val, dt, "time");
-        let time_hi = ctx.builder.build_int_truncate(
-            ctx.builder.build_right_shift(
-                time,
-                i64_type.const_int(32, false),
-                false,
-                "",
-            ),
-            i32_type,
-            "time.hi",
-        );
-        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo");
+        let time = ctx.builder.build_int_add(now_val, dt, "time").unwrap();
+        let time_hi = ctx.builder
+            .build_int_truncate(
+                ctx.builder.build_right_shift(
+                    time,
+                    i64_type.const_int(32, false),
+                    false,
+                    "",
+                ).unwrap(),
+                i32_type,
+                "time.hi",
+            )
+            .unwrap();
+        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo").unwrap();
 
         ctx.builder
             .build_store(now_hiptr, time_hi)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
         ctx.builder
             .build_store(now_loptr, time_lo)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
     }
@@ -174,16 +164,16 @@ impl TimeFns for NowPinningTimeFns {
             .module
             .get_global("now")
             .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
-        let now_raw = ctx.builder.build_load(now.as_pointer_value(), "now");
-
-        let BasicValueEnum::IntValue(now_raw) = now_raw else {
-            unreachable!()
-        };
+        let now_raw = ctx.builder.build_load(now.as_pointer_value(), "now")
+            .map(BasicValueEnum::into_int_value)
+            .unwrap();
 
         let i64_32 = i64_type.const_int(32, false);
-        let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now.lo");
-        let now_hi = ctx.builder.build_right_shift(now_raw, i64_32, false, "now.hi");
-        ctx.builder.build_or(now_lo, now_hi, "now_mu").into()
+        let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now.lo").unwrap();
+        let now_hi = ctx.builder.build_right_shift(now_raw, i64_32, false, "now.hi").unwrap();
+        ctx.builder.build_or(now_lo, now_hi, "now_mu")
+            .map(Into::into)
+            .unwrap()
     }
 
     fn emit_at_mu<'ctx>(&self, ctx: &mut CodeGenContext<'ctx, '_>, t: BasicValueEnum<'ctx>) {
@@ -191,39 +181,36 @@ impl TimeFns for NowPinningTimeFns {
         let i64_type = ctx.ctx.i64_type();
         let i64_32 = i64_type.const_int(32, false);
 
-        let BasicValueEnum::IntValue(time) = t else {
-            unreachable!()
-        };
+        let time = t.into_int_value();
 
-        let time_hi = ctx.builder.build_int_truncate(
-            ctx.builder.build_right_shift(time, i64_32, false, ""),
-            i32_type,
-            "time.hi",
-        );
-        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "now_trunc");
+        let time_hi = ctx.builder
+            .build_int_truncate(
+                ctx.builder.build_right_shift(time, i64_32, false, "").unwrap(),
+                i32_type,
+                "time.hi",
+            )
+            .unwrap();
+        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "now_trunc").unwrap();
         let now = ctx
             .module
             .get_global("now")
             .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
-        let now_hiptr = ctx.builder.build_bitcast(
-            now,
-            i32_type.ptr_type(AddressSpace::default()),
-            "now.hi.addr",
-        );
-
-        let BasicValueEnum::PointerValue(now_hiptr) = now_hiptr else {
-            unreachable!()
-        };
+        let now_hiptr = ctx.builder
+            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .map(BasicValueEnum::into_pointer_value)
+            .unwrap();
 
         let now_loptr = unsafe {
             ctx.builder.build_gep(now_hiptr, &[i32_type.const_int(1, false)], "now.lo.addr")
-        };
+        }.unwrap();
         ctx.builder
             .build_store(now_hiptr, time_hi)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
         ctx.builder
             .build_store(now_loptr, time_lo)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
     }
@@ -240,41 +227,41 @@ impl TimeFns for NowPinningTimeFns {
             .module
             .get_global("now")
             .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
-        let now_raw = ctx.builder.build_load(now.as_pointer_value(), "");
+        let now_raw = ctx.builder
+            .build_load(now.as_pointer_value(), "")
+            .map(BasicValueEnum::into_int_value)
+            .unwrap();
 
-        let (BasicValueEnum::IntValue(now_raw), BasicValueEnum::IntValue(dt)) = (now_raw, dt) else { 
-            unreachable!() 
-        };
+        let dt = dt.into_int_value();
 
-        let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now.lo");
-        let now_hi = ctx.builder.build_right_shift(now_raw, i64_32, false, "now.hi");
-        let now_val = ctx.builder.build_or(now_lo, now_hi, "now_val");
-        let time = ctx.builder.build_int_add(now_val, dt, "time");
-        let time_hi = ctx.builder.build_int_truncate(
-            ctx.builder.build_right_shift(time, i64_32, false, "time.hi"),
-            i32_type,
-            "now_trunc",
-        );
-        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo");
-        let now_hiptr = ctx.builder.build_bitcast(
-            now,
-            i32_type.ptr_type(AddressSpace::default()),
-            "now.hi.addr",
-        );
-
-        let BasicValueEnum::PointerValue(now_hiptr) = now_hiptr else { 
-            unreachable!()
-        };
+        let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now.lo").unwrap();
+        let now_hi = ctx.builder.build_right_shift(now_raw, i64_32, false, "now.hi").unwrap();
+        let now_val = ctx.builder.build_or(now_lo, now_hi, "now_val").unwrap();
+        let time = ctx.builder.build_int_add(now_val, dt, "time").unwrap();
+        let time_hi = ctx.builder
+            .build_int_truncate(
+                ctx.builder.build_right_shift(time, i64_32, false, "time.hi").unwrap(),
+                i32_type,
+                "now_trunc",
+            )
+            .unwrap();
+        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo").unwrap();
+        let now_hiptr = ctx.builder
+            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .map(BasicValueEnum::into_pointer_value)
+            .unwrap();
 
         let now_loptr = unsafe {
             ctx.builder.build_gep(now_hiptr, &[i32_type.const_int(1, false)], "now.lo.addr")
-        };
+        }.unwrap();
         ctx.builder
             .build_store(now_hiptr, time_hi)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
         ctx.builder
             .build_store(now_loptr, time_lo)
+            .unwrap()
             .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
             .unwrap();
     }
@@ -289,7 +276,10 @@ impl TimeFns for ExternTimeFns {
         let now_mu = ctx.module.get_function("now_mu").unwrap_or_else(|| {
             ctx.module.add_function("now_mu", ctx.ctx.i64_type().fn_type(&[], false), None)
         });
-        ctx.builder.build_call(now_mu, &[], "now_mu").try_as_basic_value().left().unwrap()
+        ctx.builder.build_call(now_mu, &[], "now_mu")
+            .map(CallSiteValue::try_as_basic_value)
+            .map(Either::unwrap_left)
+            .unwrap()
     }
 
     fn emit_at_mu<'ctx>(&self, ctx: &mut CodeGenContext<'ctx, '_>, t: BasicValueEnum<'ctx>) {
@@ -300,7 +290,7 @@ impl TimeFns for ExternTimeFns {
                 None,
             )
         });
-        ctx.builder.build_call(at_mu, &[t.into()], "at_mu");
+        ctx.builder.build_call(at_mu, &[t.into()], "at_mu").unwrap();
     }
 
     fn emit_delay_mu<'ctx>(
@@ -315,7 +305,7 @@ impl TimeFns for ExternTimeFns {
                 None,
             )
         });
-        ctx.builder.build_call(delay_mu, &[dt.into()], "delay_mu");
+        ctx.builder.build_call(delay_mu, &[dt.into()], "delay_mu").unwrap();
     }
 }
 

nac3ast/Cargo.toml

@@ -12,5 +12,5 @@ fold = []
 [dependencies]
 lazy_static = "1.4"
 parking_lot = "0.12"
-string-interner = "0.14"
+string-interner = "0.15"
 fxhash = "0.2"

nac3ast/src/ast_gen.rs

@@ -5,10 +5,10 @@ pub use crate::constant::*;
 
 use std::{fmt, collections::HashMap, cell::RefCell};
 use parking_lot::{Mutex, MutexGuard};
-use string_interner::{DefaultBackend, DefaultSymbol, StringInterner, symbol::SymbolU32};
+use string_interner::{DefaultBackend, StringInterner, symbol::SymbolU32};
 use fxhash::FxBuildHasher;
 
-pub type Interner = StringInterner<DefaultBackend<DefaultSymbol>, FxBuildHasher>;
+pub type Interner = StringInterner<DefaultBackend, FxBuildHasher>;
 lazy_static! {
     static ref INTERNER: Mutex<Interner> = Mutex::new(StringInterner::with_hasher(FxBuildHasher::default()));
 }

nac3core/Cargo.toml

@@ -7,12 +7,13 @@ edition = "2021"
 [dependencies]
 itertools = "0.12"
 crossbeam = "0.8"
+indexmap = "2.2"
 parking_lot = "0.12"
-rayon = "1.5"
+rayon = "1.8"
 nac3parser = { path = "../nac3parser" }
 
 [dependencies.inkwell]
-version = "0.2"
+version = "0.4"
 default-features = false
 features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
 

nac3core/build.rs

@@ -14,10 +14,15 @@ fn main() {
      * HACK: Sadly, clang doesn't let us emit generic LLVM bitcode.
      * Compiling for WASM32 and filtering the output with regex is the closest we can get.
      */
-    const FLAG: &[&str] = &[
+    let flags: &[&str] = &[
         "--target=wasm32",
         FILE,
-        "-O3",
+        "-fno-discard-value-names",
+        match env::var("PROFILE").as_deref() {
+            Ok("debug") => "-O0",
+            Ok("release") => "-O3",
+            flavor => panic!("Unknown or missing build flavor {flavor:?}"),
+        },
         "-emit-llvm",
         "-S",
         "-Wall",
@@ -31,7 +36,7 @@ fn main() {
     let out_path = Path::new(&out_dir);
 
     let output = Command::new("clang-irrt")
-        .args(FLAG)
+        .args(flags)
         .output()
         .map(|o| {
             assert!(o.status.success(), "{}", std::str::from_utf8(&o.stderr).unwrap());

nac3core/src/codegen/concrete_type.rs

@@ -3,12 +3,13 @@ use crate::{
     toplevel::DefinitionId,
     typecheck::{
         type_inferencer::PrimitiveStore,
-        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier},
+        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
     },
 };
 
 use nac3parser::ast::StrRef;
 use std::collections::HashMap;
+use indexmap::IndexMap;
 
 pub struct ConcreteTypeStore {
     store: Vec<ConcreteTypeEnum>,
@@ -50,7 +51,7 @@ pub enum ConcreteTypeEnum {
     TObj {
         obj_id: DefinitionId,
         fields: HashMap<StrRef, (ConcreteType, bool)>,
-        params: HashMap<u32, ConcreteType>,
+        params: IndexMap<u32, ConcreteType>,
     },
     TVirtual {
         ty: ConcreteType,
@@ -60,9 +61,8 @@ pub enum ConcreteTypeEnum {
         ret: ConcreteType,
         vars: HashMap<u32, ConcreteType>,
     },
-    TConstant {
-        value: SymbolValue,
-        ty: ConcreteType,
+    TLiteral {
+        values: Vec<SymbolValue>,
     },
 }
 
@@ -202,9 +202,8 @@ impl ConcreteTypeStore {
                 TypeEnum::TFunc(signature) => {
                     self.from_signature(unifier, primitives, signature, cache)
                 }
-                TypeEnum::TConstant { value, ty, .. } => ConcreteTypeEnum::TConstant {
-                    value: value.clone(),
-                    ty: self.from_unifier_type(unifier, primitives, *ty, cache),
+                TypeEnum::TLiteral { values, .. } => ConcreteTypeEnum::TLiteral {
+                    values: values.clone(),
                 },
                 _ => unreachable!("{:?}", ty_enum.get_type_name()),
             };
@@ -276,7 +275,7 @@ impl ConcreteTypeStore {
                 params: params
                     .iter()
                     .map(|(id, cty)| (*id, self.to_unifier_type(unifier, primitives, *cty, cache)))
-                    .collect::<HashMap<_, _>>(),
+                    .collect::<VarMap>(),
             },
             ConcreteTypeEnum::TFunc { args, ret, vars } => TypeEnum::TFunc(FunSignature {
                 args: args
@@ -291,11 +290,10 @@ impl ConcreteTypeStore {
                 vars: vars
                     .iter()
                     .map(|(id, cty)| (*id, self.to_unifier_type(unifier, primitives, *cty, cache)))
-                    .collect::<HashMap<_, _>>(),
+                    .collect::<VarMap>(),
             }),
-            ConcreteTypeEnum::TConstant { value, ty } => TypeEnum::TConstant {
-                value: value.clone(),
-                ty: self.to_unifier_type(unifier, primitives, *ty, cache),
+            ConcreteTypeEnum::TLiteral { values, .. } => TypeEnum::TLiteral {
+                values: values.clone(),
                 loc: None,
             }
         };

nac3core/src/codegen/extern_fns.rs

@@ -0,0 +1,613 @@
+use inkwell::attributes::{Attribute, AttributeLoc};
+use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue};
+use itertools::Either;
+
+use crate::codegen::CodeGenContext;
+
+/// Invokes the [`tan`](https://en.cppreference.com/w/c/numeric/math/tan) function.
+pub fn call_tan<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "tan";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`asin`](https://en.cppreference.com/w/c/numeric/math/asin) function.
+pub fn call_asin<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "asin";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`acos`](https://en.cppreference.com/w/c/numeric/math/acos) function.
+pub fn call_acos<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "acos";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`atan`](https://en.cppreference.com/w/c/numeric/math/atan) function.
+pub fn call_atan<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "atan";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`sinh`](https://en.cppreference.com/w/c/numeric/math/sinh) function.
+pub fn call_sinh<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "sinh";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`cosh`](https://en.cppreference.com/w/c/numeric/math/cosh) function.
+pub fn call_cosh<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "cosh";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`tanh`](https://en.cppreference.com/w/c/numeric/math/tanh) function.
+pub fn call_tanh<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "tanh";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`asinh`](https://en.cppreference.com/w/c/numeric/math/asinh) function.
+pub fn call_asinh<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "asinh";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`acosh`](https://en.cppreference.com/w/c/numeric/math/acosh) function.
+pub fn call_acosh<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "acosh";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`atanh`](https://en.cppreference.com/w/c/numeric/math/atanh) function.
+pub fn call_atanh<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "atanh";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`expm1`](https://en.cppreference.com/w/c/numeric/math/expm1) function.
+pub fn call_expm1<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "expm1";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`cbrt`](https://en.cppreference.com/w/c/numeric/math/cbrt) function.
+pub fn call_cbrt<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "cbrt";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nosync", "nounwind", "readonly", "willreturn"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`erf`](https://en.cppreference.com/w/c/numeric/math/erf) function.
+pub fn call_erf<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "erf";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        func.add_attribute(
+            AttributeLoc::Function,
+            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
+        );
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`erfc`](https://en.cppreference.com/w/c/numeric/math/erfc) function.
+pub fn call_erfc<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "erfc";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        func.add_attribute(
+            AttributeLoc::Function,
+            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
+        );
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`j1`](https://www.gnu.org/software/libc/manual/html_node/Special-Functions.html#index-j1)
+/// function.
+pub fn call_j1<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "j1";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        func.add_attribute(
+            AttributeLoc::Function,
+            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
+        );
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`atan2`](https://en.cppreference.com/w/c/numeric/math/atan2) function.
+pub fn call_atan2<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    y: FloatValue<'ctx>,
+    x: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "atan2";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(y.get_type(), llvm_f64);
+    debug_assert_eq!(x.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[y.into(), x.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`ldexp`](https://en.cppreference.com/w/c/numeric/math/ldexp) function.
+pub fn call_ldexp<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    arg: FloatValue<'ctx>,
+    exp: IntValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "ldexp";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    let llvm_i32 = ctx.ctx.i32_type();
+    debug_assert_eq!(arg.get_type(), llvm_f64);
+    debug_assert_eq!(exp.get_type(), llvm_i32);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_i32.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0)
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into(), exp.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`hypot`](https://en.cppreference.com/w/c/numeric/math/hypot) function.
+pub fn call_hypot<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    x: FloatValue<'ctx>,
+    y: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "hypot";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(x.get_type(), llvm_f64);
+    debug_assert_eq!(y.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        func.add_attribute(
+            AttributeLoc::Function,
+            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
+        );
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[x.into(), y.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`nextafter`](https://en.cppreference.com/w/c/numeric/math/nextafter) function.
+pub fn call_nextafter<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    from: FloatValue<'ctx>,
+    to: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    const FN_NAME: &str = "nextafter";
+
+    let llvm_f64 = ctx.ctx.f64_type();
+    debug_assert_eq!(from.get_type(), llvm_f64);
+    debug_assert_eq!(to.get_type(), llvm_f64);
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_f64.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        func.add_attribute(
+            AttributeLoc::Function,
+            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0)
+        );
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[from.into(), to.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}

nac3core/src/codegen/generator.rs

@@ -1,5 +1,5 @@
 use crate::{
-    codegen::{expr::*, stmt::*, bool_to_i1, bool_to_i8, CodeGenContext},
+    codegen::{classes::ArraySliceValue, expr::*, stmt::*, bool_to_i1, bool_to_i8, CodeGenContext},
     symbol_resolver::ValueEnum,
     toplevel::{DefinitionId, TopLevelDef},
     typecheck::typedef::{FunSignature, Type},
@@ -92,6 +92,18 @@ pub trait CodeGenerator {
         gen_var(ctx, ty, name)
     }
 
+    /// Allocate memory for a variable and return a pointer pointing to it.
+    /// The default implementation places the allocations at the start of the function.
+    fn gen_array_var_alloc<'ctx>(
+        &mut self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        ty: BasicTypeEnum<'ctx>,
+        size: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> Result<ArraySliceValue<'ctx>, String> {
+        gen_array_var(ctx, ty, size, name)
+    }
+
     /// Return a pointer pointing to the target of the expression.
     fn gen_store_target<'ctx>(
         &mut self,

nac3core/src/codegen/irrt/irrt.c

@@ -8,6 +8,8 @@ typedef unsigned _BitInt(64) uint64_t;
 # define MAX(a, b) (a > b ? a : b)
 # define MIN(a, b) (a > b ? b : a)
 
+# define NULL ((void *) 0)
+
 // adapted from GNU Scientific Library: https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
 // need to make sure `exp >= 0` before calling this function
 #define DEF_INT_EXP(T) T __nac3_int_exp_##T( \
@@ -196,4 +198,184 @@ double __nac3_j0(double x) {
     }
 
     return j0(x);
-}
+}
+
+uint32_t __nac3_ndarray_calc_size(
+    const uint64_t *list_data,
+    uint32_t list_len
+) {
+    uint32_t num_elems = 1;
+    for (uint32_t i = 0; i < list_len; ++i) {
+        uint64_t val = list_data[i];
+        __builtin_assume(val > 0);
+        num_elems *= val;
+    }
+    return num_elems;
+}
+
+uint64_t __nac3_ndarray_calc_size64(
+    const uint64_t *list_data,
+    uint64_t list_len
+) {
+    uint64_t num_elems = 1;
+    for (uint64_t i = 0; i < list_len; ++i) {
+        uint64_t val = list_data[i];
+        __builtin_assume(val > 0);
+       num_elems *= val;
+    }
+    return num_elems;
+}
+
+void __nac3_ndarray_calc_nd_indices(
+    uint32_t index,
+    const uint32_t* dims,
+    uint32_t num_dims,
+    uint32_t* idxs
+) {
+    uint32_t stride = 1;
+    for (uint32_t dim = 0; dim < num_dims; dim++) {
+        uint32_t i = num_dims - dim - 1;
+        __builtin_assume(dims[i] > 0);
+        idxs[i] = (index / stride) % dims[i];
+        stride *= dims[i];
+    }
+}
+
+void __nac3_ndarray_calc_nd_indices64(
+    uint64_t index,
+    const uint64_t* dims,
+    uint64_t num_dims,
+    uint32_t* idxs
+) {
+    uint64_t stride = 1;
+    for (uint64_t dim = 0; dim < num_dims; dim++) {
+        uint64_t i = num_dims - dim - 1;
+        __builtin_assume(dims[i] > 0);
+        idxs[i] = (uint32_t) ((index / stride) % dims[i]);
+        stride *= dims[i];
+    }
+}
+
+uint32_t __nac3_ndarray_flatten_index(
+    const uint32_t* dims,
+    uint32_t num_dims,
+    const uint32_t* indices,
+    uint32_t num_indices
+) {
+    uint32_t idx = 0;
+    uint32_t stride = 1;
+    for (uint32_t i = 0; i < num_dims; ++i) {
+        uint32_t ri = num_dims - i - 1;
+        if (ri < num_indices) {
+            idx += (stride * indices[ri]);
+        }
+
+        __builtin_assume(dims[i] > 0);
+        stride *= dims[ri];
+    }
+    return idx;
+}
+
+uint64_t __nac3_ndarray_flatten_index64(
+    const uint64_t* dims,
+    uint64_t num_dims,
+    const uint32_t* indices,
+    uint64_t num_indices
+) {
+    uint64_t idx = 0;
+    uint64_t stride = 1;
+    for (uint64_t i = 0; i < num_dims; ++i) {
+        uint64_t ri = num_dims - i - 1;
+        if (ri < num_indices) {
+            idx += (stride * indices[ri]);
+        }
+
+        __builtin_assume(dims[i] > 0);
+        stride *= dims[ri];
+    }
+    return idx;
+}
+
+void __nac3_ndarray_calc_broadcast(
+    const uint32_t *lhs_dims,
+    uint32_t lhs_ndims,
+    const uint32_t *rhs_dims,
+    uint32_t rhs_ndims,
+    uint32_t *out_dims
+) {
+    uint32_t max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
+
+    for (uint32_t i = 0; i < max_ndims; ++i) {
+        uint32_t *lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : NULL;
+        uint32_t *rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : NULL;
+        uint32_t *out_dim = &out_dims[max_ndims - i - 1];
+
+        if (lhs_dim_sz == NULL) {
+            *out_dim = *rhs_dim_sz;
+        } else if (rhs_dim_sz == NULL) {
+            *out_dim = *lhs_dim_sz;
+        } else if (*lhs_dim_sz == 1) {
+            *out_dim = *rhs_dim_sz;
+        } else if (*rhs_dim_sz == 1) {
+            *out_dim = *lhs_dim_sz;
+        } else if (*lhs_dim_sz == *rhs_dim_sz) {
+            *out_dim = *lhs_dim_sz;
+        } else {
+            __builtin_unreachable();
+        }
+    }
+}
+
+void __nac3_ndarray_calc_broadcast64(
+    const uint64_t *lhs_dims,
+    uint64_t lhs_ndims,
+    const uint64_t *rhs_dims,
+    uint64_t rhs_ndims,
+    uint64_t *out_dims
+) {
+    uint64_t max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
+
+    for (uint64_t i = 0; i < max_ndims; ++i) {
+        uint64_t *lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : NULL;
+        uint64_t *rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : NULL;
+        uint64_t *out_dim = &out_dims[max_ndims - i - 1];
+
+        if (lhs_dim_sz == NULL) {
+            *out_dim = *rhs_dim_sz;
+        } else if (rhs_dim_sz == NULL) {
+            *out_dim = *lhs_dim_sz;
+        } else if (*lhs_dim_sz == 1) {
+            *out_dim = *rhs_dim_sz;
+        } else if (*rhs_dim_sz == 1) {
+            *out_dim = *lhs_dim_sz;
+        } else if (*lhs_dim_sz == *rhs_dim_sz) {
+            *out_dim = *lhs_dim_sz;
+        } else {
+            __builtin_unreachable();
+        }
+    }
+}
+
+void __nac3_ndarray_calc_broadcast_idx(
+    const uint32_t *src_dims,
+    uint32_t src_ndims,
+    const uint32_t *in_idx,
+    uint32_t *out_idx
+) {
+    for (uint32_t i = 0; i < src_ndims; ++i) {
+        uint32_t src_i = src_ndims - i - 1;
+        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
+    }
+}
+
+void __nac3_ndarray_calc_broadcast_idx64(
+    const uint64_t *src_dims,
+    uint64_t src_ndims,
+    const uint32_t *in_idx,
+    uint32_t *out_idx
+) {
+    for (uint64_t i = 0; i < src_ndims; ++i) {
+        uint64_t src_i = src_ndims - i - 1;
+        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : (uint32_t) in_idx[src_i];
+    }
+}

nac3core/src/codegen/irrt/mod.rs

@@ -1,16 +1,32 @@
 use crate::typecheck::typedef::Type;
 
-use super::{CodeGenContext, CodeGenerator};
+use super::{
+    classes::{
+        ArrayLikeIndexer,
+        ArrayLikeValue,
+        ArraySliceValue,
+        ListValue,
+        NDArrayValue,
+        TypedArrayLikeAdapter,
+        UntypedArrayLikeAccessor,
+    },
+    CodeGenContext,
+    CodeGenerator,
+    llvm_intrinsics,
+};
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
     context::Context,
     memory_buffer::MemoryBuffer,
     module::Module,
-    types::BasicTypeEnum,
-    values::{FloatValue, IntValue, PointerValue},
+    types::{BasicTypeEnum, IntType},
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue},
     AddressSpace, IntPredicate,
 };
+use itertools::Either;
 use nac3parser::ast::Expr;
+use crate::codegen::classes::TypedArrayLikeAccessor;
+use crate::codegen::stmt::gen_for_callback_incrementing;
 
 #[must_use]
 pub fn load_irrt(ctx: &Context) -> Module {
@@ -34,8 +50,8 @@ pub fn load_irrt(ctx: &Context) -> Module {
 
 // repeated squaring method adapted from GNU Scientific Library:
 // https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
-pub fn integer_power<'ctx>(
-    generator: &mut dyn CodeGenerator,
+pub fn integer_power<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
     ctx: &mut CodeGenContext<'ctx, '_>,
     base: IntValue<'ctx>,
     exp: IntValue<'ctx>,
@@ -59,7 +75,7 @@ pub fn integer_power<'ctx>(
         exp,
         exp.get_type().const_zero(),
         "assert_int_pow_ge_0",
-    );
+    ).unwrap();
     ctx.make_assert(
         generator,
         ge_zero,
@@ -70,13 +86,14 @@ pub fn integer_power<'ctx>(
     );
     ctx.builder
         .build_call(pow_fun, &[base.into(), exp.into()], "call_int_pow")
-        .try_as_basic_value()
-        .unwrap_left()
-        .into_int_value()
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
 
-pub fn calculate_len_for_slice_range<'ctx>(
-    generator: &mut dyn CodeGenerator,
+pub fn calculate_len_for_slice_range<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
     ctx: &mut CodeGenContext<'ctx, '_>,
     start: IntValue<'ctx>,
     end: IntValue<'ctx>,
@@ -95,7 +112,7 @@ pub fn calculate_len_for_slice_range<'ctx>(
         step,
         step.get_type().const_zero(),
         "range_step_ne",
-    );
+    ).unwrap();
     ctx.make_assert(
         generator,
         not_zero,
@@ -106,10 +123,10 @@ pub fn calculate_len_for_slice_range<'ctx>(
     );
     ctx.builder
         .build_call(len_func, &[start.into(), end.into(), step.into()], "calc_len")
-        .try_as_basic_value()
-        .left()
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
         .unwrap()
-        .into_int_value()
 }
 
 /// NOTE: the output value of the end index of this function should be compared ***inclusively***,
@@ -158,13 +175,13 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
     step: &Option<Box<Expr<Option<Type>>>>,
     ctx: &mut CodeGenContext<'ctx, '_>,
     generator: &mut G,
-    list: PointerValue<'ctx>,
+    list: ListValue<'ctx>,
 ) -> Result<Option<(IntValue<'ctx>, IntValue<'ctx>, IntValue<'ctx>)>, String> {
     let int32 = ctx.ctx.i32_type();
     let zero = int32.const_zero();
     let one = int32.const_int(1, false);
-    let length = ctx.build_gep_and_load(list, &[zero, one], Some("length")).into_int_value();
-    let length = ctx.builder.build_int_truncate_or_bit_cast(length, int32, "leni32");
+    let length = list.load_size(ctx, Some("length"));
+    let length = ctx.builder.build_int_truncate_or_bit_cast(length, int32, "leni32").unwrap();
     Ok(Some(match (start, end, step) {
         (s, e, None) => (
             if let Some(s) = s.as_ref() {
@@ -184,7 +201,7 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
                 } else {
                     length
                 };
-                ctx.builder.build_int_sub(e, one, "final_end")
+                ctx.builder.build_int_sub(e, one, "final_end").unwrap()
             },
             one,
         ),
@@ -200,7 +217,7 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
                 step,
                 step.get_type().const_zero(),
                 "range_step_ne",
-            );
+            ).unwrap();
             ctx.make_assert(
                 generator,
                 not_zero,
@@ -209,8 +226,8 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
                 [None, None, None],
                 ctx.current_loc,
             );
-            let len_id = ctx.builder.build_int_sub(length, one, "lenmin1");
-            let neg = ctx.builder.build_int_compare(IntPredicate::SLT, step, zero, "step_is_neg");
+            let len_id = ctx.builder.build_int_sub(length, one, "lenmin1").unwrap();
+            let neg = ctx.builder.build_int_compare(IntPredicate::SLT, step, zero, "step_is_neg").unwrap();
             (
                 match s {
                     Some(s) => {
@@ -225,17 +242,20 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
                                         s,
                                         length,
                                         "s_eq_len",
-                                    ),
+                                    ).unwrap(),
                                     neg,
                                     "should_minus_one",
-                                ),
-                                ctx.builder.build_int_sub(s, one, "s_min"),
+                                ).unwrap(),
+                                ctx.builder.build_int_sub(s, one, "s_min").unwrap(),
                                 s,
                                 "final_start",
                             )
-                            .into_int_value()
+                            .map(BasicValueEnum::into_int_value)
+                            .unwrap()
                     }
-                    None => ctx.builder.build_select(neg, len_id, zero, "stt").into_int_value(),
+                    None => ctx.builder.build_select(neg, len_id, zero, "stt")
+                        .map(BasicValueEnum::into_int_value)
+                        .unwrap(),
                 },
                 match e {
                     Some(e) => {
@@ -245,13 +265,16 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
                         ctx.builder
                             .build_select(
                                 neg,
-                                ctx.builder.build_int_add(e, one, "end_add_one"),
-                                ctx.builder.build_int_sub(e, one, "end_sub_one"),
+                                ctx.builder.build_int_add(e, one, "end_add_one").unwrap(),
+                                ctx.builder.build_int_sub(e, one, "end_sub_one").unwrap(),
                                 "final_end",
                             )
-                            .into_int_value()
+                            .map(BasicValueEnum::into_int_value)
+                            .unwrap()
                     }
-                    None => ctx.builder.build_select(neg, zero, len_id, "end").into_int_value(),
+                    None => ctx.builder.build_select(neg, zero, len_id, "end")
+                        .map(BasicValueEnum::into_int_value)
+                        .unwrap(),
                 },
                 step,
             )
@@ -282,22 +305,22 @@ pub fn handle_slice_index_bound<'ctx, G: CodeGenerator>(
     Ok(Some(ctx
         .builder
         .build_call(func, &[i.into(), length.into()], "bounded_ind")
-        .try_as_basic_value()
-        .left()
-        .unwrap()
-        .into_int_value()))
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()))
 }
 
 /// This function handles 'end' **inclusively**.
 /// Order of tuples `assign_idx` and `value_idx` is ('start', 'end', 'step').
 /// Negative index should be handled before entering this function
-pub fn list_slice_assignment<'ctx>(
-    generator: &mut dyn CodeGenerator,
+pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
     ctx: &mut CodeGenContext<'ctx, '_>,
     ty: BasicTypeEnum<'ctx>,
-    dest_arr: PointerValue<'ctx>,
+    dest_arr: ListValue<'ctx>,
     dest_idx: (IntValue<'ctx>, IntValue<'ctx>, IntValue<'ctx>),
-    src_arr: PointerValue<'ctx>,
+    src_arr: ListValue<'ctx>,
     src_idx: (IntValue<'ctx>, IntValue<'ctx>, IntValue<'ctx>),
 ) {
     let size_ty = generator.get_size_type(ctx.ctx);
@@ -326,22 +349,22 @@ pub fn list_slice_assignment<'ctx>(
 
     let zero = int32.const_zero();
     let one = int32.const_int(1, false);
-    let dest_arr_ptr = ctx.build_gep_and_load(dest_arr, &[zero, zero], Some("dest.addr"));
+    let dest_arr_ptr = dest_arr.data().base_ptr(ctx, generator);
     let dest_arr_ptr = ctx.builder.build_pointer_cast(
-        dest_arr_ptr.into_pointer_value(),
+        dest_arr_ptr,
         elem_ptr_type,
         "dest_arr_ptr_cast",
-    );
-    let dest_len = ctx.build_gep_and_load(dest_arr, &[zero, one], Some("dest.len")).into_int_value();
-    let dest_len = ctx.builder.build_int_truncate_or_bit_cast(dest_len, int32, "srclen32");
-    let src_arr_ptr = ctx.build_gep_and_load(src_arr, &[zero, zero], Some("src.addr"));
+    ).unwrap();
+    let dest_len = dest_arr.load_size(ctx, Some("dest.len"));
+    let dest_len = ctx.builder.build_int_truncate_or_bit_cast(dest_len, int32, "srclen32").unwrap();
+    let src_arr_ptr = src_arr.data().base_ptr(ctx, generator);
     let src_arr_ptr = ctx.builder.build_pointer_cast(
-        src_arr_ptr.into_pointer_value(),
+        src_arr_ptr,
         elem_ptr_type,
         "src_arr_ptr_cast",
-    );
-    let src_len = ctx.build_gep_and_load(src_arr, &[zero, one], Some("src.len")).into_int_value();
-    let src_len = ctx.builder.build_int_truncate_or_bit_cast(src_len, int32, "srclen32");
+    ).unwrap();
+    let src_len = src_arr.load_size(ctx, Some("src.len"));
+    let src_len = ctx.builder.build_int_truncate_or_bit_cast(src_len, int32, "srclen32").unwrap();
 
     // index in bound and positive should be done
     // assert if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest), and
@@ -353,12 +376,13 @@ pub fn list_slice_assignment<'ctx>(
                 src_idx.2,
                 zero,
                 "is_neg",
-            ),
-            ctx.builder.build_int_sub(src_idx.1, one, "e_min_one"),
-            ctx.builder.build_int_add(src_idx.1, one, "e_add_one"),
+            ).unwrap(),
+            ctx.builder.build_int_sub(src_idx.1, one, "e_min_one").unwrap(),
+            ctx.builder.build_int_add(src_idx.1, one, "e_add_one").unwrap(),
             "final_e",
         )
-        .into_int_value();
+        .map(BasicValueEnum::into_int_value)
+        .unwrap();
     let dest_end = ctx.builder
         .build_select(
             ctx.builder.build_int_compare(
@@ -366,12 +390,13 @@ pub fn list_slice_assignment<'ctx>(
                 dest_idx.2,
                 zero,
                 "is_neg",
-            ),
-            ctx.builder.build_int_sub(dest_idx.1, one, "e_min_one"),
-            ctx.builder.build_int_add(dest_idx.1, one, "e_add_one"),
+            ).unwrap(),
+            ctx.builder.build_int_sub(dest_idx.1, one, "e_min_one").unwrap(),
+            ctx.builder.build_int_add(dest_idx.1, one, "e_add_one").unwrap(),
             "final_e",
         )
-        .into_int_value();
+        .map(BasicValueEnum::into_int_value)
+        .unwrap();
     let src_slice_len =
         calculate_len_for_slice_range(generator, ctx, src_idx.0, src_end, src_idx.2);
     let dest_slice_len =
@@ -381,21 +406,21 @@ pub fn list_slice_assignment<'ctx>(
         src_slice_len,
         dest_slice_len,
         "slice_src_eq_dest",
-    );
+    ).unwrap();
     let src_slt_dest = ctx.builder.build_int_compare(
         IntPredicate::SLT,
         src_slice_len,
         dest_slice_len,
         "slice_src_slt_dest",
-    );
+    ).unwrap();
     let dest_step_eq_one = ctx.builder.build_int_compare(
         IntPredicate::EQ,
         dest_idx.2,
         dest_idx.2.get_type().const_int(1, false),
         "slice_dest_step_eq_one",
-    );
-    let cond_1 = ctx.builder.build_and(dest_step_eq_one, src_slt_dest, "slice_cond_1");
-    let cond = ctx.builder.build_or(src_eq_dest, cond_1, "slice_cond");
+    ).unwrap();
+    let cond_1 = ctx.builder.build_and(dest_step_eq_one, src_slt_dest, "slice_cond_1").unwrap();
+    let cond = ctx.builder.build_or(src_eq_dest, cond_1, "slice_cond").unwrap();
     ctx.make_assert(
         generator,
         cond,
@@ -425,34 +450,37 @@ pub fn list_slice_assignment<'ctx>(
                     BasicTypeEnum::StructType(t) => t.size_of().unwrap(),
                     _ => unreachable!(),
                 };
-                ctx.builder.build_int_truncate_or_bit_cast(s, int32, "size")
+                ctx.builder.build_int_truncate_or_bit_cast(s, int32, "size").unwrap()
             }
             .into(),
         ];
         ctx.builder
             .build_call(slice_assign_fun, args.as_slice(), "slice_assign")
-            .try_as_basic_value()
-            .unwrap_left()
-            .into_int_value()
+            .map(CallSiteValue::try_as_basic_value)
+            .map(|v| v.map_left(BasicValueEnum::into_int_value))
+            .map(Either::unwrap_left)
+            .unwrap()
     };
     // update length
-    let need_update =
-        ctx.builder.build_int_compare(IntPredicate::NE, new_len, dest_len, "need_update");
+    let need_update = ctx.builder
+        .build_int_compare(IntPredicate::NE, new_len, dest_len, "need_update")
+        .unwrap();
     let current = ctx.builder.get_insert_block().unwrap().get_parent().unwrap();
     let update_bb = ctx.ctx.append_basic_block(current, "update");
     let cont_bb = ctx.ctx.append_basic_block(current, "cont");
-    ctx.builder.build_conditional_branch(need_update, update_bb, cont_bb);
+    ctx.builder.build_conditional_branch(need_update, update_bb, cont_bb).unwrap();
     ctx.builder.position_at_end(update_bb);
-    let dest_len_ptr = unsafe { ctx.builder.build_gep(dest_arr, &[zero, one], "dest_len_ptr") };
-    let new_len = ctx.builder.build_int_z_extend_or_bit_cast(new_len, size_ty, "new_len");
-    ctx.builder.build_store(dest_len_ptr, new_len);
-    ctx.builder.build_unconditional_branch(cont_bb);
+    let new_len = ctx.builder
+        .build_int_z_extend_or_bit_cast(new_len, size_ty, "new_len")
+        .unwrap();
+    dest_arr.store_size(ctx, generator, new_len);
+    ctx.builder.build_unconditional_branch(cont_bb).unwrap();
     ctx.builder.position_at_end(cont_bb);
 }
 
 /// Generates a call to `isinf` in IR. Returns an `i1` representing the result.
-pub fn call_isinf<'ctx>(
-    generator: &mut dyn CodeGenerator,
+pub fn call_isinf<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
     ctx: &CodeGenContext<'ctx, '_>,
     v: FloatValue<'ctx>,
 ) -> IntValue<'ctx> {
@@ -463,16 +491,17 @@ pub fn call_isinf<'ctx>(
 
     let ret = ctx.builder
         .build_call(intrinsic_fn, &[v.into()], "isinf")
-        .try_as_basic_value()
-        .unwrap_left()
-        .into_int_value();
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap();
 
     generator.bool_to_i1(ctx, ret)
 }
 
 /// Generates a call to `isnan` in IR. Returns an `i1` representing the result.
-pub fn call_isnan<'ctx>(
-    generator: &mut dyn CodeGenerator,
+pub fn call_isnan<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
     ctx: &CodeGenContext<'ctx, '_>,
     v: FloatValue<'ctx>,
 ) -> IntValue<'ctx> {
@@ -483,9 +512,10 @@ pub fn call_isnan<'ctx>(
 
     let ret = ctx.builder
         .build_call(intrinsic_fn, &[v.into()], "isnan")
-        .try_as_basic_value()
-        .unwrap_left()
-        .into_int_value();
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap();
 
     generator.bool_to_i1(ctx, ret)
 }
@@ -504,9 +534,10 @@ pub fn call_gamma<'ctx>(
 
     ctx.builder
         .build_call(intrinsic_fn, &[v.into()], "gamma")
-        .try_as_basic_value()
-        .unwrap_left()
-        .into_float_value()
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
 
 /// Generates a call to `gammaln` in IR. Returns an `f64` representing the result.
@@ -523,9 +554,10 @@ pub fn call_gammaln<'ctx>(
 
     ctx.builder
         .build_call(intrinsic_fn, &[v.into()], "gammaln")
-        .try_as_basic_value()
-        .unwrap_left()
-        .into_float_value()
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
 
 /// Generates a call to `j0` in IR. Returns an `f64` representing the result.
@@ -542,7 +574,408 @@ pub fn call_j0<'ctx>(
 
     ctx.builder
         .build_call(intrinsic_fn, &[v.into()], "j0")
-        .try_as_basic_value()
-        .unwrap_left()
-        .into_float_value()
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
+
+/// Generates a call to `__nac3_ndarray_calc_size`. Returns an [`IntValue`] representing the
+/// calculated total size.
+///
+/// * `num_dims` - An [`IntValue`] containing the number of dimensions.
+/// * `dims` - A [`PointerValue`] to an array containing the size of each dimension.
+pub fn call_ndarray_calc_size<'ctx, G, Dims>(
+    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    dims: &Dims,
+) -> IntValue<'ctx>
+    where
+        G: CodeGenerator + ?Sized,
+        Dims: ArrayLikeIndexer<'ctx>, {
+    let llvm_i64 = ctx.ctx.i64_type();
+    let llvm_usize = generator.get_size_type(ctx.ctx);
+
+    let llvm_pi64 = llvm_i64.ptr_type(AddressSpace::default());
+
+    let ndarray_calc_size_fn_name = match llvm_usize.get_bit_width() {
+        32 => "__nac3_ndarray_calc_size",
+        64 => "__nac3_ndarray_calc_size64",
+        bw => unreachable!("Unsupported size type bit width: {}", bw)
+    };
+    let ndarray_calc_size_fn_t = llvm_usize.fn_type(
+        &[
+            llvm_pi64.into(),
+            llvm_usize.into(),
+        ],
+        false,
+    );
+    let ndarray_calc_size_fn = ctx.module.get_function(ndarray_calc_size_fn_name)
+        .unwrap_or_else(|| {
+            ctx.module.add_function(ndarray_calc_size_fn_name, ndarray_calc_size_fn_t, None)
+        });
+
+    ctx.builder
+        .build_call(
+            ndarray_calc_size_fn,
+            &[
+                dims.base_ptr(ctx, generator).into(),
+                dims.size(ctx, generator).into(),
+            ],
+            "",
+        )
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Generates a call to `__nac3_ndarray_calc_nd_indices`. Returns a [`TypeArrayLikeAdpater`]
+/// containing `i32` indices of the flattened index.
+///
+/// * `index` - The index to compute the multidimensional index for.
+/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
+/// `NDArray`.
+pub fn call_ndarray_calc_nd_indices<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    index: IntValue<'ctx>,
+    ndarray: NDArrayValue<'ctx>,
+) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
+    let llvm_void = ctx.ctx.void_type();
+    let llvm_i32 = ctx.ctx.i32_type();
+    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_pi32 = llvm_i32.ptr_type(AddressSpace::default());
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
+
+    let ndarray_calc_nd_indices_fn_name = match llvm_usize.get_bit_width() {
+        32 => "__nac3_ndarray_calc_nd_indices",
+        64 => "__nac3_ndarray_calc_nd_indices64",
+        bw => unreachable!("Unsupported size type bit width: {}", bw)
+    };
+    let ndarray_calc_nd_indices_fn = ctx.module.get_function(ndarray_calc_nd_indices_fn_name).unwrap_or_else(|| {
+        let fn_type = llvm_void.fn_type(
+            &[
+                llvm_usize.into(),
+                llvm_pusize.into(),
+                llvm_usize.into(),
+                llvm_pi32.into(),
+            ],
+            false,
+        );
+
+        ctx.module.add_function(ndarray_calc_nd_indices_fn_name, fn_type, None)
+    });
+
+    let ndarray_num_dims = ndarray.load_ndims(ctx);
+    let ndarray_dims = ndarray.dim_sizes();
+
+    let indices = ctx.builder.build_array_alloca(
+        llvm_i32,
+        ndarray_num_dims,
+        "",
+    ).unwrap();
+
+    ctx.builder
+        .build_call(
+            ndarray_calc_nd_indices_fn,
+            &[
+                index.into(),
+                ndarray_dims.base_ptr(ctx, generator).into(),
+                ndarray_num_dims.into(),
+                indices.into(),
+            ],
+            "",
+        )
+        .unwrap();
+
+    TypedArrayLikeAdapter::from(
+        ArraySliceValue::from_ptr_val(indices, ndarray_num_dims, None),
+        Box::new(|_, v| v.into_int_value()),
+        Box::new(|_, v| v.into()),
+    )
+}
+
+fn call_ndarray_flatten_index_impl<'ctx, G, Indices>(
+    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    ndarray: NDArrayValue<'ctx>,
+    indices: &Indices,
+) -> IntValue<'ctx>
+    where
+        G: CodeGenerator + ?Sized,
+        Indices: ArrayLikeIndexer<'ctx>, {
+    let llvm_i32 = ctx.ctx.i32_type();
+    let llvm_usize = generator.get_size_type(ctx.ctx);
+
+    let llvm_pi32 = llvm_i32.ptr_type(AddressSpace::default());
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
+
+    debug_assert_eq!(
+        IntType::try_from(indices.element_type(ctx, generator))
+            .map(IntType::get_bit_width)
+            .unwrap_or_default(),
+        llvm_i32.get_bit_width(),
+        "Expected i32 value for argument `indices` to `call_ndarray_flatten_index_impl`"
+    );
+    debug_assert_eq!(
+        indices.size(ctx, generator).get_type().get_bit_width(),
+        llvm_usize.get_bit_width(),
+        "Expected usize integer value for argument `indices_size` to `call_ndarray_flatten_index_impl`"
+    );
+
+    let ndarray_flatten_index_fn_name = match llvm_usize.get_bit_width() {
+        32 => "__nac3_ndarray_flatten_index",
+        64 => "__nac3_ndarray_flatten_index64",
+        bw => unreachable!("Unsupported size type bit width: {}", bw)
+    };
+    let ndarray_flatten_index_fn = ctx.module.get_function(ndarray_flatten_index_fn_name).unwrap_or_else(|| {
+        let fn_type = llvm_usize.fn_type(
+            &[
+                llvm_pusize.into(),
+                llvm_usize.into(),
+                llvm_pi32.into(),
+                llvm_usize.into(),
+            ],
+            false,
+        );
+
+        ctx.module.add_function(ndarray_flatten_index_fn_name, fn_type, None)
+    });
+
+    let ndarray_num_dims = ndarray.load_ndims(ctx);
+    let ndarray_dims = ndarray.dim_sizes();
+
+    let index = ctx.builder
+        .build_call(
+            ndarray_flatten_index_fn,
+            &[
+                ndarray_dims.base_ptr(ctx, generator).into(),
+                ndarray_num_dims.into(),
+                indices.base_ptr(ctx, generator).into(),
+                indices.size(ctx, generator).into(),
+            ],
+            "",
+        )
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap();
+
+    index
+}
+
+/// Generates a call to `__nac3_ndarray_flatten_index`. Returns the flattened index for the
+/// multidimensional index.
+///
+/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
+/// `NDArray`.
+/// * `indices` - The multidimensional index to compute the flattened index for.
+pub fn call_ndarray_flatten_index<'ctx, G, Index>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: NDArrayValue<'ctx>,
+    indices: &Index,
+) -> IntValue<'ctx>
+    where
+        G: CodeGenerator + ?Sized,
+        Index: ArrayLikeIndexer<'ctx>, {
+
+    call_ndarray_flatten_index_impl(
+        generator,
+        ctx,
+        ndarray,
+        indices,
+    )
+}
+
+/// Generates a call to `__nac3_ndarray_calc_broadcast`. Returns a tuple containing the number of
+/// dimension and size of each dimension of the resultant `ndarray`.
+pub fn call_ndarray_calc_broadcast<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    lhs: NDArrayValue<'ctx>,
+    rhs: NDArrayValue<'ctx>,
+) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
+    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
+
+    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
+        32 => "__nac3_ndarray_calc_broadcast",
+        64 => "__nac3_ndarray_calc_broadcast64",
+        bw => unreachable!("Unsupported size type bit width: {}", bw)
+    };
+    let ndarray_calc_broadcast_fn = ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
+        let fn_type = llvm_usize.fn_type(
+            &[
+                llvm_pusize.into(),
+                llvm_usize.into(),
+                llvm_pusize.into(),
+                llvm_usize.into(),
+                llvm_pusize.into(),
+            ],
+            false,
+        );
+
+        ctx.module.add_function(ndarray_calc_broadcast_fn_name, fn_type, None)
+    });
+
+    let lhs_ndims = lhs.load_ndims(ctx);
+    let rhs_ndims = rhs.load_ndims(ctx);
+    let min_ndims = llvm_intrinsics::call_int_umin(ctx, lhs_ndims, rhs_ndims, None);
+
+    gen_for_callback_incrementing(
+        generator,
+        ctx,
+        llvm_usize.const_zero(),
+        (min_ndims, false),
+        |generator, ctx, idx| {
+            let idx = ctx.builder.build_int_sub(min_ndims, idx, "").unwrap();
+            let (lhs_dim_sz, rhs_dim_sz) = unsafe {
+                (
+                    lhs.dim_sizes().get_typed_unchecked(ctx, generator, &idx, None),
+                    rhs.dim_sizes().get_typed_unchecked(ctx, generator, &idx, None),
+                )
+            };
+
+            let llvm_usize_const_one = llvm_usize.const_int(1, false);
+            let lhs_eqz = ctx.builder.build_int_compare(
+                IntPredicate::EQ,
+                lhs_dim_sz,
+                llvm_usize_const_one,
+                "",
+            ).unwrap();
+            let rhs_eqz = ctx.builder.build_int_compare(
+                IntPredicate::EQ,
+                rhs_dim_sz,
+                llvm_usize_const_one,
+                "",
+            ).unwrap();
+            let lhs_or_rhs_eqz = ctx.builder.build_or(
+                lhs_eqz,
+                rhs_eqz,
+                ""
+            ).unwrap();
+
+            let lhs_eq_rhs = ctx.builder.build_int_compare(
+                IntPredicate::EQ,
+                lhs_dim_sz,
+                rhs_dim_sz,
+                ""
+            ).unwrap();
+
+            let is_compatible = ctx.builder.build_or(
+                lhs_or_rhs_eqz,
+                lhs_eq_rhs,
+                ""
+            ).unwrap();
+
+            ctx.make_assert(
+                generator,
+                is_compatible,
+                "0:ValueError",
+                "operands could not be broadcast together",
+                [None, None, None],
+                ctx.current_loc,
+            );
+
+            Ok(())
+        },
+        llvm_usize.const_int(1, false),
+    ).unwrap();
+
+    let max_ndims = llvm_intrinsics::call_int_umax(ctx, lhs_ndims, rhs_ndims, None);
+    let lhs_dims = lhs.dim_sizes().base_ptr(ctx, generator);
+    let lhs_ndims = lhs.load_ndims(ctx);
+    let rhs_dims = rhs.dim_sizes().base_ptr(ctx, generator);
+    let rhs_ndims = rhs.load_ndims(ctx);
+    let out_dims = ctx.builder.build_array_alloca(llvm_usize, max_ndims, "").unwrap();
+    let out_dims = ArraySliceValue::from_ptr_val(out_dims, max_ndims, None);
+
+    ctx.builder
+        .build_call(
+            ndarray_calc_broadcast_fn,
+            &[
+                lhs_dims.into(),
+                lhs_ndims.into(),
+                rhs_dims.into(),
+                rhs_ndims.into(),
+                out_dims.base_ptr(ctx, generator).into(),
+            ],
+            "",
+        )
+        .unwrap();
+
+    TypedArrayLikeAdapter::from(
+        out_dims,
+        Box::new(|_, v| v.into_int_value()),
+        Box::new(|_, v| v.into()),
+    )
+}
+
+/// Generates a call to `__nac3_ndarray_calc_broadcast_idx`. Returns an [`ArrayAllocaValue`]
+/// containing the indices used for accessing `array` corresponding to the index of the broadcasted
+/// array `broadcast_idx`.
+pub fn call_ndarray_calc_broadcast_index<'ctx, G: CodeGenerator + ?Sized, BroadcastIdx: UntypedArrayLikeAccessor<'ctx>>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    array: NDArrayValue<'ctx>,
+    broadcast_idx: &BroadcastIdx,
+) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
+    let llvm_i32 = ctx.ctx.i32_type();
+    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_pi32 = llvm_i32.ptr_type(AddressSpace::default());
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
+
+    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
+        32 => "__nac3_ndarray_calc_broadcast_idx",
+        64 => "__nac3_ndarray_calc_broadcast_idx64",
+        bw => unreachable!("Unsupported size type bit width: {}", bw)
+    };
+    let ndarray_calc_broadcast_fn = ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
+        let fn_type = llvm_usize.fn_type(
+            &[
+                llvm_pusize.into(),
+                llvm_usize.into(),
+                llvm_pi32.into(),
+                llvm_pi32.into(),
+            ],
+            false,
+        );
+
+        ctx.module.add_function(ndarray_calc_broadcast_fn_name, fn_type, None)
+    });
+
+    let broadcast_size = broadcast_idx.size(ctx, generator);
+    let out_idx = ctx.builder.build_array_alloca(llvm_i32, broadcast_size, "").unwrap();
+
+    let array_dims = array.dim_sizes().base_ptr(ctx, generator);
+    let array_ndims = array.load_ndims(ctx);
+    let broadcast_idx_ptr = unsafe {
+        broadcast_idx.ptr_offset_unchecked(
+            ctx,
+            generator,
+            &llvm_usize.const_zero(),
+            None
+        )
+    };
+
+    ctx.builder
+        .build_call(
+            ndarray_calc_broadcast_fn,
+            &[
+                array_dims.into(),
+                array_ndims.into(),
+                broadcast_idx_ptr.into(),
+                out_idx.into(),
+            ],
+            "",
+        )
+        .unwrap();
+
+    TypedArrayLikeAdapter::from(
+        ArraySliceValue::from_ptr_val(out_idx, broadcast_size, None),
+        Box::new(|_, v| v.into_int_value()),
+        Box::new(|_, v| v.into()),
+    )
+}

nac3core/src/codegen/llvm_intrinsics.rs

@@ -0,0 +1,773 @@
+use inkwell::AddressSpace;
+use inkwell::context::Context;
+use inkwell::types::AnyTypeEnum::IntType;
+use inkwell::types::FloatType;
+use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue};
+use itertools::Either;
+use crate::codegen::CodeGenContext;
+
+/// Returns the string representation for the floating-point type `ft` when used in intrinsic
+/// functions.
+fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
+    // Standard LLVM floating-point types
+    if ft == ctx.f16_type() {
+        return "f16"
+    }
+    if ft == ctx.f32_type() {
+        return "f32"
+    }
+    if ft == ctx.f64_type() {
+        return "f64"
+    }
+    if ft == ctx.f128_type() {
+        return "f128"
+    }
+
+    // Non-standard floating-point types
+    if ft == ctx.x86_f80_type() {
+        return "f80"
+    }
+    if ft == ctx.ppc_f128_type() {
+        return "ppcf128"
+    }
+
+    unreachable!()
+}
+
+/// Invokes the [`llvm.stacksave`](https://llvm.org/docs/LangRef.html#llvm-stacksave-intrinsic)
+/// intrinsic.
+pub fn call_stacksave<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    name: Option<&str>,
+) -> PointerValue<'ctx> {
+    const FN_NAME: &str = "llvm.stacksave";
+
+    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let llvm_i8 = ctx.ctx.i8_type();
+        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
+
+        let fn_type = llvm_p0i8.fn_type(&[], false);
+
+        ctx.module.add_function(FN_NAME, fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_pointer_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the
+/// [`llvm.stackrestore`](https://llvm.org/docs/LangRef.html#llvm-stackrestore-intrinsic) intrinsic.
+pub fn call_stackrestore<'ctx>(ctx: &CodeGenContext<'ctx, '_>, ptr: PointerValue<'ctx>) {
+    const FN_NAME: &str = "llvm.stackrestore";
+
+    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let llvm_void = ctx.ctx.void_type();
+        let llvm_i8 = ctx.ctx.i8_type();
+        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
+
+        let fn_type = llvm_void.fn_type(&[llvm_p0i8.into()], false);
+
+        ctx.module.add_function(FN_NAME, fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[ptr.into()], "")
+        .unwrap();
+}
+
+/// Invokes the [`llvm.abs`](https://llvm.org/docs/LangRef.html#llvm-abs-intrinsic) intrinsic.
+///
+/// * `src` - The value for which the absolute value is to be returned.
+/// * `is_int_min_poison` - Whether `poison` is to be returned if `src` is `INT_MIN`.
+pub fn call_int_abs<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    src: IntValue<'ctx>,
+    is_int_min_poison: IntValue<'ctx>,
+    name: Option<&str>,
+) -> IntValue<'ctx> {
+    debug_assert_eq!(is_int_min_poison.get_type().get_bit_width(), 1);
+    debug_assert!(is_int_min_poison.is_const());
+
+    let llvm_src_t = src.get_type();
+
+    let fn_name = format!("llvm.abs.i{}", llvm_src_t.get_bit_width());
+
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let llvm_i1 = ctx.ctx.bool_type();
+
+        let fn_type = llvm_src_t.fn_type(&[llvm_src_t.into(), llvm_i1.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[src.into(), is_int_min_poison.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.smax`](https://llvm.org/docs/LangRef.html#llvm-smax-intrinsic) intrinsic.
+pub fn call_int_smax<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    a: IntValue<'ctx>,
+    b: IntValue<'ctx>,
+    name: Option<&str>,
+) -> IntValue<'ctx> {
+    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
+
+    let llvm_int_t = a.get_type();
+
+    let fn_name = format!("llvm.smax.i{}", llvm_int_t.get_bit_width());
+
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_int_t.fn_type(&[llvm_int_t.into(), llvm_int_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.smin`](https://llvm.org/docs/LangRef.html#llvm-smin-intrinsic) intrinsic.
+pub fn call_int_smin<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    a: IntValue<'ctx>,
+    b: IntValue<'ctx>,
+    name: Option<&str>,
+) -> IntValue<'ctx> {
+    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
+
+    let llvm_int_t = a.get_type();
+
+    let fn_name = format!("llvm.smin.i{}", llvm_int_t.get_bit_width());
+
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_int_t.fn_type(&[llvm_int_t.into(), llvm_int_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.umax`](https://llvm.org/docs/LangRef.html#llvm-umax-intrinsic) intrinsic.
+pub fn call_int_umax<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    a: IntValue<'ctx>,
+    b: IntValue<'ctx>,
+    name: Option<&str>,
+) -> IntValue<'ctx> {
+    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
+
+    let llvm_int_t = a.get_type();
+
+    let fn_name = format!("llvm.umax.i{}", llvm_int_t.get_bit_width());
+
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_int_t.fn_type(&[llvm_int_t.into(), llvm_int_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.umin`](https://llvm.org/docs/LangRef.html#llvm-umin-intrinsic) intrinsic.
+pub fn call_int_umin<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    a: IntValue<'ctx>,
+    b: IntValue<'ctx>,
+    name: Option<&str>,
+) -> IntValue<'ctx> {
+    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
+
+    let llvm_int_t = a.get_type();
+
+    let fn_name = format!("llvm.umin.i{}", llvm_int_t.get_bit_width());
+
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_int_t.fn_type(&[llvm_int_t.into(), llvm_int_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.memcpy`](https://llvm.org/docs/LangRef.html#llvm-memcpy-intrinsic) intrinsic.
+///
+/// * `dest` - The pointer to the destination. Must be a pointer to an integer type.
+/// * `src` - The pointer to the source. Must be a pointer to an integer type.
+/// * `len` - The number of bytes to copy.
+/// * `is_volatile` - Whether the `memcpy` operation should be `volatile`.
+pub fn call_memcpy<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    dest: PointerValue<'ctx>,
+    src: PointerValue<'ctx>,
+    len: IntValue<'ctx>,
+    is_volatile: IntValue<'ctx>,
+) {
+    debug_assert!(dest.get_type().get_element_type().is_int_type());
+    debug_assert!(src.get_type().get_element_type().is_int_type());
+    debug_assert_eq!(
+        dest.get_type().get_element_type().into_int_type().get_bit_width(),
+        src.get_type().get_element_type().into_int_type().get_bit_width(),
+    );
+    debug_assert!(matches!(len.get_type().get_bit_width(), 32 | 64));
+    debug_assert_eq!(is_volatile.get_type().get_bit_width(), 1);
+
+    let llvm_dest_t = dest.get_type();
+    let llvm_src_t = src.get_type();
+    let llvm_len_t = len.get_type();
+
+    let fn_name = format!(
+        "llvm.memcpy.p0i{}.p0i{}.i{}",
+        llvm_dest_t.get_element_type().into_int_type().get_bit_width(),
+        llvm_src_t.get_element_type().into_int_type().get_bit_width(),
+        llvm_len_t.get_bit_width(),
+    );
+
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let llvm_void = ctx.ctx.void_type();
+
+        let fn_type = llvm_void.fn_type(
+            &[
+                llvm_dest_t.into(),
+                llvm_src_t.into(),
+                llvm_len_t.into(),
+                is_volatile.get_type().into(),
+            ],
+            false,
+        );
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[dest.into(), src.into(), len.into(), is_volatile.into()], "")
+        .unwrap();
+}
+
+/// Invokes the `llvm.memcpy` intrinsic.
+///
+/// Unlike [`call_memcpy`], this function accepts any type of pointer value. If `dest` or `src` is
+/// not a pointer to an integer, the pointer(s) will be cast to `i8*` before invoking `memcpy`.
+pub fn call_memcpy_generic<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    dest: PointerValue<'ctx>,
+    src: PointerValue<'ctx>,
+    len: IntValue<'ctx>,
+    is_volatile: IntValue<'ctx>,
+) {
+    let llvm_i8 = ctx.ctx.i8_type();
+    let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
+
+    let dest_elem_t = dest.get_type().get_element_type();
+    let src_elem_t = src.get_type().get_element_type();
+
+    let dest = if matches!(dest_elem_t, IntType(t) if t.get_bit_width() == 8) {
+        dest
+    } else {
+        ctx.builder
+            .build_bitcast(dest, llvm_p0i8, "")
+            .map(BasicValueEnum::into_pointer_value)
+            .unwrap()
+    };
+    let src = if matches!(src_elem_t, IntType(t) if t.get_bit_width() == 8) {
+        src
+    } else {
+        ctx.builder
+            .build_bitcast(src, llvm_p0i8, "")
+            .map(BasicValueEnum::into_pointer_value)
+            .unwrap()
+    };
+
+    call_memcpy(ctx, dest, src, len, is_volatile);
+}
+
+/// Invokes the [`llvm.sqrt`](https://llvm.org/docs/LangRef.html#llvm-sqrt-intrinsic) intrinsic.
+pub fn call_float_sqrt<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.sqrt.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.powi`](https://llvm.org/docs/LangRef.html#llvm-powi-intrinsic) intrinsic.
+pub fn call_float_powi<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    power: IntValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_val_t = val.get_type();
+    let llvm_power_t = power.get_type();
+
+    let fn_name = format!(
+        "llvm.powi.{}.i{}",
+        get_float_intrinsic_repr(ctx.ctx, llvm_val_t),
+        llvm_power_t.get_bit_width(),
+    );
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_val_t.fn_type(&[llvm_val_t.into(), llvm_power_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into(), power.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.sin`](https://llvm.org/docs/LangRef.html#llvm-sin-intrinsic) intrinsic.
+pub fn call_float_sin<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.sin.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.cos`](https://llvm.org/docs/LangRef.html#llvm-cos-intrinsic) intrinsic.
+pub fn call_float_cos<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.cos.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.pow`](https://llvm.org/docs/LangRef.html#llvm-pow-intrinsic) intrinsic.
+pub fn call_float_pow<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    power: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    debug_assert_eq!(val.get_type(), power.get_type());
+
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.pow.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into(), llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into(), power.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.exp`](https://llvm.org/docs/LangRef.html#llvm-exp-intrinsic) intrinsic.
+pub fn call_float_exp<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.exp.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.exp2`](https://llvm.org/docs/LangRef.html#llvm-exp2-intrinsic) intrinsic.
+pub fn call_float_exp2<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.exp2.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+
+/// Invokes the [`llvm.log`](https://llvm.org/docs/LangRef.html#llvm-log-intrinsic) intrinsic.
+pub fn call_float_log<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.log.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.log10`](https://llvm.org/docs/LangRef.html#llvm-log10-intrinsic) intrinsic.
+pub fn call_float_log10<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.log10.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.log2`](https://llvm.org/docs/LangRef.html#llvm-log2-intrinsic) intrinsic.
+pub fn call_float_log2<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.log2.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.fabs`](https://llvm.org/docs/LangRef.html#llvm-fabs-intrinsic) intrinsic.
+pub fn call_float_fabs<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    src: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_src_t = src.get_type();
+
+    let fn_name = format!("llvm.fabs.{}", get_float_intrinsic_repr(ctx.ctx, llvm_src_t));
+
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_src_t.fn_type(&[llvm_src_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[src.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.minnum`](https://llvm.org/docs/LangRef.html#llvm-minnum-intrinsic) intrinsic.
+pub fn call_float_minnum<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val1: FloatValue<'ctx>,
+    val2: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    debug_assert_eq!(val1.get_type(), val2.get_type());
+
+    let llvm_float_t = val1.get_type();
+
+    let fn_name = format!("llvm.minnum.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into(), llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val1.into(), val2.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.maxnum`](https://llvm.org/docs/LangRef.html#llvm-maxnum-intrinsic) intrinsic.
+pub fn call_float_maxnum<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val1: FloatValue<'ctx>,
+    val2: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    debug_assert_eq!(val1.get_type(), val2.get_type());
+
+    let llvm_float_t = val1.get_type();
+
+    let fn_name = format!("llvm.maxnum.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into(), llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val1.into(), val2.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.copysign`](https://llvm.org/docs/LangRef.html#llvm-copysign-intrinsic) intrinsic.
+pub fn call_float_copysign<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    mag: FloatValue<'ctx>,
+    sgn: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    debug_assert_eq!(mag.get_type(), sgn.get_type());
+
+    let llvm_float_t = mag.get_type();
+
+    let fn_name = format!("llvm.copysign.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into(), llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[mag.into(), sgn.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.floor`](https://llvm.org/docs/LangRef.html#llvm-floor-intrinsic) intrinsic.
+pub fn call_float_floor<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.floor.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.ceil`](https://llvm.org/docs/LangRef.html#llvm-ceil-intrinsic) intrinsic.
+pub fn call_float_ceil<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.ceil.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.round`](https://llvm.org/docs/LangRef.html#llvm-round-intrinsic) intrinsic.
+pub fn call_float_round<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.round.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the 
+/// [`llvm.roundeven`](https://llvm.org/docs/LangRef.html#llvm-roundeven-intrinsic) intrinsic.
+pub fn call_float_roundeven<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: FloatValue<'ctx>,
+    name: Option<&str>,
+) -> FloatValue<'ctx> {
+    let llvm_float_t = val.get_type();
+
+    let fn_name = format!("llvm.roundeven.{}", get_float_intrinsic_repr(ctx.ctx, llvm_float_t));
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_float_t.fn_type(&[llvm_float_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
+
+/// Invokes the [`llvm.expect`](https://llvm.org/docs/LangRef.html#llvm-expect-intrinsic) intrinsic.
+pub fn call_expect<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    val: IntValue<'ctx>,
+    expected_val: IntValue<'ctx>,
+    name: Option<&str>,
+) -> IntValue<'ctx> {
+    debug_assert_eq!(val.get_type().get_bit_width(), expected_val.get_type().get_bit_width());
+
+    let llvm_int_t = val.get_type();
+
+    let fn_name = format!("llvm.expect.i{}", llvm_int_t.get_bit_width());
+    let intrinsic_fn = ctx.module.get_function(fn_name.as_str()).unwrap_or_else(|| {
+        let fn_type = llvm_int_t.fn_type(&[llvm_int_t.into(), llvm_int_t.into()], false);
+
+        ctx.module.add_function(fn_name.as_str(), fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[val.into(), expected_val.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}

nac3core/src/codegen/mod.rs

@@ -1,6 +1,11 @@
 use crate::{
     symbol_resolver::{StaticValue, SymbolResolver},
-    toplevel::{TopLevelContext, TopLevelDef},
+    toplevel::{
+        helper::PRIMITIVE_DEF_IDS, 
+        numpy::unpack_ndarray_var_tys, 
+        TopLevelContext, 
+        TopLevelDef,
+    },
     typecheck::{
         type_inferencer::{CodeLocation, PrimitiveStore},
         typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
@@ -34,10 +39,15 @@ use std::sync::{
 };
 use std::thread;
 
+pub mod builtin_fns;
+pub mod classes;
 pub mod concrete_type;
 pub mod expr;
+pub mod extern_fns;
 mod generator;
 pub mod irrt;
+pub mod llvm_intrinsics;
+pub mod numpy;
 pub mod stmt;
 
 #[cfg(test)]
@@ -236,7 +246,7 @@ pub struct WorkerRegistry {
     static_value_store: Arc<Mutex<StaticValueStore>>,
 
     /// LLVM-related options for code generation.
-    llvm_options: CodeGenLLVMOptions,
+    pub llvm_options: CodeGenLLVMOptions,
 }
 
 impl WorkerRegistry {
@@ -407,14 +417,14 @@ pub struct CodeGenTask {
 ///
 /// This function is used to obtain the in-memory representation of `ty`, e.g. a `bool` variable
 /// would be represented by an `i8`.
-fn get_llvm_type<'ctx>(
+#[allow(clippy::too_many_arguments)]
+fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
     ctx: &'ctx Context,
     module: &Module<'ctx>,
-    generator: &mut dyn CodeGenerator,
+    generator: &mut G,
     unifier: &mut Unifier,
     top_level: &TopLevelContext,
     type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
-    primitives: &PrimitiveStore,
     ty: Type,
 ) -> BasicTypeEnum<'ctx> {
     use TypeEnum::*;
@@ -424,28 +434,50 @@ fn get_llvm_type<'ctx>(
         let ty_enum = unifier.get_ty(ty);
         let result = match &*ty_enum {
             TObj { obj_id, fields, .. } => {
-                // check to avoid treating primitives other than Option as classes
-                if obj_id.0 <= 10 {
-                    match (unifier.get_ty(ty).as_ref(), unifier.get_ty(primitives.option).as_ref())
-                    {
-                        (
-                            TObj { obj_id, params, .. },
-                            TObj { obj_id: opt_id, .. },
-                        ) if *obj_id == *opt_id => {
-                            return get_llvm_type(
+                // check to avoid treating non-class primitives as classes
+                if obj_id.0 <= PRIMITIVE_DEF_IDS.max_id().0 {
+                    return match &*unifier.get_ty_immutable(ty) {
+                        TObj { obj_id, params, .. } if *obj_id == PRIMITIVE_DEF_IDS.option => {
+                            get_llvm_type(
                                 ctx,
                                 module,
                                 generator,
                                 unifier,
                                 top_level,
                                 type_cache,
-                                primitives,
                                 *params.iter().next().unwrap().1,
                             )
                             .ptr_type(AddressSpace::default())
-                            .into();
+                            .into()
                         }
-                        _ => unreachable!("must be option type"),
+
+                        TObj { obj_id, .. } if *obj_id == PRIMITIVE_DEF_IDS.ndarray => {
+                            let llvm_usize = generator.get_size_type(ctx);
+                            let (dtype, _) = unpack_ndarray_var_tys(unifier, ty);
+                            let element_type = get_llvm_type(
+                                ctx, 
+                                module, 
+                                generator, 
+                                unifier, 
+                                top_level, 
+                                type_cache, 
+                                dtype,
+                            );
+
+                            // struct NDArray { num_dims: size_t, dims: size_t*, data: T* }
+                            //
+                            // * num_dims: Number of dimensions in the array
+                            // * dims: Pointer to an array containing the size of each dimension
+                            // * data: Pointer to an array containing the array data
+                            let fields = [
+                                llvm_usize.into(),
+                                llvm_usize.ptr_type(AddressSpace::default()).into(),
+                                element_type.ptr_type(AddressSpace::default()).into(),
+                            ];
+                            ctx.struct_type(&fields, false).ptr_type(AddressSpace::default()).into()
+                        }
+
+                        _ => unreachable!("LLVM type for primitive {} is missing", unifier.stringify(ty)),
                     }
                 }
                 // a struct with fields in the order of declaration
@@ -474,7 +506,6 @@ fn get_llvm_type<'ctx>(
                                 unifier,
                                 top_level,
                                 type_cache,
-                                primitives,
                                 fields[&f.0].0,
                             )
                         })
@@ -490,7 +521,7 @@ fn get_llvm_type<'ctx>(
                     .iter()
                     .map(|ty| {
                         get_llvm_type(
-                            ctx, module, generator, unifier, top_level, type_cache, primitives, *ty,
+                            ctx, module, generator, unifier, top_level, type_cache, *ty,
                         )
                     })
                     .collect_vec();
@@ -499,7 +530,7 @@ fn get_llvm_type<'ctx>(
             TList { ty } => {
                 // a struct with an integer and a pointer to an array
                 let element_type = get_llvm_type(
-                    ctx, module, generator, unifier, top_level, type_cache, primitives, *ty,
+                    ctx, module, generator, unifier, top_level, type_cache, *ty,
                 );
                 let fields = [
                     element_type.ptr_type(AddressSpace::default()).into(),
@@ -524,10 +555,11 @@ fn get_llvm_type<'ctx>(
 /// ABI representation is that the in-memory representation must be at least byte-sized and must
 /// be byte-aligned for the variable to be addressable in memory, whereas there is no such
 /// restriction for ABI representations.
-fn get_llvm_abi_type<'ctx>(
+#[allow(clippy::too_many_arguments)]
+fn get_llvm_abi_type<'ctx, G: CodeGenerator + ?Sized>(
     ctx: &'ctx Context,
     module: &Module<'ctx>,
-    generator: &mut dyn CodeGenerator,
+    generator: &mut G,
     unifier: &mut Unifier,
     top_level: &TopLevelContext,
     type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
@@ -539,7 +571,7 @@ fn get_llvm_abi_type<'ctx>(
     return if unifier.unioned(ty, primitives.bool) {
         ctx.bool_type().into()
     } else {
-        get_llvm_type(ctx, module, generator, unifier, top_level, type_cache, primitives, ty)
+        get_llvm_type(ctx, module, generator, unifier, top_level, type_cache, ty)
     }
 }
 
@@ -580,6 +612,7 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
         let (unifier, primitives) = &top_level_ctx.unifiers.read()[task.unifier_index];
         (Unifier::from_shared_unifier(unifier), *primitives)
     };
+    unifier.put_primitive_store(&primitives);
     unifier.top_level = Some(top_level_ctx.clone());
 
     let mut cache = HashMap::new();
@@ -613,6 +646,7 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
         str: unifier.get_representative(primitives.str),
         exception: unifier.get_representative(primitives.exception),
         option: unifier.get_representative(primitives.option),
+        ..primitives
     };
 
     let mut type_cache: HashMap<_, _> = [
@@ -739,13 +773,11 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
             &mut unifier,
             top_level_ctx.as_ref(),
             &mut type_cache,
-            &primitives,
             arg.ty,
         );
-        let alloca = builder.build_alloca(
-            local_type,
-            &format!("{}.addr", &arg.name.to_string()),
-        );
+        let alloca = builder
+            .build_alloca(local_type, &format!("{}.addr", &arg.name.to_string()))
+            .unwrap();
 
         // Remap boolean parameters into i8
         let param = if local_type.is_int_type() && param.is_int_value() {
@@ -761,14 +793,14 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
             param
         };
 
-        builder.build_store(alloca, param);
+        builder.build_store(alloca, param).unwrap();
         var_assignment.insert(arg.name, (alloca, None, 0));
     }
 
     let return_buffer = if has_sret {
         Some(fn_val.get_nth_param(0).unwrap().into_pointer_value())
     } else {
-        fn_type.get_return_type().map(|v| builder.build_alloca(v, "$ret"))
+        fn_type.get_return_type().map(|v| builder.build_alloca(v, "$ret").unwrap())
     };
 
     let static_values = {
@@ -780,7 +812,7 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
         *static_val = Some(v);
     }
 
-    builder.build_unconditional_branch(body_bb);
+    builder.build_unconditional_branch(body_bb).unwrap();
     builder.position_at_end(body_bb);
 
     let (dibuilder, compile_unit) = module.create_debug_info_builder(
@@ -789,7 +821,7 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
         /* filename */
         &task
             .body
-            .get(0)
+            .first()
             .map_or_else(
                 || "<nac3_internal>".to_string(),
                 |f| f.location.file.0.to_string(),
@@ -819,7 +851,7 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
         inkwell::debug_info::DIFlags::PUBLIC,
     );
     let (row, col) =
-        task.body.get(0).map_or_else(|| (0, 0), |b| (b.location.row, b.location.column));
+        task.body.first().map_or_else(|| (0, 0), |b| (b.location.row, b.location.column));
     let func_scope: DISubprogram<'_> = dibuilder.create_function(
         /* scope */ compile_unit.as_debug_info_scope(),
         /* func name */ symbol,
@@ -874,7 +906,7 @@ pub fn gen_func_impl<'ctx, G: CodeGenerator, F: FnOnce(&mut G, &mut CodeGenConte
 
     // after static analysis, only void functions can have no return at the end.
     if !code_gen_context.is_terminated() {
-        code_gen_context.builder.build_return(None);
+        code_gen_context.builder.build_return(None).unwrap();
     }
 
     code_gen_context.builder.unset_current_debug_location();
@@ -916,12 +948,14 @@ fn bool_to_i1<'ctx>(builder: &Builder<'ctx>, bool_value: IntValue<'ctx>) -> IntV
     if bool_value.get_type().get_bit_width() == 1 {
         bool_value
     } else {
-        builder.build_int_compare(
-            IntPredicate::NE,
-            bool_value,
-            bool_value.get_type().const_zero(),
-            "tobool"
-        )
+        builder
+            .build_int_compare(
+                IntPredicate::NE,
+                bool_value,
+                bool_value.get_type().const_zero(),
+                "tobool",
+            )
+            .unwrap()
     }
 }
 
@@ -934,16 +968,18 @@ fn bool_to_i8<'ctx>(
     let value_bits = bool_value.get_type().get_bit_width();
     match value_bits {
         8 => bool_value,
-        1 => builder.build_int_z_extend(bool_value, ctx.i8_type(), "frombool"),
+        1 => builder.build_int_z_extend(bool_value, ctx.i8_type(), "frombool").unwrap(),
         _ => bool_to_i8(
             builder,
             ctx,
-            builder.build_int_compare(
-                IntPredicate::NE,
-                bool_value,
-                bool_value.get_type().const_zero(),
-                ""
-            )
+            builder
+                .build_int_compare(
+                    IntPredicate::NE,
+                    bool_value,
+                    bool_value.get_type().const_zero(),
+                    "",
+                )
+                .unwrap()
         ),
     }
 }
@@ -969,9 +1005,13 @@ fn gen_in_range_check<'ctx>(
     stop: IntValue<'ctx>,
     step: IntValue<'ctx>,
 ) -> IntValue<'ctx> {
-    let sign = ctx.builder.build_int_compare(IntPredicate::SGT, step, ctx.ctx.i32_type().const_zero(), "");
-    let lo = ctx.builder.build_select(sign, value, stop, "").into_int_value();
-    let hi = ctx.builder.build_select(sign, stop, value, "").into_int_value();
+    let sign = ctx.builder.build_int_compare(IntPredicate::SGT, step, ctx.ctx.i32_type().const_zero(), "").unwrap();
+    let lo = ctx.builder.build_select(sign, value, stop, "")
+        .map(BasicValueEnum::into_int_value)
+        .unwrap();
+    let hi = ctx.builder.build_select(sign, stop, value, "")
+        .map(BasicValueEnum::into_int_value)
+        .unwrap();
 
-    ctx.builder.build_int_compare(IntPredicate::SLT, lo, hi, "cmp")
+    ctx.builder.build_int_compare(IntPredicate::SLT, lo, hi, "cmp").unwrap()
 }

nac3core/src/codegen/test.rs

@@ -5,11 +5,12 @@ use crate::{
     },
     symbol_resolver::{SymbolResolver, ValueEnum},
     toplevel::{
-        composer::TopLevelComposer, DefinitionId, FunInstance, TopLevelContext, TopLevelDef,
+        composer::{ComposerConfig, TopLevelComposer}, DefinitionId, FunInstance, TopLevelContext,
+        TopLevelDef,
     },
     typecheck::{
         type_inferencer::{FunctionData, Inferencer, PrimitiveStore},
-        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier},
+        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
     },
 };
 use indoc::indoc;
@@ -91,7 +92,7 @@ fn test_primitives() {
         "};
     let statements = parse_program(source, Default::default()).unwrap();
 
-    let composer: TopLevelComposer = Default::default();
+    let composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 32).0;
     let mut unifier = composer.unifier.clone();
     let primitives = composer.primitives_ty;
     let top_level = Arc::new(composer.make_top_level_context());
@@ -110,7 +111,7 @@ fn test_primitives() {
             FuncArg { name: "b".into(), ty: primitives.int32, default_value: None },
         ],
         ret: primitives.int32,
-        vars: HashMap::new(),
+        vars: VarMap::new(),
     };
 
     let mut store = ConcreteTypeStore::new();
@@ -248,7 +249,7 @@ fn test_simple_call() {
         "};
     let statements_2 = parse_program(source_2, Default::default()).unwrap();
 
-    let composer: TopLevelComposer = Default::default();
+    let composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 32).0;
     let mut unifier = composer.unifier.clone();
     let primitives = composer.primitives_ty;
     let top_level = Arc::new(composer.make_top_level_context());
@@ -257,7 +258,7 @@ fn test_simple_call() {
     let signature = FunSignature {
         args: vec![FuncArg { name: "a".into(), ty: primitives.int32, default_value: None }],
         ret: primitives.int32,
-        vars: HashMap::new(),
+        vars: VarMap::new(),
     };
     let fun_ty = unifier.add_ty(TypeEnum::TFunc(signature.clone()));
     let mut store = ConcreteTypeStore::new();

nac3core/src/symbol_resolver.rs

@@ -3,20 +3,16 @@ use std::sync::Arc;
 use std::{collections::HashMap, collections::HashSet, fmt::Display};
 use std::rc::Rc;
 
-use crate::typecheck::typedef::TypeEnum;
 use crate::{
-    codegen::CodeGenContext,
+    codegen::{CodeGenContext, CodeGenerator},
     toplevel::{DefinitionId, TopLevelDef, type_annotation::TypeAnnotation},
-};
-use crate::{
-    codegen::CodeGenerator,
     typecheck::{
         type_inferencer::PrimitiveStore,
-        typedef::{Type, Unifier},
+        typedef::{Type, TypeEnum, Unifier, VarMap},
     },
 };
 use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
-use itertools::{chain, izip};
+use itertools::{chain, Itertools, izip};
 use nac3parser::ast::{Constant, Expr, Location, StrRef};
 use parking_lot::RwLock;
 
@@ -114,6 +110,40 @@ impl SymbolValue {
         }
     }
 
+    /// Creates a [`SymbolValue`] from a [`Constant`], with its type being inferred from the constant value.
+    ///
+    /// * `constant` - The constant to create the value from.
+    pub fn from_constant_inferred(
+        constant: &Constant,
+    ) -> Result<Self, String> {
+        match constant {
+            Constant::None => Ok(SymbolValue::OptionNone),
+            Constant::Bool(b) => Ok(SymbolValue::Bool(*b)),
+            Constant::Str(s) => Ok(SymbolValue::Str(s.to_string())),
+            Constant::Int(i) => {
+                let i = *i;
+                if i >= 0 {
+                    i32::try_from(i).map(SymbolValue::I32)
+                        .or_else(|_| i64::try_from(i).map(SymbolValue::I64))
+                        .map_err(|_| format!("Literal cannot be expressed as any integral type: {i}"))
+                } else {
+                    u32::try_from(i).map(SymbolValue::U32)
+                        .or_else(|_| u64::try_from(i).map(SymbolValue::U64))
+                        .map_err(|_| format!("Literal cannot be expressed as any integral type: {i}"))
+                }
+            }
+            Constant::Tuple(t) => {
+                let elems = t
+                    .iter()
+                    .map(Self::from_constant_inferred)
+                    .collect::<Result<Vec<SymbolValue>, _>>()?;
+                Ok(SymbolValue::Tuple(elems))
+            }
+            Constant::Float(f) => Ok(SymbolValue::Double(*f)),
+            _ => Err(format!("Unsupported value type {constant:?}")),
+        }
+    }
+
     /// Returns the [`Type`] representing the data type of this value.
     pub fn get_type(&self, primitives: &PrimitiveStore, unifier: &mut Unifier) -> Type {
         match self {
@@ -140,13 +170,13 @@ impl SymbolValue {
     /// Returns the [`TypeAnnotation`] representing the data type of this value.
     pub fn get_type_annotation(&self, primitives: &PrimitiveStore, unifier: &mut Unifier) -> TypeAnnotation {
         match self {
-            SymbolValue::Bool(..) => TypeAnnotation::Primitive(primitives.bool),
-            SymbolValue::Double(..) => TypeAnnotation::Primitive(primitives.float),
-            SymbolValue::I32(..) => TypeAnnotation::Primitive(primitives.int32),
-            SymbolValue::I64(..) => TypeAnnotation::Primitive(primitives.int64),
-            SymbolValue::U32(..) => TypeAnnotation::Primitive(primitives.uint32),
-            SymbolValue::U64(..) => TypeAnnotation::Primitive(primitives.uint64),
-            SymbolValue::Str(..) => TypeAnnotation::Primitive(primitives.str),
+            SymbolValue::Bool(..)
+            | SymbolValue::Double(..)
+            | SymbolValue::I32(..)
+            | SymbolValue::I64(..)
+            | SymbolValue::U32(..)
+            | SymbolValue::U64(..)
+            | SymbolValue::Str(..) => TypeAnnotation::Primitive(self.get_type(primitives, unifier)),
             SymbolValue::Tuple(vs) => {
                 let vs_tys = vs
                     .iter()
@@ -155,13 +185,13 @@ impl SymbolValue {
                 TypeAnnotation::Tuple(vs_tys)
             }
             SymbolValue::OptionNone => TypeAnnotation::CustomClass {
-                id: primitives.option.get_obj_id(unifier),
+                id: primitives.option.obj_id(unifier).unwrap(),
                 params: Vec::default(),
             },
             SymbolValue::OptionSome(v) => {
                 let ty = v.get_type_annotation(primitives, unifier);
                 TypeAnnotation::CustomClass {
-                    id: primitives.option.get_obj_id(unifier),
+                    id: primitives.option.obj_id(unifier).unwrap(),
                     params: vec![ty],
                 }
             }
@@ -200,6 +230,38 @@ impl Display for SymbolValue {
     }
 }
 
+impl TryFrom<SymbolValue> for u64 {
+    type Error = ();
+
+    /// Tries to convert a [`SymbolValue`] into a [`u64`], returning [`Err`] if the value is not
+    /// numeric or if the value cannot be converted into a `u64` without overflow.
+    fn try_from(value: SymbolValue) -> Result<Self, Self::Error> {
+        match value {
+            SymbolValue::I32(v) => u64::try_from(v).map_err(|_| ()),
+            SymbolValue::I64(v) => u64::try_from(v).map_err(|_| ()),
+            SymbolValue::U32(v) => Ok(v as u64),
+            SymbolValue::U64(v) => Ok(v),
+            _ => Err(()),
+        }
+    }
+}
+
+impl TryFrom<SymbolValue> for i128 {
+    type Error = ();
+
+    /// Tries to convert a [`SymbolValue`] into a [`i128`], returning [`Err`] if the value is not
+    /// numeric.
+    fn try_from(value: SymbolValue) -> Result<Self, Self::Error> {
+        match value {
+            SymbolValue::I32(v) => Ok(v as i128),
+            SymbolValue::I64(v) => Ok(v as i128),
+            SymbolValue::U32(v) => Ok(v as i128),
+            SymbolValue::U64(v) => Ok(v as i128),
+            _ => Err(()),
+        }
+    }
+}
+
 pub trait StaticValue {
     /// Returns a unique identifier for this value.
     fn get_unique_identifier(&self) -> u64;
@@ -319,7 +381,7 @@ pub trait SymbolResolver {
 }
 
 thread_local! {
-    static IDENTIFIER_ID: [StrRef; 11] = [
+    static IDENTIFIER_ID: [StrRef; 12] = [
         "int32".into(),
         "int64".into(),
         "float".into(),
@@ -331,6 +393,7 @@ thread_local! {
         "Exception".into(),
         "uint32".into(),
         "uint64".into(),
+        "Literal".into(),
     ];
 }
 
@@ -355,6 +418,7 @@ pub fn parse_type_annotation<T>(
     let exn_id = ids[8];
     let uint32_id = ids[9];
     let uint64_id = ids[10];
+    let literal_id = ids[11];
 
     let name_handling = |id: &StrRef, loc: Location, unifier: &mut Unifier| {
         if *id == int32_id {
@@ -394,7 +458,7 @@ pub fn parse_type_annotation<T>(
                     Ok(unifier.add_ty(TypeEnum::TObj {
                         obj_id,
                         fields,
-                        params: HashMap::default(),
+                        params: VarMap::default(),
                     }))
                 } else {
                     Err(HashSet::from([
@@ -439,6 +503,27 @@ pub fn parse_type_annotation<T>(
                     "Expected multiple elements for tuple".into()
                 ]))
             }
+        } else if *id == literal_id {
+            let mut parse_literal = |elt: &Expr<T>| {
+                let ty = parse_type_annotation(resolver, top_level_defs, unifier, primitives, elt)?;
+                let ty_enum = &*unifier.get_ty_immutable(ty);
+                match ty_enum {
+                    TypeEnum::TLiteral { values, .. } => Ok(values.clone()),
+                    _ => Err(HashSet::from([
+                        format!("Expected literal in type argument for Literal at {}", elt.location),
+                    ]))
+                }
+            };
+
+            let values = if let Tuple { elts, .. } = &slice.node {
+                elts.iter()
+                    .map(&mut parse_literal)
+                    .collect::<Result<Vec<_>, _>>()?
+            } else {
+                vec![parse_literal(slice)?]
+            }.into_iter().flatten().collect_vec();
+
+            Ok(unifier.get_fresh_literal(values, Some(slice.location)))
         } else {
             let types = if let Tuple { elts, .. } = &slice.node {
                 elts.iter()
@@ -462,7 +547,7 @@ pub fn parse_type_annotation<T>(
                         ),
                     ]))
                 }
-                let mut subst = HashMap::new();
+                let mut subst = VarMap::new();
                 for (var, ty) in izip!(type_vars.iter(), types.iter()) {
                     let id = if let TypeEnum::TVar { id, .. } = &*unifier.get_ty(*var) {
                         *id
@@ -502,6 +587,9 @@ pub fn parse_type_annotation<T>(
                 ]))
             }
         }
+        Constant { value, .. } => SymbolValue::from_constant_inferred(value)
+            .map(|v| unifier.get_fresh_literal(vec![v], Some(expr.location)))
+            .map_err(|err| HashSet::from([err])),
         _ => Err(HashSet::from([
             format!("unsupported type expression at {}", expr.location),
         ])),

nac3core/src/toplevel/composer.rs

@@ -4,7 +4,10 @@ use std::rc::Rc;
 use crate::{
     codegen::{expr::get_subst_key, stmt::exn_constructor},
     symbol_resolver::SymbolValue,
-    typecheck::type_inferencer::{FunctionData, Inferencer},
+    typecheck::{
+        type_inferencer::{FunctionData, Inferencer},
+        typedef::VarMap,
+    },
 };
 
 use super::*;
@@ -37,12 +40,8 @@ pub struct TopLevelComposer {
     // number of built-in function and classes in the definition list, later skip
     pub builtin_num: usize,
     pub core_config: ComposerConfig,
-}
-
-impl Default for TopLevelComposer {
-    fn default() -> Self {
-        Self::new(vec![], ComposerConfig::default()).0
-    }
+    /// The size of a native word on the target platform.
+    pub size_t: u32,
 }
 
 impl TopLevelComposer {
@@ -52,11 +51,10 @@ impl TopLevelComposer {
     pub fn new(
         builtins: Vec<(StrRef, FunSignature, Arc<GenCall>)>,
         core_config: ComposerConfig,
+        size_t: u32,
     ) -> (Self, HashMap<StrRef, DefinitionId>, HashMap<StrRef, Type>) {
-        let mut primitives = Self::make_primitives();
-        let mut definition_ast_list = builtins::get_builtins(&mut primitives);
-        let primitives_ty = primitives.0;
-        let mut unifier = primitives.1;
+        let (primitives_ty, mut unifier) = Self::make_primitives(size_t);
+        let mut definition_ast_list = builtins::get_builtins(&mut unifier, &primitives_ty);
         let mut keyword_list: HashSet<StrRef> = HashSet::from_iter(vec![
             "Generic".into(),
             "virtual".into(),
@@ -146,6 +144,7 @@ impl TopLevelComposer {
                 defined_names,
                 method_class,
                 core_config,
+                size_t,
             },
             builtin_id,
             builtin_ty,
@@ -223,7 +222,7 @@ impl TopLevelComposer {
                 let constructor_ty = self.unifier.get_dummy_var().0;
                 let mut class_def_ast = (
                     Arc::new(RwLock::new(Self::make_top_level_class_def(
-                        class_def_id,
+                        DefinitionId(class_def_id),
                         resolver.clone(),
                         fully_qualified_class_name,
                         Some(constructor_ty),
@@ -563,7 +562,6 @@ impl TopLevelComposer {
                         &primitive_types,
                         b,
                         vec![(*class_def_id, class_type_vars.clone())].into_iter().collect(),
-                        None,
                     )?;
 
                     if let TypeAnnotation::CustomClass { .. } = &base_ty {
@@ -847,7 +845,7 @@ impl TopLevelComposer {
             let resolver = resolver.unwrap();
             let resolver = &**resolver;
 
-            let mut function_var_map: HashMap<u32, Type> = HashMap::new();
+            let mut function_var_map = VarMap::new();
             let arg_types = {
                 // make sure no duplicate parameter
                 let mut defined_parameter_name: HashSet<_> = HashSet::new();
@@ -904,7 +902,6 @@ impl TopLevelComposer {
                             // NOTE: since only class need this, for function
                             // it should be fine to be empty map
                             HashMap::new(),
-                            None,
                         )?;
 
                         let type_vars_within =
@@ -971,7 +968,6 @@ impl TopLevelComposer {
                             // NOTE: since only class need this, for function
                             // it should be fine to be empty map
                             HashMap::new(),
-                            None,
                         )?
                     };
 
@@ -1087,7 +1083,7 @@ impl TopLevelComposer {
                     let (method_dummy_ty, method_id) =
                         Self::get_class_method_def_info(class_methods_def, *name)?;
 
-                    let mut method_var_map: HashMap<u32, Type> = HashMap::new();
+                    let mut method_var_map = VarMap::new();
 
                     let arg_types: Vec<FuncArg> = {
                         // check method parameters cannot have same name
@@ -1158,7 +1154,6 @@ impl TopLevelComposer {
                                         vec![(class_id, class_type_vars_def.clone())]
                                             .into_iter()
                                             .collect(),
-                                        None,
                                     )?
                                 };
                                 // find type vars within this method parameter type annotation
@@ -1224,7 +1219,6 @@ impl TopLevelComposer {
                                 primitives,
                                 result,
                                 vec![(class_id, class_type_vars_def.clone())].into_iter().collect(),
-                                None,
                             )?;
                             // find type vars within this return type annotation
                             let type_vars_within =
@@ -1319,7 +1313,6 @@ impl TopLevelComposer {
                                 primitives,
                                 annotation.as_ref(),
                                 vec![(class_id, class_type_vars_def.clone())].into_iter().collect(),
-                                None,
                             )?;
                             // find type vars within this return type annotation
                             let type_vars_within =
@@ -1358,9 +1351,9 @@ impl TopLevelComposer {
                         ]))
                     }
                 }
-                ast::StmtKind::Assign { .. } => {}, // we don't class attributes
-                ast::StmtKind::Pass { .. } => {}
-                ast::StmtKind::Expr { value: _, .. } => {} // typically a docstring; ignoring all expressions matches CPython behavior
+                ast::StmtKind::Assign { .. } // we don't class attributes
+                | ast::StmtKind::Expr { value: _, .. } // typically a docstring; ignoring all expressions matches CPython behavior
+                | ast::StmtKind::Pass { .. } => {}
                 _ => {
                     return Err(HashSet::from([
                         format!(
@@ -1582,7 +1575,7 @@ impl TopLevelComposer {
                             },
                         ],
                         ret: self_type,
-                        vars: HashMap::default(),
+                        vars: VarMap::default(),
                     }));
                     let cons_fun = TopLevelDef::Function {
                         name: format!("{}.{}", class_name, "__init__"),
@@ -1606,7 +1599,7 @@ impl TopLevelComposer {
                 // get the class constructor type correct
                 let (contor_args, contor_type_vars) = {
                     let mut constructor_args: Vec<FuncArg> = Vec::new();
-                    let mut type_vars: HashMap<u32, Type> = HashMap::new();
+                    let mut type_vars = VarMap::new();
                     for (name, func_sig, id) in methods {
                         if *name == init_str_id {
                             init_id = Some(*id);
@@ -1757,13 +1750,13 @@ impl TopLevelComposer {
                         })
                         .multi_cartesian_product()
                         .collect_vec();
-                    let mut result: Vec<HashMap<u32, Type>> = Vec::default();
+                    let mut result: Vec<VarMap> = Vec::default();
                     for comb in var_combs {
                         result.push(vars.keys().copied().zip(comb).collect());
                     }
                     // NOTE: if is empty, means no type var, append a empty subst, ok to do this?
                     if result.is_empty() {
-                        result.push(HashMap::new());
+                        result.push(VarMap::new());
                     }
                     (result, no_ranges)
                 };
@@ -1803,7 +1796,7 @@ impl TopLevelComposer {
                                             None
                                         }
                                     })
-                                    .collect::<HashMap<_, _>>()
+                                    .collect::<VarMap>()
                             };
                             unifier.subst(self_type, &subst_for_self).unwrap_or(self_type)
                         })
@@ -1931,9 +1924,8 @@ impl TopLevelComposer {
                             ret_str,
                             name,
                             ast.as_ref().unwrap().location
-                        ),
-                    ]))
-                        }
+                        ),]))
+                    }
 
                     instance_to_stmt.insert(
                         get_subst_key(unifier, self_type, &subst, Some(&vars.keys().copied().collect())),

nac3core/src/toplevel/helper.rs

@@ -1,10 +1,78 @@
 use std::convert::TryInto;
 
 use crate::symbol_resolver::SymbolValue;
+use crate::typecheck::typedef::{Mapping, VarMap};
 use nac3parser::ast::{Constant, Location};
 
 use super::*;
 
+/// Structure storing [`DefinitionId`] for primitive types.
+#[derive(Clone, Copy)]
+pub struct PrimitiveDefinitionIds {
+    pub int32: DefinitionId,
+    pub int64: DefinitionId,
+    pub uint32: DefinitionId,
+    pub uint64: DefinitionId,
+    pub float: DefinitionId,
+    pub bool: DefinitionId,
+    pub none: DefinitionId,
+    pub range: DefinitionId,
+    pub str: DefinitionId,
+    pub exception: DefinitionId,
+    pub option: DefinitionId,
+    pub ndarray: DefinitionId,
+}
+
+impl PrimitiveDefinitionIds {
+    /// Returns all [`DefinitionId`] of primitives as a [`Vec`].
+    ///
+    /// There are no guarantees on ordering of the IDs.
+    #[must_use]
+    fn as_vec(&self) -> Vec<DefinitionId> {
+        vec![
+            self.int32,
+            self.int64,
+            self.uint32,
+            self.uint64,
+            self.float,
+            self.bool,
+            self.none,
+            self.range,
+            self.str,
+            self.exception,
+            self.option,
+            self.ndarray,
+        ]
+    }
+
+    /// Returns an iterator over all [`DefinitionId`]s of this instance in indeterminate order.
+    pub fn iter(&self) -> impl Iterator<Item=DefinitionId> {
+        self.as_vec().into_iter()
+    }
+
+    /// Returns the primitive with the largest [`DefinitionId`].
+    #[must_use]
+    pub fn max_id(&self) -> DefinitionId {
+        self.iter().max().unwrap()
+    }
+}
+
+/// The [definition IDs][DefinitionId] for primitive types.
+pub const PRIMITIVE_DEF_IDS: PrimitiveDefinitionIds = PrimitiveDefinitionIds {
+    int32: DefinitionId(0),
+    int64: DefinitionId(1),
+    uint32: DefinitionId(8),
+    uint64: DefinitionId(9),
+    float: DefinitionId(2),
+    bool: DefinitionId(3),
+    none: DefinitionId(4),
+    range: DefinitionId(5),
+    str: DefinitionId(6),
+    exception: DefinitionId(7),
+    option: DefinitionId(10),
+    ndarray: DefinitionId(14),
+};
+
 impl TopLevelDef {
     pub fn to_string(&self, unifier: &mut Unifier) -> String {
         match self {
@@ -44,45 +112,45 @@ impl TopLevelDef {
 
 impl TopLevelComposer {
     #[must_use]
-    pub fn make_primitives() -> (PrimitiveStore, Unifier) {
+    pub fn make_primitives(size_t: u32) -> (PrimitiveStore, Unifier) {
         let mut unifier = Unifier::new();
         let int32 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(0),
+            obj_id: PRIMITIVE_DEF_IDS.int32,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let int64 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(1),
+            obj_id: PRIMITIVE_DEF_IDS.int64,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let float = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(2),
+            obj_id: PRIMITIVE_DEF_IDS.float,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let bool = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(3),
+            obj_id: PRIMITIVE_DEF_IDS.bool,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let none = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(4),
+            obj_id: PRIMITIVE_DEF_IDS.none,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let range = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(5),
+            obj_id: PRIMITIVE_DEF_IDS.range,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let str = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(6),
+            obj_id: PRIMITIVE_DEF_IDS.str,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let exception = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(7),
+            obj_id: PRIMITIVE_DEF_IDS.exception,
             fields: vec![
                 ("__name__".into(), (int32, true)),
                 ("__file__".into(), (str, true)),
@@ -96,32 +164,32 @@ impl TopLevelComposer {
             ]
             .into_iter()
             .collect::<HashMap<_, _>>(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let uint32 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(8),
+            obj_id: PRIMITIVE_DEF_IDS.uint32,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let uint64 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(9),
+            obj_id: PRIMITIVE_DEF_IDS.uint64,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
 
         let option_type_var = unifier.get_fresh_var(Some("option_type_var".into()), None);
         let is_some_type_fun_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
             args: vec![],
             ret: bool,
-            vars: HashMap::from([(option_type_var.1, option_type_var.0)]),
+            vars: VarMap::from([(option_type_var.1, option_type_var.0)]),
         }));
         let unwrap_fun_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
             args: vec![],
             ret: option_type_var.0,
-            vars: HashMap::from([(option_type_var.1, option_type_var.0)]),
+            vars: VarMap::from([(option_type_var.1, option_type_var.0)]),
         }));
         let option = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(10),
+            obj_id: PRIMITIVE_DEF_IDS.option,
             fields: vec![
                 ("is_some".into(), (is_some_type_fun_ty, true)),
                 ("is_none".into(), (is_some_type_fun_ty, true)),
@@ -129,9 +197,54 @@ impl TopLevelComposer {
             ]
             .into_iter()
             .collect::<HashMap<_, _>>(),
-            params: HashMap::from([(option_type_var.1, option_type_var.0)]),
+            params: VarMap::from([(option_type_var.1, option_type_var.0)]),
         });
 
+        let size_t_ty = match size_t {
+            32 => uint32,
+            64 => uint64,
+            _ => unreachable!(),
+        };
+
+        let ndarray_dtype_tvar = unifier.get_fresh_var(Some("ndarray_dtype".into()), None);
+        let ndarray_ndims_tvar = unifier.get_fresh_const_generic_var(size_t_ty, Some("ndarray_ndims".into()), None);
+        let ndarray_copy_fun_ret_ty = unifier.get_fresh_var(None, None);
+        let ndarray_copy_fun_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
+            args: vec![],
+            ret: ndarray_copy_fun_ret_ty.0,
+            vars: VarMap::from([
+                (ndarray_dtype_tvar.1, ndarray_dtype_tvar.0),
+                (ndarray_ndims_tvar.1, ndarray_ndims_tvar.0),
+            ]),
+        }));
+        let ndarray_fill_fun_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
+            args: vec![
+                FuncArg {
+                    name: "value".into(),
+                    ty: ndarray_dtype_tvar.0,
+                    default_value: None,
+                },
+            ],
+            ret: none,
+            vars: VarMap::from([
+                (ndarray_dtype_tvar.1, ndarray_dtype_tvar.0),
+                (ndarray_ndims_tvar.1, ndarray_ndims_tvar.0),
+            ]),
+        }));
+        let ndarray = unifier.add_ty(TypeEnum::TObj {
+            obj_id: PRIMITIVE_DEF_IDS.ndarray,
+            fields: Mapping::from([
+                ("copy".into(), (ndarray_copy_fun_ty, true)),
+                ("fill".into(), (ndarray_fill_fun_ty, true)),
+            ]),
+            params: VarMap::from([
+                (ndarray_dtype_tvar.1, ndarray_dtype_tvar.0),
+                (ndarray_ndims_tvar.1, ndarray_ndims_tvar.0),
+            ]),
+        });
+
+        unifier.unify(ndarray_copy_fun_ret_ty.0, ndarray).unwrap();
+
         let primitives = PrimitiveStore {
             int32,
             int64,
@@ -144,7 +257,10 @@ impl TopLevelComposer {
             str,
             exception,
             option,
+            ndarray,
+            size_t,
         };
+        unifier.put_primitive_store(&primitives);
         crate::typecheck::magic_methods::set_primitives_magic_methods(&primitives, &mut unifier);
         (primitives, unifier)
     }
@@ -153,7 +269,7 @@ impl TopLevelComposer {
     /// when first registering, the `type_vars`, fields, methods, ancestors are invalid
     #[must_use]
     pub fn make_top_level_class_def(
-        index: usize,
+        obj_id: DefinitionId,
         resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
         name: StrRef,
         constructor: Option<Type>,
@@ -161,7 +277,7 @@ impl TopLevelComposer {
     ) -> TopLevelDef {
         TopLevelDef::Class {
             name,
-            object_id: DefinitionId(index),
+            object_id: obj_id,
             type_vars: Vec::default(),
             fields: Vec::default(),
             methods: Vec::default(),
@@ -438,7 +554,7 @@ impl TopLevelComposer {
                     TypeAnnotation::CustomClass { id: e_id, params: e_param },
                 ) => {
                     *f_id == *e_id
-                        && *f_id == primitive.option.get_obj_id(unifier)
+                        && *f_id == primitive.option.obj_id(unifier).unwrap()
                         && (f_param.is_empty()
                             || (f_param.len() == 1
                                 && e_param.len() == 1

nac3core/src/toplevel/mod.rs

@@ -8,7 +8,7 @@ use std::{
 
 use super::codegen::CodeGenContext;
 use super::typecheck::type_inferencer::PrimitiveStore;
-use super::typecheck::typedef::{FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, Unifier};
+use super::typecheck::typedef::{FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, Unifier, VarMap};
 use crate::{
     codegen::CodeGenerator,
     symbol_resolver::{SymbolResolver, ValueEnum},
@@ -25,13 +25,14 @@ pub struct DefinitionId(pub usize);
 pub mod builtins;
 pub mod composer;
 pub mod helper;
+pub mod numpy;
 pub mod type_annotation;
 use composer::*;
 use type_annotation::*;
 #[cfg(test)]
 mod test;
 
-type GenCallCallback = Box<
+type GenCallCallback = 
     dyn for<'ctx, 'a> Fn(
             &mut CodeGenContext<'ctx, 'a>,
             Option<(Type, ValueEnum<'ctx>)>,
@@ -40,19 +41,25 @@ type GenCallCallback = Box<
             &mut dyn CodeGenerator,
         ) -> Result<Option<BasicValueEnum<'ctx>>, String>
         + Send
-        + Sync,
->;
+        + Sync;
 
 pub struct GenCall {
-    fp: GenCallCallback,
+    fp: Box<GenCallCallback>,
 }
 
 impl GenCall {
     #[must_use]
-    pub fn new(fp: GenCallCallback) -> GenCall {
+    pub fn new(fp: Box<GenCallCallback>) -> GenCall {
         GenCall { fp }
     }
 
+    /// Creates a dummy instance of [`GenCall`], which invokes [`unreachable!()`] with the given 
+    /// `reason`.
+    #[must_use]
+    pub fn create_dummy(reason: String) -> GenCall {
+        Self::new(Box::new(move |_, _, _, _, _| unreachable!("{reason}")))
+    }
+
     pub fn run<'ctx>(
         &self,
         ctx: &mut CodeGenContext<'ctx, '_>,
@@ -75,7 +82,7 @@ impl Debug for GenCall {
 pub struct FunInstance {
     pub body: Arc<Vec<Stmt<Option<Type>>>>,
     pub calls: Arc<HashMap<CodeLocation, CallId>>,
-    pub subst: HashMap<u32, Type>,
+    pub subst: VarMap,
     pub unifier_id: usize,
 }
 

nac3core/src/toplevel/numpy.rs

@@ -0,0 +1,103 @@
+use itertools::Itertools;
+use crate::{
+    toplevel::helper::PRIMITIVE_DEF_IDS,
+    typecheck::{
+        type_inferencer::PrimitiveStore,
+        typedef::{Type, TypeEnum, Unifier, VarMap},
+    },
+};
+
+/// Creates a `ndarray` [`Type`] with the given type arguments.
+/// 
+/// * `dtype` - The element type of the `ndarray`, or [`None`] if the type variable is not
+/// specialized.
+/// * `ndims` - The number of dimensions of the `ndarray`, or [`None`] if the type variable is not
+/// specialized.
+pub fn make_ndarray_ty(
+    unifier: &mut Unifier,
+    primitives: &PrimitiveStore,
+    dtype: Option<Type>,
+    ndims: Option<Type>,
+) -> Type {
+    subst_ndarray_tvars(unifier, primitives.ndarray, dtype, ndims)
+}
+
+/// Substitutes type variables in `ndarray`.
+///
+/// * `dtype` - The element type of the `ndarray`, or [`None`] if the type variable is not
+/// specialized.
+/// * `ndims` - The number of dimensions of the `ndarray`, or [`None`] if the type variable is not
+/// specialized.
+pub fn subst_ndarray_tvars(
+    unifier: &mut Unifier,
+    ndarray: Type,
+    dtype: Option<Type>,
+    ndims: Option<Type>,
+) -> Type {
+    let TypeEnum::TObj { obj_id, params, .. } = &*unifier.get_ty_immutable(ndarray) else {
+        panic!("Expected `ndarray` to be TObj, but got {}", unifier.stringify(ndarray))
+    };
+    debug_assert_eq!(*obj_id, PRIMITIVE_DEF_IDS.ndarray);
+
+    if dtype.is_none() && ndims.is_none() {
+        return ndarray
+    }
+
+    let tvar_ids = params.iter()
+        .map(|(obj_id, _)| *obj_id)
+        .collect_vec();
+    debug_assert_eq!(tvar_ids.len(), 2);
+
+    let mut tvar_subst = VarMap::new();
+    if let Some(dtype) = dtype {
+        tvar_subst.insert(tvar_ids[0], dtype);
+    }
+    if let Some(ndims) = ndims {
+        tvar_subst.insert(tvar_ids[1], ndims);
+    }
+
+    unifier.subst(ndarray, &tvar_subst).unwrap_or(ndarray)
+}
+
+fn unpack_ndarray_tvars(
+    unifier: &mut Unifier,
+    ndarray: Type,
+) -> Vec<(u32, Type)> {
+    let TypeEnum::TObj { obj_id, params, .. } = &*unifier.get_ty_immutable(ndarray) else {
+        panic!("Expected `ndarray` to be TObj, but got {}", unifier.stringify(ndarray))
+    };
+    debug_assert_eq!(*obj_id, PRIMITIVE_DEF_IDS.ndarray);
+    debug_assert_eq!(params.len(), 2);
+
+    params.iter()
+        .sorted_by_key(|(obj_id, _)| *obj_id)
+        .map(|(var_id, ty)| (*var_id, *ty))
+        .collect_vec()
+}
+
+/// Unpacks the type variable IDs of `ndarray` into a tuple. The elements of the tuple corresponds 
+/// to `dtype` (the element type) and `ndims` (the number of dimensions) of the `ndarray` 
+/// respectively.
+pub fn unpack_ndarray_var_ids(
+    unifier: &mut Unifier,
+    ndarray: Type,
+) -> (u32, u32) {
+    unpack_ndarray_tvars(unifier, ndarray)
+        .into_iter()
+        .map(|v| v.0)
+        .collect_tuple()
+        .unwrap()
+}
+
+/// Unpacks the type variables of `ndarray` into a tuple. The elements of the tuple corresponds to
+/// `dtype` (the element type) and `ndims` (the number of dimensions) of the `ndarray` respectively.
+pub fn unpack_ndarray_var_tys(
+    unifier: &mut Unifier,
+    ndarray: Type,
+) -> (Type, Type) {
+    unpack_ndarray_tvars(unifier, ndarray)
+        .into_iter()
+        .map(|v| v.1)
+        .collect_tuple()
+        .unwrap()
+}

nac3core/src/toplevel/snapshots/nac3core__toplevel__test__test_analyze__generic_class.snap

@@ -5,7 +5,7 @@ expression: res_vec
 [
     "Class {\nname: \"Generic_A\",\nancestors: [\"Generic_A[V]\", \"B\"],\nfields: [\"aa\", \"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\"), (\"fun\", \"fn[[a:int32], V]\")],\ntype_vars: [\"V\"]\n}\n",
     "Function {\nname: \"Generic_A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [22]\n}\n",
+    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [238]\n}\n",
     "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [\"aa\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\")],\ntype_vars: []\n}\n",
     "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
     "Function {\nname: \"B.foo\",\nsig: \"fn[[b:T], none]\",\nvar_id: []\n}\n",

nac3core/src/toplevel/snapshots/nac3core__toplevel__test__test_analyze__inheritance_override.snap

@@ -7,7 +7,7 @@ expression: res_vec
     "Function {\nname: \"A.__init__\",\nsig: \"fn[[t:T], none]\",\nvar_id: []\n}\n",
     "Function {\nname: \"A.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
     "Function {\nname: \"A.foo\",\nsig: \"fn[[c:C], none]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B[typevar11]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar11\"]\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B[typevar227]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar227\"]\n}\n",
     "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
     "Function {\nname: \"B.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
     "Class {\nname: \"C\",\nancestors: [\"C\", \"B[bool]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\", \"e\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: []\n}\n",

nac3core/src/toplevel/snapshots/nac3core__toplevel__test__test_analyze__list_tuple_generic.snap

@@ -5,9 +5,9 @@ expression: res_vec
 [
     "Function {\nname: \"foo\",\nsig: \"fn[[a:list[int32], b:tuple[T, float]], A[B, bool]]\",\nvar_id: []\n}\n",
     "Class {\nname: \"A\",\nancestors: [\"A[T, V]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[v:V], none]\"), (\"fun\", \"fn[[a:T], V]\")],\ntype_vars: [\"T\", \"V\"]\n}\n",
-    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [24]\n}\n",
-    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [29]\n}\n",
-    "Function {\nname: \"gfun\",\nsig: \"fn[[a:A[int32, list[float]]], none]\",\nvar_id: []\n}\n",
+    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [240]\n}\n",
+    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [245]\n}\n",
+    "Function {\nname: \"gfun\",\nsig: \"fn[[a:A[list[float], int32]], none]\",\nvar_id: []\n}\n",
     "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [],\nmethods: [(\"__init__\", \"fn[[], none]\")],\ntype_vars: []\n}\n",
     "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
 ]

nac3core/src/toplevel/snapshots/nac3core__toplevel__test__test_analyze__self1.snap

@@ -3,11 +3,11 @@ source: nac3core/src/toplevel/test.rs
 expression: res_vec
 ---
 [
-    "Class {\nname: \"A\",\nancestors: [\"A[typevar10, typevar11]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[bool, float], b:B], none]\"), (\"fun\", \"fn[[a:A[bool, float]], A[bool, int32]]\")],\ntype_vars: [\"typevar10\", \"typevar11\"]\n}\n",
-    "Function {\nname: \"A.__init__\",\nsig: \"fn[[a:A[bool, float], b:B], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:A[bool, float]], A[bool, int32]]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B\", \"A[int64, bool]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:A[bool, float]], A[bool, int32]]\"), (\"foo\", \"fn[[b:B], B]\"), (\"bar\", \"fn[[a:A[int32, list[B]]], tuple[A[bool, virtual[A[B, int32]]], B]]\")],\ntype_vars: []\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A[typevar226, typevar227]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar226\", \"typevar227\"]\n}\n",
+    "Function {\nname: \"A.__init__\",\nsig: \"fn[[a:A[float, bool], b:B], none]\",\nvar_id: []\n}\n",
+    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:A[float, bool]], A[bool, int32]]\",\nvar_id: []\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B\", \"A[int64, bool]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\"), (\"foo\", \"fn[[b:B], B]\"), (\"bar\", \"fn[[a:A[list[B], int32]], tuple[A[virtual[A[B, int32]], bool], B]]\")],\ntype_vars: []\n}\n",
     "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
     "Function {\nname: \"B.foo\",\nsig: \"fn[[b:B], B]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"B.bar\",\nsig: \"fn[[a:A[int32, list[B]]], tuple[A[bool, virtual[A[B, int32]]], B]]\",\nvar_id: []\n}\n",
+    "Function {\nname: \"B.bar\",\nsig: \"fn[[a:A[list[B], int32]], tuple[A[virtual[A[B, int32]], bool], B]]\",\nvar_id: []\n}\n",
 ]

nac3core/src/toplevel/snapshots/nac3core__toplevel__test__test_analyze__simple_class_compose.snap

@@ -6,12 +6,12 @@ expression: res_vec
     "Class {\nname: \"A\",\nancestors: [\"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
     "Function {\nname: \"A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
     "Function {\nname: \"A.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [30]\n}\n",
+    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [246]\n}\n",
     "Class {\nname: \"B\",\nancestors: [\"B\", \"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
     "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
     "Class {\nname: \"C\",\nancestors: [\"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
     "Function {\nname: \"C.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
     "Function {\nname: \"C.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
     "Function {\nname: \"foo\",\nsig: \"fn[[a:A], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [38]\n}\n",
+    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [254]\n}\n",
 ]

nac3core/src/toplevel/test.rs

@@ -111,7 +111,7 @@ impl SymbolResolver for Resolver {
     "register"
 )]
 fn test_simple_register(source: Vec<&str>) {
-    let mut composer: TopLevelComposer = Default::default();
+    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
 
     for s in source {
         let ast = parse_program(s, Default::default()).unwrap();
@@ -131,7 +131,7 @@ fn test_simple_register(source: Vec<&str>) {
     "register"
 )]
 fn test_simple_register_without_constructor(source: &str) {
-    let mut composer: TopLevelComposer = Default::default();
+    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
     let ast = parse_program(source, Default::default()).unwrap();
     let ast = ast[0].clone();
     composer.register_top_level(ast, None, "".into(), true).unwrap();
@@ -165,7 +165,7 @@ fn test_simple_register_without_constructor(source: &str) {
     "function compose"
 )]
 fn test_simple_function_analyze(source: Vec<&str>, tys: Vec<&str>, names: Vec<&str>) {
-    let mut composer: TopLevelComposer = Default::default();
+    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
 
     let internal_resolver = Arc::new(ResolverInternal {
         id_to_def: Default::default(),
@@ -513,7 +513,7 @@ fn test_simple_function_analyze(source: Vec<&str>, tys: Vec<&str>, names: Vec<&s
 )]
 fn test_analyze(source: Vec<&str>, res: Vec<&str>) {
     let print = false;
-    let mut composer: TopLevelComposer = Default::default();
+    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
 
     let internal_resolver = make_internal_resolver_with_tvar(
         vec![
@@ -690,7 +690,7 @@ fn test_analyze(source: Vec<&str>, res: Vec<&str>) {
 )]
 fn test_inference(source: Vec<&str>, res: Vec<&str>) {
     let print = true;
-    let mut composer: TopLevelComposer = Default::default();
+    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
 
     let internal_resolver = make_internal_resolver_with_tvar(
         vec![

nac3core/src/toplevel/type_annotation.rs

@@ -1,5 +1,8 @@
 use crate::symbol_resolver::SymbolValue;
+use crate::toplevel::helper::PRIMITIVE_DEF_IDS;
+use crate::typecheck::typedef::VarMap;
 use super::*;
+use nac3parser::ast::Constant;
 
 #[derive(Clone, Debug)]
 pub enum TypeAnnotation {
@@ -13,16 +16,8 @@ pub enum TypeAnnotation {
     // can only be CustomClassKind
     Virtual(Box<TypeAnnotation>),
     TypeVar(Type),
-    /// A constant used in the context of a const-generic variable.
-    Constant {
-        /// The non-type variable associated with this constant.
-        ///
-        /// Invoking [Unifier::get_ty] on this type will return a [TypeEnum::TVar] representing the
-        /// const generic variable of which this constant is associated with.
-        ty: Type,
-        /// The constant value of this constant.
-        value: SymbolValue
-    },
+    /// A `Literal` allowing a subset of literals.
+    Literal(Vec<Constant>),
     List(Box<TypeAnnotation>),
     Tuple(Vec<TypeAnnotation>),
 }
@@ -57,7 +52,7 @@ impl TypeAnnotation {
                     }
                 )
             }
-            Constant { value, .. } => format!("Const({value})"),
+            Literal(values) => format!("Literal({})", values.iter().map(|v| format!("{v:?}")).join(", ")),
             Virtual(ty) => format!("virtual[{}]", ty.stringify(unifier)),
             List(ty) => format!("list[{}]", ty.stringify(unifier)),
             Tuple(types) => {
@@ -81,7 +76,6 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
     expr: &ast::Expr<T>,
     // the key stores the type_var of this topleveldef::class, we only need this field here
     locked: HashMap<DefinitionId, Vec<Type>>,
-    type_var: Option<Type>,
 ) -> Result<TypeAnnotation, HashSet<String>> {
     let name_handle = |id: &StrRef,
                        unifier: &mut Unifier,
@@ -101,7 +95,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
         } else if id == &"str".into() {
             Ok(TypeAnnotation::Primitive(primitives.str))
         } else if id == &"Exception".into() {
-            Ok(TypeAnnotation::CustomClass { id: DefinitionId(7), params: Vec::default() })
+            Ok(TypeAnnotation::CustomClass { id: PRIMITIVE_DEF_IDS.exception, params: Vec::default() })
         } else if let Ok(obj_id) = resolver.get_identifier_def(*id) {
             let type_vars = {
                 let def_read = top_level_defs[obj_id.0].try_read();
@@ -191,8 +185,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 }
                 let result = params_ast
                     .iter()
-                    .enumerate()
-                    .map(|(idx, x)| {
+                    .map(|x| {
                         parse_ast_to_type_annotation_kinds(
                             resolver,
                             top_level_defs,
@@ -203,7 +196,6 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                                 locked.insert(obj_id, type_vars.clone());
                                 locked.clone()
                             },
-                            Some(type_vars[idx]),
                         )
                     })
                     .collect::<Result<Vec<_>, _>>()?;
@@ -239,7 +231,6 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 primitives,
                 slice.as_ref(),
                 locked,
-                None,
             )?;
             if !matches!(def, TypeAnnotation::CustomClass { .. }) {
                 unreachable!("must be concretized custom class kind in the virtual")
@@ -260,7 +251,6 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 primitives,
                 slice.as_ref(),
                 locked,
-                None,
             )?;
             Ok(TypeAnnotation::List(def_ann.into()))
         }
@@ -278,7 +268,6 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 primitives,
                 slice.as_ref(),
                 locked,
-                None,
             )?;
             let id =
                 if let TypeEnum::TObj { obj_id, .. } = unifier.get_ty(primitives.option).as_ref() {
@@ -312,13 +301,58 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                         primitives,
                         e,
                         locked.clone(),
-                        None,
                     )
                 })
                 .collect::<Result<Vec<_>, _>>()?;
             Ok(TypeAnnotation::Tuple(type_annotations))
         }
 
+        // Literal
+        ast::ExprKind::Subscript { value, slice, .. }
+        if {
+            matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"Literal".into())
+        } => {
+            let tup_elts = {
+                if let ast::ExprKind::Tuple { elts, .. } = &slice.node {
+                    elts.as_slice()
+                } else {
+                    std::slice::from_ref(slice.as_ref())
+                }
+            };
+            let type_annotations = tup_elts
+                .iter()
+                .map(|e| {
+                    match &e.node {
+                        ast::ExprKind::Constant { value, .. } => Ok(
+                            TypeAnnotation::Literal(vec![value.clone()]),
+                        ),
+                        _ => parse_ast_to_type_annotation_kinds(
+                            resolver,
+                            top_level_defs,
+                            unifier,
+                            primitives,
+                            e,
+                            locked.clone(),
+                        ),
+                    }
+                })
+                .collect::<Result<Vec<_>, _>>()?
+                .into_iter()
+                .flat_map(|type_ann| match type_ann {
+                    TypeAnnotation::Literal(values) => values,
+                    _ => unreachable!(),
+                })
+                .collect_vec();
+
+            if type_annotations.len() == 1 {
+                Ok(TypeAnnotation::Literal(type_annotations))
+            } else {
+                Err(HashSet::from([
+                    format!("multiple literal bounds are currently unsupported (at {})", value.location)
+                ]))
+            }
+        }
+
         // custom class
         ast::ExprKind::Subscript { value, slice, .. } => {
             if let ast::ExprKind::Name { id, .. } = &value.node {
@@ -331,30 +365,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
         }
 
         ast::ExprKind::Constant { value, .. } => {
-            let type_var = type_var.expect("Expect type variable to be present");
-
-            let ntv_ty_enum = unifier.get_ty_immutable(type_var);
-            let TypeEnum::TVar { range: underlying_ty, .. } = ntv_ty_enum.as_ref() else {
-                unreachable!()
-            };
-            let underlying_ty = underlying_ty[0];
-
-            let value = SymbolValue::from_constant(value, underlying_ty, primitives, unifier)
-                .map_err(|err| HashSet::from([err]))?;
-
-            if matches!(value, SymbolValue::Str(_) | SymbolValue::Tuple(_) | SymbolValue::OptionSome(_)) {
-                return Err(HashSet::from([
-                    format!(
-                        "expression {value} is not allowed for constant type annotation (at {})",
-                        expr.location
-                    ),
-                ]))
-            }
-
-            Ok(TypeAnnotation::Constant {
-                ty: type_var,
-                value,
-            })
+            Ok(TypeAnnotation::Literal(vec![value.clone()]))
         }
 
         _ => Err(HashSet::from([
@@ -390,22 +401,22 @@ pub fn get_type_from_type_annotation_kinds(
                 ]))
             }
 
-                    let param_ty = params
-                        .iter()
-                        .map(|x| {
-                            get_type_from_type_annotation_kinds(
-                                top_level_defs,
-                                unifier,
-                                x,
-                                subst_list
-                            )
-                        })
-                        .collect::<Result<Vec<_>, _>>()?;
+            let param_ty = params
+                .iter()
+                .map(|x| {
+                    get_type_from_type_annotation_kinds(
+                        top_level_defs,
+                        unifier,
+                        x,
+                        subst_list
+                    )
+                })
+                .collect::<Result<Vec<_>, _>>()?;
 
             let subst = {
                 // check for compatible range
                 // TODO: if allow type var to be applied(now this disallowed in the parse_to_type_annotation), need more check
-                let mut result: HashMap<u32, Type> = HashMap::new();
+                let mut result = VarMap::new();
                 for (tvar, p) in type_vars.iter().zip(param_ty) {
                     match unifier.get_ty(*tvar).as_ref() {
                         TypeEnum::TVar { id, range, fields: None, name, loc, is_const_generic: false } => {
@@ -495,14 +506,13 @@ pub fn get_type_from_type_annotation_kinds(
             Ok(ty)
         }
         TypeAnnotation::Primitive(ty) | TypeAnnotation::TypeVar(ty) => Ok(*ty),
-        TypeAnnotation::Constant { ty, value, .. } => {
-            let ty_enum = unifier.get_ty(*ty);
-            let TypeEnum::TVar { range: ntv_underlying_ty, loc, is_const_generic: true, .. } = &*ty_enum else {
-                unreachable!("{} ({})", unifier.stringify(*ty), ty_enum.get_type_name());
-            };
+        TypeAnnotation::Literal(values) => {
+            let values = values.iter()
+                .map(SymbolValue::from_constant_inferred)
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|err| HashSet::from([err]))?;
 
-            let ty = ntv_underlying_ty[0];
-            let var = unifier.get_fresh_constant(value.clone(), ty, *loc);
+            let var = unifier.get_fresh_literal(values, None);
             Ok(var)
         }
         TypeAnnotation::Virtual(ty) => {
@@ -576,7 +586,7 @@ pub fn get_type_var_contained_in_type_annotation(ann: &TypeAnnotation) -> Vec<Ty
                 result.extend(get_type_var_contained_in_type_annotation(a));
             }
         }
-        TypeAnnotation::Primitive(..) | TypeAnnotation::Constant { .. } => {}
+        TypeAnnotation::Primitive(..) | TypeAnnotation::Literal { .. } => {}
     }
     result
 }

nac3core/src/typecheck/function_check.rs

@@ -208,6 +208,27 @@ impl<'a> Inferencer<'a> {
         Ok(())
     }
 
+    /// Check that the return value is a non-`alloca` type, effectively only allowing primitive types.
+    ///
+    /// This is a workaround preventing the caller from using a variable `alloca`-ed in the body, which
+    /// is freed when the function returns.
+    fn check_return_value_ty(&mut self, ret_ty: Type) -> bool {
+        match &*self.unifier.get_ty_immutable(ret_ty) {
+            TypeEnum::TObj { .. } => {
+                [
+                    self.primitives.int32,
+                    self.primitives.int64,
+                    self.primitives.uint32,
+                    self.primitives.uint64,
+                    self.primitives.float,
+                    self.primitives.bool,
+                ].iter().any(|allowed_ty| self.unifier.unioned(ret_ty, *allowed_ty))
+            }
+            TypeEnum::TTuple { ty } => ty.iter().all(|t| self.check_return_value_ty(*t)),
+            _ => false,
+        }
+    }
+
     // check statements for proper identifier def-use and return on all paths
     fn check_stmt(
         &mut self,
@@ -302,6 +323,27 @@ impl<'a> Inferencer<'a> {
                 if let Some(value) = value {
                     self.check_expr(value, defined_identifiers)?;
                     self.should_have_value(value)?;
+
+                    // Check that the return value is a non-`alloca` type, effectively only allowing primitive types.
+                    // This is a workaround preventing the caller from using a variable `alloca`-ed in the body, which
+                    // is freed when the function returns.
+                    if let Some(ret_ty) = value.custom {
+                        // Explicitly allow ellipsis as a return value, as the type of the ellipsis is contextually
+                        // inferred and just generates an unconditional assertion
+                        if matches!(value.node, ExprKind::Constant { value: Constant::Ellipsis, .. }) {
+                            return Ok(true)
+                        }
+
+                        if !self.check_return_value_ty(ret_ty) {
+                            return Err(HashSet::from([
+                                format!(
+                                    "return value of type {} must be a primitive or a tuple of primitives at {}",
+                                    self.unifier.stringify(ret_ty),
+                                    value.location,
+                                ),
+                            ]))
+                        }
+                    }
                 }
                 Ok(true)
             }
@@ -324,7 +366,7 @@ impl<'a> Inferencer<'a> {
         let mut ret = false;
         for stmt in block {
             if ret {
-                eprintln!("warning: dead code at {:?}\n", stmt.location);
+                eprintln!("warning: dead code at {}\n", stmt.location);
             }
             if self.check_stmt(stmt, defined_identifiers)? {
                 ret = true;

nac3core/src/typecheck/magic_methods.rs

@@ -1,11 +1,16 @@
+use std::cmp::max;
+use crate::symbol_resolver::SymbolValue;
+use crate::toplevel::helper::PRIMITIVE_DEF_IDS;
+use crate::toplevel::numpy::{make_ndarray_ty, unpack_ndarray_var_tys};
 use crate::typecheck::{
     type_inferencer::*,
-    typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier},
+    typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
 };
 use nac3parser::ast::StrRef;
 use nac3parser::ast::{Cmpop, Operator, Unaryop};
 use std::collections::HashMap;
 use std::rc::Rc;
+use itertools::Itertools;
 
 #[must_use]
 pub fn binop_name(op: &Operator) -> &'static str {
@@ -90,7 +95,7 @@ pub fn impl_binop(
     _store: &PrimitiveStore,
     ty: Type,
     other_ty: &[Type],
-    ret_ty: Type,
+    ret_ty: Option<Type>,
     ops: &[Operator],
 ) {
     with_fields(unifier, ty, |unifier, fields| {
@@ -102,11 +107,13 @@ pub fn impl_binop(
         };
 
         let function_vars = if let Some(var_id) = other_var_id {
-            vec![(var_id, other_ty)].into_iter().collect::<HashMap<_, _>>()
+            vec![(var_id, other_ty)].into_iter().collect::<VarMap>()
         } else {
-            HashMap::new()
+            VarMap::new()
         };
 
+        let ret_ty = ret_ty.unwrap_or_else(|| unifier.get_fresh_var(None, None).0);
+
         for op in ops {
             fields.insert(binop_name(op).into(), {
                 (
@@ -141,15 +148,17 @@ pub fn impl_binop(
     });
 }
 
-pub fn impl_unaryop(unifier: &mut Unifier, ty: Type, ret_ty: Type, ops: &[Unaryop]) {
+pub fn impl_unaryop(unifier: &mut Unifier, ty: Type, ret_ty: Option<Type>, ops: &[Unaryop]) {
     with_fields(unifier, ty, |unifier, fields| {
+        let ret_ty = ret_ty.unwrap_or_else(|| unifier.get_fresh_var(None, None).0);
+
         for op in ops {
             fields.insert(
                 unaryop_name(op).into(),
                 (
                     unifier.add_ty(TypeEnum::TFunc(FunSignature {
                         ret: ret_ty,
-                        vars: HashMap::new(),
+                        vars: VarMap::new(),
                         args: vec![],
                     })),
                     false,
@@ -161,19 +170,35 @@ pub fn impl_unaryop(unifier: &mut Unifier, ty: Type, ret_ty: Type, ops: &[Unaryo
 
 pub fn impl_cmpop(
     unifier: &mut Unifier,
-    store: &PrimitiveStore,
+    _store: &PrimitiveStore,
     ty: Type,
-    other_ty: Type,
+    other_ty: &[Type],
     ops: &[Cmpop],
+    ret_ty: Option<Type>,
 ) {
     with_fields(unifier, ty, |unifier, fields| {
+        let (other_ty, other_var_id) = if other_ty.len() == 1 {
+            (other_ty[0], None)
+        } else {
+            let (ty, var_id) = unifier.get_fresh_var_with_range(other_ty, Some("N".into()), None);
+            (ty, Some(var_id))
+        };
+
+        let function_vars = if let Some(var_id) = other_var_id {
+            vec![(var_id, other_ty)].into_iter().collect::<VarMap>()
+        } else {
+            VarMap::new()
+        };
+
+        let ret_ty = ret_ty.unwrap_or_else(|| unifier.get_fresh_var(None, None).0);
+
         for op in ops {
             fields.insert(
                 comparison_name(op).unwrap().into(),
                 (
                     unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                        ret: store.bool,
-                        vars: HashMap::new(),
+                        ret: ret_ty,
+                        vars: function_vars.clone(),
                         args: vec![FuncArg {
                             ty: other_ty,
                             default_value: None,
@@ -193,7 +218,7 @@ pub fn impl_basic_arithmetic(
     store: &PrimitiveStore,
     ty: Type,
     other_ty: &[Type],
-    ret_ty: Type,
+    ret_ty: Option<Type>,
 ) {
     impl_binop(
         unifier,
@@ -211,7 +236,7 @@ pub fn impl_pow(
     store: &PrimitiveStore,
     ty: Type,
     other_ty: &[Type],
-    ret_ty: Type,
+    ret_ty: Option<Type>,
 ) {
     impl_binop(unifier, store, ty, other_ty, ret_ty, &[Operator::Pow]);
 }
@@ -223,19 +248,25 @@ pub fn impl_bitwise_arithmetic(unifier: &mut Unifier, store: &PrimitiveStore, ty
         store,
         ty,
         &[ty],
-        ty,
+        Some(ty),
         &[Operator::BitAnd, Operator::BitOr, Operator::BitXor],
     );
 }
 
 /// `LShift`, `RShift`
 pub fn impl_bitwise_shift(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_binop(unifier, store, ty, &[store.int32, store.uint32], ty, &[Operator::LShift, Operator::RShift]);
+    impl_binop(unifier, store, ty, &[store.int32, store.uint32], Some(ty), &[Operator::LShift, Operator::RShift]);
 }
 
 /// `Div`
-pub fn impl_div(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: &[Type]) {
-    impl_binop(unifier, store, ty, other_ty, store.float, &[Operator::Div]);
+pub fn impl_div(
+    unifier: &mut Unifier,
+    store: &PrimitiveStore,
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Option<Type>,
+) {
+    impl_binop(unifier, store, ty, other_ty, ret_ty, &[Operator::Div]);
 }
 
 /// `FloorDiv`
@@ -244,7 +275,7 @@ pub fn impl_floordiv(
     store: &PrimitiveStore,
     ty: Type,
     other_ty: &[Type],
-    ret_ty: Type,
+    ret_ty: Option<Type>,
 ) {
     impl_binop(unifier, store, ty, other_ty, ret_ty, &[Operator::FloorDiv]);
 }
@@ -255,40 +286,308 @@ pub fn impl_mod(
     store: &PrimitiveStore,
     ty: Type,
     other_ty: &[Type],
-    ret_ty: Type,
+    ret_ty: Option<Type>,
 ) {
     impl_binop(unifier, store, ty, other_ty, ret_ty, &[Operator::Mod]);
 }
 
+/// [`Operator::MatMult`]
+pub fn impl_matmul(
+    unifier: &mut Unifier,
+    store: &PrimitiveStore,
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Option<Type>, 
+) {
+    impl_binop(unifier, store, ty, other_ty, ret_ty, &[Operator::MatMult]);
+}
+
 /// `UAdd`, `USub`
-pub fn impl_sign(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type) {
-    impl_unaryop(unifier, ty, ty, &[Unaryop::UAdd, Unaryop::USub]);
+pub fn impl_sign(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type, ret_ty: Option<Type>) {
+    impl_unaryop(unifier, ty, ret_ty, &[Unaryop::UAdd, Unaryop::USub]);
 }
 
 /// `Invert`
-pub fn impl_invert(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type) {
-    impl_unaryop(unifier, ty, ty, &[Unaryop::Invert]);
+pub fn impl_invert(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type, ret_ty: Option<Type>) {
+    impl_unaryop(unifier, ty, ret_ty, &[Unaryop::Invert]);
 }
 
 /// `Not`
-pub fn impl_not(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_unaryop(unifier, ty, store.bool, &[Unaryop::Not]);
+pub fn impl_not(unifier: &mut Unifier, _store: &PrimitiveStore, ty: Type, ret_ty: Option<Type>) {
+    impl_unaryop(unifier, ty, ret_ty, &[Unaryop::Not]);
 }
 
 /// `Lt`, `LtE`, `Gt`, `GtE`
-pub fn impl_comparison(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type, other_ty: Type) {
+pub fn impl_comparison(
+    unifier: &mut Unifier,
+    store: &PrimitiveStore,
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Option<Type>,
+) {
     impl_cmpop(
         unifier,
         store,
         ty,
         other_ty,
         &[Cmpop::Lt, Cmpop::Gt, Cmpop::LtE, Cmpop::GtE],
+        ret_ty,
     );
 }
 
 /// `Eq`, `NotEq`
-pub fn impl_eq(unifier: &mut Unifier, store: &PrimitiveStore, ty: Type) {
-    impl_cmpop(unifier, store, ty, ty, &[Cmpop::Eq, Cmpop::NotEq]);
+pub fn impl_eq(
+    unifier: &mut Unifier,
+    store: &PrimitiveStore,
+    ty: Type,
+    other_ty: &[Type],
+    ret_ty: Option<Type>,
+) {
+    impl_cmpop(unifier, store, ty, other_ty, &[Cmpop::Eq, Cmpop::NotEq], ret_ty);
+}
+
+/// Returns the expected return type of binary operations with at least one `ndarray` operand.
+pub fn typeof_ndarray_broadcast(
+    unifier: &mut Unifier,
+    primitives: &PrimitiveStore,
+    left: Type,
+    right: Type,
+) -> Result<Type, String> {
+    let is_left_ndarray = left.obj_id(unifier).is_some_and(|id| id ==  PRIMITIVE_DEF_IDS.ndarray);
+    let is_right_ndarray = right.obj_id(unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray);
+
+    assert!(is_left_ndarray || is_right_ndarray);
+
+    if is_left_ndarray && is_right_ndarray {
+        // Perform broadcasting on two ndarray operands.
+
+        let (left_ty_dtype, left_ty_ndims) = unpack_ndarray_var_tys(unifier, left);
+        let (right_ty_dtype, right_ty_ndims) = unpack_ndarray_var_tys(unifier, right);
+
+        assert!(unifier.unioned(left_ty_dtype, right_ty_dtype));
+
+        let left_ty_ndims = match &*unifier.get_ty_immutable(left_ty_ndims) {
+            TypeEnum::TLiteral { values, .. } => values.clone(),
+            _ => unreachable!(),
+        };
+        let right_ty_ndims = match &*unifier.get_ty_immutable(right_ty_ndims) {
+            TypeEnum::TLiteral { values, .. } => values.clone(),
+            _ => unreachable!(),
+        };
+
+        let res_ndims = left_ty_ndims.into_iter()
+            .cartesian_product(right_ty_ndims)
+            .map(|(left, right)| {
+                let left_val = u64::try_from(left).unwrap();
+                let right_val = u64::try_from(right).unwrap();
+
+                max(left_val, right_val)
+            })
+            .unique()
+            .map(SymbolValue::U64)
+            .collect_vec();
+        let res_ndims = unifier.get_fresh_literal(res_ndims, None);
+
+        Ok(make_ndarray_ty(unifier, primitives, Some(left_ty_dtype), Some(res_ndims)))
+    } else {
+        let (ndarray_ty, scalar_ty) = if is_left_ndarray {
+            (left, right)
+        } else {
+            (right, left)
+        };
+
+        let (ndarray_ty_dtype, _) = unpack_ndarray_var_tys(unifier, ndarray_ty);
+
+        if unifier.unioned(ndarray_ty_dtype, scalar_ty) {
+            Ok(ndarray_ty)
+        } else {
+            let (expected_ty, actual_ty) = if is_left_ndarray {
+                (ndarray_ty_dtype, scalar_ty)
+            } else {
+                (scalar_ty, ndarray_ty_dtype)
+            };
+
+            Err(format!(
+                "Expected right-hand side operand to be {}, got {}",
+                unifier.stringify(expected_ty),
+                unifier.stringify(actual_ty),
+            ))
+        }
+    }
+}
+
+/// Returns the return type given a binary operator and its primitive operands.
+pub fn typeof_binop(
+    unifier: &mut Unifier,
+    primitives: &PrimitiveStore,
+    op: &Operator,
+    lhs: Type,
+    rhs: Type,
+) -> Result<Option<Type>, String> {
+    let is_left_ndarray = lhs.obj_id(unifier).is_some_and(|id| id ==  PRIMITIVE_DEF_IDS.ndarray);
+    let is_right_ndarray = rhs.obj_id(unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray);
+
+    Ok(Some(match op {
+        Operator::Add
+        | Operator::Sub
+        | Operator::Mult
+        | Operator::Mod
+        | Operator::FloorDiv => {
+            if is_left_ndarray || is_right_ndarray {
+                typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?
+            } else if unifier.unioned(lhs, rhs) {
+                lhs
+            } else {
+                return Ok(None)
+            }
+        }
+
+        Operator::MatMult => {
+            let (_, lhs_ndims) = unpack_ndarray_var_tys(unifier, lhs);
+            let lhs_ndims = match &*unifier.get_ty_immutable(lhs_ndims) {
+                TypeEnum::TLiteral { values, .. } => {
+                    assert_eq!(values.len(), 1);
+                    u64::try_from(values[0].clone()).unwrap()
+                }
+                _ => unreachable!(),
+            };
+            let (_, rhs_ndims) = unpack_ndarray_var_tys(unifier, rhs);
+            let rhs_ndims = match &*unifier.get_ty_immutable(rhs_ndims) {
+                TypeEnum::TLiteral { values, .. } => {
+                    assert_eq!(values.len(), 1);
+                    u64::try_from(values[0].clone()).unwrap()
+                }
+                _ => unreachable!(),
+            };
+
+            match (lhs_ndims, rhs_ndims) {
+                (2, 2) => typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?,
+                (lhs, rhs) if lhs == 0 || rhs == 0 => {
+                    return Err(format!(
+                        "Input operand {} does not have enough dimensions (has {lhs}, requires {rhs})",
+                        (rhs == 0) as u8
+                    ))
+                }
+                (lhs, rhs) => {
+                    return Err(format!("ndarray.__matmul__ on {lhs}D and {rhs}D operands not supported"))
+                }
+            }
+        }
+
+        Operator::Div => {
+            if is_left_ndarray || is_right_ndarray {
+                typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?
+            } else if unifier.unioned(lhs, rhs) {
+                primitives.float
+            } else {
+                return Ok(None)
+            }
+        }
+
+        Operator::Pow => {
+            if is_left_ndarray || is_right_ndarray {
+                typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?
+            } else if [primitives.int32, primitives.int64, primitives.uint32, primitives.uint64, primitives.float].into_iter().any(|ty| unifier.unioned(lhs, ty)) {
+                lhs
+            } else {
+                return Ok(None)
+            }
+        }
+
+        Operator::LShift
+        | Operator::RShift => lhs,
+        Operator::BitOr
+        | Operator::BitXor
+        | Operator::BitAnd => {
+            if unifier.unioned(lhs, rhs) {
+                lhs
+            } else {
+                return Ok(None)
+            }
+        }
+    }))
+}
+
+pub fn typeof_unaryop(
+    unifier: &mut Unifier,
+    primitives: &PrimitiveStore,
+    op: &Unaryop,
+    operand: Type,
+) -> Result<Option<Type>, String> {
+    let operand_obj_id = operand.obj_id(unifier);
+
+    if *op == Unaryop::Not && operand_obj_id.is_some_and(|id| id == primitives.ndarray.obj_id(unifier).unwrap()) {
+        return Err("The truth value of an array with more than one element is ambiguous".to_string())
+    }
+
+    Ok(match *op {
+        Unaryop::Not => {
+            match operand_obj_id {
+                Some(v) if v == PRIMITIVE_DEF_IDS.ndarray => Some(operand),
+                Some(_) => Some(primitives.bool),
+                _ => None
+            }
+        }
+
+        Unaryop::Invert => {
+            if operand_obj_id.is_some_and(|id| id == PRIMITIVE_DEF_IDS.bool) {
+                Some(primitives.int32)
+            } else if operand_obj_id.is_some_and(|id| PRIMITIVE_DEF_IDS.iter().any(|prim_id| id == prim_id)) {
+                Some(operand)
+            } else {
+                None
+            }
+        }
+
+        Unaryop::UAdd
+        | Unaryop::USub => {
+            if operand_obj_id.is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray) {
+                let (dtype, _) = unpack_ndarray_var_tys(unifier, operand);
+                if dtype.obj_id(unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.bool) {
+                    return Err(if *op == Unaryop::UAdd {
+                        "The ufunc 'positive' cannot be applied to ndarray[bool, N]".to_string()
+                    } else {
+                        "The numpy boolean negative, the `-` operator, is not supported, use the `~` operator function instead.".to_string()
+                    })
+                }
+
+                Some(operand)
+            } else if operand_obj_id.is_some_and(|id| id == PRIMITIVE_DEF_IDS.bool) {
+                Some(primitives.int32)
+            } else if operand_obj_id.is_some_and(|id| PRIMITIVE_DEF_IDS.iter().any(|prim_id| id == prim_id)) {
+                Some(operand)
+            } else {
+                None
+            }
+        }
+    })
+}
+
+/// Returns the return type given a comparison operator and its primitive operands.
+pub fn typeof_cmpop(
+    unifier: &mut Unifier,
+    primitives: &PrimitiveStore,
+    _op: &Cmpop,
+    lhs: Type,
+    rhs: Type,
+) -> Result<Option<Type>, String> {
+    let is_left_ndarray = lhs
+        .obj_id(unifier)
+        .is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray);
+    let is_right_ndarray = rhs
+        .obj_id(unifier)
+        .is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray);
+
+    Ok(Some(if is_left_ndarray || is_right_ndarray {
+        let brd = typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?;
+        let (_, ndims) = unpack_ndarray_var_tys(unifier, brd);
+
+        make_ndarray_ty(unifier, primitives, Some(primitives.bool), Some(ndims))
+    } else if unifier.unioned(lhs, rhs) {
+        primitives.bool
+    } else {
+        return Ok(None)
+    }))
 }
 
 pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifier) {
@@ -299,39 +598,63 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
         bool: bool_t,
         uint32: uint32_t,
         uint64: uint64_t,
+        ndarray: ndarray_t,
         ..
     } = *store;
+    let size_t = store.usize();
 
     /* int ======== */
     for t in [int32_t, int64_t, uint32_t, uint64_t] {
-        impl_basic_arithmetic(unifier, store, t, &[t], t);
-        impl_pow(unifier, store, t, &[t], t);
+        let ndarray_int_t = make_ndarray_ty(unifier, store, Some(t), None);
+        impl_basic_arithmetic(unifier, store, t, &[t, ndarray_int_t], None);
+        impl_pow(unifier, store, t, &[t, ndarray_int_t], None);
         impl_bitwise_arithmetic(unifier, store, t);
         impl_bitwise_shift(unifier, store, t);
-        impl_div(unifier, store, t, &[t]);
-        impl_floordiv(unifier, store, t, &[t], t);
-        impl_mod(unifier, store, t, &[t], t);
-        impl_invert(unifier, store, t);
-        impl_not(unifier, store, t);
-        impl_comparison(unifier, store, t, t);
-        impl_eq(unifier, store, t);
+        impl_div(unifier, store, t, &[t, ndarray_int_t], None);
+        impl_floordiv(unifier, store, t, &[t, ndarray_int_t], None);
+        impl_mod(unifier, store, t, &[t, ndarray_int_t], None);
+        impl_invert(unifier, store, t, Some(t));
+        impl_not(unifier, store, t, Some(bool_t));
+        impl_comparison(unifier, store, t, &[t, ndarray_int_t], None);
+        impl_eq(unifier, store, t, &[t, ndarray_int_t], None);
     }
     for t in [int32_t, int64_t] {
-        impl_sign(unifier, store, t);
+        impl_sign(unifier, store, t, Some(t));
     }
 
     /* float ======== */
-    impl_basic_arithmetic(unifier, store, float_t, &[float_t], float_t);
-    impl_pow(unifier, store, float_t, &[int32_t, float_t], float_t);
-    impl_div(unifier, store, float_t, &[float_t]);
-    impl_floordiv(unifier, store, float_t, &[float_t], float_t);
-    impl_mod(unifier, store, float_t, &[float_t], float_t);
-    impl_sign(unifier, store, float_t);
-    impl_not(unifier, store, float_t);
-    impl_comparison(unifier, store, float_t, float_t);
-    impl_eq(unifier, store, float_t);
+    let ndarray_float_t = make_ndarray_ty(unifier, store, Some(float_t), None);
+    let ndarray_int32_t = make_ndarray_ty(unifier, store, Some(int32_t), None);
+    impl_basic_arithmetic(unifier, store, float_t, &[float_t, ndarray_float_t], None);
+    impl_pow(unifier, store, float_t, &[int32_t, float_t, ndarray_int32_t, ndarray_float_t], None);
+    impl_div(unifier, store, float_t, &[float_t, ndarray_float_t], None);
+    impl_floordiv(unifier, store, float_t, &[float_t, ndarray_float_t], None);
+    impl_mod(unifier, store, float_t, &[float_t, ndarray_float_t], None);
+    impl_sign(unifier, store, float_t, Some(float_t));
+    impl_not(unifier, store, float_t, Some(bool_t));
+    impl_comparison(unifier, store, float_t, &[float_t, ndarray_float_t], None);
+    impl_eq(unifier, store, float_t, &[float_t, ndarray_float_t], None);
 
     /* bool ======== */
-    impl_not(unifier, store, bool_t);
-    impl_eq(unifier, store, bool_t);
+    let ndarray_bool_t = make_ndarray_ty(unifier, store, Some(bool_t), None);
+    impl_invert(unifier, store, bool_t, Some(int32_t));
+    impl_not(unifier, store, bool_t, Some(bool_t));
+    impl_sign(unifier, store, bool_t, Some(int32_t));
+    impl_eq(unifier, store, bool_t, &[bool_t, ndarray_bool_t], None);
+
+    /* ndarray ===== */
+    let ndarray_usized_ndims_tvar = unifier.get_fresh_const_generic_var(size_t, Some("ndarray_ndims".into()), None);
+    let ndarray_unsized_t = make_ndarray_ty(unifier, store, None, Some(ndarray_usized_ndims_tvar.0));
+    let (ndarray_dtype_t, _) = unpack_ndarray_var_tys(unifier, ndarray_t);
+    let (ndarray_unsized_dtype_t, _) = unpack_ndarray_var_tys(unifier, ndarray_unsized_t);
+    impl_basic_arithmetic(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
+    impl_pow(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
+    impl_div(unifier, store, ndarray_t, &[ndarray_t, ndarray_dtype_t], None);
+    impl_floordiv(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
+    impl_mod(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
+    impl_matmul(unifier, store, ndarray_t, &[ndarray_t], Some(ndarray_t));
+    impl_sign(unifier, store, ndarray_t, Some(ndarray_t));
+    impl_invert(unifier, store, ndarray_t, Some(ndarray_t));
+    impl_eq(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
+    impl_comparison(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
 }

nac3core/src/typecheck/type_inferencer/mod.rs

@@ -3,15 +3,18 @@ use std::convert::{From, TryInto};
 use std::iter::once;
 use std::{cell::RefCell, sync::Arc};
 
-use super::typedef::{Call, FunSignature, FuncArg, RecordField, Type, TypeEnum, Unifier};
-use super::{magic_methods::*, typedef::CallId};
-use crate::{symbol_resolver::SymbolResolver, toplevel::TopLevelContext};
-use itertools::izip;
-use nac3parser::ast::{
-    self,
-    fold::{self, Fold},
-    Arguments, Comprehension, ExprContext, ExprKind, Located, Location, StrRef,
+use super::typedef::{Call, FunSignature, FuncArg, RecordField, Type, TypeEnum, Unifier, VarMap};
+use super::{magic_methods::*, type_error::TypeError, typedef::CallId};
+use crate::{
+    symbol_resolver::{SymbolResolver, SymbolValue}, 
+    toplevel::{
+        helper::PRIMITIVE_DEF_IDS,
+        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
+        TopLevelContext,
+    },
 };
+use itertools::{Itertools, izip};
+use nac3parser::ast::{self, fold::{self, Fold}, Arguments, Comprehension, ExprContext, ExprKind, Located, Location, StrRef};
 
 #[cfg(test)]
 mod test;
@@ -41,6 +44,30 @@ pub struct PrimitiveStore {
     pub str: Type,
     pub exception: Type,
     pub option: Type,
+    pub ndarray: Type,
+    pub size_t: u32,
+}
+
+impl PrimitiveStore {
+    /// Returns a [`Type`] representing a signed representation of `size_t`.
+    #[must_use]
+    pub fn isize(&self) -> Type {
+        match self.size_t {
+            32 => self.int32,
+            64 => self.int64,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Returns a [Type] representing `size_t`.
+    #[must_use]
+    pub fn usize(&self) -> Type {
+        match self.size_t {
+            32 => self.uint32,
+            64 => self.uint64,
+            _ => unreachable!(),
+        }
+    }
 }
 
 pub struct FunctionData {
@@ -205,8 +232,12 @@ impl<'a> Fold<()> for Inferencer<'a> {
                 if self.unifier.unioned(iter.custom.unwrap(), self.primitives.range) {
                     self.unify(self.primitives.int32, target.custom.unwrap(), &target.location)?;
                 } else {
-                    let list = self.unifier.add_ty(TypeEnum::TList { ty: target.custom.unwrap() });
-                    self.unify(list, iter.custom.unwrap(), &iter.location)?;
+                    let list_like_ty = match &*self.unifier.get_ty(iter.custom.unwrap()) {
+                        TypeEnum::TList { .. } => self.unifier.add_ty(TypeEnum::TList { ty: target.custom.unwrap() }),
+                        TypeEnum::TObj { obj_id, .. } if *obj_id == PRIMITIVE_DEF_IDS.ndarray => todo!(),
+                        _ => unreachable!(),
+                    };
+                    self.unify(list_like_ty, iter.custom.unwrap(), &iter.location)?;
                 }
                 let body =
                     body.into_iter().map(|b| self.fold_stmt(b)).collect::<Result<Vec<_>, _>>()?;
@@ -394,13 +425,13 @@ impl<'a> Fold<()> for Inferencer<'a> {
                                 || self.unifier.get_dummy_var().0,
                                 |var| var.custom.unwrap(),
                             ),
-                            vars: HashMap::default(),
+                            vars: VarMap::default(),
                         });
                         let enter = self.unifier.add_ty(enter);
                         let exit = TypeEnum::TFunc(FunSignature {
                             args: vec![],
                             ret: self.unifier.get_dummy_var().0,
-                            vars: HashMap::default(),
+                            vars: VarMap::default(),
                         });
                         let exit = self.unifier.add_ty(exit);
                         let mut fields = HashMap::new();
@@ -472,7 +503,7 @@ impl<'a> Fold<()> for Inferencer<'a> {
                                 assert_eq!(*id, *id_var);
                                 (*id, self.unifier.get_fresh_var_with_range(range, *name, *loc).0)
                             })
-                            .collect::<HashMap<_, _>>();
+                            .collect::<VarMap>();
                         Some(self.unifier.subst(self.primitives.option, &var_map).unwrap())
                     } else {
                         unreachable!("must be tobj")
@@ -508,9 +539,11 @@ impl<'a> Fold<()> for Inferencer<'a> {
             ExprKind::BinOp { left, op, right } => {
                 Some(self.infer_bin_ops(expr.location, left, op, right, false)?)
             }
-            ExprKind::UnaryOp { op, operand } => Some(self.infer_unary_ops(op, operand)?),
+            ExprKind::UnaryOp { op, operand } => {
+                Some(self.infer_unary_ops(expr.location, op, operand)?)
+            }
             ExprKind::Compare { left, ops, comparators } => {
-                Some(self.infer_compare(left, ops, comparators)?)
+                Some(self.infer_compare(expr.location, left, ops, comparators)?)
             }
             ExprKind::Subscript { value, slice, ctx, .. } => {
                 Some(self.infer_subscript(value.as_ref(), slice.as_ref(), ctx)?)
@@ -585,7 +618,14 @@ impl<'a> Inferencer<'a> {
                                 loc: Some(location),
                             };
                             if let Some(ret) = ret {
-                                self.unifier.unify(sign.ret, ret).unwrap();
+                                self.unifier.unify(sign.ret, ret)
+                                    .map_err(|err| {
+                                        format!("Cannot unify {} <: {} - {:?}",
+                                                self.unifier.stringify(sign.ret),
+                                                self.unifier.stringify(ret),
+                                                TypeError::new(err.kind, Some(location)))
+                                    })
+                                    .unwrap();
                             }
                             let required: Vec<_> = sign
                                 .args
@@ -673,7 +713,7 @@ impl<'a> Inferencer<'a> {
                 .map(|(k, ty)| FuncArg { name: *k, ty: *ty, default_value: None })
                 .collect(),
             ret,
-            vars: HashMap::default(),
+            vars: VarMap::default(),
         };
         let body = new_context.fold_expr(body)?;
         new_context.unify(fun.ret, body.custom.unwrap(), &location)?;
@@ -761,6 +801,458 @@ impl<'a> Inferencer<'a> {
         })
     }
 
+    /// Tries to fold a special call. Returns [`Some`] if the call expression `func` is a special call, otherwise
+    /// returns [`None`].
+    fn try_fold_special_call(
+        &mut self,
+        location: Location,
+        func: &ast::Expr<()>,
+        args: &mut Vec<ast::Expr<()>>,
+        keywords: &Vec<Located<ast::KeywordData>>,
+    ) -> Result<Option<ast::Expr<Option<Type>>>, HashSet<String>> {
+        let Located { location: func_location, node: ExprKind::Name { id, ctx }, .. } = func else {
+            return Ok(None)
+        };
+
+        // handle special functions that cannot be typed in the usual way...
+        if id == &"virtual".into() {
+            if args.is_empty() || args.len() > 2 || !keywords.is_empty() {
+                return report_error(
+                    "`virtual` can only accept 1/2 positional arguments",
+                    *func_location,
+                )
+            }
+            let arg0 = self.fold_expr(args.remove(0))?;
+            let ty = if let Some(arg) = args.pop() {
+                let top_level_defs = self.top_level.definitions.read();
+                self.function_data.resolver.parse_type_annotation(
+                    top_level_defs.as_slice(),
+                    self.unifier,
+                    self.primitives,
+                    &arg,
+                )?
+            } else {
+                self.unifier.get_dummy_var().0
+            };
+            self.virtual_checks.push((arg0.custom.unwrap(), ty, *func_location));
+            let custom = Some(self.unifier.add_ty(TypeEnum::TVirtual { ty }));
+            return Ok(Some(Located {
+                location,
+                custom,
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: None,
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: ctx.clone() },
+                    }),
+                    args: vec![arg0],
+                    keywords: vec![],
+                },
+            }))
+        }
+
+        if [
+            "int32",
+            "float",
+            "bool",
+            "round",
+            "round64",
+            "np_isnan",
+            "np_isinf",
+        ].iter().any(|fun_id| id == &(*fun_id).into()) && args.len() == 1 {
+            let target_ty = if id == &"int32".into() || id == &"round".into() || id == &"floor".into() || id == &"ceil".into() {
+                self.primitives.int32
+            } else if id == &"round64".into() || id == &"floor64".into() || id == &"ceil64".into() {
+                self.primitives.int64
+            } else if id == &"float".into() {
+                self.primitives.float
+            } else if id == &"bool".into() || id == &"np_isnan".into() || id == &"np_isinf".into() {
+                self.primitives.bool
+            } else { unreachable!() };
+
+            let arg0 = self.fold_expr(args.remove(0))?;
+            let arg0_ty = arg0.custom.unwrap();
+
+            let ret = if arg0_ty.obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray) {
+                let (_, ndarray_ndims) = unpack_ndarray_var_tys(self.unifier, arg0_ty);
+
+                make_ndarray_ty(self.unifier, self.primitives, Some(target_ty), Some(ndarray_ndims))
+            } else {
+                target_ty
+            };
+
+            let custom = self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                args: vec![
+                    FuncArg {
+                        name: "n".into(),
+                        ty: arg0.custom.unwrap(),
+                        default_value: None,
+                    },
+                ],
+                ret,
+                vars: VarMap::new(),
+            }));
+
+            return Ok(Some(Located {
+                location,
+                custom: Some(ret),
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: Some(custom),
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: ctx.clone() },
+                    }),
+                    args: vec![arg0],
+                    keywords: vec![],
+                },
+            }))
+        }
+
+        if [
+            "np_min",
+            "np_max",
+        ].iter().any(|fun_id| id == &(*fun_id).into()) && args.len() == 1 {
+            let arg0 = self.fold_expr(args.remove(0))?;
+            let arg0_ty = arg0.custom.unwrap();
+
+            let ret = if arg0_ty.obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray) {
+                let (ndarray_dtype, _) = unpack_ndarray_var_tys(self.unifier, arg0_ty);
+
+                ndarray_dtype
+            } else {
+                arg0_ty
+            };
+
+            let custom = self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                args: vec![
+                    FuncArg {
+                        name: "a".into(),
+                        ty: arg0.custom.unwrap(),
+                        default_value: None,
+                    },
+                ],
+                ret,
+                vars: VarMap::new(),
+            }));
+
+            return Ok(Some(Located {
+                location,
+                custom: Some(ret),
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: Some(custom),
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: ctx.clone() },
+                    }),
+                    args: vec![arg0],
+                    keywords: vec![],
+                },
+            }))
+        }
+
+        if [
+            "np_minimum",
+            "np_maximum",
+            "np_arctan2",
+            "np_copysign",
+            "np_fmax",
+            "np_fmin",
+            "np_ldexp",
+            "np_hypot",
+            "np_nextafter",
+        ].iter().any(|fun_id| id == &(*fun_id).into()) && args.len() == 2 {
+            let arg0 = self.fold_expr(args.remove(0))?;
+            let arg0_ty = arg0.custom.unwrap();
+            let arg1 = self.fold_expr(args.remove(0))?;
+            let arg1_ty = arg1.custom.unwrap();
+
+            let arg0_dtype = if arg0_ty.obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray) {
+                unpack_ndarray_var_tys(self.unifier, arg0_ty).0
+            } else {
+                arg0_ty
+            };
+
+            let arg1_dtype = if arg1_ty.obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray) {
+                unpack_ndarray_var_tys(self.unifier, arg1_ty).0
+            } else {
+                arg1_ty
+            };
+
+            let expected_arg1_dtype = if id == &"np_ldexp".into() {
+                self.primitives.int32
+            } else {
+                arg0_dtype
+            };
+            if !self.unifier.unioned(arg1_dtype, expected_arg1_dtype) {
+                return report_error(
+                    format!(
+                        "Expected broadcast-compatible type of ndarray[{}, N] for second argument of {id}, got {}",
+                        self.unifier.stringify(expected_arg1_dtype),
+                        self.unifier.stringify(arg1_dtype),
+                    ).as_str(),
+                    arg0.location,
+                )
+            }
+
+            let target_ty = if id == &"np_minimum".into() || id == &"np_maximum".into() {
+                arg0_dtype
+            } else {
+                self.primitives.float
+            };
+
+            let ret = if [
+                &arg0_ty,
+                &arg1_ty,
+            ].into_iter().any(|arg_ty| arg_ty.obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray)) {
+                // typeof_ndarray_broadcast requires both dtypes to be the same, but ldexp accepts
+                // (float, int32), so convert it to align with the dtype of the first arg
+                let arg1_ty = if id == &"np_ldexp".into() {
+                    if arg1_ty.obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray) {
+                        let (_, ndims) = unpack_ndarray_var_tys(self.unifier, arg1_ty);
+
+                        make_ndarray_ty(self.unifier, self.primitives, Some(target_ty), Some(ndims))
+                    } else {
+                        target_ty
+                    }
+                } else {
+                    arg1_ty
+                };
+
+                match typeof_ndarray_broadcast(self.unifier, self.primitives, arg0_ty, arg1_ty) {
+                    Ok(broadcasted_ty) => broadcasted_ty,
+                    Err(err) => return report_error(err.as_str(), location),
+                }
+            } else {
+                target_ty
+            };
+
+            let custom = self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                args: vec![
+                    FuncArg {
+                        name: "x1".into(),
+                        ty: arg0.custom.unwrap(),
+                        default_value: None,
+                    },
+                    FuncArg {
+                        name: "x2".into(),
+                        ty: arg1.custom.unwrap(),
+                        default_value: None,
+                    },
+                ],
+                ret,
+                vars: VarMap::new(),
+            }));
+
+            return Ok(Some(Located {
+                location,
+                custom: Some(ret),
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: Some(custom),
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: ctx.clone() },
+                    }),
+                    args: vec![arg0, arg1],
+                    keywords: vec![],
+                },
+            }))
+        }
+
+        // int64, uint32 and uint64 are special because their argument can be a constant outside the 
+        // range of int32s
+        if [
+            "int64",
+            "uint32",
+            "uint64",
+        ].iter().any(|fun_id| id == &(*fun_id).into()) && args.len() == 1 {
+            let target_ty = if id == &"int64".into() {
+                self.primitives.int64
+            } else if id == &"uint32".into() {
+                self.primitives.uint32
+            } else if id == &"uint64".into() {
+                self.primitives.uint64
+            } else { unreachable!() };
+
+            // Handle constants first to ensure that their types are not defaulted to int32, which
+            // causes an "Integer out of bound" error
+            if let ExprKind::Constant { 
+                value: ast::Constant::Int(val),
+                kind 
+            } = &args[0].node {
+                let conv_is_ok = if self.unifier.unioned(target_ty, self.primitives.int64) {
+                    i64::try_from(*val).is_ok()
+                } else if self.unifier.unioned(target_ty, self.primitives.uint32) {
+                    u32::try_from(*val).is_ok()
+                } else if self.unifier.unioned(target_ty, self.primitives.uint64) {
+                    u64::try_from(*val).is_ok()
+                } else { unreachable!() };
+        
+                return if conv_is_ok {
+                    Ok(Some(Located {
+                        location: args[0].location,
+                        custom: Some(target_ty),
+                        node: ExprKind::Constant {
+                            value: ast::Constant::Int(*val),
+                            kind: kind.clone(),
+                        },
+                    }))
+                } else {
+                    report_error("Integer out of bound", args[0].location)
+                }
+            }
+
+            let arg0 = self.fold_expr(args.remove(0))?;
+            let arg0_ty = arg0.custom.unwrap();
+
+            let ret = if arg0_ty.obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray) {
+                let (_, ndarray_ndims) = unpack_ndarray_var_tys(self.unifier, arg0_ty);
+
+                make_ndarray_ty(self.unifier, self.primitives, Some(target_ty), Some(ndarray_ndims))
+            } else {
+                target_ty
+            };
+
+            let custom = self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                args: vec![
+                    FuncArg {
+                        name: "n".into(),
+                        ty: arg0.custom.unwrap(),
+                        default_value: None,
+                    },
+                ],
+                ret,
+                vars: VarMap::new(),
+            }));
+
+            return Ok(Some(Located {
+                location,
+                custom: Some(ret),
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: Some(custom),
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: ctx.clone() },
+                    }),
+                    args: vec![arg0],
+                    keywords: vec![],
+                },
+            }))
+        }
+
+        // 1-argument ndarray n-dimensional creation functions
+        if [
+            "np_ndarray".into(),
+            "np_empty".into(),
+            "np_zeros".into(),
+            "np_ones".into(),
+        ].contains(id) && args.len() == 1 {
+            let ExprKind::List { elts, .. } = &args[0].node else {
+                return report_error(
+                    format!("Expected List literal for first argument of {id}, got {}", args[0].node.name()).as_str(),
+                    args[0].location
+                )
+            };
+
+            let ndims = elts.len() as u64;
+
+            let arg0 = self.fold_expr(args.remove(0))?;
+            let ndims = self.unifier.get_fresh_literal(
+                vec![SymbolValue::U64(ndims)],
+                None,
+            );
+            let ret = make_ndarray_ty(
+                self.unifier,
+                self.primitives,
+                Some(self.primitives.float),
+                Some(ndims),
+            );
+            let custom = self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                args: vec![
+                    FuncArg {
+                        name: "shape".into(),
+                        ty: arg0.custom.unwrap(),
+                        default_value: None,
+                    },
+                ],
+                ret,
+                vars: VarMap::new(),
+            }));
+
+            return Ok(Some(Located {
+                location,
+                custom: Some(ret),
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: Some(custom),
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: ctx.clone() },
+                    }),
+                    args: vec![arg0],
+                    keywords: vec![],
+                },
+            }))
+        }
+
+        // 2-argument ndarray n-dimensional creation functions
+        if id == &"np_full".into() && args.len() == 2 {
+            let ExprKind::List { elts, .. } = &args[0].node else {
+                return report_error(
+                    format!("Expected List literal for first argument of {id}, got {}", args[0].node.name()).as_str(),
+                    args[0].location
+                )
+            };
+
+            let ndims = elts.len() as u64;
+
+            let arg0 = self.fold_expr(args.remove(0))?;
+            let arg1 = self.fold_expr(args.remove(0))?;
+
+            let ty = arg1.custom.unwrap();
+            let ndims = self.unifier.get_fresh_literal(
+                vec![SymbolValue::U64(ndims)],
+                None,
+            );
+            let ret = make_ndarray_ty(
+                self.unifier,
+                self.primitives,
+                Some(ty),
+                Some(ndims),
+            );
+            let custom = self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
+                args: vec![
+                    FuncArg {
+                        name: "shape".into(),
+                        ty: arg0.custom.unwrap(),
+                        default_value: None,
+                    },
+                    FuncArg {
+                        name: "fill_value".into(),
+                        ty: arg1.custom.unwrap(),
+                        default_value: None,
+                    },
+                ],
+                ret,
+                vars: VarMap::new(),
+            }));
+
+            return Ok(Some(Located {
+                location,
+                custom: Some(ret),
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: Some(custom),
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: ctx.clone() },
+                    }),
+                    args: vec![arg0, arg1],
+                    keywords: vec![],
+                },
+            }))
+        }
+
+        Ok(None)
+    }
+
     fn fold_call(
         &mut self,
         location: Location,
@@ -768,111 +1260,11 @@ impl<'a> Inferencer<'a> {
         mut args: Vec<ast::Expr<()>>,
         keywords: Vec<Located<ast::KeywordData>>,
     ) -> Result<ast::Expr<Option<Type>>, HashSet<String>> {
-        let func =
-            if let Located { location: func_location, custom, node: ExprKind::Name { id, ctx } } =
-                func
-            {
-                // handle special functions that cannot be typed in the usual way...
-                if id == "virtual".into() {
-                    if args.is_empty() || args.len() > 2 || !keywords.is_empty() {
-                        return report_error(
-                            "`virtual` can only accept 1/2 positional arguments",
-                            func_location,
-                        );
-                    }
-                    let arg0 = self.fold_expr(args.remove(0))?;
-                    let ty = if let Some(arg) = args.pop() {
-                        let top_level_defs = self.top_level.definitions.read();
-                        self.function_data.resolver.parse_type_annotation(
-                            top_level_defs.as_slice(),
-                            self.unifier,
-                            self.primitives,
-                            &arg,
-                        )?
-                    } else {
-                        self.unifier.get_dummy_var().0
-                    };
-                    self.virtual_checks.push((arg0.custom.unwrap(), ty, func_location));
-                    let custom = Some(self.unifier.add_ty(TypeEnum::TVirtual { ty }));
-                    return Ok(Located {
-                        location,
-                        custom,
-                        node: ExprKind::Call {
-                            func: Box::new(Located {
-                                custom: None,
-                                location: func.location,
-                                node: ExprKind::Name { id, ctx },
-                            }),
-                            args: vec![arg0],
-                            keywords: vec![],
-                        },
-                    });
-                }
-                // int64 is special because its argument can be a constant larger than int32
-                if id == "int64".into() && args.len() == 1 {
-                    if let ExprKind::Constant { value: ast::Constant::Int(val), kind } =
-                        &args[0].node
-                    {
-                        let custom = Some(self.primitives.int64);
-                        let v: Result<i64, _> = (*val).try_into();
-                        return if v.is_ok() {
-                            Ok(Located {
-                                location: args[0].location,
-                                custom,
-                                node: ExprKind::Constant {
-                                    value: ast::Constant::Int(*val),
-                                    kind: kind.clone(),
-                                },
-                            })
-                        } else {
-                            report_error("Integer out of bound", args[0].location)
-                        }
-                    }
-                }
-                if id == "uint32".into() && args.len() == 1 {
-                    if let ExprKind::Constant { value: ast::Constant::Int(val), kind } =
-                        &args[0].node
-                    {
-                        let custom = Some(self.primitives.uint32);
-                        let v: Result<u32, _> = (*val).try_into();
-                        return if v.is_ok() {
-                             Ok(Located {
-                                location: args[0].location,
-                                custom,
-                                node: ExprKind::Constant {
-                                    value: ast::Constant::Int(*val),
-                                    kind: kind.clone(),
-                                },
-                            })
-                        } else {
-                            report_error("Integer out of bound", args[0].location)
-                        }
-                    }
-                }
-                if id == "uint64".into() && args.len() == 1 {
-                    if let ExprKind::Constant { value: ast::Constant::Int(val), kind } =
-                    &args[0].node
-                    {
-                        let custom = Some(self.primitives.uint64);
-                        let v: Result<u64, _> = (*val).try_into();
-                        return if v.is_ok() {
-                            Ok(Located {
-                                location: args[0].location,
-                                custom,
-                                node: ExprKind::Constant {
-                                    value: ast::Constant::Int(*val),
-                                    kind: kind.clone(),
-                                },
-                            })
-                        } else {
-                            report_error("Integer out of bound", args[0].location)
-                        }
-                    }
-                }
-                Located { location: func_location, custom, node: ExprKind::Name { id, ctx } }
-            } else {
-                func
-            };
+        let func = if let Some(spec_call_func) = self.try_fold_special_call(location, &func, &mut args, &keywords)? {
+            return Ok(spec_call_func)
+        } else {
+            func
+        };
         let func = Box::new(self.fold_expr(func)?);
         let args = args.into_iter().map(|v| self.fold_expr(v)).collect::<Result<Vec<_>, _>>()?;
         let keywords = keywords
@@ -930,6 +1322,7 @@ impl<'a> Inferencer<'a> {
         Ok(Located { location, custom: Some(ret), node: ExprKind::Call { func, args, keywords } })
     }
 
+    #[allow(clippy::unnecessary_wraps)]
     fn infer_identifier(&mut self, id: StrRef) -> InferenceResult {
         Ok(if let Some(ty) = self.variable_mapping.get(&id) {
             *ty
@@ -982,6 +1375,7 @@ impl<'a> Inferencer<'a> {
         Ok(self.unifier.add_ty(TypeEnum::TList { ty }))
     }
 
+    #[allow(clippy::unnecessary_wraps)]
     fn infer_tuple(&mut self, elts: &[ast::Expr<Option<Type>>]) -> InferenceResult {
         let ty = elts.iter().map(|x| x.custom.unwrap()).collect();
         Ok(self.unifier.add_ty(TypeEnum::TTuple { ty }))
@@ -1035,8 +1429,11 @@ impl<'a> Inferencer<'a> {
         right: &ast::Expr<Option<Type>>,
         is_aug_assign: bool,
     ) -> InferenceResult {
+        let left_ty = left.custom.unwrap();
+        let right_ty = right.custom.unwrap();
+
         let method = if let TypeEnum::TObj { fields, .. } =
-            self.unifier.get_ty_immutable(left.custom.unwrap()).as_ref()
+            self.unifier.get_ty_immutable(left_ty).as_ref()
         {
             let (binop_name, binop_assign_name) = (
                 binop_name(op).into(),
@@ -1051,46 +1448,152 @@ impl<'a> Inferencer<'a> {
         } else {
             binop_name(op).into()
         };
+
+        let ret = if is_aug_assign {
+            // The type of augmented assignment operator should never change
+            Some(left_ty)
+        } else {
+            typeof_binop(
+                self.unifier,
+                self.primitives,
+                op,
+                left_ty,
+                right_ty,
+            ).map_err(|e| HashSet::from([format!("{e} (at {location})")]))?
+        };
+
         self.build_method_call(
             location,
             method,
-            left.custom.unwrap(),
-            vec![right.custom.unwrap()],
-            None,
+            left_ty,
+            vec![right_ty],
+            ret,
         )
     }
 
     fn infer_unary_ops(
         &mut self,
+        location: Location,
         op: &ast::Unaryop,
         operand: &ast::Expr<Option<Type>>,
     ) -> InferenceResult {
         let method = unaryop_name(op).into();
-        self.build_method_call(operand.location, method, operand.custom.unwrap(), vec![], None)
+
+        let ret = typeof_unaryop(
+            self.unifier,
+            self.primitives,
+            op,
+            operand.custom.unwrap(),
+        ).map_err(|e| HashSet::from([format!("{e} (at {location})")]))?;
+
+        self.build_method_call(location, method, operand.custom.unwrap(), vec![], ret)
     }
 
     fn infer_compare(
         &mut self,
+        location: Location,
         left: &ast::Expr<Option<Type>>,
         ops: &[ast::Cmpop],
         comparators: &[ast::Expr<Option<Type>>],
     ) -> InferenceResult {
-        let boolean = self.primitives.bool;
+        if ops.len() > 1 && once(left).chain(comparators).any(|expr| expr.custom.unwrap().obj_id(self.unifier).is_some_and(|id| id == PRIMITIVE_DEF_IDS.ndarray)) {
+            return Err(HashSet::from([String::from("Comparator chaining with ndarray types not supported")]))
+        }
+
+        let mut res = None;
         for (a, b, c) in izip!(once(left).chain(comparators), comparators, ops) {
             let method = comparison_name(c)
                 .ok_or_else(|| HashSet::from([
                     "unsupported comparator".to_string()
                 ]))?
                 .into();
-            self.build_method_call(
-                a.location,
+
+            let ret = typeof_cmpop(
+                self.unifier,
+                self.primitives,
+                c,
+                a.custom.unwrap(),
+                b.custom.unwrap(),
+            ).map_err(|e| HashSet::from([format!("{e} (at {})", b.location)]))?;
+
+            res.replace(self.build_method_call(
+                location,
                 method,
                 a.custom.unwrap(),
                 vec![b.custom.unwrap()],
-                Some(boolean),
-            )?;
+                ret,
+            )?);
+        }
+
+        Ok(res.unwrap())
+    }
+
+    /// Infers the type of a subscript expression on an `ndarray`.
+    fn infer_subscript_ndarray(
+        &mut self,
+        value: &ast::Expr<Option<Type>>,
+        dummy_tvar: Type,
+        ndims: Type,
+    ) -> InferenceResult {
+        debug_assert!(matches!(
+            &*self.unifier.get_ty_immutable(dummy_tvar),
+            TypeEnum::TVar { is_const_generic: false, .. }
+        ));
+
+        let constrained_ty = make_ndarray_ty(
+            self.unifier,
+            self.primitives,
+            Some(dummy_tvar),
+            Some(ndims),
+        );
+        self.constrain(value.custom.unwrap(), constrained_ty, &value.location)?;
+
+        let TypeEnum::TLiteral { values, .. } = &*self.unifier.get_ty_immutable(ndims) else {
+            panic!("Expected TLiteral for ndarray.ndims, got {}", self.unifier.stringify(ndims))
+        };
+
+        let ndims = values.iter()
+            .map(|ndim| match *ndim {
+                SymbolValue::U64(v) => Ok(v),
+                SymbolValue::U32(v) => Ok(v as u64),
+                SymbolValue::I32(v) => u64::try_from(v).map_err(|_| HashSet::from([
+                    format!("Expected non-negative literal for ndarray.ndims, got {v}"),
+                ])),
+                SymbolValue::I64(v) => u64::try_from(v).map_err(|_| HashSet::from([
+                    format!("Expected non-negative literal for ndarray.ndims, got {v}"),
+                ])),
+                _ => unreachable!(),
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        assert!(!ndims.is_empty());
+
+        if ndims.len() == 1 && ndims[0] == 1 {
+            // ndarray[T, Literal[1]] - Index always returns an object of type T
+
+            assert_ne!(ndims[0], 0);
+
+            Ok(dummy_tvar)
+        } else {
+            // ndarray[T, Literal[N]] where N != 1 - Index returns an object of type ndarray[T, Literal[N - 1]]
+
+            if ndims.iter().any(|v| *v == 0) {
+                unimplemented!("Inference for ndarray subscript operator with Literal[0, ...] bound unimplemented")
+            }
+
+            let ndims_min_one_ty = self.unifier.get_fresh_literal(
+                ndims.into_iter().map(|v| SymbolValue::U64(v - 1)).collect(),
+                None,
+            );
+            let subscripted_ty = make_ndarray_ty(
+                self.unifier,
+                self.primitives,
+                Some(dummy_tvar),
+                Some(ndims_min_one_ty),
+            );
+
+            Ok(subscripted_ty)
         }
-        Ok(boolean)
     }
 
     fn infer_subscript(
@@ -1105,33 +1608,70 @@ impl<'a> Inferencer<'a> {
                 for v in [lower.as_ref(), upper.as_ref(), step.as_ref()].iter().flatten() {
                     self.constrain(v.custom.unwrap(), self.primitives.int32, &v.location)?;
                 }
-                let list = self.unifier.add_ty(TypeEnum::TList { ty });
-                self.constrain(value.custom.unwrap(), list, &value.location)?;
-                Ok(list)
+                let list_like_ty = match &*self.unifier.get_ty(value.custom.unwrap()) {
+                    TypeEnum::TList { .. } => self.unifier.add_ty(TypeEnum::TList { ty }),
+                    TypeEnum::TObj { obj_id, .. } if *obj_id == PRIMITIVE_DEF_IDS.ndarray => {
+                        let (_, ndims) = unpack_ndarray_var_tys(self.unifier, value.custom.unwrap());
+
+                        make_ndarray_ty(self.unifier, self.primitives, Some(ty), Some(ndims))
+                    }
+
+                    _ => unreachable!()
+                };
+                self.constrain(value.custom.unwrap(), list_like_ty, &value.location)?;
+                Ok(list_like_ty)
             }
             ExprKind::Constant { value: ast::Constant::Int(val), .. } => {
-                // the index is a constant, so value can be a sequence.
-                let ind: Option<i32> = (*val).try_into().ok();
-                let ind = ind.ok_or_else(|| HashSet::from(["Index must be int32".to_string()]))?;
-                let map = once((
-                    ind.into(),
-                    RecordField::new(ty, ctx == &ExprContext::Store, Some(value.location)),
-                ))
-                .collect();
-                let seq = self.unifier.add_record(map);
-                self.constrain(value.custom.unwrap(), seq, &value.location)?;
-                Ok(ty)
+                match &*self.unifier.get_ty(value.custom.unwrap()) {
+                    TypeEnum::TObj { obj_id, .. } if *obj_id == PRIMITIVE_DEF_IDS.ndarray => {
+                        let (_, ndims) = unpack_ndarray_var_tys(self.unifier, value.custom.unwrap());
+                        self.infer_subscript_ndarray(value, ty, ndims)
+                    }
+                    _ => {
+                        // the index is a constant, so value can be a sequence.
+                        let ind: Option<i32> = (*val).try_into().ok();
+                        let ind = ind.ok_or_else(|| HashSet::from(["Index must be int32".to_string()]))?;
+                        let map = once((
+                            ind.into(),
+                            RecordField::new(ty, ctx == &ExprContext::Store, Some(value.location)),
+                        ))
+                            .collect();
+                        let seq = self.unifier.add_record(map);
+                        self.constrain(value.custom.unwrap(), seq, &value.location)?;
+                        Ok(ty)
+                    }
+                }
             }
             _ => {
-                if let TypeEnum::TTuple { .. } = &*self.unifier.get_ty(value.custom.unwrap())
-                {
+                if let TypeEnum::TTuple { .. } = &*self.unifier.get_ty(value.custom.unwrap()) {
                     return report_error("Tuple index must be a constant (KernelInvariant is also not supported)", slice.location)
                 }
-                // the index is not a constant, so value can only be a list
-                self.constrain(slice.custom.unwrap(), self.primitives.int32, &slice.location)?;
-                let list = self.unifier.add_ty(TypeEnum::TList { ty });
-                self.constrain(value.custom.unwrap(), list, &value.location)?;
-                Ok(ty)
+
+                // the index is not a constant, so value can only be a list-like structure
+                match &*self.unifier.get_ty(value.custom.unwrap()) {
+                    TypeEnum::TList { .. } => {
+                        self.constrain(slice.custom.unwrap(), self.primitives.int32, &slice.location)?;
+                        let list = self.unifier.add_ty(TypeEnum::TList { ty });
+                        self.constrain(value.custom.unwrap(), list, &value.location)?;
+                        Ok(ty)
+                    }
+                    TypeEnum::TObj { obj_id, .. } if *obj_id == PRIMITIVE_DEF_IDS.ndarray => {
+                        let (_, ndims) = unpack_ndarray_var_tys(self.unifier, value.custom.unwrap());
+
+                        let valid_index_tys = [
+                            self.primitives.int32,
+                            self.primitives.isize(),
+                        ].into_iter().unique().collect_vec();
+                        let valid_index_ty = self.unifier.get_fresh_var_with_range(
+                            valid_index_tys.as_slice(),
+                            None,
+                            None,
+                        ).0;
+                        self.constrain(slice.custom.unwrap(), valid_index_ty, &slice.location)?;
+                        self.infer_subscript_ndarray(value, ty, ndims)
+                    }
+                    _ => unreachable!(),
+                }
             }
         }
     }

nac3core/src/typecheck/type_inferencer/test.rs

@@ -3,7 +3,7 @@ use super::*;
 use crate::{
     codegen::CodeGenContext,
     symbol_resolver::ValueEnum,
-    toplevel::{DefinitionId, TopLevelDef},
+    toplevel::{DefinitionId, helper::PRIMITIVE_DEF_IDS, TopLevelDef},
 };
 use indoc::indoc;
 use std::iter::zip;
@@ -73,67 +73,77 @@ impl TestEnvironment {
         let mut unifier = Unifier::new();
 
         let int32 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(0),
+            obj_id: PRIMITIVE_DEF_IDS.int32,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         with_fields(&mut unifier, int32, |unifier, fields| {
             let add_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
                 args: vec![FuncArg { name: "other".into(), ty: int32, default_value: None }],
                 ret: int32,
-                vars: HashMap::new(),
+                vars: VarMap::new(),
             }));
             fields.insert("__add__".into(), (add_ty, false));
         });
         let int64 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(1),
+            obj_id: PRIMITIVE_DEF_IDS.int64,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let float = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(2),
+            obj_id: PRIMITIVE_DEF_IDS.float,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let bool = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(3),
+            obj_id: PRIMITIVE_DEF_IDS.bool,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let none = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(4),
+            obj_id: PRIMITIVE_DEF_IDS.none,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let range = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(5),
+            obj_id: PRIMITIVE_DEF_IDS.range,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let str = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(6),
+            obj_id: PRIMITIVE_DEF_IDS.str,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let exception = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(7),
+            obj_id: PRIMITIVE_DEF_IDS.exception,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let uint32 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(8),
+            obj_id: PRIMITIVE_DEF_IDS.uint32,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let uint64 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(9),
+            obj_id: PRIMITIVE_DEF_IDS.uint64,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let option = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(10),
+            obj_id: PRIMITIVE_DEF_IDS.option,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
+        });
+        let ndarray_dtype_tvar = unifier.get_fresh_var(Some("ndarray_dtype".into()), None);
+        let ndarray_ndims_tvar = unifier.get_fresh_const_generic_var(uint64, Some("ndarray_ndims".into()), None);
+        let ndarray = unifier.add_ty(TypeEnum::TObj {
+            obj_id: PRIMITIVE_DEF_IDS.ndarray,
+            fields: HashMap::new(),
+            params: VarMap::from([
+                (ndarray_dtype_tvar.1, ndarray_dtype_tvar.0),
+                (ndarray_ndims_tvar.1, ndarray_ndims_tvar.0),
+            ]),
         });
         let primitives = PrimitiveStore {
             int32,
@@ -147,7 +157,10 @@ impl TestEnvironment {
             uint32,
             uint64,
             option,
+            ndarray,
+            size_t: 64,
         };
+        unifier.put_primitive_store(&primitives);
         set_primitives_magic_methods(&primitives, &mut unifier);
 
         let id_to_name = [
@@ -198,67 +211,72 @@ impl TestEnvironment {
         let mut identifier_mapping = HashMap::new();
         let mut top_level_defs: Vec<Arc<RwLock<TopLevelDef>>> = Vec::new();
         let int32 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(0),
+            obj_id: PRIMITIVE_DEF_IDS.int32,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         with_fields(&mut unifier, int32, |unifier, fields| {
             let add_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
                 args: vec![FuncArg { name: "other".into(), ty: int32, default_value: None }],
                 ret: int32,
-                vars: HashMap::new(),
+                vars: VarMap::new(),
             }));
             fields.insert("__add__".into(), (add_ty, false));
         });
         let int64 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(1),
+            obj_id: PRIMITIVE_DEF_IDS.int64,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let float = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(2),
+            obj_id: PRIMITIVE_DEF_IDS.float,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let bool = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(3),
+            obj_id: PRIMITIVE_DEF_IDS.bool,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let none = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(4),
+            obj_id: PRIMITIVE_DEF_IDS.none,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let range = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(5),
+            obj_id: PRIMITIVE_DEF_IDS.range,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let str = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(6),
+            obj_id: PRIMITIVE_DEF_IDS.str,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let exception = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(7),
+            obj_id: PRIMITIVE_DEF_IDS.exception,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let uint32 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(8),
+            obj_id: PRIMITIVE_DEF_IDS.uint32,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let uint64 = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(9),
+            obj_id: PRIMITIVE_DEF_IDS.uint64,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
         });
         let option = unifier.add_ty(TypeEnum::TObj {
-            obj_id: DefinitionId(10),
+            obj_id: PRIMITIVE_DEF_IDS.option,
             fields: HashMap::new(),
-            params: HashMap::new(),
+            params: VarMap::new(),
+        });
+        let ndarray = unifier.add_ty(TypeEnum::TObj {
+            obj_id: PRIMITIVE_DEF_IDS.ndarray,
+            fields: HashMap::new(),
+            params: VarMap::new(),
         });
         identifier_mapping.insert("None".into(), none);
         for (i, name) in ["int32", "int64", "float", "bool", "none", "range", "str", "Exception"]
@@ -294,14 +312,18 @@ impl TestEnvironment {
             uint32,
             uint64,
             option,
+            ndarray,
+            size_t: 64,
         };
 
+        unifier.put_primitive_store(&primitives);
+
         let (v0, id) = unifier.get_dummy_var();
 
         let foo_ty = unifier.add_ty(TypeEnum::TObj {
             obj_id: DefinitionId(defs + 1),
             fields: [("a".into(), (v0, true))].iter().cloned().collect::<HashMap<_, _>>(),
-            params: [(id, v0)].iter().cloned().collect::<HashMap<_, _>>(),
+            params: [(id, v0)].iter().cloned().collect::<VarMap>(),
         });
         top_level_defs.push(
             RwLock::new(TopLevelDef::Class {

nac3core/src/typecheck/typedef/mod.rs

@@ -5,6 +5,7 @@ use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::{borrow::Cow, collections::HashSet};
 use std::iter::zip;
+use indexmap::IndexMap;
 use itertools::Itertools;
 
 use nac3parser::ast::{Location, StrRef};
@@ -13,6 +14,7 @@ use super::type_error::{TypeError, TypeErrorKind};
 use super::unification_table::{UnificationKey, UnificationTable};
 use crate::symbol_resolver::SymbolValue;
 use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef};
+use crate::typecheck::type_inferencer::PrimitiveStore;
 
 #[cfg(test)]
 mod test;
@@ -24,7 +26,10 @@ pub type Type = UnificationKey;
 pub struct CallId(pub(super) usize);
 
 pub type Mapping<K, V = Type> = HashMap<K, V>;
-type VarMap = Mapping<u32>;
+pub type IndexMapping<K, V = Type> = IndexMap<K, V>;
+
+/// The mapping between type variable ID and [unifier type][`Type`].
+pub type VarMap = IndexMapping<u32>;
 
 #[derive(Clone)]
 pub struct Call {
@@ -56,13 +61,14 @@ pub enum RecordKey {
 }
 
 impl Type {
-    // a wrapper function for cleaner code so that we don't need to
-    // write this long pattern matching just to get the field `obj_id`
-    pub fn get_obj_id(self, unifier: &Unifier) -> DefinitionId {
-        if let TypeEnum::TObj { obj_id, .. } = unifier.get_ty_immutable(self).as_ref() {
-            *obj_id
+    /// Wrapper function for cleaner code so that we don't need to write this long pattern matching 
+    /// just to get the field `obj_id`.
+    #[must_use]
+    pub fn obj_id(self, unifier: &Unifier) -> Option<DefinitionId> {
+        if let TypeEnum::TObj { obj_id, .. } = &*unifier.get_ty_immutable(self) {
+            Some(*obj_id)
         } else {
-            unreachable!("expect a object type")
+            None
         }
     }
 }
@@ -139,12 +145,10 @@ pub enum TypeEnum {
         is_const_generic: bool,
     },
 
-    /// A constant for substitution into a const generic variable.
-    TConstant {
+    /// A literal generic type matching `typing.Literal`.
+    TLiteral {
         /// The value of the constant.
-        value: SymbolValue,
-        /// The underlying type of the value.
-        ty: Type,
+        values: Vec<SymbolValue>,
         loc: Option<Location>,
     },
 
@@ -191,7 +195,7 @@ impl TypeEnum {
         match self {
             TypeEnum::TRigidVar { .. } => "TRigidVar",
             TypeEnum::TVar { .. } => "TVar",
-            TypeEnum::TConstant { .. } => "TConstant",
+            TypeEnum::TLiteral { .. } => "TConstant",
             TypeEnum::TTuple { .. } => "TTuple",
             TypeEnum::TList { .. } => "TList",
             TypeEnum::TObj { .. } => "TObj",
@@ -211,7 +215,8 @@ pub struct Unifier {
     pub(crate) calls: Vec<Rc<Call>>,
     var_id: u32,
     unify_cache: HashSet<(Type, Type)>,
-    snapshot: Option<(usize, u32)>
+    snapshot: Option<(usize, u32)>,
+    primitive_store: Option<PrimitiveStore>,
 }
 
 impl Default for Unifier {
@@ -231,9 +236,27 @@ impl Unifier {
             unify_cache: HashSet::new(),
             top_level: None,
             snapshot: None,
+            primitive_store: None,
         }
     }
 
+    /// Sets the [`PrimitiveStore`] instance within this `Unifier`.
+    ///
+    /// This function can only be invoked once. Any subsequent invocations will result in an
+    /// assertion error.
+    pub fn put_primitive_store(&mut self, primitives: &PrimitiveStore) {
+        assert!(self.primitive_store.is_none());
+        self.primitive_store.replace(*primitives);
+    }
+
+    /// Returns the [`UnificationTable`] associated with this `Unifier`.
+    /// 
+    /// # Safety
+    /// 
+    /// The use of this function is discouraged under most circumstances. Only use this function if
+    /// in-place manipulation of type variables and/or type fields is necessary, otherwise prefer to
+    /// [add a new type][`Unifier::add_ty`] and [unify the type][`Unifier::unify`] with an existing
+    /// type.
     pub unsafe fn get_unification_table(&mut self) -> &mut UnificationTable<Rc<TypeEnum>> {
         &mut self.unification_table
     }
@@ -252,6 +275,7 @@ impl Unifier {
             top_level: None,
             unify_cache: HashSet::new(),
             snapshot: None,
+            primitive_store: None,
         }
     }
 
@@ -358,8 +382,7 @@ impl Unifier {
         (self.add_ty(TypeEnum::TVar { id, range, fields: None, name, loc, is_const_generic: false }), id)
     }
 
-    /// Returns a fresh type representing a constant generic variable with the given underlying type
-    /// `ty`.
+    /// Returns a fresh type representing a constant generic variable with the given underlying type `ty`.
     pub fn get_fresh_const_generic_var(
         &mut self,
         ty: Type,
@@ -371,17 +394,17 @@ impl Unifier {
         (self.add_ty(TypeEnum::TVar { id, range: vec![ty], fields: None, name, loc, is_const_generic: true }), id)
     }
 
-    /// Returns a fresh type representing a [fresh constant][TypeEnum::TConstant] with the given
-    /// `value` and type `ty`.
-    pub fn get_fresh_constant(
+    /// Returns a fresh type representing a [literal][TypeEnum::TConstant] with the given `values`.
+    pub fn get_fresh_literal(
         &mut self,
-        value: SymbolValue,
-        ty: Type,
+        values: Vec<SymbolValue>,
         loc: Option<Location>,
     ) -> Type {
-        assert!(matches!(self.get_ty(ty).as_ref(), TypeEnum::TObj { .. }));
-
-        self.add_ty(TypeEnum::TConstant { ty, value, loc })
+        let ty_enum = TypeEnum::TLiteral {
+            values: values.into_iter().dedup().collect(),
+            loc
+        };
+        self.add_ty(ty_enum)
     }
 
     /// Unification would not unify rigid variables with other types, but we want to do this for
@@ -456,17 +479,21 @@ impl Unifier {
     pub fn is_concrete(&mut self, a: Type, allowed_typevars: &[Type]) -> bool {
         use TypeEnum::*;
         match &*self.get_ty(a) {
-            TRigidVar { .. } | TConstant { .. } => true,
+            TRigidVar { .. } 
+            | TLiteral { .. }
+            // functions are instantiated for each call sites, so the function type can contain
+            // type variables.
+            | TFunc { .. } => true,
+
             TVar { .. } => allowed_typevars.iter().any(|b| self.unification_table.unioned(a, *b)),
             TCall { .. } => false,
-            TList { ty } | TVirtual { ty } => self.is_concrete(*ty, allowed_typevars),
+            TList { ty } 
+            | TVirtual { ty } => self.is_concrete(*ty, allowed_typevars),
+
             TTuple { ty } => ty.iter().all(|ty| self.is_concrete(*ty, allowed_typevars)),
             TObj { params: vars, .. } => {
                 vars.values().all(|ty| self.is_concrete(*ty, allowed_typevars))
             }
-            // functions are instantiated for each call sites, so the function type can contain
-            // type variables.
-            TFunc { .. } => true,
         }
     }
 
@@ -678,7 +705,7 @@ impl Unifier {
                 self.set_a_to_b(a, x);
             }
             (TVar { fields: Some(fields), range, is_const_generic: false, .. }, TTuple { ty }) => {
-                let len = ty.len() as i32;
+                let len = i32::try_from(ty.len()).unwrap();
                 for (k, v) in fields {
                     match *k {
                         RecordKey::Int(i) => {
@@ -734,18 +761,65 @@ impl Unifier {
                 self.set_a_to_b(a, b);
             }
 
-            (TVar { range: ty1, is_const_generic: true, .. }, TConstant { ty: ty2, .. }) => {
-                let ty1 = ty1[0];
+            (TVar { range: tys, is_const_generic: true, .. }, TLiteral { values, .. }) => {
+                assert_eq!(tys.len(), 1);
+                assert_eq!(values.len(), 1);
+
+                let primitives = &self.primitive_store
+                    .expect("Expected PrimitiveStore to be present");
+
+                let ty = tys[0];
+                let value= &values[0];
+                let value_ty = value.get_type(primitives, self);
+
+                // If the types don't match, try to implicitly promote integers
+                if !self.unioned(ty, value_ty) {
+                    let Ok(num_val) = i128::try_from(value.clone()) else {
+                        return Self::incompatible_types(a, b)
+                    };
+
+                    let can_convert = if self.unioned(ty, primitives.int32) {
+                        i32::try_from(num_val).is_ok()
+                    } else if self.unioned(ty, primitives.int64) {
+                        i64::try_from(num_val).is_ok()
+                    } else if self.unioned(ty, primitives.uint32) {
+                        u32::try_from(num_val).is_ok()
+                    } else if self.unioned(ty, primitives.uint64) {
+                        u64::try_from(num_val).is_ok()
+                    } else {
+                        false
+                    };
+
+                    if !can_convert {
+                        return Self::incompatible_types(a, b)
+                    }
+                }
 
-                self.unify_impl(ty1, *ty2, false)?;
                 self.set_a_to_b(a, b);
             }
 
-            (TConstant { value: val1, ty: ty1, .. }, TConstant { value: val2, ty: ty2, .. }) => {
-                if val1 != val2 {
-                    return self.incompatible_types(a, b)
+            (TLiteral { values: val1, .. }, TLiteral { values: val2, .. }) => {
+                for (v1, v2) in zip(val1, val2) {
+                    if v1 != v2 {
+                        let symbol_value_to_int = |value: &SymbolValue| -> Option<i128> {
+                            match value {
+                                SymbolValue::I32(v) => Some(*v as i128),
+                                SymbolValue::I64(v) => Some(*v as i128),
+                                SymbolValue::U32(v) => Some(*v as i128),
+                                SymbolValue::U64(v) => Some(*v as i128),
+                                _ => None,
+                            }
+                        };
+
+                        // Try performing integer promotion on literals
+                        let v1i = symbol_value_to_int(v1);
+                        let v2i = symbol_value_to_int(v2);
+
+                        if v1i != v2i {
+                            return Self::incompatible_types(a, b)
+                        }
+                    }
                 }
-                self.unify_impl(*ty1, *ty2, false)?;
 
                 self.set_a_to_b(a, b);
             }
@@ -842,14 +916,14 @@ impl Unifier {
                 TObj { obj_id: id2, params: params2, .. },
             ) => {
                 if id1 != id2 {
-                    self.incompatible_types(a, b)?;
+                    Self::incompatible_types(a, b)?;
                 }
 
                 // Sort the type arguments by its UnificationKey first, since `HashMap::iter` visits
                 // all K-V pairs "in arbitrary order"
                 let (tv1, tv2) = (
-                    params1.iter().sorted_by_key(|(k, _)| *k).map(|(_, v)| v).collect_vec(),
-                    params2.iter().sorted_by_key(|(k, _)| *k).map(|(_, v)| v).collect_vec(),
+                    params1.iter().map(|(_, v)| v).collect_vec(),
+                    params2.iter().map(|(_, v)| v).collect_vec(),
                 );
                 for (x, y) in zip(tv1, tv2) {
                     if self.unify_impl(*x, *y, false).is_err() {
@@ -912,7 +986,7 @@ impl Unifier {
             }
             _ => {
                 if swapped {
-                    return self.incompatible_types(a, b);
+                    return Self::incompatible_types(a, b);
                 }
 
                 self.unify_impl(b, a, true)?;
@@ -1003,8 +1077,8 @@ impl Unifier {
                 };
                 n
             }
-            TypeEnum::TConstant { value, .. } => {
-                format!("const({value})")
+            TypeEnum::TLiteral { values, .. } => {
+                format!("const({})", values.iter().map(|v| format!("{v:?}")).join(", "))
             }
             TypeEnum::TTuple { ty } => {
                 let mut fields =
@@ -1025,11 +1099,9 @@ impl Unifier {
                 if params.is_empty() {
                     name
                 } else {
-                    let params = params
+                    let mut params = params
                         .iter()
                         .map(|(_, v)| self.internal_stringify(*v, obj_to_name, var_to_name, notes));
-                    // sort to preserve order
-                    let mut params = params.sorted();
                     format!("{}[{}]", name, params.join(", "))
                 }
             }
@@ -1069,7 +1141,7 @@ impl Unifier {
         table.set_value(a, ty_b);
     }
 
-    fn incompatible_types(&mut self, a: Type, b: Type) -> Result<(), TypeError> {
+    fn incompatible_types(a: Type, b: Type) -> Result<(), TypeError> {
         Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None))
     }
 
@@ -1133,7 +1205,7 @@ impl Unifier {
         // variables, i.e. things like TRecord, TCall should not occur, and we
         // should be safe to not implement the substitution for those variants.
         match &*ty {
-            TypeEnum::TRigidVar { .. } => None,
+            TypeEnum::TRigidVar { .. } | TypeEnum::TLiteral { .. } => None,
             TypeEnum::TVar { id, .. } => mapping.get(id).copied(),
             TypeEnum::TTuple { ty } => {
                 let mut new_ty = Cow::from(ty);
@@ -1203,7 +1275,7 @@ impl Unifier {
                     None
                 }
             }
-            _ => {
+            TypeEnum::TCall(_) => {
                 unreachable!("{} not expected", ty.get_type_name())
             }
         }
@@ -1211,12 +1283,12 @@ impl Unifier {
 
     fn subst_map<K>(
         &mut self,
-        map: &Mapping<K>,
+        map: &IndexMapping<K>,
         mapping: &VarMap,
         cache: &mut HashMap<Type, Option<Type>>,
-    ) -> Option<Mapping<K>>
-    where
-        K: std::hash::Hash + Eq + Clone,
+    ) -> Option<IndexMapping<K>>
+        where
+            K: std::hash::Hash + Eq + Clone,
     {
         let mut map2 = None;
         for (k, v) in map {

nac3core/src/typecheck/typedef/test.rs

@@ -40,14 +40,14 @@ impl Unifier {
                 TypeEnum::TObj { obj_id: id1, params: params1, .. },
                 TypeEnum::TObj { obj_id: id2, params: params2, .. },
             ) => id1 == id2 && self.map_eq(params1, params2),
-            // TCall and TFunc are not yet implemented
+            // TLiteral, TCall and TFunc are not yet implemented
             _ => false,
         }
     }
 
-    fn map_eq<K>(&mut self, map1: &Mapping<K>, map2: &Mapping<K>) -> bool
-    where
-        K: std::hash::Hash + Eq + Clone,
+    fn map_eq<K>(&mut self, map1: &IndexMapping<K>, map2: &IndexMapping<K>) -> bool 
+        where
+            K: std::hash::Hash + Eq + Clone 
     {
         if map1.len() != map2.len() {
             return false;
@@ -91,7 +91,7 @@ impl TestEnvironment {
             unifier.add_ty(TypeEnum::TObj {
                 obj_id: DefinitionId(0),
                 fields: HashMap::new(),
-                params: HashMap::new(),
+                params: VarMap::new(),
             }),
         );
         type_mapping.insert(
@@ -99,7 +99,7 @@ impl TestEnvironment {
             unifier.add_ty(TypeEnum::TObj {
                 obj_id: DefinitionId(1),
                 fields: HashMap::new(),
-                params: HashMap::new(),
+                params: VarMap::new(),
             }),
         );
         type_mapping.insert(
@@ -107,7 +107,7 @@ impl TestEnvironment {
             unifier.add_ty(TypeEnum::TObj {
                 obj_id: DefinitionId(2),
                 fields: HashMap::new(),
-                params: HashMap::new(),
+                params: VarMap::new(),
             }),
         );
         let (v0, id) = unifier.get_dummy_var();
@@ -116,7 +116,7 @@ impl TestEnvironment {
             unifier.add_ty(TypeEnum::TObj {
                 obj_id: DefinitionId(3),
                 fields: [("a".into(), (v0, true))].iter().cloned().collect::<HashMap<_, _>>(),
-                params: [(id, v0)].iter().cloned().collect::<HashMap<_, _>>(),
+                params: [(id, v0)].iter().cloned().collect::<VarMap>(),
             }),
         );
 
@@ -363,7 +363,7 @@ fn test_virtual() {
     let fun = env.unifier.add_ty(TypeEnum::TFunc(FunSignature {
         args: vec![],
         ret: int,
-        vars: HashMap::new(),
+        vars: VarMap::new(),
     }));
     let bar = env.unifier.add_ty(TypeEnum::TObj {
         obj_id: DefinitionId(5),
@@ -371,7 +371,7 @@ fn test_virtual() {
             .iter()
             .cloned()
             .collect::<HashMap<StrRef, _>>(),
-        params: HashMap::new(),
+        params: VarMap::new(),
     });
     let v0 = env.unifier.get_dummy_var().0;
     let v1 = env.unifier.get_dummy_var().0;

nac3parser/Cargo.toml

@@ -16,7 +16,7 @@ lalrpop-util = "0.20"
 log = "0.4"
 unic-emoji-char = "0.9"
 unic-ucd-ident  = "0.9"
-unicode_names2 = "1.0"
+unicode_names2 = "1.2"
 phf = { version = "0.11", features = ["macros"] }
 ahash = "0.8"
 

nac3standalone/Cargo.toml

@@ -10,10 +10,10 @@ nac3parser = { path = "../nac3parser" }
 nac3core = { path = "../nac3core" }
 
 [dependencies.clap]
-version = "4.4"
+version = "4.5"
 features = ["derive"]
 
 [dependencies.inkwell]
-version = "0.2"
+version = "0.4"
 default-features = false
 features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]

nac3standalone/demo/demo.c

@@ -1,3 +1,4 @@
+#include <inttypes.h>
 #include <math.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -5,13 +6,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#if __SIZEOF_POINTER__ == 8
-    #define usize uint64_t
-#elif __SIZEOF_POINTER__ == 4
-    #define usize uint32_t
-#else
-    #error "Unsupported platform - Platform is not 32-bit or 64-bit"
-#endif
+#define usize size_t
 
 double dbl_nan(void) {
   return NAN;
@@ -26,19 +21,19 @@ void output_bool(bool x) {
 }
 
 void output_int32(int32_t x) {
-    printf("%d\n", x);
+    printf("%"PRId32"\n", x);
 }
 
 void output_int64(int64_t x) {
-    printf("%lld\n", x);
+    printf("%"PRId64"\n", x);
 }
 
 void output_uint32(uint32_t x) {
-    printf("%u\n", x);
+    printf("%"PRIu32"\n", x);
 }
 
 void output_uint64(uint64_t x) {
-    printf("%llu\n", x);
+    printf("%"PRIu64"\n", x);
 }
 
 void output_float64(double x) {
@@ -94,13 +89,13 @@ uint64_t dbg_stack_address(__attribute__((unused)) struct cslice *slice) {
 }
 
 uint32_t __nac3_personality(uint32_t state, uint32_t exception_object, uint32_t context) {
-    printf("__nac3_personality(state: %u, exception_object: %u, context: %u\n", state, exception_object, context);
+    printf("__nac3_personality(state: %u, exception_object: %u, context: %u)\n", state, exception_object, context);
     exit(101);
     __builtin_unreachable();
 }
 
 uint32_t __nac3_raise(uint32_t state, uint32_t exception_object, uint32_t context) {
-    printf("__nac3_raise(state: %u, exception_object: %u, context: %u\n", state, exception_object, context);
+    printf("__nac3_raise(state: %u, exception_object: %u, context: %u)\n", state, exception_object, context);
     exit(101);
     __builtin_unreachable();
 }

nac3standalone/demo/interpret_demo.py

@@ -5,11 +5,12 @@ import importlib.util
 import importlib.machinery
 import math
 import numpy as np
+import numpy.typing as npt
 import pathlib
 
 from numpy import int32, int64, uint32, uint64
 from scipy import special
-from typing import TypeVar, Generic
+from typing import TypeVar, Generic, Literal, Union
 
 T = TypeVar('T')
 class Option(Generic[T]):
@@ -50,11 +51,45 @@ class _ConstGenericMarker:
 def ConstGeneric(name, constraint):
     return TypeVar(name, _ConstGenericMarker, constraint)
 
-def round_away_zero(x):
-    if x >= 0.0:
-        return math.floor(x + 0.5)
+N = TypeVar("N", bound=np.uint64)
+class _NDArrayDummy(Generic[T, N]):
+    pass
+
+# https://stackoverflow.com/questions/67803260/how-to-create-a-type-alias-with-a-throw-away-generic
+NDArray = Union[npt.NDArray[T], _NDArrayDummy[T, N]]
+
+def _bool(x):
+    if isinstance(x, np.ndarray):
+        return np.bool_(x)
     else:
-        return math.ceil(x - 0.5)
+        return bool(x)
+
+def _float(x):
+    if isinstance(x, np.ndarray):
+        return np.float_(x)
+    else:
+        return float(x)
+
+def round_away_zero(x):
+    if isinstance(x, np.ndarray):
+        return np.vectorize(round_away_zero)(x)
+    else:
+        if x >= 0.0:
+            return math.floor(x + 0.5)
+        else:
+            return math.ceil(x - 0.5)
+
+def _floor(x):
+    if isinstance(x, np.ndarray):
+        return np.vectorize(_floor)(x)
+    else:
+        return math.floor(x)
+
+def _ceil(x):
+    if isinstance(x, np.ndarray):
+        return np.vectorize(_ceil)(x)
+    else:
+        return math.ceil(x)
 
 def patch(module):
     def dbl_nan():
@@ -104,9 +139,12 @@ def patch(module):
     module.int64 = int64
     module.uint32 = uint32
     module.uint64 = uint64
+    module.bool = _bool
+    module.float = _float
     module.TypeVar = TypeVar
     module.ConstGeneric = ConstGeneric
     module.Generic = Generic
+    module.Literal = Literal
     module.extern = extern
     module.Option = Option
     module.Some = Some
@@ -116,16 +154,30 @@ def patch(module):
     module.round = round_away_zero
     module.round64 = round_away_zero
     module.np_round = np.round
-    module.floor = math.floor
-    module.floor64 = math.floor
+    module.floor = _floor
+    module.floor64 = _floor
     module.np_floor = np.floor
-    module.ceil = math.ceil
-    module.ceil64 = math.ceil
+    module.ceil = _ceil
+    module.ceil64 = _ceil
     module.np_ceil = np.ceil
 
+    # NumPy ndarray functions
+    module.ndarray = NDArray
+    module.np_ndarray = np.ndarray
+    module.np_empty = np.empty
+    module.np_zeros = np.zeros
+    module.np_ones = np.ones
+    module.np_full = np.full
+    module.np_eye = np.eye
+    module.np_identity = np.identity
+
     # NumPy Math functions
     module.np_isnan = np.isnan
     module.np_isinf = np.isinf
+    module.np_min = np.min
+    module.np_minimum = np.minimum
+    module.np_max = np.max
+    module.np_maximum = np.maximum
     module.np_sin = np.sin
     module.np_cos = np.cos
     module.np_exp = np.exp
@@ -165,6 +217,14 @@ def patch(module):
     module.sp_spec_j0 = special.j0
     module.sp_spec_j1 = special.j1
 
+    # NumPy NDArray Functions
+    module.np_ndarray = np.ndarray
+    module.np_empty = np.empty
+    module.np_zeros = np.zeros
+    module.np_ones = np.ones
+    module.np_full = np.full
+    module.np_eye = np.eye
+    module.np_identity = np.identity
 
 def file_import(filename, prefix="file_import_"):
     filename = pathlib.Path(filename)

nac3standalone/demo/run_demo.sh

@@ -10,6 +10,10 @@ fi
 declare -a nac3args
 while [ $# -ge 1 ]; do
   case "$1" in
+    --help)
+      echo "Usage: run_demo.sh [--help] [--out OUTFILE] [--lli] [--debug] -- [NAC3ARGS...]"
+      exit
+      ;;
     --out)
       shift
       outfile="$1"
@@ -17,14 +21,28 @@ while [ $# -ge 1 ]; do
     --lli)
       use_lli=1
       ;;
+    --debug)
+      debug=1
+      ;;
+    --)
+      shift
+      break
+      ;;
     *)
-      nac3args+=("$1")
+      break
       ;;
   esac
   shift
 done
 
-if [ -e ../../target/release/nac3standalone ]; then
+while [ $# -ge 1 ]; do
+  nac3args+=("$1")
+  shift
+done
+
+if [ -n "$debug" ] && [ -e ../../target/debug/nac3standalone ]; then
+    nac3standalone=../../target/debug/nac3standalone
+elif [ -e ../../target/release/nac3standalone ]; then
     nac3standalone=../../target/release/nac3standalone
 else
     # used by Nix builds

nac3standalone/demo/src/classes.py

@@ -23,8 +23,8 @@ class A:
     def get_a(self) -> int32:
         return self.a
     
-    def get_b(self) -> B:
-        return self.b
+    # def get_b(self) -> B:
+    #     return self.b
 
 
 def run() -> int32:

nac3standalone/demo/src/const_generic.py

@@ -16,28 +16,28 @@ class HybridGenericClass2(Generic[A, T]):
 class HybridGenericClass3(Generic[T, A, B]):
     pass
 
-def make_generic_2() -> ConstGenericClass[2]:
+def make_generic_2() -> ConstGenericClass[Literal[2]]:
     return ...
 
-def make_generic2_1_2() -> ConstGeneric2Class[1, 2]:
+def make_generic2_1_2() -> ConstGeneric2Class[Literal[1], Literal[2]]:
     return ...
 
-def make_hybrid_class_2_int32() -> HybridGenericClass2[2, int32]:
+def make_hybrid_class_2_int32() -> HybridGenericClass2[Literal[2], int32]:
     return ...
 
-def make_hybrid_class_i32_0_1() -> HybridGenericClass3[int32, 0, 1]:
+def make_hybrid_class_i32_0_1() -> HybridGenericClass3[int32, Literal[0], Literal[1]]:
     return ...
 
-def consume_generic_2(instance: ConstGenericClass[2]):
+def consume_generic_2(instance: ConstGenericClass[Literal[2]]):
     pass
 
-def consume_generic2_1_2(instance: ConstGeneric2Class[1, 2]):
+def consume_generic2_1_2(instance: ConstGeneric2Class[Literal[1], Literal[2]]):
     pass
 
-def consume_hybrid_class_2_i32(instance: HybridGenericClass2[2, int32]):
+def consume_hybrid_class_2_i32(instance: HybridGenericClass2[Literal[2], int32]):
     pass
 
-def consume_hybrid_class_i32_0_1(instance: HybridGenericClass3[int32, 0, 1]):
+def consume_hybrid_class_i32_0_1(instance: HybridGenericClass3[int32, Literal[0], Literal[1]]):
     pass
 
 def f():

nac3standalone/demo/src/math.py

@@ -162,7 +162,7 @@ def test_np_expm1():
 
 def test_np_cbrt():
     for x in [1.0, 8.0, 27.0, dbl_inf(), -dbl_inf(), dbl_nan()]:
-        output_float64(np_expm1(x))
+        output_float64(np_cbrt(x))
 
 def test_sp_spec_erf():
     for x in [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, dbl_inf(), -dbl_inf(), dbl_nan()]:

nac3standalone/demo/src/operators.py

@@ -1,5 +1,9 @@
 from __future__ import annotations
 
+@extern
+def output_bool(x: bool):
+    ...
+
 @extern
 def output_int32(x: int32):
     ...
@@ -17,14 +21,27 @@ def output_float64(x: float):
     ...
 
 def run() -> int32:
+    test_bool()
     test_int32()
     test_uint32()
     test_int64()
     test_uint64()
-    test_A()
-    test_B()
+    # test_A()
+    # test_B()
     return 0
 
+def test_bool():
+    t = True
+    f = False
+    output_bool(not t)
+    output_bool(not f)
+    output_int32(~t)
+    output_int32(~f)
+    output_int32(+t)
+    output_int32(+f)
+    output_int32(-t)
+    output_int32(-f)
+
 def test_int32():
     a = 17
     b = 3
@@ -173,91 +190,92 @@ def test_uint64():
     a >>= uint32(b)
     output_uint64(a)
 
-class A:
-    a: int32
-    def __init__(self, a: int32):
-        self.a = a
-    
-    def __add__(self, other: A) -> A:
-        output_int32(self.a + other.a)
-        return A(self.a + other.a)
-
-    def __sub__(self, other: A) -> A:
-        output_int32(self.a - other.a)
-        return A(self.a - other.a)
-
-def test_A():
-    a = A(17)
-    b = A(3)
-    
-    c = a + b
-    # fail due to alloca in __add__ function
-    # output_int32(c.a)
-
-    a += b
-    # fail due to alloca in __add__ function
-    # output_int32(a.a)
-    
-    a = A(17)
-    b = A(3)
-    d = a - b
-    # fail due to alloca in __add__ function
-    # output_int32(c.a)
-
-    a -= b
-    # fail due to alloca in __add__ function
-    # output_int32(a.a)
-
-    a = A(17)
-    b = A(3)
-    a.__add__(b)
-    a.__sub__(b)
-
-
-class B:
-    a: int32
-    def __init__(self, a: int32):
-        self.a = a
-    
-    def __add__(self, other: B) -> B:
-        output_int32(self.a + other.a)
-        return B(self.a + other.a)
-
-    def __sub__(self, other: B) -> B:
-        output_int32(self.a - other.a)
-        return B(self.a - other.a)
-    
-    def __iadd__(self, other: B) -> B:
-        output_int32(self.a + other.a + 24)
-        return B(self.a + other.a + 24)
-
-    def __isub__(self, other: B) -> B:
-        output_int32(self.a - other.a - 24)
-        return B(self.a - other.a - 24)
-
-def test_B():
-    a = B(17)
-    b = B(3)
-    
-    c = a + b
-    # fail due to alloca in __add__ function
-    # output_int32(c.a)
-
-    a += b
-    # fail due to alloca in __add__ function
-    # output_int32(a.a)
-    
-    a = B(17)
-    b = B(3)
-    d = a - b
-    # fail due to alloca in __add__ function
-    # output_int32(c.a)
-
-    a -= b
-    # fail due to alloca in __add__ function
-    # output_int32(a.a)
-
-    a = B(17)
-    b = B(3)
-    a.__add__(b)
-    a.__sub__(b)
+# FIXME Fix returning objects of non-primitive types; Currently this is disabled in the function checker
+# class A:
+#     a: int32
+#     def __init__(self, a: int32):
+#         self.a = a
+#
+#     def __add__(self, other: A) -> A:
+#         output_int32(self.a + other.a)
+#         return A(self.a + other.a)
+#
+#     def __sub__(self, other: A) -> A:
+#         output_int32(self.a - other.a)
+#         return A(self.a - other.a)
+#
+# def test_A():
+#     a = A(17)
+#     b = A(3)
+#
+#     c = a + b
+#     # fail due to alloca in __add__ function
+#     # output_int32(c.a)
+#
+#     a += b
+#     # fail due to alloca in __add__ function
+#     # output_int32(a.a)
+#
+#     a = A(17)
+#     b = A(3)
+#     d = a - b
+#     # fail due to alloca in __add__ function
+#     # output_int32(c.a)
+#
+#     a -= b
+#     # fail due to alloca in __add__ function
+#     # output_int32(a.a)
+#
+#     a = A(17)
+#     b = A(3)
+#     a.__add__(b)
+#     a.__sub__(b)
+#
+#
+# class B:
+#     a: int32
+#     def __init__(self, a: int32):
+#         self.a = a
+#
+#     def __add__(self, other: B) -> B:
+#         output_int32(self.a + other.a)
+#         return B(self.a + other.a)
+#
+#     def __sub__(self, other: B) -> B:
+#         output_int32(self.a - other.a)
+#         return B(self.a - other.a)
+#
+#     def __iadd__(self, other: B) -> B:
+#         output_int32(self.a + other.a + 24)
+#         return B(self.a + other.a + 24)
+#
+#     def __isub__(self, other: B) -> B:
+#         output_int32(self.a - other.a - 24)
+#         return B(self.a - other.a - 24)
+#
+# def test_B():
+#     a = B(17)
+#     b = B(3)
+#
+#     c = a + b
+#     # fail due to alloca in __add__ function
+#     # output_int32(c.a)
+#
+#     a += b
+#     # fail due to alloca in __add__ function
+#     # output_int32(a.a)
+#
+#     a = B(17)
+#     b = B(3)
+#     d = a - b
+#     # fail due to alloca in __add__ function
+#     # output_int32(c.a)
+#
+#     a -= b
+#     # fail due to alloca in __add__ function
+#     # output_int32(a.a)
+#
+#     a = B(17)
+#     b = B(3)
+#     a.__add__(b)
+#     a.__sub__(b)

nac3standalone/src/basic_symbol_resolver.rs

@@ -64,7 +64,9 @@ impl SymbolResolver for Resolver {
 
     fn get_identifier_def(&self, id: StrRef) -> Result<DefinitionId, HashSet<String>> {
         self.0.id_to_def.lock().get(&id).copied()
-            .ok_or_else(|| HashSet::from(["Undefined identifier".to_string()]))
+            .ok_or_else(|| HashSet::from([
+                format!("Undefined identifier `{id}`"),
+            ]))
     }
 
     fn get_string_id(&self, s: &str) -> i32 {
@@ -72,7 +74,8 @@ impl SymbolResolver for Resolver {
         if let Some(id) = str_store.get(s) {
             *id
         } else {
-            let id = str_store.len() as i32;
+            let id = i32::try_from(str_store.len())
+                .expect("Symbol resolver string store size exceeds max capacity (i32::MAX)");
             str_store.insert(s.to_string(), id);
             id
         }

nac3standalone/src/main.rs

@@ -17,12 +17,14 @@ use nac3core::{
     },
     symbol_resolver::SymbolResolver,
     toplevel::{
-        composer::TopLevelComposer, helper::parse_parameter_default_value, type_annotation::*,
+        composer::{ComposerConfig, TopLevelComposer},
+        helper::parse_parameter_default_value, 
+        type_annotation::*,
         TopLevelDef,
     },
     typecheck::{
         type_inferencer::PrimitiveStore,
-        typedef::{FunSignature, Type, Unifier},
+        typedef::{FunSignature, Type, Unifier, VarMap},
     },
 };
 use nac3parser::{
@@ -32,7 +34,6 @@ use nac3parser::{
 
 mod basic_symbol_resolver;
 use basic_symbol_resolver::*;
-use nac3core::toplevel::composer::ComposerConfig;
 
 /// Command-line argument parser definition.
 #[derive(Parser)]
@@ -104,7 +105,6 @@ fn handle_typevar_definition(
                         primitives,
                         x,
                         HashMap::default(),
-                        None,
                     )?;
                     get_type_from_type_annotation_kinds(
                         def_list, unifier, &ty, &mut None
@@ -146,7 +146,6 @@ fn handle_typevar_definition(
                 primitives,
                 &args[1],
                 HashMap::default(),
-                None,
             )?;
             let constraint = get_type_from_type_annotation_kinds(
                 def_list, unifier, &ty, &mut None
@@ -248,6 +247,8 @@ fn handle_assignment_pattern(
 }
 
 fn main() {
+    const SIZE_T: u32 = usize::BITS;
+
     let cli = CommandLineArgs::parse();
     let CommandLineArgs {
         file_name,
@@ -297,9 +298,9 @@ fn main() {
         }
     };
 
-    let primitive: PrimitiveStore = TopLevelComposer::make_primitives().0;
+    let primitive: PrimitiveStore = TopLevelComposer::make_primitives(SIZE_T).0;
     let (mut composer, builtins_def, builtins_ty) =
-        TopLevelComposer::new(vec![], ComposerConfig::default());
+        TopLevelComposer::new(vec![], ComposerConfig::default(), SIZE_T);
 
     let internal_resolver: Arc<ResolverInternal> = ResolverInternal {
         id_to_type: builtins_ty.into(),
@@ -346,7 +347,7 @@ fn main() {
         }
     }
 
-    let signature = FunSignature { args: vec![], ret: primitive.int32, vars: HashMap::new() };
+    let signature = FunSignature { args: vec![], ret: primitive.int32, vars: VarMap::new() };
     let mut store = ConcreteTypeStore::new();
     let mut cache = HashMap::new();
     let signature = store.from_signature(&mut composer.unifier, &primitive, &signature, &mut cache);
@@ -402,7 +403,7 @@ fn main() {
         membuffer.lock().push(buffer);
     })));
     let threads = (0..threads)
-        .map(|i| Box::new(DefaultCodeGenerator::new(format!("module{i}"), 64)))
+        .map(|i| Box::new(DefaultCodeGenerator::new(format!("module{i}"), SIZE_T)))
         .collect();
     let (registry, handles) = WorkerRegistry::create_workers(threads, top_level, &llvm_options, &f);
     registry.add_task(task);

nix/windows/msys2_packages.nix

@@ -1,57 +1,51 @@
 { pkgs } : [
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libffi-3.4.4-1-any.pkg.tar.zst";
-  sha256 = "0mws1g7w11riczc168x7kzb8nl74iry4bzkb72nspw1vmlblxfy6";
-  name = "mingw-w64-clang-x86_64-libffi-3.4.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunwind-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "0ksz7xz1lbwsmdr9sa1444k0dlfkbd8k11pq7w08ir7r1wjy6fid";
+  name = "mingw-w64-clang-x86_64-libunwind-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunwind-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "1748ncih1zj4vnj9c0gcp5rf21gm2pn9xdy2hrigp2pvfchrnmwn";
-  name = "mingw-w64-clang-x86_64-libunwind-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libc++-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "0r8skyjqv4cpkqif0niakx4hdpkscil1zf6mzj34pqna0j5gdnq2";
+  name = "mingw-w64-clang-x86_64-libc++-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libc++-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "00waw5qmpycib7xhk6aywqgqg8y26q2xbm8m4za7mpy04g2alav4";
-  name = "mingw-w64-clang-x86_64-libc++-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libffi-3.4.6-1-any.pkg.tar.zst";
+  sha256 = "1q6gms980985bp087rnnpvz2fwfakgm5266izfk3b1mbp620s1yv";
+  name = "mingw-w64-clang-x86_64-libffi-3.4.6-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-zlib-1.3-1-any.pkg.tar.zst";
-  sha256 = "0rfwz7czvwa8clickjw1kd114miyifxf1s2v9mxffkaivm45f62v";
-  name = "mingw-w64-clang-x86_64-zlib-1.3-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libiconv-1.17-4-any.pkg.tar.zst";
+  sha256 = "1g2bkhgf60dywccxw911ydyigf3m25yqfh81m5099swr7mjsmzyf";
+  name = "mingw-w64-clang-x86_64-libiconv-1.17-4-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libiconv-1.17-3-any.pkg.tar.zst";
-  sha256 = "1hxmdgivb86h7wz9hcp0had99ngv157w1fbjg7cgy068zv787m8w";
-  name = "mingw-w64-clang-x86_64-libiconv-1.17-3-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-gettext-runtime-0.22.5-2-any.pkg.tar.zst";
+  sha256 = "0ll6ci6d3mc7g04q0xixjc209bh8r874dqbczgns69jsad3wg6mi";
+  name = "mingw-w64-clang-x86_64-gettext-runtime-0.22.5-2-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-expat-2.5.0-1-any.pkg.tar.zst";
-  sha256 = "1gi9ckh48k64gras307f6pf5y558hj80izlxri8cnwvzzmmra8dg";
-  name = "mingw-w64-clang-x86_64-expat-2.5.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-xz-5.6.1-1-any.pkg.tar.zst";
+  sha256 = "14p4xxaxjjy6j1ingji82xhai1mc1gls5ali6z40fbb2ylxkaggs";
+  name = "mingw-w64-clang-x86_64-xz-5.6.1-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-gettext-0.22.4-3-any.pkg.tar.zst";
-  sha256 = "0i2gbhzvcy8cq7gnd9zsjw47jmn8gsq5pam5j3yn84jn578f3mfi";
-  name = "mingw-w64-clang-x86_64-gettext-0.22.4-3-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-zlib-1.3.1-1-any.pkg.tar.zst";
+  sha256 = "06i9xjsskf4ddb2ph4h31md5c7imj9mzjhd4lc4q44j8dmpc1w5p";
+  name = "mingw-w64-clang-x86_64-zlib-1.3.1-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-xz-5.4.5-1-any.pkg.tar.zst";
-  sha256 = "1niky9s7qq0434ljma3f9m8yybcifkvkxwhk580crzb2ifpmqxc3";
-  name = "mingw-w64-clang-x86_64-xz-5.4.5-1-any.pkg.tar.zst";
-})
-
-(pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libxml2-2.12.1-1-any.pkg.tar.zst";
-  sha256 = "0lajdhkqv3hrfmnf9wa0ddqpr9z8rvb037rv0ss60g2n0b92s5gk";
-  name = "mingw-w64-clang-x86_64-libxml2-2.12.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libxml2-2.12.6-1-any.pkg.tar.zst";
+  sha256 = "177b3rmsknqq6hf0zqwva71s3avh20ca7vzznp2ls2z5qm8vhhlp";
+  name = "mingw-w64-clang-x86_64-libxml2-2.12.6-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -61,63 +55,69 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-libs-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "13gpp9ah8g4ggzmgsskwcrck16rvjwp464i5vyw9zwm88bdhmz93";
-  name = "mingw-w64-clang-x86_64-llvm-libs-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-libs-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "0ibiy01v16naik9pj32ch7a9pkbw4yrn3gyq7p0y6kcc63fkjazy";
+  name = "mingw-w64-clang-x86_64-llvm-libs-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "103zfg4ypmzhy0gd02arjydca2l4ak2mai3g1xrck83l15v85f9h";
-  name = "mingw-w64-clang-x86_64-llvm-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "1hcfz6nb6svmmcqzfrdi96az2x7mzj0cispdv2ssbgn7nkf19pi0";
+  name = "mingw-w64-clang-x86_64-llvm-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-compiler-rt-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "0n38jb9gl3zmy7f07bqzpk70k00hdrnasrclhcxgbn4ylzlca07w";
-  name = "mingw-w64-clang-x86_64-compiler-rt-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-clang-libs-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "1k17d18g7rmq2ph4kq1mf84vs8133jzf52nkv6syh39ypjga67wa";
+  name = "mingw-w64-clang-x86_64-clang-libs-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-headers-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
-  sha256 = "1wisa5j86xn8fanx4ks5pkj2hx0k89cippcap6c6yf6d3qmj4mvr";
-  name = "mingw-w64-clang-x86_64-headers-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-compiler-rt-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "1w2j0vs888haz9shjr1l8dc4j957sk1p0377zzipkbqnzqwjf1z8";
+  name = "mingw-w64-clang-x86_64-compiler-rt-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-crt-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
-  sha256 = "0x1x3rnxivm58sqjx5v5smnzl5hdinx4qrjgkn59nylcd24fvnk4";
-  name = "mingw-w64-clang-x86_64-crt-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-headers-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  sha256 = "18csfwlk2h9pr4411crx1b41qjzn5jgbssm3h109nzwbdizkp62h";
+  name = "mingw-w64-clang-x86_64-headers-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lld-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "1028iymsay6smk856xfyccl7pkcxzigqlrhj4sgz4xxqij7xqnp0";
-  name = "mingw-w64-clang-x86_64-lld-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-crt-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  sha256 = "03l1zkrxgxxssp430xcv2gch1d03rbnbk1c0vgiqxigcs8lljh2g";
+  name = "mingw-w64-clang-x86_64-crt-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libwinpthread-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
-  sha256 = "01q7r8mvn60yc0bxlhfbb1rx8w6lbvf1bd0xfaycqmc25b8vnfnp";
-  name = "mingw-w64-clang-x86_64-libwinpthread-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lld-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "1ai4gl7ybpk9n10jmbpf3zzfa893m1krj5qhf44ajln0jabdfnbn";
+  name = "mingw-w64-clang-x86_64-lld-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-winpthreads-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
-  sha256 = "0f5828injyxhy8vxkv02wmk4fh6x5gsqnkr97p50vz692fxkwk48";
-  name = "mingw-w64-clang-x86_64-winpthreads-git-11.0.0.r404.g3a137bd87-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libwinpthread-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  sha256 = "1svhjzwhvl4ldl439jhgfy47g05y2af1cjqvydgijn1dd4g8y8vq";
+  name = "mingw-w64-clang-x86_64-libwinpthread-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-clang-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "1adfijlky02waz6gm2rx32rd413ws5rphkpybihpc8hi11yag761";
-  name = "mingw-w64-clang-x86_64-clang-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-winpthreads-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  sha256 = "0jxdhkl256vnr13xf1x3fyjrdf764zg70xcs3gki3rg109f0a6xk";
+  name = "mingw-w64-clang-x86_64-winpthreads-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-c-ares-1.22.1-1-any.pkg.tar.zst";
-  sha256 = "0bv8n3862krxhlmz0lxqq71y40dy4flpjvb7adl5a96jixgsbxav";
-  name = "mingw-w64-clang-x86_64-c-ares-1.22.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-clang-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "0ahfic7vdfv96k5v7fdkgk1agk28l833xjn2igrmbvqg96ak0w6n";
+  name = "mingw-w64-clang-x86_64-clang-18.1.2-1-any.pkg.tar.zst";
+})
+
+(pkgs.fetchurl {
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-c-ares-1.27.0-1-any.pkg.tar.zst";
+  sha256 = "06y3sgqv6a0gr3dsbzs36jrj8adklssgjqi2ms5clsyq6ay4f91r";
+  name = "mingw-w64-clang-x86_64-c-ares-1.27.0-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -133,15 +133,15 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libidn2-2.3.4-1-any.pkg.tar.zst";
-  sha256 = "105valrldri39sx7d5zdscxgsz9px382f8vbbl2zpr2xzb3jq8p8";
-  name = "mingw-w64-clang-x86_64-libidn2-2.3.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libidn2-2.3.7-2-any.pkg.tar.zst";
+  sha256 = "07k8zh5nb2s82md7lz22r8gim8214rhlg586lywck3zcla98jv1w";
+  name = "mingw-w64-clang-x86_64-libidn2-2.3.7-2-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libpsl-0.21.2-4-any.pkg.tar.zst";
-  sha256 = "0h4inq6prhiipl3h5k9br9rz5mih123b8n12wiwp2qck0h2q3x98";
-  name = "mingw-w64-clang-x86_64-libpsl-0.21.2-4-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libpsl-0.21.5-2-any.pkg.tar.zst";
+  sha256 = "1mpx77q5g8pj45s8wgc52c4ww2r93080p6d559p56f558a3cl317";
+  name = "mingw-w64-clang-x86_64-libpsl-0.21.5-2-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -151,21 +151,21 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-p11-kit-0.25.3-1-any.pkg.tar.zst";
-  sha256 = "19330k2jxpzm552m7j116hz8qrn2d14h9ybi0lcmkj4c1l25m6mf";
-  name = "mingw-w64-clang-x86_64-p11-kit-0.25.3-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-p11-kit-0.25.3-2-any.pkg.tar.zst";
+  sha256 = "1jrwkc4lvw5hm5rqmi5gqh7mfkbqfa5gi81zjij0krnl0gaxw3c8";
+  name = "mingw-w64-clang-x86_64-p11-kit-0.25.3-2-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-ca-certificates-20230311-1-any.pkg.tar.zst";
-  sha256 = "00hdl239695xi5bgld7a1ssp6kapkb9az02dpx80vmz7mqg6wwxx";
-  name = "mingw-w64-clang-x86_64-ca-certificates-20230311-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-ca-certificates-20240203-1-any.pkg.tar.zst";
+  sha256 = "1q5nxhsk04gidz66ai5wgd4dr04lfyakkfja9p0r5hrgg4ppqqjg";
+  name = "mingw-w64-clang-x86_64-ca-certificates-20240203-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openssl-3.2.0-1-any.pkg.tar.zst";
-  sha256 = "1623bkf4bjwf4cs1j5f6c37gwj4z775kjk4jswwy58r61yimwnd5";
-  name = "mingw-w64-clang-x86_64-openssl-3.2.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openssl-3.2.1-1-any.pkg.tar.zst";
+  sha256 = "0ix2r4ll09m2z5vz2k94gmwfs0pp3ipvjdimwzx7v6xhcs2l25lz";
+  name = "mingw-w64-clang-x86_64-openssl-3.2.1-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -175,33 +175,39 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp2-1.58.0-1-any.pkg.tar.zst";
-  sha256 = "00f7raqmky43v9h2356yzfbvbhkbsjpc17n6ksgpv66h31svna6q";
-  name = "mingw-w64-clang-x86_64-nghttp2-1.58.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp2-1.60.0-1-any.pkg.tar.zst";
+  sha256 = "0wxw8266hf4qd2m4zpgb1wvlrnaksmcrs0kh5y9zpf2y5sy8f2bq";
+  name = "mingw-w64-clang-x86_64-nghttp2-1.60.0-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-curl-8.4.0-2-any.pkg.tar.zst";
-  sha256 = "1qi446lq1qqq45xn7fmasfb914jhahqc0cvpnqi8vrp9vlk9dsw3";
-  name = "mingw-w64-clang-x86_64-curl-8.4.0-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-curl-8.6.0-1-any.pkg.tar.zst";
+  sha256 = "1racc7cyzj22kink9w8m8jv73ji5hfg6r6d1ka9dqmvcbx04r8p0";
+  name = "mingw-w64-clang-x86_64-curl-8.6.0-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rust-1.74.0-1-any.pkg.tar.zst";
-  sha256 = "071xpmfsnr7j7ycf6w8kyg41fxs3dclnjrcp7grinck5bb5zxn6s";
-  name = "mingw-w64-clang-x86_64-rust-1.74.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rust-1.76.0-1-any.pkg.tar.zst";
+  sha256 = "0ny3bvwvn5wmqrxzhdfw34akr0kj0m7rg9lg3w5yibqz2mkqhk11";
+  name = "mingw-w64-clang-x86_64-rust-1.76.0-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-pkgconf-1~2.1.0-1-any.pkg.tar.zst";
-  sha256 = "04y364mzx2sj984cdxq187fg73hzkrzvbpsr5d86xfzrag789nh3";
-  name = "mingw-w64-clang-x86_64-pkgconf-12.1.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-pkgconf-1~2.1.1-1-any.pkg.tar.zst";
+  sha256 = "00kxqg9ds4q74lxrzjh8z0858smqbi1j9r06s0zjadsql0ln98cq";
+  name = "mingw-w64-clang-x86_64-pkgconf-12.1.1-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-jsoncpp-1.9.5-2-any.pkg.tar.zst";
-  sha256 = "0cpy76crngj5dfg9f4l216ry0wcavp0nabyc0b9g676rg6400qas";
-  name = "mingw-w64-clang-x86_64-jsoncpp-1.9.5-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-expat-2.6.2-1-any.pkg.tar.zst";
+  sha256 = "0kj1vzjh3qh7d2g47avlgk7a6j4nc62111hy1m63jwq0alc01k38";
+  name = "mingw-w64-clang-x86_64-expat-2.6.2-1-any.pkg.tar.zst";
+})
+
+(pkgs.fetchurl {
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-jsoncpp-1.9.5-3-any.pkg.tar.zst";
+  sha256 = "1a8mdn4ram9pgqpx5fwxmhcmzc6bh1fq1s4m37xh0d8p6fpncv10";
+  name = "mingw-w64-clang-x86_64-jsoncpp-1.9.5-3-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -223,15 +229,15 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libtre-git-r128.6fb7206-2-any.pkg.tar.zst";
-  sha256 = "0bmdla75k0q88l93ql9ajbfag4vhdhyp0glzymljvcc7ir0r6f9r";
-  name = "mingw-w64-clang-x86_64-libtre-git-r128.6fb7206-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libtre-git-r177.07e66d0-2-any.pkg.tar.zst";
+  sha256 = "0fc9hxsdks1xy5fv0rcna433hlzf6jhs77hg0hfzkzhn06f9alp4";
+  name = "mingw-w64-clang-x86_64-libtre-git-r177.07e66d0-2-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libsystre-1.0.1-4-any.pkg.tar.zst";
-  sha256 = "0x5ns8ld08gd9r5a98sqi3sm0vz588caaqw10ciix16sgyisfpdh";
-  name = "mingw-w64-clang-x86_64-libsystre-1.0.1-4-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libsystre-1.0.1-5-any.pkg.tar.zst";
+  sha256 = "05qsn8fkks4f93jkas43s47axqqgx5m64b45p462si3nlb8cjirq";
+  name = "mingw-w64-clang-x86_64-libsystre-1.0.1-5-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -241,9 +247,9 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libuv-1.47.0-1-any.pkg.tar.zst";
-  sha256 = "1ch8g0mp13dmwi7sc6qxjcx18s1w0bsdl5lhkjmx5ccz55sspnyf";
-  name = "mingw-w64-clang-x86_64-libuv-1.47.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libuv-1.48.0-1-any.pkg.tar.zst";
+  sha256 = "0kfzanvx7hg7bvy35h2z2vcfxvwn44sikd36mvzhkv6c3c6y84sn";
+  name = "mingw-w64-clang-x86_64-libuv-1.48.0-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -253,27 +259,27 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rhash-1.4.3-1-any.pkg.tar.zst";
-  sha256 = "16ghg6894gb3lcrcpc8g1jd7524djnsjrqcr3krqlzskfv51hgj6";
-  name = "mingw-w64-clang-x86_64-rhash-1.4.3-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rhash-1.4.4-3-any.pkg.tar.zst";
+  sha256 = "1ysbxirpfr0yf7pvyps75lnwc897w2a2kcid3nb4j6ilw6n64jmc";
+  name = "mingw-w64-clang-x86_64-rhash-1.4.4-3-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cmake-3.27.8-1-any.pkg.tar.zst";
-  sha256 = "1hm5975q0kfd0z502qpxq1imwvby3qb93jzhbvrg2fz9zf5d31rg";
-  name = "mingw-w64-clang-x86_64-cmake-3.27.8-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cmake-3.29.0-1-any.pkg.tar.zst";
+  sha256 = "0l79lf6zihn0k8hz93qnjnq259y45yq19235g9c444jc2w093si1";
+  name = "mingw-w64-clang-x86_64-cmake-3.29.0-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-mpdecimal-2.5.1-1-any.pkg.tar.zst";
-  sha256 = "0zm9pqcgjk9a8ql6hxcxh477wvvyimndcisd6zrr6y8m5vvklsdi";
-  name = "mingw-w64-clang-x86_64-mpdecimal-2.5.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-mpdecimal-4.0.0-1-any.pkg.tar.zst";
+  sha256 = "0hrhbjgi0g3jqpw8himshqw6vazm5sxhsfmyg386nbrxwnfgl1gb";
+  name = "mingw-w64-clang-x86_64-mpdecimal-4.0.0-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-ncurses-6.4.20230708-1-any.pkg.tar.zst";
-  sha256 = "0l960cf4m558kx6dwahl9z2zdb9vlqd7qgk39kg924mzrfjrsvv5";
-  name = "mingw-w64-clang-x86_64-ncurses-6.4.20230708-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-ncurses-6.4.20231217-1-any.pkg.tar.zst";
+  sha256 = "00046d52zsr8zjifl7h22jfihhh53h20ipvbqmvf9myssw2fwjza";
+  name = "mingw-w64-clang-x86_64-ncurses-6.4.20231217-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -283,21 +289,21 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-readline-8.2.001-6-any.pkg.tar.zst";
-  sha256 = "1aw1qxjvifkzxnn52l6hba1kcj2dci8llzzj29zbvbq5hgllf6dv";
-  name = "mingw-w64-clang-x86_64-readline-8.2.001-6-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-readline-8.2.010-1-any.pkg.tar.zst";
+  sha256 = "1s47pd5iz8y3hspsxn4pnp0v3m05ccia40v5nfvx0rmwgvcaz82v";
+  name = "mingw-w64-clang-x86_64-readline-8.2.010-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-tcl-8.6.12-2-any.pkg.tar.zst";
-  sha256 = "06r7ni7m1vf83ms8ha3glalc5rfriiffh7v644jmnvzs5g9x0pzb";
-  name = "mingw-w64-clang-x86_64-tcl-8.6.12-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-tcl-8.6.13-1-any.pkg.tar.zst";
+  sha256 = "0paaqwk0sfy2zxwlxkmxf2bqq46lyg0sx7cqgzknvazwx8xa2z4x";
+  name = "mingw-w64-clang-x86_64-tcl-8.6.13-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-sqlite3-3.44.0-1-any.pkg.tar.zst";
-  sha256 = "022vy54ph6kxmgafbsmgpclvd55ljarvc4k7497ka03g7465zq6j";
-  name = "mingw-w64-clang-x86_64-sqlite3-3.44.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-sqlite3-3.45.2-1-any.pkg.tar.zst";
+  sha256 = "1icvw3f08cgi94p0177i46v72wgpsxw95p6kd0sm2w3vj0qlqbcw";
+  name = "mingw-w64-clang-x86_64-sqlite3-3.45.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
@@ -307,38 +313,38 @@
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-tzdata-2023c-1-any.pkg.tar.zst";
-  sha256 = "018qw8lk5r7gqvavnl1414gmbd4bx22528a7bjk4injfr3cib9c2";
-  name = "mingw-w64-clang-x86_64-tzdata-2023c-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-tzdata-2024a-1-any.pkg.tar.zst";
+  sha256 = "1lsfn3759cyf56zlmfvgy6ihs4iks6zhlnrbfmnq5wml02k936ji";
+  name = "mingw-w64-clang-x86_64-tzdata-2024a-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-3.11.6-2-any.pkg.tar.zst";
-  sha256 = "0j6wkjjay52f4mgvfagi7xql4v74dizhmwdx07n2fixr7j1lg6n7";
-  name = "mingw-w64-clang-x86_64-python-3.11.6-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-3.11.8-1-any.pkg.tar.zst";
+  sha256 = "0djpf4k8s25nys6nrm2x2v134lcgzhhbjs37ihkg0b3sxmmc3b0p";
+  name = "mingw-w64-clang-x86_64-python-3.11.8-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openmp-17.0.4-1-any.pkg.tar.zst";
-  sha256 = "1y2cf43fcyb1qv4kn0h0mzljmibaqklcj167krwxq5ymfbipy1yw";
-  name = "mingw-w64-clang-x86_64-openmp-17.0.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openmp-18.1.2-1-any.pkg.tar.zst";
+  sha256 = "1v9wm3ja3a7a7yna2bpqky481qf244wc98kfdl7l03k7rkvvydpl";
+  name = "mingw-w64-clang-x86_64-openmp-18.1.2-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openblas-0.3.25-1-any.pkg.tar.zst";
-  sha256 = "1789hd7sc249vbzppqqg56i080c8kc6bj6qngn9rjvzcdllh0d07";
-  name = "mingw-w64-clang-x86_64-openblas-0.3.25-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openblas-0.3.26-1-any.pkg.tar.zst";
+  sha256 = "0kdr72y5lc9dl9s1bjrw8g21qmv2iwd1xvn1r21170i277wsmqiv";
+  name = "mingw-w64-clang-x86_64-openblas-0.3.26-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-numpy-1.26.2-1-any.pkg.tar.zst";
-  sha256 = "1njbxlxha05c8fzm7yl3ksjlpanh5jxn1z1s06iv9knx2zmqjk6f";
-  name = "mingw-w64-clang-x86_64-python-numpy-1.26.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-numpy-1.26.4-1-any.pkg.tar.zst";
+  sha256 = "00h0ap954cjwlsc3p01fjwy7s3nlzs90v0kmnrzxm0rljmvn4jkf";
+  name = "mingw-w64-clang-x86_64-python-numpy-1.26.4-1-any.pkg.tar.zst";
 })
 
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-setuptools-68.2.2-1-any.pkg.tar.zst";
-  sha256 = "16m1ph7yq3mqzaaaka5vij27jzaw59lpxwbmpdxkcp8lb6h5xcn9";
-  name = "mingw-w64-clang-x86_64-python-setuptools-68.2.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-setuptools-69.1.1-1-any.pkg.tar.zst";
+  sha256 = "1mc56anasj0v92nlg84m3pa7dbqgjakxw0b4ibqlrr9cq0xzsg4b";
+  name = "mingw-w64-clang-x86_64-python-setuptools-69.1.1-1-any.pkg.tar.zst";
 })
 ]