core/ndstrides: implement subscript assignment

The IRRT implementation knows how to handle axes. But the argument is
not in NAC3 yet.

.clang-format

@@ -1,32 +1,3 @@
-BasedOnStyle: LLVM
-
-Language: Cpp
-Standard: Cpp11
-
-AccessModifierOffset: -1
-AlignEscapedNewlines: Left
-AlwaysBreakAfterReturnType: None
-AlwaysBreakTemplateDeclarations: Yes
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortFunctionsOnASingleLine: Inline
-BinPackParameters: false
-BreakBeforeBinaryOperators: NonAssignment
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializers: AfterColon
-BreakInheritanceList: AfterColon
-ColumnLimit: 120
-ConstructorInitializerAllOnOneLineOrOnePerLine: true
-ContinuationIndentWidth: 4
-DerivePointerAlignment: false
-IndentCaseLabels: true
-IndentPPDirectives: None
+BasedOnStyle: Microsoft
 IndentWidth: 4
-MaxEmptyLinesToKeep: 1
-PointerAlignment: Left
-ReflowComments: true
-SortIncludes: false
-SortUsingDeclarations: true
-SpaceAfterTemplateKeyword: false
-SpacesBeforeTrailingComments: 2
-TabWidth: 4
-UseTab: Never
+ReflowComments: false

Cargo.lock

@@ -117,9 +117,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "cc"
-version = "1.1.15"
+version = "1.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57b6a275aa2903740dc87da01c62040406b8812552e97129a63ea8850a17c6e6"
+checksum = "72db2f7947ecee9b03b510377e8bb9077afa27176fdbff55c51027e976fdcc48"
 dependencies = [
  "shlex",
 ]
@@ -161,7 +161,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -310,9 +310,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.1.1"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
+checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
 
 [[package]]
 name = "fixedbitset"
@@ -424,7 +424,7 @@ checksum = "4fa4d8d74483041a882adaa9a29f633253a66dde85055f0495c121620ac484b2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -510,9 +510,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.158"
+version = "0.2.157"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86"
 
 [[package]]
 name = "libloading"
@@ -752,7 +752,7 @@ dependencies = [
  "phf_shared 0.11.2",
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -856,7 +856,7 @@ dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -869,14 +869,14 @@ dependencies = [
  "proc-macro2",
  "pyo3-build-config",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
  "proc-macro2",
 ]
@@ -942,9 +942,9 @@ dependencies = [
 
 [[package]]
 name = "redox_users"
-version = "0.4.6"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
  "getrandom",
  "libredox",
@@ -989,9 +989,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.35"
+version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a85d50532239da68e9addb745ba38ff4612a242c1c7ceea689c4bc7c2f43c36f"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
  "bitflags",
  "errno",
@@ -1035,29 +1035,29 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 
 [[package]]
 name = "serde"
-version = "1.0.209"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.209"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.127"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
 dependencies = [
  "itoa",
  "memchr",
@@ -1147,7 +1147,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1163,9 +1163,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.76"
+version = "2.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1232,7 +1232,7 @@ checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1310,9 +1310,9 @@ checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.5"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229730647fbc343e3a80e463c1db7f78f3855d3f3739bee0dda773c9a037c90a"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
 [[package]]
 name = "unicode_names2"
@@ -1510,5 +1510,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.76",
+ "syn 2.0.75",
 ]

nac3artiq/src/codegen.rs

@@ -2,7 +2,7 @@ use nac3core::{
     codegen::{
         classes::{
             ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayType,
-            NDArrayValue, ProxyType, ProxyValue, RangeValue, UntypedArrayLikeAccessor,
+            NDArrayValue, RangeValue, UntypedArrayLikeAccessor,
         },
         expr::{destructure_range, gen_call},
         irrt::call_ndarray_calc_size,
@@ -22,7 +22,7 @@ use inkwell::{
     module::Linkage,
     types::{BasicType, IntType},
     values::{BasicValueEnum, PointerValue, StructValue},
-    AddressSpace, IntPredicate, OptimizationLevel,
+    AddressSpace, IntPredicate,
 };
 
 use pyo3::{
@@ -32,7 +32,6 @@ use pyo3::{
 
 use crate::{symbol_resolver::InnerResolver, timeline::TimeFns};
 
-use inkwell::values::IntValue;
 use itertools::Itertools;
 use std::{
     collections::{hash_map::DefaultHasher, HashMap},
@@ -487,10 +486,13 @@ fn format_rpc_arg<'ctx>(
             let buffer = ctx.builder.build_array_alloca(llvm_i8, buffer_size, "rpc.arg").unwrap();
             let buffer = ArraySliceValue::from_ptr_val(buffer, buffer_size, Some("rpc.arg"));
 
+            let ppdata = generator.gen_var_alloc(ctx, llvm_arg_ty.element_type(), None).unwrap();
+            ctx.builder.build_store(ppdata, llvm_arg.data().base_ptr(ctx, generator)).unwrap();
+
             call_memcpy_generic(
                 ctx,
                 buffer.base_ptr(ctx, generator),
-                llvm_arg.ptr_to_data(ctx),
+                ppdata,
                 llvm_pdata_sizeof,
                 llvm_i1.const_zero(),
             );
@@ -526,298 +528,6 @@ fn format_rpc_arg<'ctx>(
     arg_slot
 }
 
-/// Formats an RPC return value to conform to the expected format required by NAC3.
-fn format_rpc_ret<'ctx>(
-    generator: &mut dyn CodeGenerator,
-    ctx: &mut CodeGenContext<'ctx, '_>,
-    ret_ty: Type,
-) -> Option<BasicValueEnum<'ctx>> {
-    // -- receive value:
-    // T result = {
-    //   void *ret_ptr = alloca(sizeof(T));
-    //   void *ptr = ret_ptr;
-    //   loop: int size = rpc_recv(ptr);
-    //   // Non-zero: Provide `size` bytes of extra storage for variable-length data.
-    //   if(size) { ptr = alloca(size); goto loop; }
-    //   else *(T*)ret_ptr
-    // }
-
-    let llvm_i8 = ctx.ctx.i8_type();
-    let llvm_i32 = ctx.ctx.i32_type();
-    let llvm_i8_8 = ctx.ctx.struct_type(&[llvm_i8.array_type(8).into()], false);
-    let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
-
-    let rpc_recv = ctx.module.get_function("rpc_recv").unwrap_or_else(|| {
-        ctx.module.add_function("rpc_recv", llvm_i32.fn_type(&[llvm_pi8.into()], false), None)
-    });
-
-    if ctx.unifier.unioned(ret_ty, ctx.primitives.none) {
-        ctx.build_call_or_invoke(rpc_recv, &[llvm_pi8.const_null().into()], "rpc_recv");
-        return None;
-    }
-
-    let prehead_bb = ctx.builder.get_insert_block().unwrap();
-    let current_function = prehead_bb.get_parent().unwrap();
-    let head_bb = ctx.ctx.append_basic_block(current_function, "rpc.head");
-    let alloc_bb = ctx.ctx.append_basic_block(current_function, "rpc.continue");
-    let tail_bb = ctx.ctx.append_basic_block(current_function, "rpc.tail");
-
-    let llvm_ret_ty = ctx.get_llvm_abi_type(generator, ret_ty);
-
-    let result = match &*ctx.unifier.get_ty_immutable(ret_ty) {
-        TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
-            let llvm_i1 = ctx.ctx.bool_type();
-            let llvm_usize = generator.get_size_type(ctx.ctx);
-
-            // Round `val` up to its modulo `power_of_two`
-            let round_up = |ctx: &mut CodeGenContext<'ctx, '_>,
-                            val: IntValue<'ctx>,
-                            power_of_two: IntValue<'ctx>| {
-                debug_assert_eq!(
-                    val.get_type().get_bit_width(),
-                    power_of_two.get_type().get_bit_width()
-                );
-
-                let llvm_val_t = val.get_type();
-
-                let max_rem = ctx
-                    .builder
-                    .build_int_sub(power_of_two, llvm_val_t.const_int(1, false), "")
-                    .unwrap();
-                ctx.builder
-                    .build_and(
-                        ctx.builder.build_int_add(val, max_rem, "").unwrap(),
-                        ctx.builder.build_not(max_rem, "").unwrap(),
-                        "",
-                    )
-                    .unwrap()
-            };
-
-            // Setup types
-            let (elem_ty, ndims) = unpack_ndarray_var_tys(&mut ctx.unifier, ret_ty);
-            let llvm_elem_ty = ctx.get_llvm_type(generator, elem_ty);
-            let llvm_ret_ty = NDArrayType::new(generator, ctx.ctx, llvm_elem_ty);
-
-            // Allocate the resulting ndarray
-            // A condition after format_rpc_ret ensures this will not be popped this off.
-            let ndarray = llvm_ret_ty.new_value(generator, ctx, Some("rpc.result"));
-
-            // Setup ndims
-            let ndims =
-                if let TypeEnum::TLiteral { values, .. } = &*ctx.unifier.get_ty_immutable(ndims) {
-                    assert_eq!(values.len(), 1);
-
-                    u64::try_from(values[0].clone()).unwrap()
-                } else {
-                    unreachable!();
-                };
-            // Set `ndarray.ndims`
-            ndarray.store_ndims(ctx, generator, llvm_usize.const_int(ndims, false));
-            // Allocate `ndarray.shape` [size_t; ndims]
-            ndarray.create_dim_sizes(ctx, llvm_usize, ndarray.load_ndims(ctx));
-
-            /*
-                ndarray now:
-                  - .ndims: initialized
-                  - .shape: allocated but uninitialized .shape
-                  - .data: uninitialized
-            */
-
-            let llvm_usize_sizeof = ctx
-                .builder
-                .build_int_truncate_or_bit_cast(llvm_usize.size_of(), llvm_usize, "")
-                .unwrap();
-            let llvm_pdata_sizeof = ctx
-                .builder
-                .build_int_truncate_or_bit_cast(
-                    llvm_ret_ty.element_type().size_of().unwrap(),
-                    llvm_usize,
-                    "",
-                )
-                .unwrap();
-            let llvm_elem_sizeof = ctx
-                .builder
-                .build_int_truncate_or_bit_cast(llvm_elem_ty.size_of().unwrap(), llvm_usize, "")
-                .unwrap();
-
-            // Allocates a buffer for the initial RPC'ed object, which is guaranteed to be
-            // (4 + 4 * ndims) bytes with 8-byte alignment
-            let sizeof_dims =
-                ctx.builder.build_int_mul(ndarray.load_ndims(ctx), llvm_usize_sizeof, "").unwrap();
-            let unaligned_buffer_size =
-                ctx.builder.build_int_add(sizeof_dims, llvm_pdata_sizeof, "").unwrap();
-            let buffer_size = round_up(ctx, unaligned_buffer_size, llvm_usize.const_int(8, false));
-
-            let stackptr = call_stacksave(ctx, None);
-            // Just to be absolutely sure, alloca in [i8 x 8] slices to force 8-byte alignment
-            let buffer = ctx
-                .builder
-                .build_array_alloca(
-                    llvm_i8_8,
-                    ctx.builder
-                        .build_int_unsigned_div(buffer_size, llvm_usize.const_int(8, false), "")
-                        .unwrap(),
-                    "rpc.buffer",
-                )
-                .unwrap();
-            let buffer = ctx
-                .builder
-                .build_bitcast(buffer, llvm_pi8, "")
-                .map(BasicValueEnum::into_pointer_value)
-                .unwrap();
-            let buffer = ArraySliceValue::from_ptr_val(buffer, buffer_size, None);
-
-            // The first call to `rpc_recv` reads the top-level ndarray object: [pdata, shape]
-            //
-            // The returned value is the number of bytes for `ndarray.data`.
-            let ndarray_nbytes = ctx
-                .build_call_or_invoke(
-                    rpc_recv,
-                    &[buffer.base_ptr(ctx, generator).into()], // Reads [usize; ndims]. NOTE: We are allocated [size_t; ndims].
-                    "rpc.size.next",
-                )
-                .map(BasicValueEnum::into_int_value)
-                .unwrap();
-
-            // debug_assert(ndarray_nbytes > 0)
-            if ctx.registry.llvm_options.opt_level == OptimizationLevel::None {
-                ctx.make_assert(
-                    generator,
-                    ctx.builder
-                        .build_int_compare(
-                            IntPredicate::UGT,
-                            ndarray_nbytes,
-                            ndarray_nbytes.get_type().const_zero(),
-                            "",
-                        )
-                        .unwrap(),
-                    "0:AssertionError",
-                    "Unexpected RPC termination for ndarray - Expected data buffer next",
-                    [None, None, None],
-                    ctx.current_loc,
-                );
-            }
-
-            // Copy shape from the buffer to `ndarray.shape`.
-            let pbuffer_dims =
-                unsafe { buffer.ptr_offset_unchecked(ctx, generator, &llvm_pdata_sizeof, None) };
-
-            call_memcpy_generic(
-                ctx,
-                ndarray.dim_sizes().base_ptr(ctx, generator),
-                pbuffer_dims,
-                sizeof_dims,
-                llvm_i1.const_zero(),
-            );
-            // Restore stack from before allocation of buffer
-            call_stackrestore(ctx, stackptr);
-
-            // Allocate `ndarray.data`.
-            // `ndarray.shape` must be initialized beforehand in this implementation
-            //   (for ndarray.create_data() to know how many elements to allocate)
-            let num_elements =
-                call_ndarray_calc_size(generator, ctx, &ndarray.dim_sizes(), (None, None));
-
-            // debug_assert(nelems * sizeof(T) >= ndarray_nbytes)
-            if ctx.registry.llvm_options.opt_level == OptimizationLevel::None {
-                let sizeof_data =
-                    ctx.builder.build_int_mul(num_elements, llvm_elem_sizeof, "").unwrap();
-
-                ctx.make_assert(
-                    generator,
-                    ctx.builder.build_int_compare(IntPredicate::UGE,
-                        sizeof_data,
-                        ndarray_nbytes,
-                        "",
-                    ).unwrap(),
-                    "0:AssertionError",
-                    "Unexpected allocation size request for ndarray data - Expected up to {0} bytes, got {1} bytes",
-                    [Some(sizeof_data), Some(ndarray_nbytes), None],
-                    ctx.current_loc,
-                );
-            }
-
-            ndarray.create_data(ctx, llvm_elem_ty, num_elements);
-
-            let ndarray_data = ndarray.data().base_ptr(ctx, generator);
-            let ndarray_data_i8 =
-                ctx.builder.build_pointer_cast(ndarray_data, llvm_pi8, "").unwrap();
-
-            // NOTE: Currently on `prehead_bb`
-            ctx.builder.build_unconditional_branch(head_bb).unwrap();
-
-            // Inserting into `head_bb`. Do `rpc_recv` for `data` recursively.
-            ctx.builder.position_at_end(head_bb);
-
-            let phi = ctx.builder.build_phi(llvm_pi8, "rpc.ptr").unwrap();
-            phi.add_incoming(&[(&ndarray_data_i8, prehead_bb)]);
-
-            let alloc_size = ctx
-                .build_call_or_invoke(rpc_recv, &[phi.as_basic_value()], "rpc.size.next")
-                .map(BasicValueEnum::into_int_value)
-                .unwrap();
-
-            let is_done = ctx
-                .builder
-                .build_int_compare(IntPredicate::EQ, llvm_i32.const_zero(), alloc_size, "rpc.done")
-                .unwrap();
-            ctx.builder.build_conditional_branch(is_done, tail_bb, alloc_bb).unwrap();
-
-            ctx.builder.position_at_end(alloc_bb);
-            // Align the allocation to sizeof(T)
-            let alloc_size = round_up(ctx, alloc_size, llvm_elem_sizeof);
-            let alloc_ptr = ctx
-                .builder
-                .build_array_alloca(
-                    llvm_elem_ty,
-                    ctx.builder.build_int_unsigned_div(alloc_size, llvm_elem_sizeof, "").unwrap(),
-                    "rpc.alloc",
-                )
-                .unwrap();
-            let alloc_ptr =
-                ctx.builder.build_pointer_cast(alloc_ptr, llvm_pi8, "rpc.alloc.ptr").unwrap();
-            phi.add_incoming(&[(&alloc_ptr, alloc_bb)]);
-            ctx.builder.build_unconditional_branch(head_bb).unwrap();
-
-            ctx.builder.position_at_end(tail_bb);
-            ndarray.as_base_value().into()
-        }
-
-        _ => {
-            let slot = ctx.builder.build_alloca(llvm_ret_ty, "rpc.ret.slot").unwrap();
-            let slotgen = ctx.builder.build_bitcast(slot, llvm_pi8, "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(llvm_pi8, "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(IntPredicate::EQ, llvm_i32.const_zero(), alloc_size, "rpc.done")
-                .unwrap();
-
-            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(llvm_pi8, alloc_size, "rpc.alloc").unwrap();
-            let alloc_ptr =
-                ctx.builder.build_bitcast(alloc_ptr, llvm_pi8, "rpc.alloc.ptr").unwrap();
-            phi.add_incoming(&[(&alloc_ptr, alloc_bb)]);
-            ctx.builder.build_unconditional_branch(head_bb).unwrap();
-
-            ctx.builder.position_at_end(tail_bb);
-            ctx.builder.build_load(slot, "rpc.result").unwrap()
-        }
-    };
-
-    Some(result)
-}
-
 fn rpc_codegen_callback_fn<'ctx>(
     ctx: &mut CodeGenContext<'ctx, '_>,
     obj: Option<(Type, ValueEnum<'ctx>)>,
@@ -953,14 +663,63 @@ fn rpc_codegen_callback_fn<'ctx>(
     // reclaim stack space used by arguments
     call_stackrestore(ctx, stackptr);
 
-    let result = format_rpc_ret(generator, ctx, fun.0.ret);
+    // -- receive value:
+    // T result = {
+    //   void *ret_ptr = alloca(sizeof(T));
+    //   void *ptr = ret_ptr;
+    //   loop: int size = rpc_recv(ptr);
+    //   // Non-zero: Provide `size` bytes of extra storage for variable-length data.
+    //   if(size) { ptr = alloca(size); goto loop; }
+    //   else *(T*)ret_ptr
+    // }
+    let rpc_recv = ctx.module.get_function("rpc_recv").unwrap_or_else(|| {
+        ctx.module.add_function("rpc_recv", int32.fn_type(&[ptr_type.into()], false), None)
+    });
 
-    if !result.is_some_and(|res| res.get_type().is_pointer_type()) {
-        // An RPC returning an NDArray would not touch here.
-        call_stackrestore(ctx, stackptr);
+    if ctx.unifier.unioned(fun.0.ret, ctx.primitives.none) {
+        ctx.build_call_or_invoke(rpc_recv, &[ptr_type.const_null().into()], "rpc_recv");
+        return Ok(None);
     }
 
-    Ok(result)
+    let prehead_bb = ctx.builder.get_insert_block().unwrap();
+    let current_function = prehead_bb.get_parent().unwrap();
+    let head_bb = ctx.ctx.append_basic_block(current_function, "rpc.head");
+    let alloc_bb = ctx.ctx.append_basic_block(current_function, "rpc.continue");
+    let tail_bb = ctx.ctx.append_basic_block(current_function, "rpc.tail");
+
+    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").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").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")
+        .unwrap();
+
+    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").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).unwrap();
+
+    ctx.builder.position_at_end(tail_bb);
+
+    let result = ctx.builder.build_load(slot, "rpc.result").unwrap();
+    if need_load {
+        call_stackrestore(ctx, stackptr);
+    }
+    Ok(Some(result))
 }
 
 pub fn attributes_writeback(

nac3artiq/src/lib.rs

@@ -33,6 +33,7 @@ use inkwell::{
     OptimizationLevel,
 };
 use itertools::Itertools;
+use nac3core::codegen::irrt::setup_irrt_exceptions;
 use nac3core::codegen::{gen_func_impl, CodeGenLLVMOptions, CodeGenTargetMachineOptions};
 use nac3core::toplevel::builtins::get_exn_constructor;
 use nac3core::typecheck::typedef::{into_var_map, TypeEnum, Unifier, VarMap};
@@ -448,6 +449,7 @@ impl Nac3 {
                         pyid_to_type: pyid_to_type.clone(),
                         primitive_ids: self.primitive_ids.clone(),
                         global_value_ids: global_value_ids.clone(),
+                        class_names: Mutex::default(),
                         name_to_pyid: name_to_pyid.clone(),
                         module: module.clone(),
                         id_to_pyval: RwLock::default(),
@@ -539,6 +541,7 @@ impl Nac3 {
             pyid_to_type: pyid_to_type.clone(),
             primitive_ids: self.primitive_ids.clone(),
             global_value_ids: global_value_ids.clone(),
+            class_names: Mutex::default(),
             id_to_pyval: RwLock::default(),
             id_to_primitive: RwLock::default(),
             field_to_val: RwLock::default(),
@@ -557,7 +560,8 @@ impl Nac3 {
 
         // Process IRRT
         let context = inkwell::context::Context::create();
-        let irrt = load_irrt(&context, resolver.as_ref());
+        let irrt = load_irrt(&context);
+        setup_irrt_exceptions(&context, &irrt, resolver.as_ref());
 
         let fun_signature =
             FunSignature { args: vec![], ret: self.primitive.none, vars: VarMap::new() };

nac3artiq/src/symbol_resolver.rs

@@ -23,7 +23,7 @@ use nac3core::{
     },
 };
 use nac3parser::ast::{self, StrRef};
-use parking_lot::RwLock;
+use parking_lot::{Mutex, RwLock};
 use pyo3::{
     types::{PyDict, PyTuple},
     PyAny, PyObject, PyResult, Python,
@@ -79,6 +79,7 @@ pub struct InnerResolver {
     pub id_to_primitive: RwLock<HashMap<u64, PrimitiveValue>>,
     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>>>,
     pub pyid_to_type: Arc<RwLock<HashMap<u64, Type>>>,
     pub primitive_ids: PrimitivePythonId,

nac3core/build.rs

@@ -22,7 +22,6 @@ fn main() {
         "--target=wasm32",
         "-x",
         "c++",
-        "-std=c++20",
         "-fno-discard-value-names",
         "-fno-exceptions",
         "-fno-rtti",

nac3core/irrt/irrt.cpp

@@ -1,15 +1,15 @@
-#include "irrt/exception.hpp"
-#include "irrt/int_types.hpp"
-#include "irrt/list.hpp"
-#include "irrt/math.hpp"
-#include "irrt/ndarray.hpp"
-#include "irrt/range.hpp"
-#include "irrt/slice.hpp"
-#include "irrt/ndarray/basic.hpp"
-#include "irrt/ndarray/def.hpp"
-#include "irrt/ndarray/iter.hpp"
-#include "irrt/ndarray/indexing.hpp"
-#include "irrt/ndarray/array.hpp"
-#include "irrt/ndarray/reshape.hpp"
-#include "irrt/ndarray/broadcast.hpp"
-#include "irrt/ndarray/transpose.hpp"
+#include <irrt/exception.hpp>
+#include <irrt/int_types.hpp>
+#include <irrt/list.hpp>
+#include <irrt/math_util.hpp>
+#include <irrt/ndarray/array.hpp>
+#include <irrt/ndarray/basic.hpp>
+#include <irrt/ndarray/broadcast.hpp>
+#include <irrt/ndarray/def.hpp>
+#include <irrt/ndarray/indexing.hpp>
+#include <irrt/ndarray/iter.hpp>
+#include <irrt/ndarray/reshape.hpp>
+#include <irrt/ndarray/transpose.hpp>
+#include <irrt/original.hpp>
+#include <irrt/range.hpp>
+#include <irrt/slice.hpp>

nac3core/irrt/irrt/cslice.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "irrt/int_types.hpp"
+#include <irrt/int_types.hpp>
 
-template<typename SizeT>
-struct CSlice {
-    uint8_t* base;
+template <typename SizeT> struct CSlice
+{
+    uint8_t *base;
     SizeT len;
 };

nac3core/irrt/irrt/cstr_util.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <irrt/int_types.hpp>
+
+namespace cstr
+{
+/**
+ * @brief Implementation of `strlen()`.
+ */
+uint32_t length(const char *str)
+{
+    uint32_t length = 0;
+    while (*str != '\0')
+    {
+        length++;
+        str++;
+    }
+    return length;
+}
+} // namespace cstr

nac3core/irrt/irrt/debug.hpp

@@ -7,19 +7,17 @@
 #define IRRT_DEBUG_ASSERT_BOOL false
 #endif
 
-#define raise_debug_assert(SizeT, msg, param1, param2, param3) \
-    raise_exception(SizeT, EXN_ASSERTION_ERROR, "IRRT debug assert failed: " msg, param1, param2, param3)
+#define raise_debug_assert(SizeT, msg, param1, param2, param3)                                                         \
+    raise_exception(SizeT, EXN_ASSERTION_ERROR, "IRRT debug assert failed: " msg, param1, param2, param3);
 
-#define debug_assert_eq(SizeT, lhs, rhs)                                           \
-    if constexpr (IRRT_DEBUG_ASSERT_BOOL) {                                        \
-        if ((lhs) != (rhs)) {                                                      \
-            raise_debug_assert(SizeT, "LHS = {0}. RHS = {1}", lhs, rhs, NO_PARAM); \
-        }                                                                          \
+#define debug_assert_eq(SizeT, lhs, rhs)                                                                               \
+    if (IRRT_DEBUG_ASSERT_BOOL && (lhs) != (rhs))                                                                      \
+    {                                                                                                                  \
+        raise_debug_assert(SizeT, "LHS = {0}. RHS = {1}", lhs, rhs, NO_PARAM);                                         \
     }
 
-#define debug_assert(SizeT, expr)                                                  \
-    if constexpr (IRRT_DEBUG_ASSERT_BOOL) {                                        \
-        if (!(expr)) {                                                             \
-            raise_debug_assert(SizeT, "Got false.", NO_PARAM, NO_PARAM, NO_PARAM); \
-        }                                                                          \
+#define debug_assert(SizeT, expr)                                                                                      \
+    if (IRRT_DEBUG_ASSERT_BOOL && !(expr))                                                                             \
+    {                                                                                                                  \
+        raise_debug_assert(SizeT, "Got false.", NO_PARAM, NO_PARAM, NO_PARAM);                                         \
     }

nac3core/irrt/irrt/exception.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
-#include "irrt/cslice.hpp"
-#include "irrt/int_types.hpp"
+#include <irrt/cslice.hpp>
+#include <irrt/cstr_util.hpp>
+#include <irrt/int_types.hpp>
 
 /**
  * @brief The int type of ARTIQ exception IDs.
@@ -12,11 +13,12 @@ typedef int32_t ExceptionId;
  * Set of exceptions C++ IRRT can use.
  * Must be synchronized with `setup_irrt_exceptions` in `nac3core/src/codegen/irrt/mod.rs`.
  */
-extern "C" {
-ExceptionId EXN_INDEX_ERROR;
-ExceptionId EXN_VALUE_ERROR;
-ExceptionId EXN_ASSERTION_ERROR;
-ExceptionId EXN_TYPE_ERROR;
+extern "C"
+{
+    ExceptionId EXN_INDEX_ERROR;
+    ExceptionId EXN_VALUE_ERROR;
+    ExceptionId EXN_ASSERTION_ERROR;
+    ExceptionId EXN_TYPE_ERROR;
 }
 
 /**
@@ -25,14 +27,15 @@ ExceptionId EXN_TYPE_ERROR;
  * The parameter `err` could be `Exception<int32_t>` or `Exception<int64_t>`. The caller
  * must make sure to pass `Exception`s with the correct `SizeT` depending on the `size_t` of the runtime.
  */
-extern "C" void __nac3_raise(void* err);
+extern "C" void __nac3_raise(void *err);
 
-namespace {
+namespace
+{
 /**
  * @brief NAC3's Exception struct
  */
-template<typename SizeT>
-struct Exception {
+template <typename SizeT> struct Exception
+{
     ExceptionId id;
     CSlice<SizeT> filename;
     int32_t line;
@@ -42,32 +45,24 @@ struct Exception {
     int64_t params[3];
 };
 
-constexpr int64_t NO_PARAM = 0;
+const int64_t NO_PARAM = 0;
 
-template<typename SizeT>
-void _raise_exception_helper(ExceptionId id,
-                             const char* filename,
-                             int32_t line,
-                             const char* function,
-                             const char* msg,
-                             int64_t param0,
-                             int64_t param1,
-                             int64_t param2) {
+template <typename SizeT>
+void _raise_exception_helper(ExceptionId id, const char *filename, int32_t line, const char *function, const char *msg,
+                             int64_t param0, int64_t param1, int64_t param2)
+{
     Exception<SizeT> e = {
         .id = id,
-        .filename = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(filename)),
-                     .len = static_cast<int32_t>(__builtin_strlen(filename))},
+        .filename = {.base = (uint8_t *)filename, .len = (int32_t)cstr::length(filename)},
         .line = line,
         .column = 0,
-        .function = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(function)),
-                     .len = static_cast<int32_t>(__builtin_strlen(function))},
-        .msg = {.base = reinterpret_cast<uint8_t*>(const_cast<char*>(msg)),
-                .len = static_cast<int32_t>(__builtin_strlen(msg))},
+        .function = {.base = (uint8_t *)function, .len = (int32_t)cstr::length(function)},
+        .msg = {.base = (uint8_t *)msg, .len = (int32_t)cstr::length(msg)},
     };
     e.params[0] = param0;
     e.params[1] = param1;
     e.params[2] = param2;
-    __nac3_raise(reinterpret_cast<void*>(&e));
+    __nac3_raise((void *)&e);
     __builtin_unreachable();
 }
 
@@ -80,6 +75,6 @@ void _raise_exception_helper(ExceptionId id,
  * `param0` to `param2` are optional format arguments of `msg`. They should be set to
  * `NO_PARAM` to indicate they are unused.
  */
-#define raise_exception(SizeT, id, msg, param0, param1, param2) \
+#define raise_exception(SizeT, id, msg, param0, param1, param2)                                                        \
     _raise_exception_helper<SizeT>(id, __FILE__, __LINE__, __FUNCTION__, msg, param0, param1, param2)
-}  // namespace
+} // namespace

nac3core/irrt/irrt/int_types.hpp

@@ -6,8 +6,3 @@ using int32_t = _BitInt(32);
 using uint32_t = unsigned _BitInt(32);
 using int64_t = _BitInt(64);
 using uint64_t = unsigned _BitInt(64);
-
-// NDArray indices are always `uint32_t`.
-using NDIndexInt = uint32_t;
-// The type of an index or a value describing the length of a range/slice is always `int32_t`.
-using SliceIndex = int32_t;

nac3core/irrt/irrt/list.hpp

@@ -1,90 +1,19 @@
 #pragma once
 
-#include "irrt/int_types.hpp"
-#include "irrt/math_util.hpp"
-#include "irrt/slice.hpp"
+#include <irrt/int_types.hpp>
+#include <irrt/slice.hpp>
 
-namespace {
+namespace
+{
 /**
  * @brief A list in NAC3.
  *
  * The `items` field is opaque. You must rely on external contexts to
  * know how to interpret it.
  */
-template<typename SizeT>
-struct List {
-    uint8_t* items;
+template <typename SizeT> struct List
+{
+    uint8_t *items;
     SizeT len;
 };
-}  // namespace
-
-extern "C" {
-// Handle list assignment and dropping part of the list when
-// both dest_step and src_step are +1.
-// - All the index must *not* be out-of-bound or negative,
-// - The end index is *inclusive*,
-// - The length of src and dest slice size should already
-// be checked: if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest)
-SliceIndex __nac3_list_slice_assign_var_size(SliceIndex dest_start,
-                                             SliceIndex dest_end,
-                                             SliceIndex dest_step,
-                                             uint8_t* dest_arr,
-                                             SliceIndex dest_arr_len,
-                                             SliceIndex src_start,
-                                             SliceIndex src_end,
-                                             SliceIndex src_step,
-                                             uint8_t* src_arr,
-                                             SliceIndex src_arr_len,
-                                             const SliceIndex size) {
-    /* if dest_arr_len == 0, do nothing since we do not support extending list */
-    if (dest_arr_len == 0)
-        return dest_arr_len;
-    /* if both step is 1, memmove directly, handle the dropping of the list, and shrink size */
-    if (src_step == dest_step && dest_step == 1) {
-        const SliceIndex src_len = (src_end >= src_start) ? (src_end - src_start + 1) : 0;
-        const SliceIndex dest_len = (dest_end >= dest_start) ? (dest_end - dest_start + 1) : 0;
-        if (src_len > 0) {
-            __builtin_memmove(dest_arr + dest_start * size, src_arr + src_start * size, src_len * size);
-        }
-        if (dest_len > 0) {
-            /* dropping */
-            __builtin_memmove(dest_arr + (dest_start + src_len) * size, dest_arr + (dest_end + 1) * size,
-                              (dest_arr_len - dest_end - 1) * size);
-        }
-        /* shrink size */
-        return dest_arr_len - (dest_len - src_len);
-    }
-    /* if two range overlaps, need alloca */
-    uint8_t need_alloca = (dest_arr == src_arr)
-                          && !(max(dest_start, dest_end) < min(src_start, src_end)
-                               || max(src_start, src_end) < min(dest_start, dest_end));
-    if (need_alloca) {
-        uint8_t* tmp = reinterpret_cast<uint8_t*>(__builtin_alloca(src_arr_len * size));
-        __builtin_memcpy(tmp, src_arr, src_arr_len * size);
-        src_arr = tmp;
-    }
-    SliceIndex src_ind = src_start;
-    SliceIndex dest_ind = dest_start;
-    for (; (src_step > 0) ? (src_ind <= src_end) : (src_ind >= src_end); src_ind += src_step, dest_ind += dest_step) {
-        /* for constant optimization */
-        if (size == 1) {
-            __builtin_memcpy(dest_arr + dest_ind, src_arr + src_ind, 1);
-        } else if (size == 4) {
-            __builtin_memcpy(dest_arr + dest_ind * 4, src_arr + src_ind * 4, 4);
-        } else if (size == 8) {
-            __builtin_memcpy(dest_arr + dest_ind * 8, src_arr + src_ind * 8, 8);
-        } else {
-            /* memcpy for var size, cannot overlap after previous alloca */
-            __builtin_memcpy(dest_arr + dest_ind * size, src_arr + src_ind * size, size);
-        }
-    }
-    /* only dest_step == 1 can we shrink the dest list. */
-    /* size should be ensured prior to calling this function */
-    if (dest_step == 1 && dest_end >= dest_start) {
-        __builtin_memmove(dest_arr + dest_ind * size, dest_arr + (dest_end + 1) * size,
-                          (dest_arr_len - dest_end - 1) * size);
-        return dest_arr_len - (dest_end - dest_ind) - 1;
-    }
-    return dest_arr_len;
-}
-}  // extern "C"
+} // namespace

nac3core/irrt/irrt/math.hpp

@@ -1,93 +0,0 @@
-#pragma once
-
-namespace {
-// 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
-template<typename T>
-T __nac3_int_exp_impl(T base, T exp) {
-    T res = 1;
-    /* repeated squaring method */
-    do {
-        if (exp & 1) {
-            res *= base; /* for n odd */
-        }
-        exp >>= 1;
-        base *= base;
-    } while (exp);
-    return res;
-}
-}  // namespace
-
-#define DEF_nac3_int_exp_(T)                   \
-    T __nac3_int_exp_##T(T base, T exp) {      \
-        return __nac3_int_exp_impl(base, exp); \
-    }
-
-extern "C" {
-
-// Putting semicolons here to make clang-format not reformat this into
-// a stair shape.
-DEF_nac3_int_exp_(int32_t);
-DEF_nac3_int_exp_(int64_t);
-DEF_nac3_int_exp_(uint32_t);
-DEF_nac3_int_exp_(uint64_t);
-
-int32_t __nac3_isinf(double x) {
-    return __builtin_isinf(x);
-}
-
-int32_t __nac3_isnan(double x) {
-    return __builtin_isnan(x);
-}
-
-double tgamma(double arg);
-
-double __nac3_gamma(double z) {
-    // Handling for denormals
-    //     | x                 | Python gamma(x) | C tgamma(x) |
-    // --- | ----------------- | --------------- | ----------- |
-    // (1) | nan               | nan             | nan         |
-    // (2) | -inf              | -inf            | inf         |
-    // (3) | inf               | inf             | inf         |
-    // (4) | 0.0               | inf             | inf         |
-    // (5) | {-1.0, -2.0, ...} | inf             | nan         |
-
-    // (1)-(3)
-    if (__builtin_isinf(z) || __builtin_isnan(z)) {
-        return z;
-    }
-
-    double v = tgamma(z);
-
-    // (4)-(5)
-    return __builtin_isinf(v) || __builtin_isnan(v) ? __builtin_inf() : v;
-}
-
-double lgamma(double arg);
-
-double __nac3_gammaln(double x) {
-    // libm's handling of value overflows differs from scipy:
-    // - scipy: gammaln(-inf) -> -inf
-    // - libm : lgamma(-inf) -> inf
-
-    if (__builtin_isinf(x)) {
-        return x;
-    }
-
-    return lgamma(x);
-}
-
-double j0(double x);
-
-double __nac3_j0(double x) {
-    // libm's handling of value overflows differs from scipy:
-    // - scipy: j0(inf) -> nan
-    // - libm : j0(inf) -> 0.0
-
-    if (__builtin_isinf(x)) {
-        return __builtin_nan("");
-    }
-
-    return j0(x);
-}
-}

nac3core/irrt/irrt/math_util.hpp

@@ -1,13 +1,14 @@
 #pragma once
 
-namespace {
-template<typename T>
-const T& max(const T& a, const T& b) {
+namespace
+{
+template <typename T> const T &max(const T &a, const T &b)
+{
     return a > b ? a : b;
 }
 
-template<typename T>
-const T& min(const T& a, const T& b) {
+template <typename T> const T &min(const T &a, const T &b)
+{
     return a > b ? b : a;
 }
-}  // namespace
+} // namespace

nac3core/irrt/irrt/ndarray.hpp

@@ -1,151 +0,0 @@
-#pragma once
-
-#include "irrt/int_types.hpp"
-
-// TODO: To be deleted since NDArray with strides is done.
-
-namespace {
-template<typename SizeT>
-SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx) {
-    __builtin_assume(end_idx <= list_len);
-
-    SizeT num_elems = 1;
-    for (SizeT i = begin_idx; i < end_idx; ++i) {
-        SizeT val = list_data[i];
-        __builtin_assume(val > 0);
-        num_elems *= val;
-    }
-    return num_elems;
-}
-
-template<typename SizeT>
-void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT* dims, SizeT num_dims, NDIndexInt* idxs) {
-    SizeT stride = 1;
-    for (SizeT dim = 0; dim < num_dims; dim++) {
-        SizeT i = num_dims - dim - 1;
-        __builtin_assume(dims[i] > 0);
-        idxs[i] = (index / stride) % dims[i];
-        stride *= dims[i];
-    }
-}
-
-template<typename SizeT>
-SizeT __nac3_ndarray_flatten_index_impl(const SizeT* dims,
-                                        SizeT num_dims,
-                                        const NDIndexInt* indices,
-                                        SizeT num_indices) {
-    SizeT idx = 0;
-    SizeT stride = 1;
-    for (SizeT i = 0; i < num_dims; ++i) {
-        SizeT ri = num_dims - i - 1;
-        if (ri < num_indices) {
-            idx += stride * indices[ri];
-        }
-
-        __builtin_assume(dims[i] > 0);
-        stride *= dims[ri];
-    }
-    return idx;
-}
-
-template<typename SizeT>
-void __nac3_ndarray_calc_broadcast_impl(const SizeT* lhs_dims,
-                                        SizeT lhs_ndims,
-                                        const SizeT* rhs_dims,
-                                        SizeT rhs_ndims,
-                                        SizeT* out_dims) {
-    SizeT max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
-
-    for (SizeT i = 0; i < max_ndims; ++i) {
-        const SizeT* lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : nullptr;
-        const SizeT* rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : nullptr;
-        SizeT* out_dim = &out_dims[max_ndims - i - 1];
-
-        if (lhs_dim_sz == nullptr) {
-            *out_dim = *rhs_dim_sz;
-        } else if (rhs_dim_sz == nullptr) {
-            *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();
-        }
-    }
-}
-
-template<typename SizeT>
-void __nac3_ndarray_calc_broadcast_idx_impl(const SizeT* src_dims,
-                                            SizeT src_ndims,
-                                            const NDIndexInt* in_idx,
-                                            NDIndexInt* out_idx) {
-    for (SizeT i = 0; i < src_ndims; ++i) {
-        SizeT src_i = src_ndims - i - 1;
-        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
-    }
-}
-}  // namespace
-
-extern "C" {
-uint32_t __nac3_ndarray_calc_size(const uint32_t* list_data, uint32_t list_len, uint32_t begin_idx, uint32_t end_idx) {
-    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
-}
-
-uint64_t
-__nac3_ndarray_calc_size64(const uint64_t* list_data, uint64_t list_len, uint64_t begin_idx, uint64_t end_idx) {
-    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
-}
-
-void __nac3_ndarray_calc_nd_indices(uint32_t index, const uint32_t* dims, uint32_t num_dims, NDIndexInt* idxs) {
-    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
-}
-
-void __nac3_ndarray_calc_nd_indices64(uint64_t index, const uint64_t* dims, uint64_t num_dims, NDIndexInt* idxs) {
-    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
-}
-
-uint32_t
-__nac3_ndarray_flatten_index(const uint32_t* dims, uint32_t num_dims, const NDIndexInt* indices, uint32_t num_indices) {
-    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
-}
-
-uint64_t __nac3_ndarray_flatten_index64(const uint64_t* dims,
-                                        uint64_t num_dims,
-                                        const NDIndexInt* indices,
-                                        uint64_t num_indices) {
-    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
-}
-
-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) {
-    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
-}
-
-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) {
-    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
-}
-
-void __nac3_ndarray_calc_broadcast_idx(const uint32_t* src_dims,
-                                       uint32_t src_ndims,
-                                       const NDIndexInt* in_idx,
-                                       NDIndexInt* out_idx) {
-    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
-}
-
-void __nac3_ndarray_calc_broadcast_idx64(const uint64_t* src_dims,
-                                         uint64_t src_ndims,
-                                         const NDIndexInt* in_idx,
-                                         NDIndexInt* out_idx) {
-    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
-}
-}

nac3core/irrt/irrt/ndarray/array.hpp

@@ -1,32 +1,38 @@
 #pragma once
 
-#include "irrt/debug.hpp"
-#include "irrt/exception.hpp"
-#include "irrt/int_types.hpp"
-#include "irrt/list.hpp"
-#include "irrt/ndarray/basic.hpp"
-#include "irrt/ndarray/def.hpp"
+#include <irrt/debug.hpp>
+#include <irrt/exception.hpp>
+#include <irrt/int_types.hpp>
+#include <irrt/list.hpp>
+#include <irrt/ndarray/basic.hpp>
+#include <irrt/ndarray/def.hpp>
 
-namespace {
-namespace ndarray {
-namespace array {
+namespace
+{
+namespace ndarray
+{
+namespace array
+{
 /**
  * @brief In the context of `np.array(<list>)`, deduce the ndarray's shape produced by `<list>` and raise
- * an exception if there is anything wrong with `<shape>` (e.g., inconsistent dimensions `np.array([[1.0, 2.0],
- * [3.0]])`)
+ * an exception if there is anything wrong with `<shape>` (e.g., inconsistent dimensions `np.array([[1.0, 2.0], [3.0]])`)
  *
- * If this function finds no issues with `<list>`, the deduced shape is written to `shape`. The caller has the
- * responsibility to allocate `[SizeT; ndims]` for `shape`. The caller must also initialize `shape` with `-1`s because
- * of implementation details.
+ * If this function finds no issues with `<list>`, the deduced shape is written to `shape`. The caller has the responsibility to
+ * allocate `[SizeT; ndims]` for `shape`. The caller must also initialize `shape` with `-1`s because of implementation details.
  */
-template<typename SizeT>
-void set_and_validate_list_shape_helper(SizeT axis, List<SizeT>* list, SizeT ndims, SizeT* shape) {
-    if (shape[axis] == -1) {
+template <typename SizeT>
+void set_and_validate_list_shape_helper(SizeT axis, List<SizeT> *list, SizeT ndims, SizeT *shape)
+{
+    if (shape[axis] == -1)
+    {
         // Dimension is unspecified. Set it.
         shape[axis] = list->len;
-    } else {
+    }
+    else
+    {
         // Dimension is specified. Check.
-        if (shape[axis] != list->len) {
+        if (shape[axis] != list->len)
+        {
             // Mismatch, throw an error.
             // NOTE: NumPy's error message is more complex and needs more PARAMS to display.
             raise_exception(SizeT, EXN_VALUE_ERROR,
@@ -36,13 +42,17 @@ void set_and_validate_list_shape_helper(SizeT axis, List<SizeT>* list, SizeT ndi
         }
     }
 
-    if (axis + 1 == ndims) {
+    if (axis + 1 == ndims)
+    {
         // `list` has type `list[ItemType]`
         // Do nothing
-    } else {
+    }
+    else
+    {
         // `list` has type `list[list[...]]`
-        List<SizeT>** lists = (List<SizeT>**)(list->items);
-        for (SizeT i = 0; i < list->len; i++) {
+        List<SizeT> **lists = (List<SizeT> **)(list->items);
+        for (SizeT i = 0; i < list->len; i++)
+        {
             set_and_validate_list_shape_helper<SizeT>(axis + 1, lists[i], ndims, shape);
         }
     }
@@ -51,10 +61,11 @@ void set_and_validate_list_shape_helper(SizeT axis, List<SizeT>* list, SizeT ndi
 /**
  * @brief See `set_and_validate_list_shape_helper`.
  */
-template<typename SizeT>
-void set_and_validate_list_shape(List<SizeT>* list, SizeT ndims, SizeT* shape) {
-    for (SizeT axis = 0; axis < ndims; axis++) {
-        shape[axis] = -1;  // Sentinel to say this dimension is unspecified.
+template <typename SizeT> void set_and_validate_list_shape(List<SizeT> *list, SizeT ndims, SizeT *shape)
+{
+    for (SizeT axis = 0; axis < ndims; axis++)
+    {
+        shape[axis] = -1; // Sentinel to say this dimension is unspecified.
     }
     set_and_validate_list_shape_helper<SizeT>(0, list, ndims, shape);
 }
@@ -75,27 +86,34 @@ void set_and_validate_list_shape(List<SizeT>* list, SizeT ndims, SizeT* shape) {
  * When this function call ends:
  *   - `ndarray->data` is written with contents from `<list>`.
  */
-template<typename SizeT>
-void write_list_to_array_helper(SizeT axis, SizeT* index, List<SizeT>* list, NDArray<SizeT>* ndarray) {
+template <typename SizeT>
+void write_list_to_array_helper(SizeT axis, SizeT *index, List<SizeT> *list, NDArray<SizeT> *ndarray)
+{
     debug_assert_eq(SizeT, list->len, ndarray->shape[axis]);
-    if (IRRT_DEBUG_ASSERT_BOOL) {
-        if (!ndarray::basic::is_c_contiguous(ndarray)) {
+    if (IRRT_DEBUG_ASSERT_BOOL)
+    {
+        if (!ndarray::basic::is_c_contiguous(ndarray))
+        {
             raise_debug_assert(SizeT, "ndarray is not C-contiguous", ndarray->strides[0], ndarray->strides[1],
                                NO_PARAM);
         }
     }
 
-    if (axis + 1 == ndarray->ndims) {
+    if (axis + 1 == ndarray->ndims)
+    {
         // `list` has type `list[scalar]`
         // `ndarray` is contiguous, so we can do this, and this is fast.
-        uint8_t* dst = ndarray->data + (ndarray->itemsize * (*index));
+        uint8_t *dst = ndarray->data + (ndarray->itemsize * (*index));
         __builtin_memcpy(dst, list->items, ndarray->itemsize * list->len);
         *index += list->len;
-    } else {
+    }
+    else
+    {
         // `list` has type `list[list[...]]`
-        List<SizeT>** lists = (List<SizeT>**)(list->items);
+        List<SizeT> **lists = (List<SizeT> **)(list->items);
 
-        for (SizeT i = 0; i < list->len; i++) {
+        for (SizeT i = 0; i < list->len; i++)
+        {
             write_list_to_array_helper<SizeT>(axis + 1, index, lists[i], ndarray);
         }
     }
@@ -104,31 +122,36 @@ void write_list_to_array_helper(SizeT axis, SizeT* index, List<SizeT>* list, NDA
 /**
  * @brief See `write_list_to_array_helper`.
  */
-template<typename SizeT>
-void write_list_to_array(List<SizeT>* list, NDArray<SizeT>* ndarray) {
+template <typename SizeT> void write_list_to_array(List<SizeT> *list, NDArray<SizeT> *ndarray)
+{
     SizeT index = 0;
     write_list_to_array_helper<SizeT>((SizeT)0, &index, list, ndarray);
 }
-}  // namespace array
-}  // namespace ndarray
-}  // namespace
+} // namespace array
+} // namespace ndarray
+} // namespace
 
-extern "C" {
-using namespace ndarray::array;
+extern "C"
+{
+    using namespace ndarray::array;
 
-void __nac3_ndarray_array_set_and_validate_list_shape(List<int32_t>* list, int32_t ndims, int32_t* shape) {
-    set_and_validate_list_shape(list, ndims, shape);
-}
+    void __nac3_ndarray_array_set_and_validate_list_shape(List<int32_t> *list, int32_t ndims, int32_t *shape)
+    {
+        set_and_validate_list_shape(list, ndims, shape);
+    }
 
-void __nac3_ndarray_array_set_and_validate_list_shape64(List<int64_t>* list, int64_t ndims, int64_t* shape) {
-    set_and_validate_list_shape(list, ndims, shape);
-}
+    void __nac3_ndarray_array_set_and_validate_list_shape64(List<int64_t> *list, int64_t ndims, int64_t *shape)
+    {
+        set_and_validate_list_shape(list, ndims, shape);
+    }
 
-void __nac3_ndarray_array_write_list_to_array(List<int32_t>* list, NDArray<int32_t>* ndarray) {
-    write_list_to_array(list, ndarray);
-}
+    void __nac3_ndarray_array_write_list_to_array(List<int32_t> *list, NDArray<int32_t> *ndarray)
+    {
+        write_list_to_array(list, ndarray);
+    }
 
-void __nac3_ndarray_array_write_list_to_array64(List<int64_t>* list, NDArray<int64_t>* ndarray) {
-    write_list_to_array(list, ndarray);
-}
+    void __nac3_ndarray_array_write_list_to_array64(List<int64_t> *list, NDArray<int64_t> *ndarray)
+    {
+        write_list_to_array(list, ndarray);
+    }
 }

nac3core/irrt/irrt/ndarray/basic.hpp

@@ -1,23 +1,28 @@
 #pragma once
 
-#include "irrt/debug.hpp"
-#include "irrt/exception.hpp"
-#include "irrt/int_types.hpp"
-#include "irrt/ndarray/def.hpp"
+#include <irrt/debug.hpp>
+#include <irrt/exception.hpp>
+#include <irrt/int_types.hpp>
+#include <irrt/ndarray/def.hpp>
 
-namespace {
-namespace ndarray {
-namespace basic {
+namespace
+{
+namespace ndarray
+{
+namespace basic
+{
 /**
  * @brief Assert that `shape` does not contain negative dimensions.
  *
  * @param ndims Number of dimensions in `shape`
  * @param shape The shape to check on
  */
-template<typename SizeT>
-void assert_shape_no_negative(SizeT ndims, const SizeT* shape) {
-    for (SizeT axis = 0; axis < ndims; axis++) {
-        if (shape[axis] < 0) {
+template <typename SizeT> void assert_shape_no_negative(SizeT ndims, const SizeT *shape)
+{
+    for (SizeT axis = 0; axis < ndims; axis++)
+    {
+        if (shape[axis] < 0)
+        {
             raise_exception(SizeT, EXN_VALUE_ERROR,
                             "negative dimensions are not allowed; axis {0} "
                             "has dimension {1}",
@@ -29,19 +34,21 @@ void assert_shape_no_negative(SizeT ndims, const SizeT* shape) {
 /**
  * @brief Assert that two shapes are the same in the context of writing output to an ndarray.
  */
-template<typename SizeT>
-void assert_output_shape_same(SizeT ndarray_ndims,
-                              const SizeT* ndarray_shape,
-                              SizeT output_ndims,
-                              const SizeT* output_shape) {
-    if (ndarray_ndims != output_ndims) {
+template <typename SizeT>
+void assert_output_shape_same(SizeT ndarray_ndims, const SizeT *ndarray_shape, SizeT output_ndims,
+                              const SizeT *output_shape)
+{
+    if (ndarray_ndims != output_ndims)
+    {
         // There is no corresponding NumPy error message like this.
         raise_exception(SizeT, EXN_VALUE_ERROR, "Cannot write output of ndims {0} to an ndarray with ndims {1}",
                         output_ndims, ndarray_ndims, NO_PARAM);
     }
 
-    for (SizeT axis = 0; axis < ndarray_ndims; axis++) {
-        if (ndarray_shape[axis] != output_shape[axis]) {
+    for (SizeT axis = 0; axis < ndarray_ndims; axis++)
+    {
+        if (ndarray_shape[axis] != output_shape[axis])
+        {
             // There is no corresponding NumPy error message like this.
             raise_exception(SizeT, EXN_VALUE_ERROR,
                             "Mismatched dimensions on axis {0}, output has "
@@ -57,8 +64,8 @@ void assert_output_shape_same(SizeT ndarray_ndims,
  * @param ndims Number of dimensions in `shape`
  * @param shape The shape of the ndarray
  */
-template<typename SizeT>
-SizeT calc_size_from_shape(SizeT ndims, const SizeT* shape) {
+template <typename SizeT> SizeT calc_size_from_shape(SizeT ndims, const SizeT *shape)
+{
     SizeT size = 1;
     for (SizeT axis = 0; axis < ndims; axis++)
         size *= shape[axis];
@@ -73,9 +80,10 @@ SizeT calc_size_from_shape(SizeT ndims, const SizeT* shape) {
  * @param indices The returned indices indexing the ndarray with shape `shape`.
  * @param nth The index of the element of interest.
  */
-template<typename SizeT>
-void set_indices_by_nth(SizeT ndims, const SizeT* shape, SizeT* indices, SizeT nth) {
-    for (SizeT i = 0; i < ndims; i++) {
+template <typename SizeT> void set_indices_by_nth(SizeT ndims, const SizeT *shape, SizeT *indices, SizeT nth)
+{
+    for (SizeT i = 0; i < ndims; i++)
+    {
         SizeT axis = ndims - i - 1;
         SizeT dim = shape[axis];
 
@@ -89,8 +97,8 @@ void set_indices_by_nth(SizeT ndims, const SizeT* shape, SizeT* indices, SizeT n
  *
  * This function corresponds to `<an_ndarray>.size`
  */
-template<typename SizeT>
-SizeT size(const NDArray<SizeT>* ndarray) {
+template <typename SizeT> SizeT size(const NDArray<SizeT> *ndarray)
+{
     return calc_size_from_shape(ndarray->ndims, ndarray->shape);
 }
 
@@ -99,8 +107,8 @@ SizeT size(const NDArray<SizeT>* ndarray) {
  *
  * This function corresponds to `<an_ndarray>.nbytes`.
  */
-template<typename SizeT>
-SizeT nbytes(const NDArray<SizeT>* ndarray) {
+template <typename SizeT> SizeT nbytes(const NDArray<SizeT> *ndarray)
+{
     return size(ndarray) * ndarray->itemsize;
 }
 
@@ -111,12 +119,15 @@ SizeT nbytes(const NDArray<SizeT>* ndarray) {
  *
  * @param dst_length The length.
  */
-template<typename SizeT>
-SizeT len(const NDArray<SizeT>* ndarray) {
+template <typename SizeT> SizeT len(const NDArray<SizeT> *ndarray)
+{
     // numpy prohibits `__len__` on unsized objects
-    if (ndarray->ndims == 0) {
+    if (ndarray->ndims == 0)
+    {
         raise_exception(SizeT, EXN_TYPE_ERROR, "len() of unsized object", NO_PARAM, NO_PARAM, NO_PARAM);
-    } else {
+    }
+    else
+    {
         return ndarray->shape[0];
     }
 }
@@ -124,21 +135,16 @@ SizeT len(const NDArray<SizeT>* ndarray) {
 /**
  * @brief Return a boolean indicating if `ndarray` is (C-)contiguous.
  *
- * You may want to see ndarray's rules for C-contiguity:
- * https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
+ * You may want to see ndarray's rules for C-contiguity: https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
  */
-template<typename SizeT>
-bool is_c_contiguous(const NDArray<SizeT>* ndarray) {
+template <typename SizeT> bool is_c_contiguous(const NDArray<SizeT> *ndarray)
+{
     // References:
-    // - tinynumpy's implementation:
-    // https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L102
-    // - ndarray's flags["C_CONTIGUOUS"]:
-    // https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags
-    // - ndarray's rules for C-contiguity:
-    // https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
+    // - tinynumpy's implementation: https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L102
+    // - ndarray's flags["C_CONTIGUOUS"]: https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags
+    // - ndarray's rules for C-contiguity: https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
 
-    // From
-    // https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45:
+    // From https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45:
     //
     // The traditional rule is that for an array to be flagged as C contiguous,
     // the following must hold:
@@ -154,17 +160,21 @@ bool is_c_contiguous(const NDArray<SizeT>* ndarray) {
     // with shape[i] == 0. In the second case `strides == itemsize` will
     // can be true for all dimensions and both flags are set.
 
-    if (ndarray->ndims == 0) {
+    if (ndarray->ndims == 0)
+    {
         return true;
     }
 
-    if (ndarray->strides[ndarray->ndims - 1] != ndarray->itemsize) {
+    if (ndarray->strides[ndarray->ndims - 1] != ndarray->itemsize)
+    {
         return false;
     }
 
-    for (SizeT i = 1; i < ndarray->ndims; i++) {
+    for (SizeT i = 1; i < ndarray->ndims; i++)
+    {
         SizeT axis_i = ndarray->ndims - i - 1;
-        if (ndarray->strides[axis_i] != ndarray->shape[axis_i + 1] * ndarray->strides[axis_i + 1]) {
+        if (ndarray->strides[axis_i] != ndarray->shape[axis_i + 1] * ndarray->strides[axis_i + 1])
+        {
             return false;
         }
     }
@@ -177,9 +187,9 @@ bool is_c_contiguous(const NDArray<SizeT>* ndarray) {
  *
  * This function does no bound check.
  */
-template<typename SizeT>
-uint8_t* get_pelement_by_indices(const NDArray<SizeT>* ndarray, const SizeT* indices) {
-    uint8_t* element = ndarray->data;
+template <typename SizeT> uint8_t *get_pelement_by_indices(const NDArray<SizeT> *ndarray, const SizeT *indices)
+{
+    uint8_t *element = ndarray->data;
     for (SizeT dim_i = 0; dim_i < ndarray->ndims; dim_i++)
         element += indices[dim_i] * ndarray->strides[dim_i];
     return element;
@@ -190,10 +200,11 @@ uint8_t* get_pelement_by_indices(const NDArray<SizeT>* ndarray, const SizeT* ind
  *
  * This function does no bound check.
  */
-template<typename SizeT>
-uint8_t* get_nth_pelement(const NDArray<SizeT>* ndarray, SizeT nth) {
-    uint8_t* element = ndarray->data;
-    for (SizeT i = 0; i < ndarray->ndims; i++) {
+template <typename SizeT> uint8_t *get_nth_pelement(const NDArray<SizeT> *ndarray, SizeT nth)
+{
+    uint8_t *element = ndarray->data;
+    for (SizeT i = 0; i < ndarray->ndims; i++)
+    {
         SizeT axis = ndarray->ndims - i - 1;
         SizeT dim = ndarray->shape[axis];
         element += ndarray->strides[axis] * (nth % dim);
@@ -207,10 +218,11 @@ uint8_t* get_nth_pelement(const NDArray<SizeT>* ndarray, SizeT nth) {
  *
  * You might want to read https://ajcr.net/stride-guide-part-1/.
  */
-template<typename SizeT>
-void set_strides_by_shape(NDArray<SizeT>* ndarray) {
+template <typename SizeT> void set_strides_by_shape(NDArray<SizeT> *ndarray)
+{
     SizeT stride_product = 1;
-    for (SizeT i = 0; i < ndarray->ndims; i++) {
+    for (SizeT i = 0; i < ndarray->ndims; i++)
+    {
         SizeT axis = ndarray->ndims - i - 1;
         ndarray->strides[axis] = stride_product * ndarray->itemsize;
         stride_product *= ndarray->shape[axis];
@@ -223,8 +235,8 @@ void set_strides_by_shape(NDArray<SizeT>* ndarray) {
  * @param pelement Pointer to the element in `ndarray` to be set.
  * @param pvalue Pointer to the value `pelement` will be set to.
  */
-template<typename SizeT>
-void set_pelement_value(NDArray<SizeT>* ndarray, uint8_t* pelement, const uint8_t* pvalue) {
+template <typename SizeT> void set_pelement_value(NDArray<SizeT> *ndarray, uint8_t *pelement, const uint8_t *pvalue)
+{
     __builtin_memcpy(pelement, pvalue, ndarray->itemsize);
 }
 
@@ -233,109 +245,127 @@ void set_pelement_value(NDArray<SizeT>* ndarray, uint8_t* pelement, const uint8_
  *
  * Both ndarrays will be viewed in their flatten views when copying the elements.
  */
-template<typename SizeT>
-void copy_data(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
+template <typename SizeT> void copy_data(const NDArray<SizeT> *src_ndarray, NDArray<SizeT> *dst_ndarray)
+{
     // TODO: Make this faster with memcpy when we see a contiguous segment.
     // TODO: Handle overlapping.
 
     debug_assert_eq(SizeT, src_ndarray->itemsize, dst_ndarray->itemsize);
 
-    for (SizeT i = 0; i < size(src_ndarray); i++) {
+    for (SizeT i = 0; i < size(src_ndarray); i++)
+    {
         auto src_element = ndarray::basic::get_nth_pelement(src_ndarray, i);
         auto dst_element = ndarray::basic::get_nth_pelement(dst_ndarray, i);
         ndarray::basic::set_pelement_value(dst_ndarray, dst_element, src_element);
     }
 }
-}  // namespace basic
-}  // namespace ndarray
-}  // namespace
+} // namespace basic
+} // namespace ndarray
+} // namespace
 
-extern "C" {
-using namespace ndarray::basic;
+extern "C"
+{
+    using namespace ndarray::basic;
 
-void __nac3_ndarray_util_assert_shape_no_negative(int32_t ndims, int32_t* shape) {
-    assert_shape_no_negative(ndims, shape);
-}
+    void __nac3_ndarray_util_assert_shape_no_negative(int32_t ndims, int32_t *shape)
+    {
+        assert_shape_no_negative(ndims, shape);
+    }
 
-void __nac3_ndarray_util_assert_shape_no_negative64(int64_t ndims, int64_t* shape) {
-    assert_shape_no_negative(ndims, shape);
-}
+    void __nac3_ndarray_util_assert_shape_no_negative64(int64_t ndims, int64_t *shape)
+    {
+        assert_shape_no_negative(ndims, shape);
+    }
 
-void __nac3_ndarray_util_assert_output_shape_same(int32_t ndarray_ndims,
-                                                  const int32_t* ndarray_shape,
-                                                  int32_t output_ndims,
-                                                  const int32_t* output_shape) {
-    assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
-}
+    void __nac3_ndarray_util_assert_output_shape_same(int32_t ndarray_ndims, const int32_t *ndarray_shape,
+                                                      int32_t output_ndims, const int32_t *output_shape)
+    {
+        assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
+    }
 
-void __nac3_ndarray_util_assert_output_shape_same64(int64_t ndarray_ndims,
-                                                    const int64_t* ndarray_shape,
-                                                    int64_t output_ndims,
-                                                    const int64_t* output_shape) {
-    assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
-}
+    void __nac3_ndarray_util_assert_output_shape_same64(int64_t ndarray_ndims, const int64_t *ndarray_shape,
+                                                        int64_t output_ndims, const int64_t *output_shape)
+    {
+        assert_output_shape_same(ndarray_ndims, ndarray_shape, output_ndims, output_shape);
+    }
 
-uint32_t __nac3_ndarray_size(NDArray<int32_t>* ndarray) {
-    return size(ndarray);
-}
+    uint32_t __nac3_ndarray_size(NDArray<int32_t> *ndarray)
+    {
+        return size(ndarray);
+    }
 
-uint64_t __nac3_ndarray_size64(NDArray<int64_t>* ndarray) {
-    return size(ndarray);
-}
+    uint64_t __nac3_ndarray_size64(NDArray<int64_t> *ndarray)
+    {
+        return size(ndarray);
+    }
 
-uint32_t __nac3_ndarray_nbytes(NDArray<int32_t>* ndarray) {
-    return nbytes(ndarray);
-}
+    uint32_t __nac3_ndarray_nbytes(NDArray<int32_t> *ndarray)
+    {
+        return nbytes(ndarray);
+    }
 
-uint64_t __nac3_ndarray_nbytes64(NDArray<int64_t>* ndarray) {
-    return nbytes(ndarray);
-}
+    uint64_t __nac3_ndarray_nbytes64(NDArray<int64_t> *ndarray)
+    {
+        return nbytes(ndarray);
+    }
 
-int32_t __nac3_ndarray_len(NDArray<int32_t>* ndarray) {
-    return len(ndarray);
-}
+    int32_t __nac3_ndarray_len(NDArray<int32_t> *ndarray)
+    {
+        return len(ndarray);
+    }
 
-int64_t __nac3_ndarray_len64(NDArray<int64_t>* ndarray) {
-    return len(ndarray);
-}
+    int64_t __nac3_ndarray_len64(NDArray<int64_t> *ndarray)
+    {
+        return len(ndarray);
+    }
 
-bool __nac3_ndarray_is_c_contiguous(NDArray<int32_t>* ndarray) {
-    return is_c_contiguous(ndarray);
-}
+    bool __nac3_ndarray_is_c_contiguous(NDArray<int32_t> *ndarray)
+    {
+        return is_c_contiguous(ndarray);
+    }
 
-bool __nac3_ndarray_is_c_contiguous64(NDArray<int64_t>* ndarray) {
-    return is_c_contiguous(ndarray);
-}
+    bool __nac3_ndarray_is_c_contiguous64(NDArray<int64_t> *ndarray)
+    {
+        return is_c_contiguous(ndarray);
+    }
 
-uint8_t* __nac3_ndarray_get_nth_pelement(const NDArray<int32_t>* ndarray, int32_t nth) {
-    return get_nth_pelement(ndarray, nth);
-}
+    uint8_t *__nac3_ndarray_get_nth_pelement(const NDArray<int32_t> *ndarray, int32_t nth)
+    {
+        return get_nth_pelement(ndarray, nth);
+    }
 
-uint8_t* __nac3_ndarray_get_nth_pelement64(const NDArray<int64_t>* ndarray, int64_t nth) {
-    return get_nth_pelement(ndarray, nth);
-}
+    uint8_t *__nac3_ndarray_get_nth_pelement64(const NDArray<int64_t> *ndarray, int64_t nth)
+    {
+        return get_nth_pelement(ndarray, nth);
+    }
 
-uint8_t* __nac3_ndarray_get_pelement_by_indices(const NDArray<int32_t>* ndarray, int32_t* indices) {
-    return get_pelement_by_indices(ndarray, indices);
-}
+    uint8_t *__nac3_ndarray_get_pelement_by_indices(const NDArray<int32_t> *ndarray, int32_t *indices)
+    {
+        return get_pelement_by_indices(ndarray, indices);
+    }
 
-uint8_t* __nac3_ndarray_get_pelement_by_indices64(const NDArray<int64_t>* ndarray, int64_t* indices) {
-    return get_pelement_by_indices(ndarray, indices);
-}
+    uint8_t *__nac3_ndarray_get_pelement_by_indices64(const NDArray<int64_t> *ndarray, int64_t *indices)
+    {
+        return get_pelement_by_indices(ndarray, indices);
+    }
 
-void __nac3_ndarray_set_strides_by_shape(NDArray<int32_t>* ndarray) {
-    set_strides_by_shape(ndarray);
-}
+    void __nac3_ndarray_set_strides_by_shape(NDArray<int32_t> *ndarray)
+    {
+        set_strides_by_shape(ndarray);
+    }
 
-void __nac3_ndarray_set_strides_by_shape64(NDArray<int64_t>* ndarray) {
-    set_strides_by_shape(ndarray);
-}
+    void __nac3_ndarray_set_strides_by_shape64(NDArray<int64_t> *ndarray)
+    {
+        set_strides_by_shape(ndarray);
+    }
 
-void __nac3_ndarray_copy_data(NDArray<int32_t>* src_ndarray, NDArray<int32_t>* dst_ndarray) {
-    copy_data(src_ndarray, dst_ndarray);
-}
+    void __nac3_ndarray_copy_data(NDArray<int32_t> *src_ndarray, NDArray<int32_t> *dst_ndarray)
+    {
+        copy_data(src_ndarray, dst_ndarray);
+    }
 
-void __nac3_ndarray_copy_data64(NDArray<int64_t>* src_ndarray, NDArray<int64_t>* dst_ndarray) {
-    copy_data(src_ndarray, dst_ndarray);
-}
+    void __nac3_ndarray_copy_data64(NDArray<int64_t> *src_ndarray, NDArray<int64_t> *dst_ndarray)
+    {
+        copy_data(src_ndarray, dst_ndarray);
+    }
 }

nac3core/irrt/irrt/ndarray/broadcast.hpp

@@ -1,35 +1,43 @@
 #pragma once
 
-#include "irrt/int_types.hpp"
-#include "irrt/ndarray/def.hpp"
-#include "irrt/slice.hpp"
+#include <irrt/int_types.hpp>
+#include <irrt/ndarray/def.hpp>
+#include <irrt/slice.hpp>
 
-namespace {
-template<typename SizeT>
-struct ShapeEntry {
+namespace
+{
+template <typename SizeT> struct ShapeEntry
+{
     SizeT ndims;
-    SizeT* shape;
+    SizeT *shape;
 };
-}  // namespace
+} // namespace
 
-namespace {
-namespace ndarray {
-namespace broadcast {
+namespace
+{
+namespace ndarray
+{
+namespace broadcast
+{
 /**
  * @brief Return true if `src_shape` can broadcast to `dst_shape`.
  *
  * See https://numpy.org/doc/stable/user/basics.broadcasting.html
  */
-template<typename SizeT>
-bool can_broadcast_shape_to(SizeT target_ndims, const SizeT* target_shape, SizeT src_ndims, const SizeT* src_shape) {
-    if (src_ndims > target_ndims) {
+template <typename SizeT>
+bool can_broadcast_shape_to(SizeT target_ndims, const SizeT *target_shape, SizeT src_ndims, const SizeT *src_shape)
+{
+    if (src_ndims > target_ndims)
+    {
         return false;
     }
 
-    for (SizeT i = 0; i < src_ndims; i++) {
+    for (SizeT i = 0; i < src_ndims; i++)
+    {
         SizeT target_dim = target_shape[target_ndims - i - 1];
         SizeT src_dim = src_shape[src_ndims - i - 1];
-        if (!(src_dim == 1 || target_dim == src_dim)) {
+        if (!(src_dim == 1 || target_dim == src_dim))
+        {
             return false;
         }
     }
@@ -47,9 +55,11 @@ bool can_broadcast_shape_to(SizeT target_ndims, const SizeT* target_shape, SizeT
  * @param dst_shape The resulting shape. Must be pre-allocated by the caller. This function calculate the result
  *   of `np.broadcast_shapes` and write it here.
  */
-template<typename SizeT>
-void broadcast_shapes(SizeT num_shapes, const ShapeEntry<SizeT>* shapes, SizeT dst_ndims, SizeT* dst_shape) {
-    for (SizeT dst_axis = 0; dst_axis < dst_ndims; dst_axis++) {
+template <typename SizeT>
+void broadcast_shapes(SizeT num_shapes, const ShapeEntry<SizeT> *shapes, SizeT dst_ndims, SizeT *dst_shape)
+{
+    for (SizeT dst_axis = 0; dst_axis < dst_ndims; dst_axis++)
+    {
         dst_shape[dst_axis] = 1;
     }
 
@@ -57,7 +67,8 @@ void broadcast_shapes(SizeT num_shapes, const ShapeEntry<SizeT>* shapes, SizeT d
     SizeT max_ndims_found = 0;
 #endif
 
-    for (SizeT i = 0; i < num_shapes; i++) {
+    for (SizeT i = 0; i < num_shapes; i++)
+    {
         ShapeEntry<SizeT> entry = shapes[i];
 
         // Check pre-condition: `dst_ndims` must be `max([shape.ndims for shape in shapes])`
@@ -67,18 +78,24 @@ void broadcast_shapes(SizeT num_shapes, const ShapeEntry<SizeT>* shapes, SizeT d
         max_ndims_found = max(max_ndims_found, entry.ndims);
 #endif
 
-        for (SizeT j = 0; j < entry.ndims; j++) {
+        for (SizeT j = 0; j < entry.ndims; j++)
+        {
             SizeT entry_axis = entry.ndims - j - 1;
             SizeT dst_axis = dst_ndims - j - 1;
 
             SizeT entry_dim = entry.shape[entry_axis];
             SizeT dst_dim = dst_shape[dst_axis];
 
-            if (dst_dim == 1) {
+            if (dst_dim == 1)
+            {
                 dst_shape[dst_axis] = entry_dim;
-            } else if (entry_dim == 1 || entry_dim == dst_dim) {
+            }
+            else if (entry_dim == 1 || entry_dim == dst_dim)
+            {
                 // Do nothing
-            } else {
+            }
+            else
+            {
                 raise_exception(SizeT, EXN_VALUE_ERROR,
                                 "shape mismatch: objects cannot be broadcast "
                                 "to a single shape.",
@@ -112,10 +129,11 @@ void broadcast_shapes(SizeT num_shapes, const ShapeEntry<SizeT>* shapes, SizeT d
  *   - `dst_ndarray->shape` is unchanged.
  *   - `dst_ndarray->strides` is updated accordingly by how ndarray broadcast_to works.
  */
-template<typename SizeT>
-void broadcast_to(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
+template <typename SizeT> void broadcast_to(const NDArray<SizeT> *src_ndarray, NDArray<SizeT> *dst_ndarray)
+{
     if (!ndarray::broadcast::can_broadcast_shape_to(dst_ndarray->ndims, dst_ndarray->shape, src_ndarray->ndims,
-                                                    src_ndarray->shape)) {
+                                                    src_ndarray->shape))
+    {
         raise_exception(SizeT, EXN_VALUE_ERROR, "operands could not be broadcast together", NO_PARAM, NO_PARAM,
                         NO_PARAM);
     }
@@ -123,43 +141,48 @@ void broadcast_to(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray
     dst_ndarray->data = src_ndarray->data;
     dst_ndarray->itemsize = src_ndarray->itemsize;
 
-    for (SizeT i = 0; i < dst_ndarray->ndims; i++) {
+    for (SizeT i = 0; i < dst_ndarray->ndims; i++)
+    {
         SizeT src_axis = src_ndarray->ndims - i - 1;
         SizeT dst_axis = dst_ndarray->ndims - i - 1;
-        if (src_axis < 0 || (src_ndarray->shape[src_axis] == 1 && dst_ndarray->shape[dst_axis] != 1)) {
+        if (src_axis < 0 || (src_ndarray->shape[src_axis] == 1 && dst_ndarray->shape[dst_axis] != 1))
+        {
             // Freeze the steps in-place
             dst_ndarray->strides[dst_axis] = 0;
-        } else {
+        }
+        else
+        {
             dst_ndarray->strides[dst_axis] = src_ndarray->strides[src_axis];
         }
     }
 }
-}  // namespace broadcast
-}  // namespace ndarray
-}  // namespace
+} // namespace broadcast
+} // namespace ndarray
+} // namespace
 
-extern "C" {
-using namespace ndarray::broadcast;
+extern "C"
+{
+    using namespace ndarray::broadcast;
 
-void __nac3_ndarray_broadcast_to(NDArray<int32_t>* src_ndarray, NDArray<int32_t>* dst_ndarray) {
-    broadcast_to(src_ndarray, dst_ndarray);
-}
+    void __nac3_ndarray_broadcast_to(NDArray<int32_t> *src_ndarray, NDArray<int32_t> *dst_ndarray)
+    {
+        broadcast_to(src_ndarray, dst_ndarray);
+    }
 
-void __nac3_ndarray_broadcast_to64(NDArray<int64_t>* src_ndarray, NDArray<int64_t>* dst_ndarray) {
-    broadcast_to(src_ndarray, dst_ndarray);
-}
+    void __nac3_ndarray_broadcast_to64(NDArray<int64_t> *src_ndarray, NDArray<int64_t> *dst_ndarray)
+    {
+        broadcast_to(src_ndarray, dst_ndarray);
+    }
 
-void __nac3_ndarray_broadcast_shapes(int32_t num_shapes,
-                                     const ShapeEntry<int32_t>* shapes,
-                                     int32_t dst_ndims,
-                                     int32_t* dst_shape) {
-    broadcast_shapes(num_shapes, shapes, dst_ndims, dst_shape);
-}
+    void __nac3_ndarray_broadcast_shapes(int32_t num_shapes, const ShapeEntry<int32_t> *shapes, int32_t dst_ndims,
+                                         int32_t *dst_shape)
+    {
+        broadcast_shapes(num_shapes, shapes, dst_ndims, dst_shape);
+    }
 
-void __nac3_ndarray_broadcast_shapes64(int64_t num_shapes,
-                                       const ShapeEntry<int64_t>* shapes,
-                                       int64_t dst_ndims,
-                                       int64_t* dst_shape) {
-    broadcast_shapes(num_shapes, shapes, dst_ndims, dst_shape);
-}
+    void __nac3_ndarray_broadcast_shapes64(int64_t num_shapes, const ShapeEntry<int64_t> *shapes, int64_t dst_ndims,
+                                           int64_t *dst_shape)
+    {
+        broadcast_shapes(num_shapes, shapes, dst_ndims, dst_shape);
+    }
 }

nac3core/irrt/irrt/ndarray/def.hpp

@@ -1,20 +1,20 @@
 #pragma once
 
-#include "irrt/int_types.hpp"
+#include <irrt/int_types.hpp>
 
-namespace {
+namespace
+{
 /**
  * @brief The NDArray object
  *
- * Official numpy implementation:
- * https://github.com/numpy/numpy/blob/735a477f0bc2b5b84d0e72d92f224bde78d4e069/doc/source/reference/c-api/types-and-structures.rst
+ * Official numpy implementation: https://github.com/numpy/numpy/blob/735a477f0bc2b5b84d0e72d92f224bde78d4e069/doc/source/reference/c-api/types-and-structures.rst
  */
-template<typename SizeT>
-struct NDArray {
+template <typename SizeT> struct NDArray
+{
     /**
      * @brief The underlying data this `ndarray` is pointing to.
      */
-    uint8_t* data;
+    uint8_t *data;
 
     /**
      * @brief The number of bytes of a single element in `data`.
@@ -31,7 +31,7 @@ struct NDArray {
      *
      * Note that it may contain 0.
      */
-    SizeT* shape;
+    SizeT *shape;
 
     /**
      * @brief Array strides, with length equal to `ndims`
@@ -40,6 +40,6 @@ struct NDArray {
      *
      * Note that `strides` can have negative values or contain 0.
      */
-    SizeT* strides;
+    SizeT *strides;
 };
-}  // namespace
+} // namespace

nac3core/irrt/irrt/ndarray/indexing.hpp

@@ -1,13 +1,14 @@
 #pragma once
 
-#include "irrt/exception.hpp"
-#include "irrt/int_types.hpp"
-#include "irrt/ndarray/basic.hpp"
-#include "irrt/ndarray/def.hpp"
-#include "irrt/range.hpp"
-#include "irrt/slice.hpp"
+#include <irrt/exception.hpp>
+#include <irrt/int_types.hpp>
+#include <irrt/ndarray/basic.hpp>
+#include <irrt/ndarray/def.hpp>
+#include <irrt/range.hpp>
+#include <irrt/slice.hpp>
 
-namespace {
+namespace
+{
 typedef uint8_t NDIndexType;
 
 /**
@@ -47,7 +48,8 @@ const NDIndexType ND_INDEX_TYPE_ELLIPSIS = 3;
  *            ^^^^  ^  ^^^  ^^^^^^^^^^ each of these is represented by an NDIndex.
  * ```
  */
-struct NDIndex {
+struct NDIndex
+{
     /**
      * @brief Enum tag to specify the type of index.
      *
@@ -60,13 +62,16 @@ struct NDIndex {
      *
      * Please see the comment of each enum constant.
      */
-    uint8_t* data;
+    uint8_t *data;
 };
-}  // namespace
+} // namespace
 
-namespace {
-namespace ndarray {
-namespace indexing {
+namespace
+{
+namespace ndarray
+{
+namespace indexing
+{
 /**
  * @brief Perform ndarray "basic indexing" (https://numpy.org/doc/stable/user/basics.indexing.html#basic-indexing)
  *
@@ -94,8 +99,9 @@ namespace indexing {
  * @param src_ndarray The NDArray to be indexed.
  * @param dst_ndarray The resulting NDArray after indexing. Further details in the comments above,
  */
-template<typename SizeT>
-void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
+template <typename SizeT>
+void index(SizeT num_indices, const NDIndex *indices, const NDArray<SizeT> *src_ndarray, NDArray<SizeT> *dst_ndarray)
+{
     // Validate `indices`.
 
     // Expected value of `dst_ndarray->ndims`.
@@ -105,28 +111,40 @@ void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_
     // There may be ellipsis `...` in `indices`. There can only be 0 or 1 ellipsis.
     SizeT num_ellipsis = 0;
 
-    for (SizeT i = 0; i < num_indices; i++) {
-        if (indices[i].type == ND_INDEX_TYPE_SINGLE_ELEMENT) {
+    for (SizeT i = 0; i < num_indices; i++)
+    {
+        if (indices[i].type == ND_INDEX_TYPE_SINGLE_ELEMENT)
+        {
             expected_dst_ndims--;
             num_indexed++;
-        } else if (indices[i].type == ND_INDEX_TYPE_SLICE) {
+        }
+        else if (indices[i].type == ND_INDEX_TYPE_SLICE)
+        {
             num_indexed++;
-        } else if (indices[i].type == ND_INDEX_TYPE_NEWAXIS) {
+        }
+        else if (indices[i].type == ND_INDEX_TYPE_NEWAXIS)
+        {
             expected_dst_ndims++;
-        } else if (indices[i].type == ND_INDEX_TYPE_ELLIPSIS) {
+        }
+        else if (indices[i].type == ND_INDEX_TYPE_ELLIPSIS)
+        {
             num_ellipsis++;
-            if (num_ellipsis > 1) {
+            if (num_ellipsis > 1)
+            {
                 raise_exception(SizeT, EXN_INDEX_ERROR, "an index can only have a single ellipsis ('...')", NO_PARAM,
                                 NO_PARAM, NO_PARAM);
             }
-        } else {
+        }
+        else
+        {
             __builtin_unreachable();
         }
     }
 
     debug_assert_eq(SizeT, expected_dst_ndims, dst_ndarray->ndims);
 
-    if (src_ndarray->ndims - num_indexed < 0) {
+    if (src_ndarray->ndims - num_indexed < 0)
+    {
         raise_exception(SizeT, EXN_INDEX_ERROR,
                         "too many indices for array: array is {0}-dimensional, "
                         "but {1} were indexed",
@@ -136,18 +154,20 @@ void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_
     dst_ndarray->data = src_ndarray->data;
     dst_ndarray->itemsize = src_ndarray->itemsize;
 
-    // Reference code:
-    // https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L652
+    // Reference code: https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L652
     SizeT src_axis = 0;
     SizeT dst_axis = 0;
 
-    for (int32_t i = 0; i < num_indices; i++) {
-        const NDIndex* index = &indices[i];
-        if (index->type == ND_INDEX_TYPE_SINGLE_ELEMENT) {
-            SizeT input = (SizeT) * ((int32_t*)index->data);
+    for (int32_t i = 0; i < num_indices; i++)
+    {
+        const NDIndex *index = &indices[i];
+        if (index->type == ND_INDEX_TYPE_SINGLE_ELEMENT)
+        {
+            SizeT input = (SizeT) * ((int32_t *)index->data);
 
             SizeT k = slice::resolve_index_in_length(src_ndarray->shape[src_axis], input);
-            if (k == -1) {
+            if (k == -1)
+            {
                 raise_exception(SizeT, EXN_INDEX_ERROR,
                                 "index {0} is out of bounds for axis {1} "
                                 "with size {2}",
@@ -157,8 +177,10 @@ void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_
             dst_ndarray->data += k * src_ndarray->strides[src_axis];
 
             src_axis++;
-        } else if (index->type == ND_INDEX_TYPE_SLICE) {
-            Slice<int32_t>* slice = (Slice<int32_t>*)index->data;
+        }
+        else if (index->type == ND_INDEX_TYPE_SLICE)
+        {
+            Slice<int32_t> *slice = (Slice<int32_t> *)index->data;
 
             Range<int32_t> range = slice->indices_checked<SizeT>(src_ndarray->shape[src_axis]);
 
@@ -168,28 +190,36 @@ void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_
 
             dst_axis++;
             src_axis++;
-        } else if (index->type == ND_INDEX_TYPE_NEWAXIS) {
+        }
+        else if (index->type == ND_INDEX_TYPE_NEWAXIS)
+        {
             dst_ndarray->strides[dst_axis] = 0;
             dst_ndarray->shape[dst_axis] = 1;
 
             dst_axis++;
-        } else if (index->type == ND_INDEX_TYPE_ELLIPSIS) {
+        }
+        else if (index->type == ND_INDEX_TYPE_ELLIPSIS)
+        {
             // The number of ':' entries this '...' implies.
             SizeT ellipsis_size = src_ndarray->ndims - num_indexed;
 
-            for (SizeT j = 0; j < ellipsis_size; j++) {
+            for (SizeT j = 0; j < ellipsis_size; j++)
+            {
                 dst_ndarray->strides[dst_axis] = src_ndarray->strides[src_axis];
                 dst_ndarray->shape[dst_axis] = src_ndarray->shape[src_axis];
 
                 dst_axis++;
                 src_axis++;
             }
-        } else {
+        }
+        else
+        {
             __builtin_unreachable();
         }
     }
 
-    for (; dst_axis < dst_ndarray->ndims; dst_axis++, src_axis++) {
+    for (; dst_axis < dst_ndarray->ndims; dst_axis++, src_axis++)
+    {
         dst_ndarray->shape[dst_axis] = src_ndarray->shape[src_axis];
         dst_ndarray->strides[dst_axis] = src_ndarray->strides[src_axis];
     }
@@ -197,24 +227,23 @@ void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_
     debug_assert_eq(SizeT, src_ndarray->ndims, src_axis);
     debug_assert_eq(SizeT, dst_ndarray->ndims, dst_axis);
 }
-}  // namespace indexing
-}  // namespace ndarray
-}  // namespace
+} // namespace indexing
+} // namespace ndarray
+} // namespace
 
-extern "C" {
-using namespace ndarray::indexing;
+extern "C"
+{
+    using namespace ndarray::indexing;
 
-void __nac3_ndarray_index(int32_t num_indices,
-                          NDIndex* indices,
-                          NDArray<int32_t>* src_ndarray,
-                          NDArray<int32_t>* dst_ndarray) {
-    index(num_indices, indices, src_ndarray, dst_ndarray);
-}
+    void __nac3_ndarray_index(int32_t num_indices, NDIndex *indices, NDArray<int32_t> *src_ndarray,
+                              NDArray<int32_t> *dst_ndarray)
+    {
+        index(num_indices, indices, src_ndarray, dst_ndarray);
+    }
 
-void __nac3_ndarray_index64(int64_t num_indices,
-                            NDIndex* indices,
-                            NDArray<int64_t>* src_ndarray,
-                            NDArray<int64_t>* dst_ndarray) {
-    index(num_indices, indices, src_ndarray, dst_ndarray);
-}
+    void __nac3_ndarray_index64(int64_t num_indices, NDIndex *indices, NDArray<int64_t> *src_ndarray,
+                                NDArray<int64_t> *dst_ndarray)
+    {
+        index(num_indices, indices, src_ndarray, dst_ndarray);
+    }
 }

nac3core/irrt/irrt/ndarray/iter.hpp

@@ -1,55 +1,35 @@
 #pragma once
 
-#include "irrt/int_types.hpp"
-#include "irrt/ndarray/def.hpp"
+#include <irrt/int_types.hpp>
+#include <irrt/ndarray/def.hpp>
 
-namespace {
+namespace
+{
 /**
  * @brief Helper struct to enumerate through an ndarray *efficiently*.
  *
- * Example usage (in pseudo-code):
- * ```
- * // Suppose my_ndarray has been initialized, with shape [2, 3] and dtype `double`
- * NDIter nditer;
- * nditer.initialize(my_ndarray);
- * while (nditer.has_element()) {
- *    // This body is run 6 (= my_ndarray.size) times.
- *
- *    // [0, 0] -> [0, 1] -> [0, 2] -> [1, 0] -> [1, 1] -> [1, 2] -> end
- *    print(nditer.indices);
- *
- *    // 0 -> 1 -> 2 -> 3 -> 4 -> 5
- *    print(nditer.nth);
- *
- *    // <1st element> -> <2nd element> -> ... -> <6th element> -> end
- *    print(*((double *) nditer.element))
- *
- *    nditer.next(); // Go to next element.
- * }
- * ```
- *
  * Interesting cases:
- * - If `my_ndarray.ndims` == 0, there is one iteration.
- * - If `my_ndarray.shape` contains zeroes, there are no iterations.
+ * - If ndims == 0, there is one iteration.
+ * - If shape contains zeroes, there are no iterations.
  */
-template<typename SizeT>
-struct NDIter {
+template <typename SizeT> struct NDIter
+{
     // Information about the ndarray being iterated over.
     SizeT ndims;
-    SizeT* shape;
-    SizeT* strides;
+    SizeT *shape;
+    SizeT *strides;
 
     /**
      * @brief The current indices.
      *
      * Must be allocated by the caller.
      */
-    SizeT* indices;
+    SizeT *indices;
 
     /**
      * @brief The nth (0-based) index of the current indices.
      *
-     * Initially this is 0.
+     * Initially this is all 0s.
      */
     SizeT nth;
 
@@ -58,7 +38,7 @@ struct NDIter {
      *
      * Initially this points to first element of the ndarray.
      */
-    uint8_t* element;
+    uint8_t *element;
 
     /**
      * @brief Cache for the product of shape.
@@ -67,7 +47,11 @@ struct NDIter {
      */
     SizeT size;
 
-    void initialize(SizeT ndims, SizeT* shape, SizeT* strides, uint8_t* element, SizeT* indices) {
+    // TODO:: Not implemented: There is something called backstrides to speedup iteration.
+    // See https://ajcr.net/stride-guide-part-1/, and https://docs.scipy.org/doc/numpy-1.13.0/reference/c-api.types-and-structures.html#c.PyArrayIterObject.PyArrayIterObject.backstrides.
+
+    void initialize(SizeT ndims, SizeT *shape, SizeT *strides, uint8_t *element, SizeT *indices)
+    {
         this->ndims = ndims;
         this->shape = shape;
         this->strides = strides;
@@ -77,39 +61,41 @@ struct NDIter {
 
         // Compute size
         this->size = 1;
-        for (SizeT i = 0; i < ndims; i++) {
+        for (SizeT i = 0; i < ndims; i++)
+        {
             this->size *= shape[i];
         }
 
-        // `indices` starts on all 0s.
         for (SizeT axis = 0; axis < ndims; axis++)
             indices[axis] = 0;
         nth = 0;
     }
 
-    void initialize_by_ndarray(NDArray<SizeT>* ndarray, SizeT* indices) {
-        // NOTE: ndarray->data is pointing to the first element, and `NDIter`'s `element` should also point to the first
-        // element as well.
+    void initialize_by_ndarray(NDArray<SizeT> *ndarray, SizeT *indices)
+    {
         this->initialize(ndarray->ndims, ndarray->shape, ndarray->strides, ndarray->data, indices);
     }
 
-    // Is the current iteration valid?
-    // If true, then `element`, `indices` and `nth` contain details about the current element.
-    bool has_element() { return nth < size; }
+    bool has_next()
+    {
+        return nth < size;
+    }
 
-    // Go to the next element.
-    void next() {
-        for (SizeT i = 0; i < ndims; i++) {
+    void next()
+    {
+        for (SizeT i = 0; i < ndims; i++)
+        {
             SizeT axis = ndims - i - 1;
             indices[axis]++;
-            if (indices[axis] >= shape[axis]) {
+            if (indices[axis] >= shape[axis])
+            {
                 indices[axis] = 0;
 
-                // TODO: There is something called backstrides to speedup iteration.
-                // See https://ajcr.net/stride-guide-part-1/, and
-                // https://docs.scipy.org/doc/numpy-1.13.0/reference/c-api.types-and-structures.html#c.PyArrayIterObject.PyArrayIterObject.backstrides.
+                // TODO: Can be optimized with backstrides.
                 element -= strides[axis] * (shape[axis] - 1);
-            } else {
+            }
+            else
+            {
                 element += strides[axis];
                 break;
             }
@@ -117,30 +103,37 @@ struct NDIter {
         nth++;
     }
 };
-}  // namespace
+} // namespace
 
-extern "C" {
-void __nac3_nditer_initialize(NDIter<int32_t>* iter, NDArray<int32_t>* ndarray, int32_t* indices) {
-    iter->initialize_by_ndarray(ndarray, indices);
-}
+extern "C"
+{
+    void __nac3_nditer_initialize(NDIter<int32_t> *iter, NDArray<int32_t> *ndarray, int32_t *indices)
+    {
+        iter->initialize_by_ndarray(ndarray, indices);
+    }
 
-void __nac3_nditer_initialize64(NDIter<int64_t>* iter, NDArray<int64_t>* ndarray, int64_t* indices) {
-    iter->initialize_by_ndarray(ndarray, indices);
-}
+    void __nac3_nditer_initialize64(NDIter<int64_t> *iter, NDArray<int64_t> *ndarray, int64_t *indices)
+    {
+        iter->initialize_by_ndarray(ndarray, indices);
+    }
 
-bool __nac3_nditer_has_element(NDIter<int32_t>* iter) {
-    return iter->has_element();
-}
+    bool __nac3_nditer_has_next(NDIter<int32_t> *iter)
+    {
+        return iter->has_next();
+    }
 
-bool __nac3_nditer_has_element64(NDIter<int64_t>* iter) {
-    return iter->has_element();
-}
+    bool __nac3_nditer_has_next64(NDIter<int64_t> *iter)
+    {
+        return iter->has_next();
+    }
 
-void __nac3_nditer_next(NDIter<int32_t>* iter) {
-    iter->next();
-}
+    void __nac3_nditer_next(NDIter<int32_t> *iter)
+    {
+        iter->next();
+    }
 
-void __nac3_nditer_next64(NDIter<int64_t>* iter) {
-    iter->next();
-}
+    void __nac3_nditer_next64(NDIter<int64_t> *iter)
+    {
+        iter->next();
+    }
 }

nac3core/irrt/irrt/ndarray/reshape.hpp

@@ -1,12 +1,14 @@
 #pragma once
 
-#include "irrt/exception.hpp"
-#include "irrt/int_types.hpp"
-#include "irrt/ndarray/def.hpp"
+#include <irrt/int_types.hpp>
+#include <irrt/ndarray/def.hpp>
 
-namespace {
-namespace ndarray {
-namespace reshape {
+namespace
+{
+namespace ndarray
+{
+namespace reshape
+{
 /**
  * @brief Perform assertions on and resolve unknown dimensions in `new_shape` in `np.reshape(<ndarray>, new_shape)`
  *
@@ -20,8 +22,8 @@ namespace reshape {
  * @param new_ndims Number of elements in `new_shape`
  * @param new_shape Target shape to reshape to
  */
-template<typename SizeT>
-void resolve_and_check_new_shape(SizeT size, SizeT new_ndims, SizeT* new_shape) {
+template <typename SizeT> void resolve_and_check_new_shape(SizeT size, SizeT new_ndims, SizeT *new_shape)
+{
     // Is there a -1 in `new_shape`?
     bool neg1_exists = false;
     // Location of -1, only initialized if `neg1_exists` is true
@@ -29,19 +31,27 @@ void resolve_and_check_new_shape(SizeT size, SizeT new_ndims, SizeT* new_shape)
     // The computed ndarray size of `new_shape`
     SizeT new_size = 1;
 
-    for (SizeT axis_i = 0; axis_i < new_ndims; axis_i++) {
+    for (SizeT axis_i = 0; axis_i < new_ndims; axis_i++)
+    {
         SizeT dim = new_shape[axis_i];
-        if (dim < 0) {
-            if (dim == -1) {
-                if (neg1_exists) {
+        if (dim < 0)
+        {
+            if (dim == -1)
+            {
+                if (neg1_exists)
+                {
                     // Multiple `-1` found. Throw an error.
                     raise_exception(SizeT, EXN_VALUE_ERROR, "can only specify one unknown dimension", NO_PARAM,
                                     NO_PARAM, NO_PARAM);
-                } else {
+                }
+                else
+                {
                     neg1_exists = true;
                     neg1_axis_i = axis_i;
                 }
-            } else {
+            }
+            else
+            {
                 // TODO: What? In `np.reshape` any negative dimensions is
                 // treated like its `-1`.
                 //
@@ -53,47 +63,63 @@ void resolve_and_check_new_shape(SizeT size, SizeT new_ndims, SizeT* new_shape)
                 raise_exception(SizeT, EXN_VALUE_ERROR, "Found non -1 negative dimension {0} on axis {1}", dim, axis_i,
                                 NO_PARAM);
             }
-        } else {
+        }
+        else
+        {
             new_size *= dim;
         }
     }
 
     bool can_reshape;
-    if (neg1_exists) {
+    if (neg1_exists)
+    {
         // Let `x` be the unknown dimension
         // Solve `x * <new_size> = <size>`
-        if (new_size == 0 && size == 0) {
+        if (new_size == 0 && size == 0)
+        {
             // `x` has infinitely many solutions
             can_reshape = false;
-        } else if (new_size == 0 && size != 0) {
+        }
+        else if (new_size == 0 && size != 0)
+        {
             // `x` has no solutions
             can_reshape = false;
-        } else if (size % new_size != 0) {
+        }
+        else if (size % new_size != 0)
+        {
             // `x` has no integer solutions
             can_reshape = false;
-        } else {
-            can_reshape = true;
-            new_shape[neg1_axis_i] = size / new_size;  // Resolve dimension
         }
-    } else {
+        else
+        {
+            can_reshape = true;
+            new_shape[neg1_axis_i] = size / new_size; // Resolve dimension
+        }
+    }
+    else
+    {
         can_reshape = (new_size == size);
     }
 
-    if (!can_reshape) {
+    if (!can_reshape)
+    {
         raise_exception(SizeT, EXN_VALUE_ERROR, "cannot reshape array of size {0} into given shape", size, NO_PARAM,
                         NO_PARAM);
     }
 }
-}  // namespace reshape
-}  // namespace ndarray
-}  // namespace
+} // namespace reshape
+} // namespace ndarray
+} // namespace
 
-extern "C" {
-void __nac3_ndarray_reshape_resolve_and_check_new_shape(int32_t size, int32_t new_ndims, int32_t* new_shape) {
-    ndarray::reshape::resolve_and_check_new_shape(size, new_ndims, new_shape);
-}
+extern "C"
+{
+    void __nac3_ndarray_reshape_resolve_and_check_new_shape(int32_t size, int32_t new_ndims, int32_t *new_shape)
+    {
+        ndarray::reshape::resolve_and_check_new_shape(size, new_ndims, new_shape);
+    }
 
-void __nac3_ndarray_reshape_resolve_and_check_new_shape64(int64_t size, int64_t new_ndims, int64_t* new_shape) {
-    ndarray::reshape::resolve_and_check_new_shape(size, new_ndims, new_shape);
-}
+    void __nac3_ndarray_reshape_resolve_and_check_new_shape64(int64_t size, int64_t new_ndims, int64_t *new_shape)
+    {
+        ndarray::reshape::resolve_and_check_new_shape(size, new_ndims, new_shape);
+    }
 }

nac3core/irrt/irrt/ndarray/transpose.hpp

@@ -1,10 +1,8 @@
 #pragma once
 
-#include "irrt/debug.hpp"
-#include "irrt/exception.hpp"
-#include "irrt/int_types.hpp"
-#include "irrt/ndarray/def.hpp"
-#include "irrt/slice.hpp"
+#include <irrt/int_types.hpp>
+#include <irrt/ndarray/def.hpp>
+#include <irrt/slice.hpp>
 
 /*
  * Notes on `np.transpose(<array>, <axes>)`
@@ -15,9 +13,12 @@
  * Supporting it for now.
  */
 
-namespace {
-namespace ndarray {
-namespace transpose {
+namespace
+{
+namespace ndarray
+{
+namespace transpose
+{
 /**
  * @brief Do assertions on `<axes>` in `np.transpose(<array>, <axes>)`.
  *
@@ -29,26 +30,30 @@ namespace transpose {
  *   This should be equal to `ndims`. If not, a "ValueError: axes don't match array" is thrown.
  * @param axes The user specified `<axes>`.
  */
-template<typename SizeT>
-void assert_transpose_axes(SizeT ndims, SizeT num_axes, const SizeT* axes) {
-    if (ndims != num_axes) {
+template <typename SizeT> void assert_transpose_axes(SizeT ndims, SizeT num_axes, const SizeT *axes)
+{
+    if (ndims != num_axes)
+    {
         raise_exception(SizeT, EXN_VALUE_ERROR, "axes don't match array", NO_PARAM, NO_PARAM, NO_PARAM);
     }
 
     // TODO: Optimize this
-    bool* axe_specified = (bool*)__builtin_alloca(sizeof(bool) * ndims);
+    bool *axe_specified = (bool *)__builtin_alloca(sizeof(bool) * ndims);
     for (SizeT i = 0; i < ndims; i++)
         axe_specified[i] = false;
 
-    for (SizeT i = 0; i < ndims; i++) {
+    for (SizeT i = 0; i < ndims; i++)
+    {
         SizeT axis = slice::resolve_index_in_length(ndims, axes[i]);
-        if (axis == -1) {
+        if (axis == -1)
+        {
             // TODO: numpy actually throws a `numpy.exceptions.AxisError`
             raise_exception(SizeT, EXN_VALUE_ERROR, "axis {0} is out of bounds for array of dimension {1}", axis, ndims,
                             NO_PARAM);
         }
 
-        if (axe_specified[axis]) {
+        if (axe_specified[axis])
+        {
             raise_exception(SizeT, EXN_VALUE_ERROR, "repeated axis in transpose", NO_PARAM, NO_PARAM, NO_PARAM);
         }
 
@@ -83,8 +88,9 @@ void assert_transpose_axes(SizeT ndims, SizeT num_axes, const SizeT* axes) {
  * @param num_axes Number of elements in axes. Unused if `axes` is nullptr.
  * @param axes Axes permutation. Set it to `nullptr` if `<axes>` is `None`.
  */
-template<typename SizeT>
-void transpose(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray, SizeT num_axes, const SizeT* axes) {
+template <typename SizeT>
+void transpose(const NDArray<SizeT> *src_ndarray, NDArray<SizeT> *dst_ndarray, SizeT num_axes, const SizeT *axes)
+{
     debug_assert_eq(SizeT, src_ndarray->ndims, dst_ndarray->ndims);
     const auto ndims = src_ndarray->ndims;
 
@@ -95,7 +101,8 @@ void transpose(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray, S
     dst_ndarray->itemsize = src_ndarray->itemsize;
 
     // Check out https://ajcr.net/stride-guide-part-2/ to see how `np.transpose` works behind the scenes.
-    if (axes == nullptr) {
+    if (axes == nullptr)
+    {
         // `np.transpose(<array>, axes=None)`
 
         /*
@@ -106,15 +113,19 @@ void transpose(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray, S
          * This is a fast implementation to handle this special (but very common) case.
          */
 
-        for (SizeT axis = 0; axis < ndims; axis++) {
+        for (SizeT axis = 0; axis < ndims; axis++)
+        {
             dst_ndarray->shape[axis] = src_ndarray->shape[ndims - axis - 1];
             dst_ndarray->strides[axis] = src_ndarray->strides[ndims - axis - 1];
         }
-    } else {
+    }
+    else
+    {
         // `np.transpose(<array>, <axes>)`
 
         // Permute strides and shape according to `axes`, while resolving negative indices in `axes`
-        for (SizeT axis = 0; axis < ndims; axis++) {
+        for (SizeT axis = 0; axis < ndims; axis++)
+        {
             // `i` cannot be OUT_OF_BOUNDS because of assertions
             SizeT i = slice::resolve_index_in_length(ndims, axes[axis]);
 
@@ -123,23 +134,22 @@ void transpose(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray, S
         }
     }
 }
-}  // namespace transpose
-}  // namespace ndarray
-}  // namespace
+} // namespace transpose
+} // namespace ndarray
+} // namespace
 
-extern "C" {
-using namespace ndarray::transpose;
-void __nac3_ndarray_transpose(const NDArray<int32_t>* src_ndarray,
-                              NDArray<int32_t>* dst_ndarray,
-                              int32_t num_axes,
-                              const int32_t* axes) {
-    transpose(src_ndarray, dst_ndarray, num_axes, axes);
-}
+extern "C"
+{
+    using namespace ndarray::transpose;
+    void __nac3_ndarray_transpose(const NDArray<int32_t> *src_ndarray, NDArray<int32_t> *dst_ndarray, int32_t num_axes,
+                                  const int32_t *axes)
+    {
+        transpose(src_ndarray, dst_ndarray, num_axes, axes);
+    }
 
-void __nac3_ndarray_transpose64(const NDArray<int64_t>* src_ndarray,
-                                NDArray<int64_t>* dst_ndarray,
-                                int64_t num_axes,
-                                const int64_t* axes) {
-    transpose(src_ndarray, dst_ndarray, num_axes, axes);
-}
+    void __nac3_ndarray_transpose64(const NDArray<int64_t> *src_ndarray, NDArray<int64_t> *dst_ndarray,
+                                    int64_t num_axes, const int64_t *axes)
+    {
+        transpose(src_ndarray, dst_ndarray, num_axes, axes);
+    }
 }

nac3core/irrt/irrt/original.hpp

@@ -0,0 +1,372 @@
+#pragma once
+
+#include <irrt/int_types.hpp>
+#include <irrt/math_util.hpp>
+
+// NDArray indices are always `uint32_t`.
+using NDIndexInt = uint32_t;
+// The type of an index or a value describing the length of a range/slice is always `int32_t`.
+using SliceIndex = int32_t;
+
+namespace
+{
+// 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
+template <typename T> T __nac3_int_exp_impl(T base, T exp)
+{
+    T res = 1;
+    /* repeated squaring method */
+    do
+    {
+        if (exp & 1)
+        {
+            res *= base; /* for n odd */
+        }
+        exp >>= 1;
+        base *= base;
+    } while (exp);
+    return res;
+}
+
+template <typename SizeT>
+SizeT __nac3_ndarray_calc_size_impl(const SizeT *list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx)
+{
+    __builtin_assume(end_idx <= list_len);
+
+    SizeT num_elems = 1;
+    for (SizeT i = begin_idx; i < end_idx; ++i)
+    {
+        SizeT val = list_data[i];
+        __builtin_assume(val > 0);
+        num_elems *= val;
+    }
+    return num_elems;
+}
+
+template <typename SizeT>
+void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT *dims, SizeT num_dims, NDIndexInt *idxs)
+{
+    SizeT stride = 1;
+    for (SizeT dim = 0; dim < num_dims; dim++)
+    {
+        SizeT i = num_dims - dim - 1;
+        __builtin_assume(dims[i] > 0);
+        idxs[i] = (index / stride) % dims[i];
+        stride *= dims[i];
+    }
+}
+
+template <typename SizeT>
+SizeT __nac3_ndarray_flatten_index_impl(const SizeT *dims, SizeT num_dims, const NDIndexInt *indices, SizeT num_indices)
+{
+    SizeT idx = 0;
+    SizeT stride = 1;
+    for (SizeT i = 0; i < num_dims; ++i)
+    {
+        SizeT ri = num_dims - i - 1;
+        if (ri < num_indices)
+        {
+            idx += stride * indices[ri];
+        }
+
+        __builtin_assume(dims[i] > 0);
+        stride *= dims[ri];
+    }
+    return idx;
+}
+
+template <typename SizeT>
+void __nac3_ndarray_calc_broadcast_impl(const SizeT *lhs_dims, SizeT lhs_ndims, const SizeT *rhs_dims, SizeT rhs_ndims,
+                                        SizeT *out_dims)
+{
+    SizeT max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
+
+    for (SizeT i = 0; i < max_ndims; ++i)
+    {
+        const SizeT *lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : nullptr;
+        const SizeT *rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : nullptr;
+        SizeT *out_dim = &out_dims[max_ndims - i - 1];
+
+        if (lhs_dim_sz == nullptr)
+        {
+            *out_dim = *rhs_dim_sz;
+        }
+        else if (rhs_dim_sz == nullptr)
+        {
+            *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();
+        }
+    }
+}
+
+template <typename SizeT>
+void __nac3_ndarray_calc_broadcast_idx_impl(const SizeT *src_dims, SizeT src_ndims, const NDIndexInt *in_idx,
+                                            NDIndexInt *out_idx)
+{
+    for (SizeT i = 0; i < src_ndims; ++i)
+    {
+        SizeT src_i = src_ndims - i - 1;
+        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
+    }
+}
+} // namespace
+
+extern "C"
+{
+#define DEF_nac3_int_exp_(T)                                                                                           \
+    T __nac3_int_exp_##T(T base, T exp)                                                                                \
+    {                                                                                                                  \
+        return __nac3_int_exp_impl(base, exp);                                                                         \
+    }
+
+    DEF_nac3_int_exp_(int32_t) DEF_nac3_int_exp_(int64_t) DEF_nac3_int_exp_(uint32_t) DEF_nac3_int_exp_(uint64_t)
+
+        SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len)
+    {
+        if (i < 0)
+        {
+            i = len + i;
+        }
+        if (i < 0)
+        {
+            return 0;
+        }
+        else if (i > len)
+        {
+            return len;
+        }
+        return i;
+    }
+
+    SliceIndex __nac3_range_slice_len(const SliceIndex start, const SliceIndex end, const SliceIndex step)
+    {
+        SliceIndex diff = end - start;
+        if (diff > 0 && step > 0)
+        {
+            return ((diff - 1) / step) + 1;
+        }
+        else if (diff < 0 && step < 0)
+        {
+            return ((diff + 1) / step) + 1;
+        }
+        else
+        {
+            return 0;
+        }
+    }
+
+    // Handle list assignment and dropping part of the list when
+    // both dest_step and src_step are +1.
+    // - All the index must *not* be out-of-bound or negative,
+    // - The end index is *inclusive*,
+    // - The length of src and dest slice size should already
+    // be checked: if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest)
+    SliceIndex __nac3_list_slice_assign_var_size(SliceIndex dest_start, SliceIndex dest_end, SliceIndex dest_step,
+                                                 uint8_t *dest_arr, SliceIndex dest_arr_len, SliceIndex src_start,
+                                                 SliceIndex src_end, SliceIndex src_step, uint8_t *src_arr,
+                                                 SliceIndex src_arr_len, const SliceIndex size)
+    {
+        /* if dest_arr_len == 0, do nothing since we do not support extending list */
+        if (dest_arr_len == 0)
+            return dest_arr_len;
+        /* if both step is 1, memmove directly, handle the dropping of the list, and shrink size */
+        if (src_step == dest_step && dest_step == 1)
+        {
+            const SliceIndex src_len = (src_end >= src_start) ? (src_end - src_start + 1) : 0;
+            const SliceIndex dest_len = (dest_end >= dest_start) ? (dest_end - dest_start + 1) : 0;
+            if (src_len > 0)
+            {
+                __builtin_memmove(dest_arr + dest_start * size, src_arr + src_start * size, src_len * size);
+            }
+            if (dest_len > 0)
+            {
+                /* dropping */
+                __builtin_memmove(dest_arr + (dest_start + src_len) * size, dest_arr + (dest_end + 1) * size,
+                                  (dest_arr_len - dest_end - 1) * size);
+            }
+            /* shrink size */
+            return dest_arr_len - (dest_len - src_len);
+        }
+        /* if two range overlaps, need alloca */
+        uint8_t need_alloca = (dest_arr == src_arr) && !(max(dest_start, dest_end) < min(src_start, src_end) ||
+                                                         max(src_start, src_end) < min(dest_start, dest_end));
+        if (need_alloca)
+        {
+            uint8_t *tmp = reinterpret_cast<uint8_t *>(__builtin_alloca(src_arr_len * size));
+            __builtin_memcpy(tmp, src_arr, src_arr_len * size);
+            src_arr = tmp;
+        }
+        SliceIndex src_ind = src_start;
+        SliceIndex dest_ind = dest_start;
+        for (; (src_step > 0) ? (src_ind <= src_end) : (src_ind >= src_end); src_ind += src_step, dest_ind += dest_step)
+        {
+            /* for constant optimization */
+            if (size == 1)
+            {
+                __builtin_memcpy(dest_arr + dest_ind, src_arr + src_ind, 1);
+            }
+            else if (size == 4)
+            {
+                __builtin_memcpy(dest_arr + dest_ind * 4, src_arr + src_ind * 4, 4);
+            }
+            else if (size == 8)
+            {
+                __builtin_memcpy(dest_arr + dest_ind * 8, src_arr + src_ind * 8, 8);
+            }
+            else
+            {
+                /* memcpy for var size, cannot overlap after previous alloca */
+                __builtin_memcpy(dest_arr + dest_ind * size, src_arr + src_ind * size, size);
+            }
+        }
+        /* only dest_step == 1 can we shrink the dest list. */
+        /* size should be ensured prior to calling this function */
+        if (dest_step == 1 && dest_end >= dest_start)
+        {
+            __builtin_memmove(dest_arr + dest_ind * size, dest_arr + (dest_end + 1) * size,
+                              (dest_arr_len - dest_end - 1) * size);
+            return dest_arr_len - (dest_end - dest_ind) - 1;
+        }
+        return dest_arr_len;
+    }
+
+    int32_t __nac3_isinf(double x)
+    {
+        return __builtin_isinf(x);
+    }
+
+    int32_t __nac3_isnan(double x)
+    {
+        return __builtin_isnan(x);
+    }
+
+    double tgamma(double arg);
+
+    double __nac3_gamma(double z)
+    {
+        // Handling for denormals
+        //     | x                 | Python gamma(x) | C tgamma(x) |
+        // --- | ----------------- | --------------- | ----------- |
+        // (1) | nan               | nan             | nan         |
+        // (2) | -inf              | -inf            | inf         |
+        // (3) | inf               | inf             | inf         |
+        // (4) | 0.0               | inf             | inf         |
+        // (5) | {-1.0, -2.0, ...} | inf             | nan         |
+
+        // (1)-(3)
+        if (__builtin_isinf(z) || __builtin_isnan(z))
+        {
+            return z;
+        }
+
+        double v = tgamma(z);
+
+        // (4)-(5)
+        return __builtin_isinf(v) || __builtin_isnan(v) ? __builtin_inf() : v;
+    }
+
+    double lgamma(double arg);
+
+    double __nac3_gammaln(double x)
+    {
+        // libm's handling of value overflows differs from scipy:
+        // - scipy: gammaln(-inf) -> -inf
+        // - libm : lgamma(-inf) -> inf
+
+        if (__builtin_isinf(x))
+        {
+            return x;
+        }
+
+        return lgamma(x);
+    }
+
+    double j0(double x);
+
+    double __nac3_j0(double x)
+    {
+        // libm's handling of value overflows differs from scipy:
+        // - scipy: j0(inf) -> nan
+        // - libm : j0(inf) -> 0.0
+
+        if (__builtin_isinf(x))
+        {
+            return __builtin_nan("");
+        }
+
+        return j0(x);
+    }
+
+    uint32_t __nac3_ndarray_calc_size(const uint32_t *list_data, uint32_t list_len, uint32_t begin_idx,
+                                      uint32_t end_idx)
+    {
+        return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
+    }
+
+    uint64_t __nac3_ndarray_calc_size64(const uint64_t *list_data, uint64_t list_len, uint64_t begin_idx,
+                                        uint64_t end_idx)
+    {
+        return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
+    }
+
+    void __nac3_ndarray_calc_nd_indices(uint32_t index, const uint32_t *dims, uint32_t num_dims, NDIndexInt *idxs)
+    {
+        __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
+    }
+
+    void __nac3_ndarray_calc_nd_indices64(uint64_t index, const uint64_t *dims, uint64_t num_dims, NDIndexInt *idxs)
+    {
+        __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
+    }
+
+    uint32_t __nac3_ndarray_flatten_index(const uint32_t *dims, uint32_t num_dims, const NDIndexInt *indices,
+                                          uint32_t num_indices)
+    {
+        return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
+    }
+
+    uint64_t __nac3_ndarray_flatten_index64(const uint64_t *dims, uint64_t num_dims, const NDIndexInt *indices,
+                                            uint64_t num_indices)
+    {
+        return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
+    }
+
+    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)
+    {
+        return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
+    }
+
+    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)
+    {
+        return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
+    }
+
+    void __nac3_ndarray_calc_broadcast_idx(const uint32_t *src_dims, uint32_t src_ndims, const NDIndexInt *in_idx,
+                                           NDIndexInt *out_idx)
+    {
+        __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
+    }
+
+    void __nac3_ndarray_calc_broadcast_idx64(const uint64_t *src_dims, uint64_t src_ndims, const NDIndexInt *in_idx,
+                                             NDIndexInt *out_idx)
+    {
+        __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
+    }
+} // extern "C"

nac3core/irrt/irrt/range.hpp

@@ -1,12 +1,14 @@
 #pragma once
 
-#include "irrt/debug.hpp"
-#include "irrt/int_types.hpp"
+#include <irrt/debug.hpp>
+#include <irrt/int_types.hpp>
 
-namespace {
-namespace range {
-template<typename T>
-T len(T start, T stop, T step) {
+namespace
+{
+namespace range
+{
+template <typename T> T len(T start, T stop, T step)
+{
     // Reference:
     // https://github.com/python/cpython/blob/9dbd12375561a393eaec4b21ee4ac568a407cdb0/Objects/rangeobject.c#L933
     if (step > 0 && start < stop)
@@ -16,13 +18,13 @@ T len(T start, T stop, T step) {
     else
         return 0;
 }
-}  // namespace range
+} // namespace range
 
 /**
  * @brief A Python range.
  */
-template<typename T>
-struct Range {
+template <typename T> struct Range
+{
     T start;
     T stop;
     T step;
@@ -30,18 +32,10 @@ struct Range {
     /**
      * @brief Calculate the `len()` of this range.
      */
-    template<typename SizeT>
-    T len() {
+    template <typename SizeT> T len()
+    {
         debug_assert(SizeT, step != 0);
         return range::len(start, stop, step);
     }
 };
-}  // namespace
-
-extern "C" {
-using namespace range;
-
-SliceIndex __nac3_range_slice_len(const SliceIndex start, const SliceIndex end, const SliceIndex step) {
-    return len(start, end, step);
-}
-}
+} // namespace

nac3core/irrt/irrt/slice.hpp

@@ -1,24 +1,29 @@
 #pragma once
 
-#include "irrt/debug.hpp"
-#include "irrt/exception.hpp"
-#include "irrt/int_types.hpp"
-#include "irrt/math_util.hpp"
-#include "irrt/range.hpp"
+#include <irrt/debug.hpp>
+#include <irrt/exception.hpp>
+#include <irrt/int_types.hpp>
+#include <irrt/math_util.hpp>
+#include <irrt/range.hpp>
 
-namespace {
-namespace slice {
+namespace
+{
+namespace slice
+{
 /**
  * @brief Resolve a possibly negative index in a list of a known length.
  *
  * Returns -1 if the resolved index is out of the list's bounds.
  */
-template<typename T>
-T resolve_index_in_length(T length, T index) {
+template <typename T> T resolve_index_in_length(T length, T index)
+{
     T resolved = index < 0 ? length + index : index;
-    if (0 <= resolved && resolved < length) {
+    if (0 <= resolved && resolved < length)
+    {
         return resolved;
-    } else {
+    }
+    else
+    {
         return -1;
     }
 }
@@ -28,49 +33,51 @@ T resolve_index_in_length(T length, T index) {
  *
  * This is equivalent to `range(*slice(start, stop, step).indices(length))` in Python.
  */
-template<typename T>
-void indices(bool start_defined,
-             T start,
-             bool stop_defined,
-             T stop,
-             bool step_defined,
-             T step,
-             T length,
-             T* range_start,
-             T* range_stop,
-             T* range_step) {
+template <typename T>
+void indices(bool start_defined, T start, bool stop_defined, T stop, bool step_defined, T step, T length,
+             T *range_start, T *range_stop, T *range_step)
+{
     // Reference: https://github.com/python/cpython/blob/main/Objects/sliceobject.c#L388
     *range_step = step_defined ? step : 1;
     bool step_is_negative = *range_step < 0;
 
     T lower, upper;
-    if (step_is_negative) {
+    if (step_is_negative)
+    {
         lower = -1;
         upper = length - 1;
-    } else {
+    }
+    else
+    {
         lower = 0;
         upper = length;
     }
 
-    if (start_defined) {
+    if (start_defined)
+    {
         *range_start = start < 0 ? max(lower, start + length) : min(upper, start);
-    } else {
+    }
+    else
+    {
         *range_start = step_is_negative ? upper : lower;
     }
 
-    if (stop_defined) {
+    if (stop_defined)
+    {
         *range_stop = stop < 0 ? max(lower, stop + length) : min(upper, stop);
-    } else {
+    }
+    else
+    {
         *range_stop = step_is_negative ? lower : upper;
     }
 }
-}  // namespace slice
+} // namespace slice
 
 /**
  * @brief A Python-like slice with **unresolved** indices.
  */
-template<typename T>
-struct Slice {
+template <typename T> struct Slice
+{
     bool start_defined;
     T start;
 
@@ -80,25 +87,32 @@ struct Slice {
     bool step_defined;
     T step;
 
-    Slice() { this->reset(); }
+    Slice()
+    {
+        this->reset();
+    }
 
-    void reset() {
+    void reset()
+    {
         this->start_defined = false;
         this->stop_defined = false;
         this->step_defined = false;
     }
 
-    void set_start(T start) {
+    void set_start(T start)
+    {
         this->start_defined = true;
         this->start = start;
     }
 
-    void set_stop(T stop) {
+    void set_stop(T stop)
+    {
         this->stop_defined = true;
         this->stop = stop;
     }
 
-    void set_step(T step) {
+    void set_step(T step)
+    {
         this->step_defined = true;
         this->step = step;
     }
@@ -108,8 +122,8 @@ struct Slice {
      *
      * In Python, this would be `range(*slice(start, stop, step).indices(length))`.
      */
-    template<typename SizeT>
-    Range<T> indices(T length) {
+    template <typename SizeT> Range<T> indices(T length)
+    {
         // Reference:
         // https://github.com/python/cpython/blob/main/Objects/sliceobject.c#L388
         debug_assert(SizeT, length >= 0);
@@ -123,34 +137,22 @@ struct Slice {
     /**
      * @brief Like `.indices()` but with assertions.
      */
-    template<typename SizeT>
-    Range<T> indices_checked(T length) {
+    template <typename SizeT> Range<T> indices_checked(T length)
+    {
         // TODO: Switch to `SizeT length`
 
-        if (length < 0) {
+        if (length < 0)
+        {
             raise_exception(SizeT, EXN_VALUE_ERROR, "length should not be negative, got {0}", length, NO_PARAM,
                             NO_PARAM);
         }
 
-        if (this->step_defined && this->step == 0) {
+        if (this->step_defined && this->step == 0)
+        {
             raise_exception(SizeT, EXN_VALUE_ERROR, "slice step cannot be zero", NO_PARAM, NO_PARAM, NO_PARAM);
         }
 
         return this->indices<SizeT>(length);
     }
 };
-}  // namespace
-
-extern "C" {
-SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
-    if (i < 0) {
-        i = len + i;
-    }
-    if (i < 0) {
-        return 0;
-    } else if (i > len) {
-        return len;
-    }
-    return i;
-}
-}
+} // namespace

nac3core/src/codegen/builtin_fns.rs

@@ -8,7 +8,6 @@ use crate::codegen::classes::{
 };
 use crate::codegen::expr::destructure_range;
 use crate::codegen::irrt::calculate_len_for_slice_range;
-use crate::codegen::macros::codegen_unreachable;
 use crate::codegen::numpy::ndarray_elementwise_unaryop_impl;
 use crate::codegen::stmt::gen_for_callback_incrementing;
 use crate::codegen::{extern_fns, irrt, llvm_intrinsics, numpy, CodeGenContext, CodeGenerator};
@@ -26,8 +25,7 @@ use super::object::tuple::TupleObject;
 ///
 /// The generated message will contain the function name and the name of the unsupported type.
 fn unsupported_type(ctx: &CodeGenContext<'_, '_>, fn_name: &str, tys: &[Type]) -> ! {
-    codegen_unreachable!(
-        ctx,
+    unreachable!(
         "{fn_name}() not supported for '{}'",
         tys.iter().map(|ty| format!("'{}'", ctx.unifier.stringify(*ty))).join(", "),
     )
@@ -766,7 +764,7 @@ pub fn call_numpy_minimum<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@@ -870,7 +868,7 @@ pub fn call_numpy_max_min<'ctx, G: CodeGenerator + ?Sized>(
             match fn_name {
                 "np_argmin" | "np_argmax" => llvm_int64.const_zero().into(),
                 "np_max" | "np_min" => a,
-                _ => codegen_unreachable!(ctx),
+                _ => unreachable!(),
             }
         }
         BasicValueEnum::PointerValue(n)
@@ -925,7 +923,7 @@ pub fn call_numpy_max_min<'ctx, G: CodeGenerator + ?Sized>(
                         "np_argmax" | "np_max" => {
                             call_max(ctx, (elem_ty, accumulator), (elem_ty, elem))
                         }
-                        _ => codegen_unreachable!(ctx),
+                        _ => unreachable!(),
                     };
 
                     let updated_idx = match (accumulator, result) {
@@ -962,7 +960,7 @@ pub fn call_numpy_max_min<'ctx, G: CodeGenerator + ?Sized>(
             match fn_name {
                 "np_argmin" | "np_argmax" => ctx.builder.build_load(res_idx, "").unwrap(),
                 "np_max" | "np_min" => ctx.builder.build_load(accumulator_addr, "").unwrap(),
-                _ => codegen_unreachable!(ctx),
+                _ => unreachable!(),
             }
         }
 
@@ -1028,7 +1026,7 @@ pub fn call_numpy_maximum<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@@ -1468,7 +1466,7 @@ pub fn call_numpy_arctan2<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@@ -1535,7 +1533,7 @@ pub fn call_numpy_copysign<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@@ -1602,7 +1600,7 @@ pub fn call_numpy_fmax<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@@ -1669,7 +1667,7 @@ pub fn call_numpy_fmin<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@@ -1792,7 +1790,7 @@ pub fn call_numpy_hypot<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@@ -1859,7 +1857,7 @@ pub fn call_numpy_nextafter<'ctx, G: CodeGenerator + ?Sized>(
             } else if is_ndarray2 {
                 unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
 
             let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };

nac3core/src/codegen/classes.rs

@@ -1404,7 +1404,7 @@ impl<'ctx> NDArrayValue<'ctx> {
 
     /// Returns the double-indirection pointer to the `data` array, as if by calling `getelementptr`
     /// on the field.
-    pub fn ptr_to_data(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
+    fn ptr_to_data(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
         let llvm_i32 = ctx.ctx.i32_type();
         let var_name = self.name.map(|v| format!("{v}.data.addr")).unwrap_or_default();
 

nac3core/src/codegen/expr.rs

@@ -11,7 +11,6 @@ use crate::{
             call_expect, call_float_floor, call_float_pow, call_float_powi, call_int_smax,
             call_int_umin, call_memcpy_generic,
         },
-        macros::codegen_unreachable,
         need_sret, numpy,
         stmt::{
             gen_for_callback_incrementing, gen_if_callback, gen_if_else_expr_callback, gen_raise,
@@ -41,9 +40,12 @@ use std::cmp::min;
 use std::iter::{repeat, repeat_with};
 use std::{collections::HashMap, convert::TryInto, iter::once, iter::zip};
 
-use super::object::{
-    any::AnyObject,
-    ndarray::{indexing::util::gen_ndarray_subscript_ndindices, NDArrayObject},
+use super::{
+    model::*,
+    object::{
+        any::AnyObject,
+        ndarray::{indexing::util::gen_ndarray_subscript_ndindices, NDArrayObject},
+    },
 };
 
 pub fn get_subst_key(
@@ -114,7 +116,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
         let obj_id = match &*self.unifier.get_ty(ty) {
             TypeEnum::TObj { obj_id, .. } => *obj_id,
             // we cannot have other types, virtual type should be handled by function calls
-            _ => codegen_unreachable!(self),
+            _ => unreachable!(),
         };
         let def = &self.top_level.definitions.read()[obj_id.0];
         let (index, value) = if let TopLevelDef::Class { fields, attributes, .. } = &*def.read() {
@@ -125,7 +127,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                 (attribute_index.0, Some(attribute_index.1 .2.clone()))
             }
         } else {
-            codegen_unreachable!(self)
+            unreachable!()
         };
         (index, value)
     }
@@ -135,7 +137,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
             TypeEnum::TObj { fields, .. } => {
                 fields.iter().find_position(|x| *x.0 == attr).unwrap().0
             }
-            _ => codegen_unreachable!(self),
+            _ => unreachable!(),
         }
     }
 
@@ -190,7 +192,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                     {
                         *params.iter().next().unwrap().1
                     }
-                    _ => codegen_unreachable!(self, "must be option type"),
+                    _ => unreachable!("must be option type"),
                 };
                 let val = self.gen_symbol_val(generator, v, ty);
                 let ptr = generator
@@ -206,7 +208,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                     {
                         *params.iter().next().unwrap().1
                     }
-                    _ => codegen_unreachable!(self, "must be option type"),
+                    _ => unreachable!("must be option type"),
                 };
                 let actual_ptr_type =
                     self.get_llvm_type(generator, ty).ptr_type(AddressSpace::default());
@@ -273,7 +275,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                 {
                     self.ctx.i64_type()
                 } else {
-                    codegen_unreachable!(self)
+                    unreachable!()
                 };
                 Some(ty.const_int(*val as u64, false).into())
             }
@@ -287,7 +289,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                 let (types, is_vararg_ctx) = if let TypeEnum::TTuple { ty, is_vararg_ctx } = &*ty {
                     (ty.clone(), *is_vararg_ctx)
                 } else {
-                    codegen_unreachable!(self)
+                    unreachable!()
                 };
                 let values = zip(types, v.iter())
                     .map_while(|(ty, v)| self.gen_const(generator, v, ty))
@@ -332,7 +334,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
 
                 None
             }
-            _ => codegen_unreachable!(self),
+            _ => unreachable!(),
         }
     }
 
@@ -346,7 +348,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
         signed: bool,
     ) -> BasicValueEnum<'ctx> {
         let (BasicValueEnum::IntValue(lhs), BasicValueEnum::IntValue(rhs)) = (lhs, rhs) else {
-            codegen_unreachable!(self)
+            unreachable!()
         };
         let float = self.ctx.f64_type();
         match (op, signed) {
@@ -421,7 +423,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                         .build_right_shift(lhs, rhs, signed, "rshift")
                         .map(Into::into)
                         .unwrap(),
-                    _ => codegen_unreachable!(self),
+                    _ => unreachable!(),
                 }
             }
 
@@ -433,7 +435,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
             }
             (Operator::Pow, s) => integer_power(generator, self, lhs, rhs, s).into(),
             // special implementation?
-            (Operator::MatMult, _) => codegen_unreachable!(self),
+            (Operator::MatMult, _) => unreachable!(),
         }
     }
 
@@ -445,8 +447,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
         rhs: BasicValueEnum<'ctx>,
     ) -> BasicValueEnum<'ctx> {
         let (BasicValueEnum::FloatValue(lhs), BasicValueEnum::FloatValue(rhs)) = (lhs, rhs) else {
-            codegen_unreachable!(
-                self,
+            unreachable!(
                 "Expected (FloatValue, FloatValue), got ({}, {})",
                 lhs.get_type(),
                 rhs.get_type()
@@ -690,7 +691,7 @@ pub fn gen_constructor<'ctx, 'a, G: CodeGenerator>(
     def: &TopLevelDef,
     params: Vec<(Option<StrRef>, ValueEnum<'ctx>)>,
 ) -> Result<BasicValueEnum<'ctx>, String> {
-    let TopLevelDef::Class { methods, .. } = def else { codegen_unreachable!(ctx) };
+    let TopLevelDef::Class { methods, .. } = def else { unreachable!() };
 
     // TODO: what about other fields that require alloca?
     let fun_id = methods.iter().find(|method| method.0 == "__init__".into()).map(|method| method.2);
@@ -722,7 +723,7 @@ pub fn gen_func_instance<'ctx>(
         key,
     ) = fun
     else {
-        codegen_unreachable!(ctx)
+        unreachable!()
     };
 
     if let Some(sym) = instance_to_symbol.get(&key) {
@@ -754,7 +755,7 @@ pub fn gen_func_instance<'ctx>(
         .collect();
 
     let mut signature = store.from_signature(&mut ctx.unifier, &ctx.primitives, sign, &mut cache);
-    let ConcreteTypeEnum::TFunc { args, .. } = &mut signature else { codegen_unreachable!(ctx) };
+    let ConcreteTypeEnum::TFunc { args, .. } = &mut signature else { unreachable!() };
 
     if let Some(obj) = &obj {
         let zelf = store.from_unifier_type(&mut ctx.unifier, &ctx.primitives, obj.0, &mut cache);
@@ -1120,7 +1121,7 @@ pub fn gen_comprehension<'ctx, G: CodeGenerator>(
     ctx: &mut CodeGenContext<'ctx, '_>,
     expr: &Expr<Option<Type>>,
 ) -> Result<Option<BasicValueEnum<'ctx>>, String> {
-    let ExprKind::ListComp { elt, generators } = &expr.node else { codegen_unreachable!(ctx) };
+    let ExprKind::ListComp { elt, generators } = &expr.node else { unreachable!() };
 
     let current = ctx.builder.get_insert_block().unwrap().get_parent().unwrap();
 
@@ -1379,13 +1380,13 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
                     if let TypeEnum::TObj { params, .. } = &*ctx.unifier.get_ty_immutable(ty1) {
                         ctx.unifier.get_representative(*params.iter().next().unwrap().1)
                     } else {
-                        codegen_unreachable!(ctx)
+                        unreachable!()
                     };
                 let elem_ty2 =
                     if let TypeEnum::TObj { params, .. } = &*ctx.unifier.get_ty_immutable(ty2) {
                         ctx.unifier.get_representative(*params.iter().next().unwrap().1)
                     } else {
-                        codegen_unreachable!(ctx)
+                        unreachable!()
                     };
                 debug_assert!(ctx.unifier.unioned(elem_ty1, elem_ty2));
 
@@ -1458,7 +1459,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
                         {
                             *params.iter().next().unwrap().1
                         } else {
-                            codegen_unreachable!(ctx)
+                            unreachable!()
                         };
 
                         (elem_ty, left_val, right_val)
@@ -1468,12 +1469,12 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
                         {
                             *params.iter().next().unwrap().1
                         } else {
-                            codegen_unreachable!(ctx)
+                            unreachable!()
                         };
 
                         (elem_ty, right_val, left_val)
                     } else {
-                        codegen_unreachable!(ctx)
+                        unreachable!()
                     };
                 let list_val =
                     ListValue::from_ptr_val(list_val.into_pointer_value(), llvm_usize, None);
@@ -1640,7 +1641,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
     } else {
         let left_ty_enum = ctx.unifier.get_ty_immutable(left_ty.unwrap());
         let TypeEnum::TObj { fields, obj_id, .. } = left_ty_enum.as_ref() else {
-            codegen_unreachable!(ctx, "must be tobj")
+            unreachable!("must be tobj")
         };
         let (op_name, id) = {
             let normal_method_name = Binop::normal(op.base).op_info().method_name;
@@ -1661,19 +1662,19 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
         } else {
             let left_enum_ty = ctx.unifier.get_ty_immutable(left_ty.unwrap());
             let TypeEnum::TObj { fields, .. } = left_enum_ty.as_ref() else {
-                codegen_unreachable!(ctx, "must be tobj")
+                unreachable!("must be tobj")
             };
 
             let fn_ty = fields.get(&op_name).unwrap().0;
             let fn_ty_enum = ctx.unifier.get_ty_immutable(fn_ty);
-            let TypeEnum::TFunc(sig) = fn_ty_enum.as_ref() else { codegen_unreachable!(ctx) };
+            let TypeEnum::TFunc(sig) = fn_ty_enum.as_ref() else { unreachable!() };
 
             sig.clone()
         };
         let fun_id = {
             let defs = ctx.top_level.definitions.read();
             let obj_def = defs.get(id.0).unwrap().read();
-            let TopLevelDef::Class { methods, .. } = &*obj_def else { codegen_unreachable!(ctx) };
+            let TopLevelDef::Class { methods, .. } = &*obj_def else { unreachable!() };
 
             methods.iter().find(|method| method.0 == op_name).unwrap().2
         };
@@ -1804,8 +1805,7 @@ pub fn gen_unaryop_expr_with_values<'ctx, G: CodeGenerator>(
             if op == ast::Unaryop::Invert {
                 ast::Unaryop::Not
             } else {
-                codegen_unreachable!(
-                    ctx,
+                unreachable!(
                     "ufunc {} not supported for ndarray[bool, N]",
                     op.op_info().method_name,
                 )
@@ -1872,8 +1872,8 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
         {
             let llvm_usize = generator.get_size_type(ctx.ctx);
 
-            let (Some(left_ty), lhs) = left else { codegen_unreachable!(ctx) };
-            let (Some(right_ty), rhs) = comparators[0] else { codegen_unreachable!(ctx) };
+            let (Some(left_ty), lhs) = left else { unreachable!() };
+            let (Some(right_ty), rhs) = comparators[0] else { unreachable!() };
             let op = ops[0];
 
             let is_ndarray1 =
@@ -1980,7 +1980,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                 let op = match op {
                     ast::Cmpop::Eq | ast::Cmpop::Is => IntPredicate::EQ,
                     ast::Cmpop::NotEq => IntPredicate::NE,
-                    _ if left_ty == ctx.primitives.bool => codegen_unreachable!(ctx),
+                    _ if left_ty == ctx.primitives.bool => unreachable!(),
                     ast::Cmpop::Lt => {
                         if use_unsigned_ops {
                             IntPredicate::ULT
@@ -2009,7 +2009,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                             IntPredicate::SGE
                         }
                     }
-                    _ => codegen_unreachable!(ctx),
+                    _ => unreachable!(),
                 };
 
                 ctx.builder.build_int_compare(op, lhs, rhs, "cmp").unwrap()
@@ -2026,7 +2026,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                     ast::Cmpop::LtE => inkwell::FloatPredicate::OLE,
                     ast::Cmpop::Gt => inkwell::FloatPredicate::OGT,
                     ast::Cmpop::GtE => inkwell::FloatPredicate::OGE,
-                    _ => codegen_unreachable!(ctx),
+                    _ => unreachable!(),
                 };
                 ctx.builder.build_float_compare(op, lhs, rhs, "cmp").unwrap()
             } else if left_ty == ctx.primitives.str {
@@ -2158,7 +2158,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                         match (op, val) {
                             (Cmpop::Eq, true) | (Cmpop::NotEq, false) => llvm_i1.const_all_ones(),
                             (Cmpop::Eq, false) | (Cmpop::NotEq, true) => llvm_i1.const_zero(),
-                            (_, _) => codegen_unreachable!(ctx),
+                            (_, _) => unreachable!(),
                         }
                     };
 
@@ -2171,14 +2171,14 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                     {
                         *params.iter().next().unwrap().1
                     } else {
-                        codegen_unreachable!(ctx)
+                        unreachable!()
                     };
                     let right_elem_ty = if let TypeEnum::TObj { params, .. } =
                         &*ctx.unifier.get_ty_immutable(right_ty)
                     {
                         *params.iter().next().unwrap().1
                     } else {
-                        codegen_unreachable!(ctx)
+                        unreachable!()
                     };
 
                     if !ctx.unifier.unioned(left_elem_ty, right_elem_ty) {
@@ -2386,10 +2386,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                                 })
                                 .map(BasicValueEnum::into_int_value)?;
 
-                            Ok(ctx.builder.build_not(
-                                generator.bool_to_i1(ctx, cmp),
-                                "",
-                            ).unwrap())
+                            Ok(ctx.builder.build_not(cmp, "").unwrap())
                         },
                         |_, ctx| {
                             let bb = ctx.builder.get_insert_block().unwrap();
@@ -2538,7 +2535,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                         .const_null()
                         .into()
                 }
-                _ => codegen_unreachable!(ctx, "must be option type"),
+                _ => unreachable!("must be option type"),
             }
         }
         ExprKind::Name { id, .. } => match ctx.var_assignment.get(id) {
@@ -2548,7 +2545,29 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
             Some((_, Some(static_value), _)) => ValueEnum::Static(static_value.clone()),
             None => {
                 let resolver = ctx.resolver.clone();
-                resolver.get_symbol_value(*id, ctx).unwrap()
+                if let Some(res) = resolver.get_symbol_value(*id, ctx) {
+                    res
+                } else {
+                    // Allow "raise Exception" short form
+                    let def_id = resolver.get_identifier_def(*id).map_err(|e| {
+                        format!("{} (at {})", e.iter().next().unwrap(), expr.location)
+                    })?;
+                    let def = ctx.top_level.definitions.read();
+                    if let TopLevelDef::Class { constructor, .. } = *def[def_id.0].read() {
+                        let TypeEnum::TFunc(signature) =
+                            ctx.unifier.get_ty(constructor.unwrap()).as_ref().clone()
+                        else {
+                            return Err(format!(
+                                "Failed to resolve symbol {} (at {})",
+                                id, expr.location
+                            ));
+                        };
+                        return Ok(generator
+                            .gen_call(ctx, None, (&signature, def_id), Vec::default())?
+                            .map(Into::into));
+                    }
+                    return Err(format!("Failed to resolve symbol {} (at {})", id, expr.location));
+                }
             }
         },
         ExprKind::List { elts, .. } => {
@@ -2577,7 +2596,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
 
                     *params.iter().next().unwrap().1
                 } else {
-                    codegen_unreachable!(ctx)
+                    unreachable!()
                 };
 
                 if let TypeEnum::TVar { .. } = &*ctx.unifier.get_ty_immutable(ty) {
@@ -2671,9 +2690,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
 
                             return generator.gen_expr(ctx, &modified_expr);
                         }
-                        None => {
-                            codegen_unreachable!(ctx, "Function Type should not have attributes")
-                        }
+                        None => unreachable!("Function Type should not have attributes"),
                     }
                 } else if let TypeEnum::TObj { obj_id, fields, params } = &*ctx.unifier.get_ty(c) {
                     if fields.is_empty() && params.is_empty() {
@@ -2695,7 +2712,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
 
                                 return generator.gen_expr(ctx, &modified_expr);
                             }
-                            None => codegen_unreachable!(ctx),
+                            None => unreachable!(),
                         }
                     }
                 }
@@ -2797,7 +2814,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                 }
                 (Some(a), None) => a.into(),
                 (None, Some(b)) => b.into(),
-                (None, None) => codegen_unreachable!(ctx),
+                (None, None) => unreachable!(),
             }
         }
         ExprKind::BinOp { op, left, right } => {
@@ -2887,9 +2904,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                 ctx.unifier.get_call_signature(*call).unwrap()
             } else {
                 let ty = func.custom.unwrap();
-                let TypeEnum::TFunc(sign) = &*ctx.unifier.get_ty(ty) else {
-                    codegen_unreachable!(ctx)
-                };
+                let TypeEnum::TFunc(sign) = &*ctx.unifier.get_ty(ty) else { unreachable!() };
 
                 sign.clone()
             };
@@ -2908,26 +2923,17 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                     let Some(val) = generator.gen_expr(ctx, value)? else { return Ok(None) };
 
                     // Handle Class Method calls
-                    // The attribute will be `DefinitionId` of the method if the call is to one of the parent methods
-                    let func_id = attr.to_string().parse::<usize>();
-
                     let id = if let TypeEnum::TObj { obj_id, .. } =
                         &*ctx.unifier.get_ty(value.custom.unwrap())
                     {
                         *obj_id
                     } else {
-                        codegen_unreachable!(ctx)
+                        unreachable!()
                     };
-
-                    // Use the `DefinitionID` from attribute if it is available
-                    let fun_id = if let Ok(func_id) = func_id {
-                        DefinitionId(func_id)
-                    } else {
+                    let fun_id = {
                         let defs = ctx.top_level.definitions.read();
                         let obj_def = defs.get(id.0).unwrap().read();
-                        let TopLevelDef::Class { methods, .. } = &*obj_def else {
-                            codegen_unreachable!(ctx)
-                        };
+                        let TopLevelDef::Class { methods, .. } = &*obj_def else { unreachable!() };
 
                         methods.iter().find(|method| method.0 == *attr).unwrap().2
                     };
@@ -2998,9 +3004,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                                         .unwrap(),
                                 ));
                             }
-                            ValueEnum::Dynamic(_) => {
-                                codegen_unreachable!(ctx, "option must be static or ptr")
-                            }
+                            ValueEnum::Dynamic(_) => unreachable!("option must be static or ptr"),
                         }
                     }
 
@@ -3157,10 +3161,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                         if let ExprKind::Constant { value: Constant::Int(v), .. } = &slice.node {
                             (*v).try_into().unwrap()
                         } else {
-                            codegen_unreachable!(
-                                ctx,
-                                "tuple subscript must be const int after type check"
-                            );
+                            unreachable!("tuple subscript must be const int after type check");
                         };
                     match generator.gen_expr(ctx, value)? {
                         Some(ValueEnum::Dynamic(v)) => {
@@ -3183,10 +3184,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                         None => return Ok(None),
                     }
                 }
-                _ => codegen_unreachable!(
-                    ctx,
-                    "should not be other subscriptable types after type check"
-                ),
+                _ => unreachable!("should not be other subscriptable types after type check"),
             }
         }
         ExprKind::ListComp { .. } => {
@@ -3199,3 +3197,42 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
         _ => unimplemented!(),
     }))
 }
+
+/// Generate LLVM IR for an [`ExprKind::Slice`]
+#[allow(clippy::type_complexity)]
+pub fn gen_slice<'ctx, G: CodeGenerator>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    lower: &Option<Box<Expr<Option<Type>>>>,
+    upper: &Option<Box<Expr<Option<Type>>>>,
+    step: &Option<Box<Expr<Option<Type>>>>,
+) -> Result<
+    (
+        Option<Instance<'ctx, Int<Int32>>>,
+        Option<Instance<'ctx, Int<Int32>>>,
+        Option<Instance<'ctx, Int<Int32>>>,
+    ),
+    String,
+> {
+    let mut help = |value_expr: &Option<Box<Expr<Option<Type>>>>| -> Result<_, String> {
+        Ok(match value_expr {
+            None => None,
+            Some(value_expr) => {
+                let value_expr = generator
+                    .gen_expr(ctx, value_expr)?
+                    .unwrap()
+                    .to_basic_value_enum(ctx, generator, ctx.primitives.int32)?;
+
+                let value_expr = Int(Int32).check_value(generator, ctx.ctx, value_expr).unwrap();
+
+                Some(value_expr)
+            }
+        })
+    };
+
+    let lower = help(lower)?;
+    let upper = help(upper)?;
+    let step = help(step)?;
+
+    Ok((lower, upper, step))
+}

nac3core/src/codegen/irrt/mod.rs

@@ -3,19 +3,19 @@ use crate::{symbol_resolver::SymbolResolver, typecheck::typedef::Type};
 use super::{
     classes::{
         ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue,
-        TypedArrayLikeAccessor, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
+        TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
     },
     llvm_intrinsics,
-    macros::codegen_unreachable,
     model::*,
     object::{
         list::List,
         ndarray::{broadcast::ShapeEntry, indexing::NDIndex, nditer::NDIter, NDArray},
     },
-    stmt::gen_for_callback_incrementing,
     CodeGenContext, CodeGenerator,
 };
-use function::FnCall;
+use crate::codegen::classes::TypedArrayLikeAccessor;
+use crate::codegen::stmt::gen_for_callback_incrementing;
+use function::CallFunction;
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
     context::Context,
@@ -29,7 +29,7 @@ use itertools::Either;
 use nac3parser::ast::Expr;
 
 #[must_use]
-pub fn load_irrt<'ctx>(ctx: &'ctx Context, symbol_resolver: &dyn SymbolResolver) -> Module<'ctx> {
+pub fn load_irrt(ctx: &Context) -> Module {
     let bitcode_buf = MemoryBuffer::create_from_memory_range(
         include_bytes!(concat!(env!("OUT_DIR"), "/irrt.bc")),
         "irrt_bitcode_buffer",
@@ -45,25 +45,6 @@ pub fn load_irrt<'ctx>(ctx: &'ctx Context, symbol_resolver: &dyn SymbolResolver)
         let function = irrt_mod.get_function(symbol).unwrap();
         function.add_attribute(AttributeLoc::Function, ctx.create_enum_attribute(inline_attr, 0));
     }
-
-    // Initialize all global `EXN_*` exception IDs in IRRT with the [`SymbolResolver`].
-    let exn_id_type = ctx.i32_type();
-    let errors = &[
-        ("EXN_INDEX_ERROR", "0:IndexError"),
-        ("EXN_VALUE_ERROR", "0:ValueError"),
-        ("EXN_ASSERTION_ERROR", "0:AssertionError"),
-        ("EXN_TYPE_ERROR", "0:TypeError"),
-    ];
-    for (irrt_name, symbol_name) in errors {
-        let exn_id = symbol_resolver.get_string_id(symbol_name);
-        let exn_id = exn_id_type.const_int(exn_id as u64, false).as_basic_value_enum();
-
-        let global = irrt_mod.get_global(irrt_name).unwrap_or_else(|| {
-            panic!("Exception symbol name '{irrt_name}' should exist in the IRRT LLVM module")
-        });
-        global.set_initializer(&exn_id);
-    }
-
     irrt_mod
 }
 
@@ -81,7 +62,7 @@ pub fn integer_power<'ctx, G: CodeGenerator + ?Sized>(
         (64, 64, true) => "__nac3_int_exp_int64_t",
         (32, 32, false) => "__nac3_int_exp_uint32_t",
         (64, 64, false) => "__nac3_int_exp_uint64_t",
-        _ => codegen_unreachable!(ctx),
+        _ => unreachable!(),
     };
     let base_type = base.get_type();
     let pow_fun = ctx.module.get_function(symbol).unwrap_or_else(|| {
@@ -467,7 +448,7 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
                     BasicTypeEnum::IntType(t) => t.size_of(),
                     BasicTypeEnum::PointerType(t) => t.size_of(),
                     BasicTypeEnum::StructType(t) => t.size_of().unwrap(),
-                    _ => codegen_unreachable!(ctx),
+                    _ => unreachable!(),
                 };
                 ctx.builder.build_int_truncate_or_bit_cast(s, int32, "size").unwrap()
             }
@@ -612,7 +593,7 @@ where
     let ndarray_calc_size_fn_name = match llvm_usize.get_bit_width() {
         32 => "__nac3_ndarray_calc_size",
         64 => "__nac3_ndarray_calc_size64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
+        bw => unreachable!("Unsupported size type bit width: {}", bw),
     };
     let ndarray_calc_size_fn_t = llvm_usize.fn_type(
         &[llvm_pusize.into(), llvm_usize.into(), llvm_usize.into(), llvm_usize.into()],
@@ -663,7 +644,7 @@ pub fn call_ndarray_calc_nd_indices<'ctx, G: CodeGenerator + ?Sized>(
     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 => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
+        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(|| {
@@ -732,7 +713,7 @@ where
     let ndarray_flatten_index_fn_name = match llvm_usize.get_bit_width() {
         32 => "__nac3_ndarray_flatten_index",
         64 => "__nac3_ndarray_flatten_index64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
+        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(|| {
@@ -800,7 +781,7 @@ pub fn call_ndarray_calc_broadcast<'ctx, G: CodeGenerator + ?Sized>(
     let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
         32 => "__nac3_ndarray_calc_broadcast",
         64 => "__nac3_ndarray_calc_broadcast64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
+        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(|| {
@@ -920,7 +901,7 @@ pub fn call_ndarray_calc_broadcast_index<
     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 => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
+        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(|| {
@@ -956,6 +937,32 @@ pub fn call_ndarray_calc_broadcast_index<
     )
 }
 
+/// Initialize all global `EXN_*` exception IDs in IRRT with the [`SymbolResolver`].
+pub fn setup_irrt_exceptions<'ctx>(
+    ctx: &'ctx Context,
+    module: &Module<'ctx>,
+    symbol_resolver: &dyn SymbolResolver,
+) {
+    let exn_id_type = ctx.i32_type();
+
+    let errors = &[
+        ("EXN_INDEX_ERROR", "0:IndexError"),
+        ("EXN_VALUE_ERROR", "0:ValueError"),
+        ("EXN_ASSERTION_ERROR", "0:AssertionError"),
+        ("EXN_TYPE_ERROR", "0:TypeError"),
+    ];
+
+    for (irrt_name, symbol_name) in errors {
+        let exn_id = symbol_resolver.get_string_id(symbol_name);
+        let exn_id = exn_id_type.const_int(exn_id as u64, false).as_basic_value_enum();
+
+        let global = module.get_global(irrt_name).unwrap_or_else(|| {
+            panic!("Exception symbol name '{irrt_name}' should exist in the IRRT LLVM module")
+        });
+        global.set_initializer(&exn_id);
+    }
+}
+
 // When [`TypeContext::size_type`] is 32-bits, the function name is "{fn_name}".
 // When [`TypeContext::size_type`] is 64-bits, the function name is "{fn_name}64".
 #[must_use]
@@ -986,7 +993,7 @@ pub fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator +
         ctx,
         "__nac3_ndarray_util_assert_shape_no_negative",
     );
-    FnCall::builder(generator, ctx, &name).arg(ndims).arg(shape).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(ndims).arg(shape).returning_void();
 }
 
 pub fn call_nac3_ndarray_util_assert_output_shape_same<'ctx, G: CodeGenerator + ?Sized>(
@@ -1002,7 +1009,7 @@ pub fn call_nac3_ndarray_util_assert_output_shape_same<'ctx, G: CodeGenerator +
         ctx,
         "__nac3_ndarray_util_assert_output_shape_same",
     );
-    FnCall::builder(generator, ctx, &name)
+    CallFunction::begin(generator, ctx, &name)
         .arg(ndarray_ndims)
         .arg(ndarray_shape)
         .arg(output_ndims)
@@ -1016,7 +1023,7 @@ pub fn call_nac3_ndarray_size<'ctx, G: CodeGenerator + ?Sized>(
     ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
 ) -> Instance<'ctx, Int<SizeT>> {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_size");
-    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("size")
+    CallFunction::begin(generator, ctx, &name).arg(ndarray).returning_auto("size")
 }
 
 pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
@@ -1025,7 +1032,7 @@ pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
     ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
 ) -> Instance<'ctx, Int<SizeT>> {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_nbytes");
-    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("nbytes")
+    CallFunction::begin(generator, ctx, &name).arg(ndarray).returning_auto("nbytes")
 }
 
 pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
@@ -1034,7 +1041,7 @@ pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
     ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
 ) -> Instance<'ctx, Int<SizeT>> {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_len");
-    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("len")
+    CallFunction::begin(generator, ctx, &name).arg(ndarray).returning_auto("len")
 }
 
 pub fn call_nac3_ndarray_is_c_contiguous<'ctx, G: CodeGenerator + ?Sized>(
@@ -1043,7 +1050,7 @@ pub fn call_nac3_ndarray_is_c_contiguous<'ctx, G: CodeGenerator + ?Sized>(
     ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
 ) -> Instance<'ctx, Int<Bool>> {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_is_c_contiguous");
-    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_auto("is_c_contiguous")
+    CallFunction::begin(generator, ctx, &name).arg(ndarray).returning_auto("is_c_contiguous")
 }
 
 pub fn call_nac3_ndarray_get_nth_pelement<'ctx, G: CodeGenerator + ?Sized>(
@@ -1053,7 +1060,7 @@ pub fn call_nac3_ndarray_get_nth_pelement<'ctx, G: CodeGenerator + ?Sized>(
     index: Instance<'ctx, Int<SizeT>>,
 ) -> Instance<'ctx, Ptr<Int<Byte>>> {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_get_nth_pelement");
-    FnCall::builder(generator, ctx, &name).arg(ndarray).arg(index).returning_auto("pelement")
+    CallFunction::begin(generator, ctx, &name).arg(ndarray).arg(index).returning_auto("pelement")
 }
 
 pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized>(
@@ -1064,7 +1071,7 @@ pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized
 ) -> Instance<'ctx, Ptr<Int<Byte>>> {
     let name =
         get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_get_pelement_by_indices");
-    FnCall::builder(generator, ctx, &name).arg(ndarray).arg(indices).returning_auto("pelement")
+    CallFunction::begin(generator, ctx, &name).arg(ndarray).arg(indices).returning_auto("pelement")
 }
 
 pub fn call_nac3_ndarray_set_strides_by_shape<'ctx, G: CodeGenerator + ?Sized>(
@@ -1074,7 +1081,7 @@ pub fn call_nac3_ndarray_set_strides_by_shape<'ctx, G: CodeGenerator + ?Sized>(
 ) {
     let name =
         get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_set_strides_by_shape");
-    FnCall::builder(generator, ctx, &name).arg(ndarray).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(ndarray).returning_void();
 }
 
 pub fn call_nac3_ndarray_copy_data<'ctx, G: CodeGenerator + ?Sized>(
@@ -1084,7 +1091,7 @@ pub fn call_nac3_ndarray_copy_data<'ctx, G: CodeGenerator + ?Sized>(
     dst_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
 ) {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_copy_data");
-    FnCall::builder(generator, ctx, &name).arg(src_ndarray).arg(dst_ndarray).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(src_ndarray).arg(dst_ndarray).returning_void();
 }
 
 pub fn call_nac3_nditer_initialize<'ctx, G: CodeGenerator + ?Sized>(
@@ -1095,16 +1102,16 @@ pub fn call_nac3_nditer_initialize<'ctx, G: CodeGenerator + ?Sized>(
     indices: Instance<'ctx, Ptr<Int<SizeT>>>,
 ) {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_initialize");
-    FnCall::builder(generator, ctx, &name).arg(iter).arg(ndarray).arg(indices).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(iter).arg(ndarray).arg(indices).returning_void();
 }
 
-pub fn call_nac3_nditer_has_element<'ctx, G: CodeGenerator + ?Sized>(
+pub fn call_nac3_nditer_has_next<'ctx, G: CodeGenerator + ?Sized>(
     generator: &mut G,
     ctx: &mut CodeGenContext<'ctx, '_>,
     iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
 ) -> Instance<'ctx, Int<Bool>> {
-    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_has_element");
-    FnCall::builder(generator, ctx, &name).arg(iter).returning_auto("has_element")
+    let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_has_next");
+    CallFunction::begin(generator, ctx, &name).arg(iter).returning_auto("has_next")
 }
 
 pub fn call_nac3_nditer_next<'ctx, G: CodeGenerator + ?Sized>(
@@ -1113,7 +1120,7 @@ pub fn call_nac3_nditer_next<'ctx, G: CodeGenerator + ?Sized>(
     iter: Instance<'ctx, Ptr<Struct<NDIter>>>,
 ) {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_nditer_next");
-    FnCall::builder(generator, ctx, &name).arg(iter).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(iter).returning_void();
 }
 
 pub fn call_nac3_ndarray_index<'ctx, G: CodeGenerator + ?Sized>(
@@ -1125,7 +1132,7 @@ pub fn call_nac3_ndarray_index<'ctx, G: CodeGenerator + ?Sized>(
     dst_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
 ) {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_index");
-    FnCall::builder(generator, ctx, &name)
+    CallFunction::begin(generator, ctx, &name)
         .arg(num_indices)
         .arg(indices)
         .arg(src_ndarray)
@@ -1145,7 +1152,7 @@ pub fn call_nac3_ndarray_array_set_and_validate_list_shape<'ctx, G: CodeGenerato
         ctx,
         "__nac3_ndarray_array_set_and_validate_list_shape",
     );
-    FnCall::builder(generator, ctx, &name).arg(list).arg(ndims).arg(shape).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(list).arg(ndims).arg(shape).returning_void();
 }
 
 pub fn call_nac3_ndarray_array_write_list_to_array<'ctx, G: CodeGenerator + ?Sized>(
@@ -1159,7 +1166,7 @@ pub fn call_nac3_ndarray_array_write_list_to_array<'ctx, G: CodeGenerator + ?Siz
         ctx,
         "__nac3_ndarray_array_write_list_to_array",
     );
-    FnCall::builder(generator, ctx, &name).arg(list).arg(ndarray).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(list).arg(ndarray).returning_void();
 }
 
 pub fn call_nac3_ndarray_reshape_resolve_and_check_new_shape<'ctx, G: CodeGenerator + ?Sized>(
@@ -1174,7 +1181,11 @@ pub fn call_nac3_ndarray_reshape_resolve_and_check_new_shape<'ctx, G: CodeGenera
         ctx,
         "__nac3_ndarray_reshape_resolve_and_check_new_shape",
     );
-    FnCall::builder(generator, ctx, &name).arg(size).arg(new_ndims).arg(new_shape).returning_void();
+    CallFunction::begin(generator, ctx, &name)
+        .arg(size)
+        .arg(new_ndims)
+        .arg(new_shape)
+        .returning_void();
 }
 
 pub fn call_nac3_ndarray_broadcast_to<'ctx, G: CodeGenerator + ?Sized>(
@@ -1184,7 +1195,7 @@ pub fn call_nac3_ndarray_broadcast_to<'ctx, G: CodeGenerator + ?Sized>(
     dst_ndarray: Instance<'ctx, Ptr<Struct<NDArray>>>,
 ) {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_broadcast_to");
-    FnCall::builder(generator, ctx, &name).arg(src_ndarray).arg(dst_ndarray).returning_void();
+    CallFunction::begin(generator, ctx, &name).arg(src_ndarray).arg(dst_ndarray).returning_void();
 }
 
 pub fn call_nac3_ndarray_broadcast_shapes<'ctx, G: CodeGenerator + ?Sized>(
@@ -1196,7 +1207,7 @@ pub fn call_nac3_ndarray_broadcast_shapes<'ctx, G: CodeGenerator + ?Sized>(
     dst_shape: Instance<'ctx, Ptr<Int<SizeT>>>,
 ) {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_broadcast_shapes");
-    FnCall::builder(generator, ctx, &name)
+    CallFunction::begin(generator, ctx, &name)
         .arg(num_shape_entries)
         .arg(shape_entries)
         .arg(dst_ndims)
@@ -1213,7 +1224,7 @@ pub fn call_nac3_ndarray_transpose<'ctx, G: CodeGenerator + ?Sized>(
     axes: Instance<'ctx, Ptr<Int<SizeT>>>,
 ) {
     let name = get_sizet_dependent_function_name(generator, ctx, "__nac3_ndarray_transpose");
-    FnCall::builder(generator, ctx, &name)
+    CallFunction::begin(generator, ctx, &name)
         .arg(src_ndarray)
         .arg(dst_ndarray)
         .arg(num_axes)

nac3core/src/codegen/mod.rs

@@ -54,22 +54,6 @@ mod test;
 use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
 pub use generator::{CodeGenerator, DefaultCodeGenerator};
 
-mod macros {
-    /// Codegen-variant of [`std::unreachable`] which accepts an instance of [`CodeGenContext`] as
-    /// its first argument to provide Python source information to indicate the codegen location
-    /// causing the assertion.
-    macro_rules! codegen_unreachable {
-        ($ctx:expr $(,)?) => {
-            std::unreachable!("unreachable code while processing {}", &$ctx.current_loc)
-        };
-        ($ctx:expr, $($arg:tt)*) => {
-            std::unreachable!("unreachable code while processing {}: {}", &$ctx.current_loc, std::format!("{}", std::format_args!($($arg)+)))
-        };
-    }
-
-    pub(crate) use codegen_unreachable;
-}
-
 #[derive(Default)]
 pub struct StaticValueStore {
     pub lookup: HashMap<Vec<(usize, u64)>, usize>,
@@ -509,7 +493,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                         }
 
                         TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
-                            Ptr(Struct(NDArray)).llvm_type(generator, ctx).as_basic_type_enum()
+                            Ptr(Struct(NDArray)).get_type(generator, ctx).as_basic_type_enum()
                         }
 
                         _ => unreachable!(

nac3core/src/codegen/model/any.rs

@@ -18,7 +18,7 @@ impl<'ctx> Model<'ctx> for Any<'ctx> {
     type Value = BasicValueEnum<'ctx>;
     type Type = BasicTypeEnum<'ctx>;
 
-    fn llvm_type<G: CodeGenerator + ?Sized>(
+    fn get_type<G: CodeGenerator + ?Sized>(
         &self,
         _generator: &G,
         _ctx: &'ctx Context,

nac3core/src/codegen/model/array.rs

@@ -11,8 +11,8 @@ use crate::codegen::{CodeGenContext, CodeGenerator};
 use super::*;
 
 /// Trait for Rust structs identifying length values for [`Array`].
-pub trait ArrayLen: fmt::Debug + Clone + Copy {
-    fn length(&self) -> u32;
+pub trait LenKind: fmt::Debug + Clone + Copy {
+    fn get_length(&self) -> u32;
 }
 
 /// A statically known length.
@@ -23,14 +23,14 @@ pub struct Len<const N: u32>;
 #[derive(Debug, Clone, Copy)]
 pub struct AnyLen(pub u32);
 
-impl<const N: u32> ArrayLen for Len<N> {
-    fn length(&self) -> u32 {
+impl<const N: u32> LenKind for Len<N> {
+    fn get_length(&self) -> u32 {
         N
     }
 }
 
-impl ArrayLen for AnyLen {
-    fn length(&self) -> u32 {
+impl LenKind for AnyLen {
+    fn get_length(&self) -> u32 {
         self.0
     }
 }
@@ -46,16 +46,12 @@ pub struct Array<Len, Item> {
     pub item: Item,
 }
 
-impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Model<'ctx> for Array<Len, Item> {
+impl<'ctx, Len: LenKind, Item: Model<'ctx>> Model<'ctx> for Array<Len, Item> {
     type Value = ArrayValue<'ctx>;
     type Type = ArrayType<'ctx>;
 
-    fn llvm_type<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &'ctx Context,
-    ) -> Self::Type {
-        self.item.llvm_type(generator, ctx).array_type(self.len.length())
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type {
+        self.item.get_type(generator, ctx).array_type(self.len.get_length())
     }
 
     fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
@@ -69,11 +65,11 @@ impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Model<'ctx> for Array<Len, Item> {
             return Err(ModelError(format!("Expecting ArrayType, but got {ty:?}")));
         };
 
-        if ty.len() != self.len.length() {
+        if ty.len() != self.len.get_length() {
             return Err(ModelError(format!(
                 "Expecting ArrayType with size {}, but got an ArrayType with size {}",
                 ty.len(),
-                self.len.length()
+                self.len.get_length()
             )));
         }
 
@@ -85,7 +81,7 @@ impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Model<'ctx> for Array<Len, Item> {
     }
 }
 
-impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Instance<'ctx, Ptr<Array<Len, Item>>> {
+impl<'ctx, Len: LenKind, Item: Model<'ctx>> Instance<'ctx, Ptr<Array<Len, Item>>> {
     /// Get the pointer to the `i`-th (0-based) array element.
     pub fn gep(
         &self,
@@ -95,15 +91,15 @@ impl<'ctx, Len: ArrayLen, Item: Model<'ctx>> Instance<'ctx, Ptr<Array<Len, Item>
         let zero = ctx.ctx.i32_type().const_zero();
         let ptr = unsafe { ctx.builder.build_in_bounds_gep(self.value, &[zero, i], "").unwrap() };
 
-        unsafe { Ptr(self.model.0.item).believe_value(ptr) }
+        Ptr(self.model.0.item).believe_value(ptr)
     }
 
     /// Like `gep` but `i` is a constant.
     pub fn gep_const(&self, ctx: &CodeGenContext<'ctx, '_>, i: u64) -> Instance<'ctx, Ptr<Item>> {
         assert!(
-            i < u64::from(self.model.0.len.length()),
+            i < u64::from(self.model.0.len.get_length()),
             "Index {i} is out of bounds. Array length = {}",
-            self.model.0.len.length()
+            self.model.0.len.get_length()
         );
 
         let i = ctx.ctx.i32_type().const_int(i, false);

nac3core/src/codegen/model/core.rs

@@ -11,7 +11,7 @@ use crate::codegen::{CodeGenContext, CodeGenerator};
 pub struct ModelError(pub String);
 
 impl ModelError {
-    /// Append a context message to the error.
+    // Append a context message to the error.
     pub(super) fn under_context(mut self, context: &str) -> Self {
         self.0.push_str(" ... in ");
         self.0.push_str(context);
@@ -47,7 +47,7 @@ impl ModelError {
 /// }
 /// ```
 ///
-/// ### Notes on converting between Inkwell and model/ge.
+/// ### Notes on converting between Inkwell and model.
 ///
 /// Suppose you have an [`IntValue`], and you want to pass it into a function that takes a [`Instance<'ctx, Int<Int32>>`]. You can do use
 /// [`Model::check_value`] or [`Model::believe_value`].
@@ -68,16 +68,15 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
 
     /// Return the [`BasicType`] of this model.
     #[must_use]
-    fn llvm_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context)
-        -> Self::Type;
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type;
 
     /// Get the number of bytes of the [`BasicType`] of this model.
-    fn size_of<G: CodeGenerator + ?Sized>(
+    fn sizeof<G: CodeGenerator + ?Sized>(
         &self,
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> IntValue<'ctx> {
-        self.llvm_type(generator, ctx).size_of().unwrap()
+        self.get_type(generator, ctx).size_of().unwrap()
     }
 
     /// Check if a [`BasicType`] matches the [`BasicType`] of this model.
@@ -90,11 +89,9 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
 
     /// Create an instance from a value.
     ///
-    /// # Safety
-    ///
     /// Caller must make sure the type of `value` and the type of this `model` are equivalent.
     #[must_use]
-    unsafe fn believe_value(&self, value: Self::Value) -> Instance<'ctx, Self> {
+    fn believe_value(&self, value: Self::Value) -> Instance<'ctx, Self> {
         Instance { model: *self, value }
     }
 
@@ -113,7 +110,7 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
         let Ok(value) = Self::Value::try_from(value) else {
             unreachable!("check_type() has bad implementation")
         };
-        unsafe { Ok(self.believe_value(value)) }
+        Ok(self.believe_value(value))
     }
 
     // Allocate a value on the stack and return its pointer.
@@ -122,8 +119,8 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
         generator: &mut G,
         ctx: &CodeGenContext<'ctx, '_>,
     ) -> Instance<'ctx, Ptr<Self>> {
-        let p = ctx.builder.build_alloca(self.llvm_type(generator, ctx.ctx), "").unwrap();
-        unsafe { Ptr(*self).believe_value(p) }
+        let p = ctx.builder.build_alloca(self.get_type(generator, ctx.ctx), "").unwrap();
+        Ptr(*self).believe_value(p)
     }
 
     // Allocate an array on the stack and return its pointer.
@@ -133,9 +130,8 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
         ctx: &CodeGenContext<'ctx, '_>,
         len: IntValue<'ctx>,
     ) -> Instance<'ctx, Ptr<Self>> {
-        let p =
-            ctx.builder.build_array_alloca(self.llvm_type(generator, ctx.ctx), len, "").unwrap();
-        unsafe { Ptr(*self).believe_value(p) }
+        let p = ctx.builder.build_array_alloca(self.get_type(generator, ctx.ctx), len, "").unwrap();
+        Ptr(*self).believe_value(p)
     }
 
     fn var_alloca<G: CodeGenerator + ?Sized>(
@@ -144,9 +140,9 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
         ctx: &mut CodeGenContext<'ctx, '_>,
         name: Option<&str>,
     ) -> Result<Instance<'ctx, Ptr<Self>>, String> {
-        let ty = self.llvm_type(generator, ctx.ctx).as_basic_type_enum();
+        let ty = self.get_type(generator, ctx.ctx).as_basic_type_enum();
         let p = generator.gen_var_alloc(ctx, ty, name)?;
-        unsafe { Ok(Ptr(*self).believe_value(p)) }
+        Ok(Ptr(*self).believe_value(p))
     }
 
     fn array_var_alloca<G: CodeGenerator + ?Sized>(
@@ -157,9 +153,9 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
         name: Option<&'ctx str>,
     ) -> Result<Instance<'ctx, Ptr<Self>>, String> {
         // TODO: Remove ArraySliceValue
-        let ty = self.llvm_type(generator, ctx.ctx).as_basic_type_enum();
+        let ty = self.get_type(generator, ctx.ctx).as_basic_type_enum();
         let p = generator.gen_array_var_alloc(ctx, ty, len, name)?;
-        unsafe { Ok(Ptr(*self).believe_value(PointerValue::from(p))) }
+        Ok(Ptr(*self).believe_value(PointerValue::from(p)))
     }
 
     /// Allocate a constant array.
@@ -180,7 +176,7 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
             };
         }
 
-        let value = match self.llvm_type(generator, ctx).as_basic_type_enum() {
+        let value = match self.get_type(generator, ctx).as_basic_type_enum() {
             BasicTypeEnum::ArrayType(t) => make!(t, BasicValueEnum::into_array_value),
             BasicTypeEnum::IntType(t) => make!(t, BasicValueEnum::into_int_value),
             BasicTypeEnum::FloatType(t) => make!(t, BasicValueEnum::into_float_value),
@@ -199,7 +195,6 @@ pub trait Model<'ctx>: fmt::Debug + Clone + Copy {
 pub struct Instance<'ctx, M: Model<'ctx>> {
     /// The model of this instance.
     pub model: M,
-
     /// The value of this instance.
     ///
     /// It is guaranteed the [`BasicType`] of `value` is consistent with that of `model`.

nac3core/src/codegen/model/float.rs

@@ -63,11 +63,7 @@ impl<'ctx, N: FloatKind<'ctx>> Model<'ctx> for Float<N> {
     type Value = FloatValue<'ctx>;
     type Type = FloatType<'ctx>;
 
-    fn llvm_type<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &'ctx Context,
-    ) -> Self::Type {
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type {
         self.0.get_float_type(generator, ctx)
     }
 

nac3core/src/codegen/model/function.rs

@@ -35,7 +35,7 @@ struct Arg<'ctx> {
 /// If `my_function_name` has not been declared in `ctx.module`, once `.returning()` is called, a function
 /// declaration of `my_function_name` is added to `ctx.module`, where the [`FunctionType`] is deduced from
 /// the argument types and returning type.
-pub struct FnCall<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> {
+pub struct CallFunction<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> {
     generator: &'d mut G,
     ctx: &'b CodeGenContext<'ctx, 'a>,
     /// Function name
@@ -46,9 +46,9 @@ pub struct FnCall<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> {
     attrs: Vec<&'static str>,
 }
 
-impl<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> FnCall<'ctx, 'a, 'b, 'c, 'd, G> {
-    pub fn builder(generator: &'d mut G, ctx: &'b CodeGenContext<'ctx, 'a>, name: &'c str) -> Self {
-        FnCall { generator, ctx, name, args: Vec::new(), attrs: Vec::new() }
+impl<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> CallFunction<'ctx, 'a, 'b, 'c, 'd, G> {
+    pub fn begin(generator: &'d mut G, ctx: &'b CodeGenContext<'ctx, 'a>, name: &'c str) -> Self {
+        CallFunction { generator, ctx, name, args: Vec::new(), attrs: Vec::new() }
     }
 
     /// Push a list of LLVM function attributes to the function declaration.
@@ -63,7 +63,7 @@ impl<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> FnCall<'ctx, 'a, 'b, 'c, '
     #[must_use]
     pub fn arg<M: Model<'ctx>>(mut self, arg: Instance<'ctx, M>) -> Self {
         let arg = Arg {
-            ty: arg.model.llvm_type(self.generator, self.ctx.ctx).as_basic_type_enum().into(),
+            ty: arg.model.get_type(self.generator, self.ctx.ctx).as_basic_type_enum().into(),
             val: arg.value.as_basic_value_enum().into(),
         };
         self.args.push(arg);
@@ -73,7 +73,7 @@ impl<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> FnCall<'ctx, 'a, 'b, 'c, '
     /// Call the function and expect the function to return a value of type of `return_model`.
     #[must_use]
     pub fn returning<M: Model<'ctx>>(self, name: &str, return_model: M) -> Instance<'ctx, M> {
-        let ret_ty = return_model.llvm_type(self.generator, self.ctx.ctx);
+        let ret_ty = return_model.get_type(self.generator, self.ctx.ctx);
 
         let ret = self.call(|tys| ret_ty.fn_type(tys, false), name);
         let ret = BasicValueEnum::try_from(ret.as_any_value_enum()).unwrap(); // Must work

nac3core/src/codegen/model/int.rs

@@ -100,11 +100,7 @@ impl<'ctx, N: IntKind<'ctx>> Model<'ctx> for Int<N> {
     type Value = IntValue<'ctx>;
     type Type = IntType<'ctx>;
 
-    fn llvm_type<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &'ctx Context,
-    ) -> Self::Type {
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type {
         self.0.get_int_type(generator, ctx)
     }
 
@@ -138,10 +134,9 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         generator: &mut G,
         ctx: &'ctx Context,
         value: u64,
-        sign_extend: bool,
     ) -> Instance<'ctx, Self> {
-        let value = self.llvm_type(generator, ctx).const_int(value, sign_extend);
-        unsafe { self.believe_value(value) }
+        let value = self.get_type(generator, ctx).const_int(value, false);
+        self.believe_value(value)
     }
 
     pub fn const_0<G: CodeGenerator + ?Sized>(
@@ -149,8 +144,8 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> Instance<'ctx, Self> {
-        let value = self.llvm_type(generator, ctx).const_zero();
-        unsafe { self.believe_value(value) }
+        let value = self.get_type(generator, ctx).const_zero();
+        self.believe_value(value)
     }
 
     pub fn const_1<G: CodeGenerator + ?Sized>(
@@ -158,7 +153,7 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> Instance<'ctx, Self> {
-        self.const_int(generator, ctx, 1, false)
+        self.const_int(generator, ctx, 1)
     }
 
     pub fn const_all_ones<G: CodeGenerator + ?Sized>(
@@ -166,8 +161,8 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> Instance<'ctx, Self> {
-        let value = self.llvm_type(generator, ctx).const_all_ones();
-        unsafe { self.believe_value(value) }
+        let value = self.get_type(generator, ctx).const_all_ones();
+        self.believe_value(value)
     }
 
     pub fn s_extend_or_bit_cast<G: CodeGenerator + ?Sized>(
@@ -182,9 +177,9 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         );
         let value = ctx
             .builder
-            .build_int_s_extend_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
+            .build_int_s_extend_or_bit_cast(value, self.get_type(generator, ctx.ctx), "")
             .unwrap();
-        unsafe { self.believe_value(value) }
+        self.believe_value(value)
     }
 
     pub fn s_extend<G: CodeGenerator + ?Sized>(
@@ -198,8 +193,8 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
                 < self.0.get_int_type(generator, ctx.ctx).get_bit_width()
         );
         let value =
-            ctx.builder.build_int_s_extend(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
-        unsafe { self.believe_value(value) }
+            ctx.builder.build_int_s_extend(value, self.get_type(generator, ctx.ctx), "").unwrap();
+        self.believe_value(value)
     }
 
     pub fn z_extend_or_bit_cast<G: CodeGenerator + ?Sized>(
@@ -214,9 +209,9 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         );
         let value = ctx
             .builder
-            .build_int_z_extend_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
+            .build_int_z_extend_or_bit_cast(value, self.get_type(generator, ctx.ctx), "")
             .unwrap();
-        unsafe { self.believe_value(value) }
+        self.believe_value(value)
     }
 
     pub fn z_extend<G: CodeGenerator + ?Sized>(
@@ -230,8 +225,8 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
                 < self.0.get_int_type(generator, ctx.ctx).get_bit_width()
         );
         let value =
-            ctx.builder.build_int_z_extend(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
-        unsafe { self.believe_value(value) }
+            ctx.builder.build_int_z_extend(value, self.get_type(generator, ctx.ctx), "").unwrap();
+        self.believe_value(value)
     }
 
     pub fn truncate_or_bit_cast<G: CodeGenerator + ?Sized>(
@@ -246,9 +241,9 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         );
         let value = ctx
             .builder
-            .build_int_truncate_or_bit_cast(value, self.llvm_type(generator, ctx.ctx), "")
+            .build_int_truncate_or_bit_cast(value, self.get_type(generator, ctx.ctx), "")
             .unwrap();
-        unsafe { self.believe_value(value) }
+        self.believe_value(value)
     }
 
     pub fn truncate<G: CodeGenerator + ?Sized>(
@@ -262,8 +257,8 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
                 > self.0.get_int_type(generator, ctx.ctx).get_bit_width()
         );
         let value =
-            ctx.builder.build_int_truncate(value, self.llvm_type(generator, ctx.ctx), "").unwrap();
-        unsafe { self.believe_value(value) }
+            ctx.builder.build_int_truncate(value, self.get_type(generator, ctx.ctx), "").unwrap();
+        self.believe_value(value)
     }
 
     /// `sext` or `trunc` an int to this model's int type. Does nothing if equal bit-widths.
@@ -277,7 +272,7 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         let our_width = self.0.get_int_type(generator, ctx.ctx).get_bit_width();
         match their_width.cmp(&our_width) {
             Ordering::Less => self.s_extend(generator, ctx, value),
-            Ordering::Equal => unsafe { self.believe_value(value) },
+            Ordering::Equal => self.believe_value(value),
             Ordering::Greater => self.truncate(generator, ctx, value),
         }
     }
@@ -293,7 +288,7 @@ impl<'ctx, N: IntKind<'ctx>> Int<N> {
         let our_width = self.0.get_int_type(generator, ctx.ctx).get_bit_width();
         match their_width.cmp(&our_width) {
             Ordering::Less => self.z_extend(generator, ctx, value),
-            Ordering::Equal => unsafe { self.believe_value(value) },
+            Ordering::Equal => self.believe_value(value),
             Ordering::Greater => self.truncate(generator, ctx, value),
         }
     }
@@ -306,7 +301,7 @@ impl Int<Bool> {
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> Instance<'ctx, Self> {
-        self.const_int(generator, ctx, 0, false)
+        self.const_int(generator, ctx, 0)
     }
 
     #[must_use]
@@ -315,7 +310,7 @@ impl Int<Bool> {
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> Instance<'ctx, Self> {
-        self.const_int(generator, ctx, 1, false)
+        self.const_int(generator, ctx, 1)
     }
 }
 
@@ -395,19 +390,19 @@ impl<'ctx, N: IntKind<'ctx>> Instance<'ctx, Int<N>> {
     #[must_use]
     pub fn add(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
         let value = ctx.builder.build_int_add(self.value, other.value, "").unwrap();
-        unsafe { self.model.believe_value(value) }
+        self.model.believe_value(value)
     }
 
     #[must_use]
     pub fn sub(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
         let value = ctx.builder.build_int_sub(self.value, other.value, "").unwrap();
-        unsafe { self.model.believe_value(value) }
+        self.model.believe_value(value)
     }
 
     #[must_use]
     pub fn mul(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {
         let value = ctx.builder.build_int_mul(self.value, other.value, "").unwrap();
-        unsafe { self.model.believe_value(value) }
+        self.model.believe_value(value)
     }
 
     pub fn compare(
@@ -417,6 +412,6 @@ impl<'ctx, N: IntKind<'ctx>> Instance<'ctx, Int<N>> {
         other: Self,
     ) -> Instance<'ctx, Int<Bool>> {
         let value = ctx.builder.build_int_compare(op, self.value, other.value, "").unwrap();
-        unsafe { Int(Bool).believe_value(value) }
+        Int(Bool).believe_value(value)
     }
 }

nac3core/src/codegen/model/ptr.rs

@@ -31,13 +31,9 @@ impl<'ctx, Item: Model<'ctx>> Model<'ctx> for Ptr<Item> {
     type Value = PointerValue<'ctx>;
     type Type = PointerType<'ctx>;
 
-    fn llvm_type<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &'ctx Context,
-    ) -> Self::Type {
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type {
         // TODO: LLVM 15: ctx.ptr_type(AddressSpace::default())
-        self.0.llvm_type(generator, ctx).ptr_type(AddressSpace::default())
+        self.0.get_type(generator, ctx).ptr_type(AddressSpace::default())
     }
 
     fn check_type<T: BasicType<'ctx>, G: CodeGenerator + ?Sized>(
@@ -75,8 +71,8 @@ impl<'ctx, Item: Model<'ctx>> Ptr<Item> {
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> Instance<'ctx, Ptr<Item>> {
-        let ptr = self.llvm_type(generator, ctx).const_null();
-        unsafe { self.believe_value(ptr) }
+        let ptr = self.get_type(generator, ctx).const_null();
+        self.believe_value(ptr)
     }
 
     /// Cast a pointer into this model with [`inkwell::builder::Builder::build_pointer_cast`]
@@ -91,9 +87,9 @@ impl<'ctx, Item: Model<'ctx>> Ptr<Item> {
         // ```
         // return self.believe_value(ptr);
         // ```
-        let t = self.llvm_type(generator, ctx.ctx);
+        let t = self.get_type(generator, ctx.ctx);
         let ptr = ctx.builder.build_pointer_cast(ptr, t, "").unwrap();
-        unsafe { self.believe_value(ptr) }
+        self.believe_value(ptr)
     }
 }
 
@@ -106,7 +102,7 @@ impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
         offset: IntValue<'ctx>,
     ) -> Instance<'ctx, Ptr<Item>> {
         let p = unsafe { ctx.builder.build_in_bounds_gep(self.value, &[offset], "").unwrap() };
-        unsafe { self.model.believe_value(p) }
+        self.model.believe_value(p)
     }
 
     /// Offset the pointer by [`inkwell::builder::Builder::build_in_bounds_gep`] by a constant offset.
@@ -114,9 +110,9 @@ impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
     pub fn offset_const(
         &self,
         ctx: &CodeGenContext<'ctx, '_>,
-        offset: i64,
+        offset: u64,
     ) -> Instance<'ctx, Ptr<Item>> {
-        let offset = ctx.ctx.i32_type().const_int(offset as u64, true);
+        let offset = ctx.ctx.i32_type().const_int(offset, false);
         self.offset(ctx, offset)
     }
 
@@ -132,7 +128,7 @@ impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
     pub fn set_index_const(
         &self,
         ctx: &CodeGenContext<'ctx, '_>,
-        index: i64,
+        index: u64,
         value: Instance<'ctx, Item>,
     ) {
         self.offset_const(ctx, index).store(ctx, value);
@@ -151,7 +147,7 @@ impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
         &self,
         generator: &mut G,
         ctx: &CodeGenContext<'ctx, '_>,
-        index: i64,
+        index: u64,
     ) -> Instance<'ctx, Item> {
         self.offset_const(ctx, index).load(generator, ctx)
     }
@@ -194,13 +190,13 @@ impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
     /// Check if the pointer is null with [`inkwell::builder::Builder::build_is_null`].
     pub fn is_null(&self, ctx: &CodeGenContext<'ctx, '_>) -> Instance<'ctx, Int<Bool>> {
         let value = ctx.builder.build_is_null(self.value, "").unwrap();
-        unsafe { Int(Bool).believe_value(value) }
+        Int(Bool).believe_value(value)
     }
 
     /// Check if the pointer is not null with [`inkwell::builder::Builder::build_is_not_null`].
     pub fn is_not_null(&self, ctx: &CodeGenContext<'ctx, '_>) -> Instance<'ctx, Int<Bool>> {
         let value = ctx.builder.build_is_not_null(self.value, "").unwrap();
-        unsafe { Int(Bool).believe_value(value) }
+        Int(Bool).believe_value(value)
     }
 
     /// `memcpy` from another pointer.
@@ -212,9 +208,9 @@ impl<'ctx, Item: Model<'ctx>> Instance<'ctx, Ptr<Item>> {
         num_items: IntValue<'ctx>,
     ) {
         // Force extend `num_items` and `itemsize` to `i64` so their types would match.
-        let itemsize = self.model.size_of(generator, ctx.ctx);
-        let itemsize = Int(SizeT).z_extend_or_truncate(generator, ctx, itemsize);
-        let num_items = Int(SizeT).z_extend_or_truncate(generator, ctx, num_items);
+        let itemsize = self.model.sizeof(generator, ctx.ctx);
+        let itemsize = Int(Int64).z_extend_or_truncate(generator, ctx, itemsize);
+        let num_items = Int(Int64).z_extend_or_truncate(generator, ctx, num_items);
         let totalsize = itemsize.mul(ctx, num_items);
 
         let is_volatile = ctx.ctx.bool_type().const_zero(); // is_volatile = false

nac3core/src/codegen/model/structure.rs

@@ -13,16 +13,16 @@ use super::*;
 /// A traveral that traverses a Rust `struct` that is used to declare an LLVM's struct's field types.
 pub trait FieldTraversal<'ctx> {
     /// Output type of [`FieldTraversal::add`].
-    type Output<M>;
+    type Out<M>;
 
     /// Traverse through the type of a declared field and do something with it.
     ///
     /// * `name` - The cosmetic name of the LLVM field. Used for debugging.
     /// * `model` - The [`Model`] representing the LLVM type of this field.
-    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M>;
+    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Out<M>;
 
     /// Like [`FieldTraversal::add`] but [`Model`] is automatically inferred from its [`Default`] trait.
-    fn add_auto<M: Model<'ctx> + Default>(&mut self, name: &'static str) -> Self::Output<M> {
+    fn add_auto<M: Model<'ctx> + Default>(&mut self, name: &'static str) -> Self::Out<M> {
         self.add(name, M::default())
     }
 }
@@ -31,7 +31,7 @@ pub trait FieldTraversal<'ctx> {
 #[derive(Debug, Clone, Copy)]
 pub struct GepField<M> {
     /// The GEP index of this field. This is the index to use with `build_gep`.
-    pub gep_index: u32,
+    pub gep_index: u64,
     /// The cosmetic name of this field.
     pub name: &'static str,
     /// The [`Model`] of this field's type.
@@ -41,16 +41,16 @@ pub struct GepField<M> {
 /// A traversal to calculate the GEP index of fields.
 pub struct GepFieldTraversal {
     /// The current GEP index.
-    gep_index_counter: u32,
+    gep_index_counter: u64,
 }
 
 impl<'ctx> FieldTraversal<'ctx> for GepFieldTraversal {
-    type Output<M> = GepField<M>;
+    type Out<M> = GepField<M>;
 
-    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M> {
+    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Out<M> {
         let gep_index = self.gep_index_counter;
         self.gep_index_counter += 1;
-        Self::Output { gep_index, name, model }
+        Self::Out { gep_index, name, model }
     }
 }
 
@@ -65,10 +65,10 @@ struct TypeFieldTraversal<'ctx, 'a, G: CodeGenerator + ?Sized> {
 }
 
 impl<'ctx, 'a, G: CodeGenerator + ?Sized> FieldTraversal<'ctx> for TypeFieldTraversal<'ctx, 'a, G> {
-    type Output<M> = (); // Checking types return nothing.
+    type Out<M> = (); // Checking types return nothing.
 
-    fn add<M: Model<'ctx>>(&mut self, _name: &'static str, model: M) -> Self::Output<M> {
-        let t = model.llvm_type(self.generator, self.ctx).as_basic_type_enum();
+    fn add<M: Model<'ctx>>(&mut self, _name: &'static str, model: M) -> Self::Out<M> {
+        let t = model.get_type(self.generator, self.ctx).as_basic_type_enum();
         self.field_types.push(t);
     }
 }
@@ -89,9 +89,9 @@ struct CheckTypeFieldTraversal<'ctx, 'a, G: CodeGenerator + ?Sized> {
 impl<'ctx, 'a, G: CodeGenerator + ?Sized> FieldTraversal<'ctx>
     for CheckTypeFieldTraversal<'ctx, 'a, G>
 {
-    type Output<M> = (); // Checking types return nothing.
+    type Out<M> = (); // Checking types return nothing.
 
-    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Output<M> {
+    fn add<M: Model<'ctx>>(&mut self, name: &'static str, model: M) -> Self::Out<M> {
         let gep_index = self.gep_index_counter;
         self.gep_index_counter += 1;
 
@@ -100,8 +100,7 @@ impl<'ctx, 'a, G: CodeGenerator + ?Sized> FieldTraversal<'ctx>
                 self.errors
                     .push(err.under_context(format!("field #{gep_index} '{name}'").as_str()));
             }
-        }
-        // Otherwise, it will be caught by Struct's `check_type`.
+        } // Otherwise, it will be caught by Struct's `check_type`.
     }
 }
 
@@ -193,13 +192,13 @@ pub trait StructKind<'ctx>: fmt::Debug + Clone + Copy {
     /// Traverse through all fields of this [`StructKind`].
     ///
     /// Only used internally in this module for implementing other components.
-    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F>;
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F>;
 
     /// Get a convenience structure to get a struct field's GEP index through its corresponding Rust field.
     ///
     /// Only used internally in this module for implementing other components.
     fn fields(&self) -> Self::Fields<GepFieldTraversal> {
-        self.iter_fields(&mut GepFieldTraversal { gep_index_counter: 0 })
+        self.traverse_fields(&mut GepFieldTraversal { gep_index_counter: 0 })
     }
 
     /// Get the LLVM [`StructType`] of this [`StructKind`].
@@ -209,7 +208,7 @@ pub trait StructKind<'ctx>: fmt::Debug + Clone + Copy {
         ctx: &'ctx Context,
     ) -> StructType<'ctx> {
         let mut traversal = TypeFieldTraversal { generator, ctx, field_types: Vec::new() };
-        self.iter_fields(&mut traversal);
+        self.traverse_fields(&mut traversal);
 
         ctx.struct_type(&traversal.field_types, false)
     }
@@ -243,11 +242,7 @@ impl<'ctx, S: StructKind<'ctx>> Model<'ctx> for Struct<S> {
     type Value = StructValue<'ctx>;
     type Type = StructType<'ctx>;
 
-    fn llvm_type<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &'ctx Context,
-    ) -> Self::Type {
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type {
         self.0.get_struct_type(generator, ctx)
     }
 
@@ -270,7 +265,7 @@ impl<'ctx, S: StructKind<'ctx>> Model<'ctx> for Struct<S> {
             errors: Vec::new(),
             scrutinee: ty,
         };
-        self.0.iter_fields(&mut traversal);
+        self.0.traverse_fields(&mut traversal);
 
         // Check the number of fields.
         let exp_num_fields = traversal.gep_index_counter;
@@ -303,7 +298,7 @@ impl<'ctx, S: StructKind<'ctx>> Instance<'ctx, Struct<S>> {
         GetField: FnOnce(S::Fields<GepFieldTraversal>) -> GepField<M>,
     {
         let field = get_field(self.model.0.fields());
-        let val = self.value.get_field_at_index(field.gep_index).unwrap();
+        let val = self.value.get_field_at_index(field.gep_index as u32).unwrap();
         field.model.check_value(generator, ctx, val).unwrap()
     }
 }
@@ -326,13 +321,13 @@ impl<'ctx, S: StructKind<'ctx>> Instance<'ctx, Ptr<Struct<S>>> {
             ctx.builder
                 .build_in_bounds_gep(
                     self.value,
-                    &[llvm_i32.const_zero(), llvm_i32.const_int(u64::from(field.gep_index), false)],
+                    &[llvm_i32.const_zero(), llvm_i32.const_int(field.gep_index, false)],
                     field.name,
                 )
                 .unwrap()
         };
 
-        unsafe { Ptr(field.model).believe_value(ptr) }
+        Ptr(field.model).believe_value(ptr)
     }
 
     /// Convenience function equivalent to `.gep(...).load(...)`.

nac3core/src/codegen/model/util.rs

@@ -34,7 +34,7 @@ where
         start.value,
         (stop.value, false),
         |g, ctx, hooks, i| {
-            let i = unsafe { int_model.believe_value(i) };
+            let i = int_model.believe_value(i);
             body(g, ctx, hooks, i)
         },
         step.value,

nac3core/src/codegen/numpy.rs

@@ -12,7 +12,6 @@ use crate::{
             call_ndarray_calc_size,
         },
         llvm_intrinsics::{self, call_memcpy_generic},
-        macros::codegen_unreachable,
         model::*,
         object::{
             any::AnyObject,
@@ -265,7 +264,7 @@ fn ndarray_zero_value<'ctx, G: CodeGenerator + ?Sized>(
     } else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
         ctx.gen_string(generator, "").into()
     } else {
-        codegen_unreachable!(ctx)
+        unreachable!()
     }
 }
 
@@ -293,7 +292,7 @@ fn ndarray_one_value<'ctx, G: CodeGenerator + ?Sized>(
     } else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
         ctx.gen_string(generator, "1").into()
     } else {
-        codegen_unreachable!(ctx)
+        unreachable!()
     }
 }
 
@@ -361,7 +360,7 @@ fn call_ndarray_empty_impl<'ctx, G: CodeGenerator + ?Sized>(
 
             create_ndarray_const_shape(generator, ctx, elem_ty, &[shape_int])
         }
-        _ => codegen_unreachable!(ctx),
+        _ => unreachable!(),
     }
 }
 
@@ -632,7 +631,7 @@ fn call_ndarray_full_impl<'ctx, G: CodeGenerator + ?Sized>(
         } else if fill_value.is_int_value() || fill_value.is_float_value() {
             fill_value
         } else {
-            codegen_unreachable!(ctx)
+            unreachable!()
         };
 
         Ok(value)
@@ -2052,7 +2051,7 @@ pub fn ndarray_dot<'ctx, G: CodeGenerator + ?Sized>(
                             .build_float_mul(e1, elem2.into_float_value(), "")
                             .unwrap()
                             .as_basic_value_enum(),
-                        _ => codegen_unreachable!(ctx),
+                        _ => unreachable!(),
                     };
                     let acc_val = ctx.builder.build_load(acc, "").unwrap();
                     let acc_val = match acc_val {
@@ -2066,7 +2065,7 @@ pub fn ndarray_dot<'ctx, G: CodeGenerator + ?Sized>(
                             .build_float_add(e1, product.into_float_value(), "")
                             .unwrap()
                             .as_basic_value_enum(),
-                        _ => codegen_unreachable!(ctx),
+                        _ => unreachable!(),
                     };
                     ctx.builder.build_store(acc, acc_val).unwrap();
 
@@ -2083,8 +2082,7 @@ pub fn ndarray_dot<'ctx, G: CodeGenerator + ?Sized>(
         (BasicValueEnum::FloatValue(e1), BasicValueEnum::FloatValue(e2)) => {
             Ok(ctx.builder.build_float_mul(e1, e2, "").unwrap().as_basic_value_enum())
         }
-        _ => codegen_unreachable!(
-            ctx,
+        _ => unreachable!(
             "{FN_NAME}() not supported for '{}'",
             format!("'{}'", ctx.unifier.stringify(x1_ty))
         ),

nac3core/src/codegen/object/list.rs

@@ -8,9 +8,9 @@ use super::any::AnyObject;
 /// Fields of [`List`]
 pub struct ListFields<'ctx, F: FieldTraversal<'ctx>, Item: Model<'ctx>> {
     /// Array pointer to content
-    pub items: F::Output<Ptr<Item>>,
+    pub items: F::Out<Ptr<Item>>,
     /// Number of items in the array
-    pub len: F::Output<Int<SizeT>>,
+    pub len: F::Out<Int<SizeT>>,
 }
 
 /// A list in NAC3.
@@ -23,7 +23,7 @@ pub struct List<Item> {
 impl<'ctx, Item: Model<'ctx>> StructKind<'ctx> for List<Item> {
     type Fields<F: FieldTraversal<'ctx>> = ListFields<'ctx, F, Item>;
 
-    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
         Self::Fields {
             items: traversal.add("items", Ptr(self.item)),
             len: traversal.add_auto("len"),

nac3core/src/codegen/object/ndarray/array.rs

@@ -40,7 +40,7 @@ impl<'ctx> NDArrayObject<'ctx> {
         // Validate `list` has a consistent shape.
         // Raise an exception if `list` is something abnormal like `[[1, 2], [3]]`.
         // If `list` has a consistent shape, deduce the shape and write it to `shape`.
-        let ndims = Int(SizeT).const_int(generator, ctx.ctx, ndims_int, false);
+        let ndims = Int(SizeT).const_int(generator, ctx.ctx, ndims_int);
         let shape = Int(SizeT).array_alloca(generator, ctx, ndims.value);
         call_nac3_ndarray_array_set_and_validate_list_shape(
             generator, ctx, list_value, ndims, shape,

nac3core/src/codegen/object/ndarray/broadcast.rs

@@ -10,8 +10,8 @@ use super::NDArrayObject;
 
 /// Fields of [`ShapeEntry`]
 pub struct ShapeEntryFields<'ctx, F: FieldTraversal<'ctx>> {
-    pub ndims: F::Output<Int<SizeT>>,
-    pub shape: F::Output<Ptr<Int<SizeT>>>,
+    pub ndims: F::Out<Int<SizeT>>,
+    pub shape: F::Out<Ptr<Int<SizeT>>>,
 }
 
 /// An IRRT structure used in broadcasting.
@@ -21,7 +21,7 @@ pub struct ShapeEntry;
 impl<'ctx> StructKind<'ctx> for ShapeEntry {
     type Fields<F: FieldTraversal<'ctx>> = ShapeEntryFields<'ctx, F>;
 
-    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
         Self::Fields { ndims: traversal.add_auto("ndims"), shape: traversal.add_auto("shape") }
     }
 }
@@ -73,23 +73,19 @@ fn broadcast_shapes<'ctx, G: CodeGenerator + ?Sized>(
     broadcast_shape: Instance<'ctx, Ptr<Int<SizeT>>>,
 ) {
     // Prepare input shape entries to be passed to `call_nac3_ndarray_broadcast_shapes`.
-    let num_shape_entries = Int(SizeT).const_int(
-        generator,
-        ctx.ctx,
-        u64::try_from(in_shape_entries.len()).unwrap(),
-        false,
-    );
+    let num_shape_entries =
+        Int(SizeT).const_int(generator, ctx.ctx, u64::try_from(in_shape_entries.len()).unwrap());
     let shape_entries = Struct(ShapeEntry).array_alloca(generator, ctx, num_shape_entries.value);
     for (i, (in_shape, in_ndims)) in in_shape_entries.iter().enumerate() {
-        let pshape_entry = shape_entries.offset_const(ctx, i64::try_from(i).unwrap());
+        let pshape_entry = shape_entries.offset_const(ctx, i as u64);
 
-        let in_ndims = Int(SizeT).const_int(generator, ctx.ctx, *in_ndims, false);
+        let in_ndims = Int(SizeT).const_int(generator, ctx.ctx, *in_ndims);
         pshape_entry.set(ctx, |f| f.ndims, in_ndims);
 
         pshape_entry.set(ctx, |f| f.shape, *in_shape);
     }
 
-    let broadcast_ndims = Int(SizeT).const_int(generator, ctx.ctx, broadcast_ndims, false);
+    let broadcast_ndims = Int(SizeT).const_int(generator, ctx.ctx, broadcast_ndims);
     call_nac3_ndarray_broadcast_shapes(
         generator,
         ctx,
@@ -113,7 +109,7 @@ impl<'ctx> NDArrayObject<'ctx> {
         // Infer the broadcast output ndims.
         let broadcast_ndims_int = ndarrays.iter().map(|ndarray| ndarray.ndims).max().unwrap();
 
-        let broadcast_ndims = Int(SizeT).const_int(generator, ctx.ctx, broadcast_ndims_int, false);
+        let broadcast_ndims = Int(SizeT).const_int(generator, ctx.ctx, broadcast_ndims_int);
         let broadcast_shape = Int(SizeT).array_alloca(generator, ctx, broadcast_ndims.value);
 
         let shape_entries = ndarrays

nac3core/src/codegen/object/ndarray/factory.rs

@@ -76,7 +76,7 @@ impl<'ctx> NDArrayObject<'ctx> {
         shape: Instance<'ctx, Ptr<Int<SizeT>>>,
     ) -> Self {
         // Validate `shape`
-        let ndims_llvm = Int(SizeT).const_int(generator, ctx.ctx, ndims, false);
+        let ndims_llvm = Int(SizeT).const_int(generator, ctx.ctx, ndims);
         call_nac3_ndarray_util_assert_shape_no_negative(generator, ctx, ndims_llvm, shape);
 
         let ndarray = NDArrayObject::alloca(generator, ctx, dtype, ndims);

nac3core/src/codegen/object/ndarray/indexing.rs

@@ -12,8 +12,8 @@ pub type NDIndexType = Byte;
 /// Fields of [`NDIndex`]
 #[derive(Debug, Clone, Copy)]
 pub struct NDIndexFields<'ctx, F: FieldTraversal<'ctx>> {
-    pub type_: F::Output<Int<NDIndexType>>,
-    pub data: F::Output<Ptr<Int<Byte>>>,
+    pub type_: F::Out<Int<NDIndexType>>, // Defined to be uint8_t in IRRT
+    pub data: F::Out<Ptr<Int<Byte>>>,
 }
 
 /// An IRRT representation of an ndarray subscript index.
@@ -23,7 +23,7 @@ pub struct NDIndex;
 impl<'ctx> StructKind<'ctx> for NDIndex {
     type Fields<F: FieldTraversal<'ctx>> = NDIndexFields<'ctx, F>;
 
-    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
         Self::Fields { type_: traversal.add_auto("type"), data: traversal.add_auto("data") }
     }
 }
@@ -49,7 +49,7 @@ impl<'ctx> RustNDIndex<'ctx> {
         }
     }
 
-    /// Serialize this [`RustNDIndex`] by writing it into an LLVM [`NDIndex`].
+    /// Write the contents to an LLVM [`NDIndex`].
     fn write_to_ndindex<G: CodeGenerator + ?Sized>(
         &self,
         generator: &mut G,
@@ -59,7 +59,7 @@ impl<'ctx> RustNDIndex<'ctx> {
         // Set `dst_ndindex_ptr->type`
         dst_ndindex_ptr.gep(ctx, |f| f.type_).store(
             ctx,
-            Int(NDIndexType::default()).const_int(generator, ctx.ctx, self.get_type_id(), false),
+            Int(NDIndexType::default()).const_int(generator, ctx.ctx, self.get_type_id()),
         );
 
         // Set `dst_ndindex_ptr->data`
@@ -84,7 +84,7 @@ impl<'ctx> RustNDIndex<'ctx> {
         }
     }
 
-    /// Serialize a list of `RustNDIndex` as a newly allocated LLVM array of `NDIndex`.
+    /// Allocate an array of `NDIndex`es on the stack and return the array pointer.
     pub fn make_ndindices<G: CodeGenerator + ?Sized>(
         generator: &mut G,
         ctx: &CodeGenContext<'ctx, '_>,
@@ -92,14 +92,10 @@ impl<'ctx> RustNDIndex<'ctx> {
     ) -> (Instance<'ctx, Int<SizeT>>, Instance<'ctx, Ptr<Struct<NDIndex>>>) {
         let ndindex_model = Struct(NDIndex);
 
-        // Allocate the LLVM ndindices.
-        let num_ndindices =
-            Int(SizeT).const_int(generator, ctx.ctx, in_ndindices.len() as u64, false);
+        let num_ndindices = Int(SizeT).const_int(generator, ctx.ctx, in_ndindices.len() as u64);
         let ndindices = ndindex_model.array_alloca(generator, ctx, num_ndindices.value);
-
-        // Initialize all of them.
         for (i, in_ndindex) in in_ndindices.iter().enumerate() {
-            let pndindex = ndindices.offset_const(ctx, i64::try_from(i).unwrap());
+            let pndindex = ndindices.offset_const(ctx, i as u64);
             in_ndindex.write_to_ndindex(generator, ctx, pndindex);
         }
 
@@ -159,7 +155,10 @@ pub mod util {
     use nac3parser::ast::{Expr, ExprKind};
 
     use crate::{
-        codegen::{model::*, object::utils::slice::util::gen_slice, CodeGenContext, CodeGenerator},
+        codegen::{
+            expr::gen_slice, model::*, object::utils::slice::RustSlice, CodeGenContext,
+            CodeGenerator,
+        },
         typecheck::typedef::Type,
     };
 
@@ -207,8 +206,8 @@ pub mod util {
             // so the code/implementation looks awkward - we have to do pattern matching on the expression
             let ndindex = if let ExprKind::Slice { lower, upper, step } = &index_expr.node {
                 // Handle slices
-                let slice = gen_slice(generator, ctx, lower, upper, step)?;
-                RustNDIndex::Slice(slice)
+                let (lower, upper, step) = gen_slice(generator, ctx, lower, upper, step)?;
+                RustNDIndex::Slice(RustSlice { int_kind: Int32, start: lower, stop: upper, step })
             } else {
                 // Treat and handle everything else as a single element index.
                 let index = generator.gen_expr(ctx, index_expr)?.unwrap().to_basic_value_enum(

nac3core/src/codegen/object/ndarray/mod.rs

@@ -32,11 +32,11 @@ use super::{any::AnyObject, tuple::TupleObject};
 
 /// Fields of [`NDArray`]
 pub struct NDArrayFields<'ctx, F: FieldTraversal<'ctx>> {
-    pub data: F::Output<Ptr<Int<Byte>>>,
-    pub itemsize: F::Output<Int<SizeT>>,
-    pub ndims: F::Output<Int<SizeT>>,
-    pub shape: F::Output<Ptr<Int<SizeT>>>,
-    pub strides: F::Output<Ptr<Int<SizeT>>>,
+    pub data: F::Out<Ptr<Int<Byte>>>,
+    pub itemsize: F::Out<Int<SizeT>>,
+    pub ndims: F::Out<Int<SizeT>>,
+    pub shape: F::Out<Ptr<Int<SizeT>>>,
+    pub strides: F::Out<Ptr<Int<SizeT>>>,
 }
 
 /// A strided ndarray in NAC3.
@@ -48,7 +48,7 @@ pub struct NDArray;
 impl<'ctx> StructKind<'ctx> for NDArray {
     type Fields<F: FieldTraversal<'ctx>> = NDArrayFields<'ctx, F>;
 
-    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
         Self::Fields {
             data: traversal.add_auto("data"),
             itemsize: traversal.add_auto("itemsize"),
@@ -98,7 +98,7 @@ impl<'ctx> NDArrayObject<'ctx> {
         generator: &mut G,
         ctx: &'ctx Context,
     ) -> Instance<'ctx, Int<SizeT>> {
-        Int(SizeT).const_int(generator, ctx, self.ndims, false)
+        Int(SizeT).const_int(generator, ctx, self.ndims)
     }
 
     /// Allocate an ndarray on the stack given its `ndims` and `dtype`.
@@ -123,7 +123,7 @@ impl<'ctx> NDArrayObject<'ctx> {
         let itemsize = Int(SizeT).z_extend_or_truncate(generator, ctx, itemsize);
         ndarray.set(ctx, |f| f.itemsize, itemsize);
 
-        let ndims_val = Int(SizeT).const_int(generator, ctx.ctx, ndims, false);
+        let ndims_val = Int(SizeT).const_int(generator, ctx.ctx, ndims);
         ndarray.set(ctx, |f| f.ndims, ndims_val);
 
         let shape = Int(SizeT).array_alloca(generator, ctx, ndims_val.value);
@@ -149,8 +149,8 @@ impl<'ctx> NDArrayObject<'ctx> {
         // Write shape
         let dst_shape = ndarray.instance.get(generator, ctx, |f| f.shape);
         for (i, dim) in shape.iter().enumerate() {
-            let dim = Int(SizeT).const_int(generator, ctx.ctx, *dim, false);
-            dst_shape.offset_const(ctx, i64::try_from(i).unwrap()).store(ctx, dim);
+            let dim = Int(SizeT).const_int(generator, ctx.ctx, *dim);
+            dst_shape.offset_const(ctx, i as u64).store(ctx, dim);
         }
 
         ndarray
@@ -170,7 +170,7 @@ impl<'ctx> NDArrayObject<'ctx> {
         // Write shape
         let dst_shape = ndarray.instance.get(generator, ctx, |f| f.shape);
         for (i, dim) in shape.iter().enumerate() {
-            dst_shape.offset_const(ctx, i64::try_from(i).unwrap()).store(ctx, *dim);
+            dst_shape.offset_const(ctx, i as u64).store(ctx, *dim);
         }
 
         ndarray
@@ -419,8 +419,6 @@ impl<'ctx> NDArrayObject<'ctx> {
         ctx: &mut CodeGenContext<'ctx, '_>,
         value: BasicValueEnum<'ctx>,
     ) {
-        // TODO: It is possible to optimize this by exploiting contiguous strides with memset.
-        // Probably best to implement in IRRT.
         self.foreach(generator, ctx, |generator, ctx, _hooks, nditer| {
             let p = nditer.get_pointer(generator, ctx);
             ctx.builder.build_store(p, value).unwrap();
@@ -445,7 +443,7 @@ impl<'ctx> NDArrayObject<'ctx> {
             let dim = self
                 .instance
                 .get(generator, ctx, |f| f.shape)
-                .get_index_const(generator, ctx, i64::try_from(i).unwrap())
+                .get_index_const(generator, ctx, i)
                 .truncate_or_bit_cast(generator, ctx, Int32);
 
             objects.push(AnyObject {
@@ -473,7 +471,7 @@ impl<'ctx> NDArrayObject<'ctx> {
             let dim = self
                 .instance
                 .get(generator, ctx, |f| f.strides)
-                .get_index_const(generator, ctx, i64::try_from(i).unwrap())
+                .get_index_const(generator, ctx, i)
                 .truncate_or_bit_cast(generator, ctx, Int32);
 
             objects.push(AnyObject {

nac3core/src/codegen/object/ndarray/nditer.rs

@@ -1,7 +1,7 @@
 use inkwell::{types::BasicType, values::PointerValue, AddressSpace};
 
 use crate::codegen::{
-    irrt::{call_nac3_nditer_has_element, call_nac3_nditer_initialize, call_nac3_nditer_next},
+    irrt::{call_nac3_nditer_has_next, call_nac3_nditer_initialize, call_nac3_nditer_next},
     model::*,
     object::any::AnyObject,
     stmt::{gen_for_callback, BreakContinueHooks},
@@ -12,15 +12,15 @@ use super::NDArrayObject;
 
 /// Fields of [`NDIter`]
 pub struct NDIterFields<'ctx, F: FieldTraversal<'ctx>> {
-    pub ndims: F::Output<Int<SizeT>>,
-    pub shape: F::Output<Ptr<Int<SizeT>>>,
-    pub strides: F::Output<Ptr<Int<SizeT>>>,
+    pub ndims: F::Out<Int<SizeT>>,
+    pub shape: F::Out<Ptr<Int<SizeT>>>,
+    pub strides: F::Out<Ptr<Int<SizeT>>>,
 
-    pub indices: F::Output<Ptr<Int<SizeT>>>,
-    pub nth: F::Output<Int<SizeT>>,
-    pub element: F::Output<Ptr<Int<Byte>>>,
+    pub indices: F::Out<Ptr<Int<SizeT>>>,
+    pub nth: F::Out<Int<SizeT>>,
+    pub element: F::Out<Ptr<Int<Byte>>>,
 
-    pub size: F::Output<Int<SizeT>>,
+    pub size: F::Out<Int<SizeT>>,
 }
 
 /// An IRRT helper structure used to iterate through an ndarray.
@@ -30,7 +30,7 @@ pub struct NDIter;
 impl<'ctx> StructKind<'ctx> for NDIter {
     type Fields<F: FieldTraversal<'ctx>> = NDIterFields<'ctx, F>;
 
-    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
         Self::Fields {
             ndims: traversal.add_auto("ndims"),
             shape: traversal.add_auto("shape"),
@@ -72,22 +72,20 @@ impl<'ctx> NDIterHandle<'ctx> {
         NDIterHandle { ndarray, instance: nditer, indices }
     }
 
-    /// Is the current iteration valid?
-    ///
-    /// If true, then `element`, `indices` and `nth` contain details about the current element.
+    /// Is there a next element?
     ///
     /// If `ndarray` is unsized, this returns true only for the first iteration.
     /// If `ndarray` is 0-sized, this always returns false.
     #[must_use]
-    pub fn has_element<G: CodeGenerator + ?Sized>(
+    pub fn has_next<G: CodeGenerator + ?Sized>(
         &self,
         generator: &mut G,
         ctx: &mut CodeGenContext<'ctx, '_>,
     ) -> Instance<'ctx, Int<Bool>> {
-        call_nac3_nditer_has_element(generator, ctx, self.instance)
+        call_nac3_nditer_has_next(generator, ctx, self.instance)
     }
 
-    /// Go to the next element. If `has_element()` is false, then this has undefined behavior.
+    /// Go to the next element. If `has_next()` is false, then this has undefined behavior.
     ///
     /// If `ndarray` is unsized, this can only be called once.
     /// If `ndarray` is 0-sized, this can never be called.
@@ -168,7 +166,7 @@ impl<'ctx> NDArrayObject<'ctx> {
             ctx,
             Some("ndarray_foreach"),
             |generator, ctx| Ok(NDIterHandle::new(generator, ctx, *self)),
-            |generator, ctx, nditer| Ok(nditer.has_element(generator, ctx).value),
+            |generator, ctx, nditer| Ok(nditer.has_next(generator, ctx).value),
             |generator, ctx, hooks, nditer| body(generator, ctx, hooks, nditer),
             |generator, ctx, nditer| {
                 nditer.next(generator, ctx);

nac3core/src/codegen/object/ndarray/shape_util.rs

@@ -77,7 +77,7 @@ pub fn parse_numpy_int_sequence<'ctx, G: CodeGenerator + ?Sized>(
                 let int = input_sequence.index(ctx, i).value.into_int_value();
                 let int = Int(SizeT).s_extend_or_bit_cast(generator, ctx, int);
 
-                result.set_index_const(ctx, i64::try_from(i).unwrap(), int);
+                result.set_index_const(ctx, i as u64, int);
             }
 
             (len, result)

nac3core/src/codegen/object/tuple.rs

@@ -81,7 +81,7 @@ impl<'ctx> TupleObject<'ctx> {
         generator: &mut G,
         ctx: &mut CodeGenContext<'ctx, '_>,
     ) -> Instance<'ctx, Int<SizeT>> {
-        Int(SizeT).const_int(generator, ctx.ctx, self.num_elements() as u64, false)
+        Int(SizeT).const_int(generator, ctx.ctx, self.num_elements() as u64)
     }
 
     /// Get the `i`-th (0-based) object in this tuple.

nac3core/src/codegen/object/utils/slice.rs

@@ -3,12 +3,12 @@ use crate::codegen::{model::*, CodeGenContext, CodeGenerator};
 /// Fields of [`Slice`]
 #[derive(Debug, Clone)]
 pub struct SliceFields<'ctx, F: FieldTraversal<'ctx>, N: IntKind<'ctx>> {
-    pub start_defined: F::Output<Int<Bool>>,
-    pub start: F::Output<Int<N>>,
-    pub stop_defined: F::Output<Int<Bool>>,
-    pub stop: F::Output<Int<N>>,
-    pub step_defined: F::Output<Int<Bool>>,
-    pub step: F::Output<Int<N>>,
+    pub start_defined: F::Out<Int<Bool>>,
+    pub start: F::Out<Int<N>>,
+    pub stop_defined: F::Out<Int<Bool>>,
+    pub stop: F::Out<Int<N>>,
+    pub step_defined: F::Out<Int<Bool>>,
+    pub step: F::Out<Int<N>>,
 }
 
 /// An IRRT representation of an (unresolved) slice.
@@ -18,7 +18,7 @@ pub struct Slice<N>(pub N);
 impl<'ctx, N: IntKind<'ctx>> StructKind<'ctx> for Slice<N> {
     type Fields<F: FieldTraversal<'ctx>> = SliceFields<'ctx, F, N>;
 
-    fn iter_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F> {
         Self::Fields {
             start_defined: traversal.add_auto("start_defined"),
             start: traversal.add("start", Int(self.0)),

nac3core/src/codegen/stmt.rs

@@ -1,9 +1,7 @@
 use super::{
-    classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
-    expr::{destructure_range, gen_binop_expr},
-    gen_in_range_check,
+    super::symbol_resolver::ValueEnum,
+    expr::destructure_range,
     irrt::{handle_slice_indices, list_slice_assignment},
-    macros::codegen_unreachable,
     object::{
         any::AnyObject,
         ndarray::{
@@ -13,7 +11,11 @@ use super::{
     CodeGenContext, CodeGenerator,
 };
 use crate::{
-    symbol_resolver::ValueEnum,
+    codegen::{
+        classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
+        expr::gen_binop_expr,
+        gen_in_range_check,
+    },
     toplevel::{DefinitionId, TopLevelDef},
     typecheck::{
         magic_methods::Binop,
@@ -125,7 +127,7 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
                 return Ok(None);
             };
             let BasicValueEnum::PointerValue(ptr) = val else {
-                codegen_unreachable!(ctx);
+                unreachable!();
             };
             unsafe {
                 ctx.builder.build_in_bounds_gep(
@@ -139,7 +141,7 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
             }
             .unwrap()
         }
-        _ => codegen_unreachable!(ctx),
+        _ => unreachable!(),
     }))
 }
 
@@ -180,14 +182,6 @@ pub fn gen_assign<'ctx, G: CodeGenerator>(
                 }
             }
             let val = value.to_basic_value_enum(ctx, generator, target.custom.unwrap())?;
-
-            // Perform i1 <-> i8 conversion as needed
-            let val = if ctx.unifier.unioned(target.custom.unwrap(), ctx.primitives.bool) {
-                generator.bool_to_i8(ctx, val.into_int_value()).into()
-            } else {
-                val
-            };
-
             ctx.builder.build_store(ptr, val).unwrap();
         }
     };
@@ -205,12 +199,12 @@ pub fn gen_assign_target_list<'ctx, G: CodeGenerator>(
     // Deconstruct the tuple `value`
     let BasicValueEnum::StructValue(tuple) = value.to_basic_value_enum(ctx, generator, value_ty)?
     else {
-        codegen_unreachable!(ctx)
+        unreachable!()
     };
 
     // NOTE: Currently, RHS's type is forced to be a Tuple by the type inferencer.
     let TypeEnum::TTuple { ty: tuple_tys, .. } = &*ctx.unifier.get_ty(value_ty) else {
-        codegen_unreachable!(ctx);
+        unreachable!();
     };
 
     assert_eq!(tuple.get_type().count_fields() as usize, tuple_tys.len());
@@ -270,7 +264,7 @@ pub fn gen_assign_target_list<'ctx, G: CodeGenerator>(
             // Now assign with that sub-tuple to the starred target.
             generator.gen_assign(ctx, target, ValueEnum::Dynamic(sub_tuple_val), sub_tuple_ty)?;
         } else {
-            codegen_unreachable!(ctx) // The typechecker ensures this
+            unreachable!() // The typechecker ensures this
         }
 
         // Handle assignment after the starred target
@@ -318,9 +312,7 @@ pub fn gen_setitem<'ctx, G: CodeGenerator>(
 
             if let ExprKind::Slice { .. } = &key.node {
                 // Handle assigning to a slice
-                let ExprKind::Slice { lower, upper, step } = &key.node else {
-                    codegen_unreachable!(ctx)
-                };
+                let ExprKind::Slice { lower, upper, step } = &key.node else { unreachable!() };
                 let Some((start, end, step)) = handle_slice_indices(
                     lower,
                     upper,
@@ -470,9 +462,7 @@ pub fn gen_for<G: CodeGenerator>(
     ctx: &mut CodeGenContext<'_, '_>,
     stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::For { iter, target, body, orelse, .. } = &stmt.node else {
-        codegen_unreachable!(ctx)
-    };
+    let StmtKind::For { iter, target, body, orelse, .. } = &stmt.node else { unreachable!() };
 
     // var_assignment static values may be changed in another branch
     // if so, remove the static value as it may not be correct in this branch
@@ -514,7 +504,7 @@ pub fn gen_for<G: CodeGenerator>(
             let Some(target_i) =
                 generator.gen_store_target(ctx, target, Some("for.target.addr"))?
             else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
             let (start, stop, step) = destructure_range(ctx, iter_val);
 
@@ -957,7 +947,7 @@ pub fn gen_while<G: CodeGenerator>(
     ctx: &mut CodeGenContext<'_, '_>,
     stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::While { test, body, orelse, .. } = &stmt.node else { codegen_unreachable!(ctx) };
+    let StmtKind::While { test, body, orelse, .. } = &stmt.node else { unreachable!() };
 
     // var_assignment static values may be changed in another branch
     // if so, remove the static value as it may not be correct in this branch
@@ -987,7 +977,7 @@ pub fn gen_while<G: CodeGenerator>(
 
         return Ok(());
     };
-    let BasicValueEnum::IntValue(test) = test else { codegen_unreachable!(ctx) };
+    let BasicValueEnum::IntValue(test) = test else { unreachable!() };
 
     ctx.builder
         .build_conditional_branch(generator.bool_to_i1(ctx, test), body_bb, orelse_bb)
@@ -1135,7 +1125,7 @@ pub fn gen_if<G: CodeGenerator>(
     ctx: &mut CodeGenContext<'_, '_>,
     stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::If { test, body, orelse, .. } = &stmt.node else { codegen_unreachable!(ctx) };
+    let StmtKind::If { test, body, orelse, .. } = &stmt.node else { unreachable!() };
 
     // var_assignment static values may be changed in another branch
     // if so, remove the static value as it may not be correct in this branch
@@ -1258,11 +1248,11 @@ pub fn exn_constructor<'ctx>(
     let zelf_id = if let TypeEnum::TObj { obj_id, .. } = &*ctx.unifier.get_ty(zelf_ty) {
         obj_id.0
     } else {
-        codegen_unreachable!(ctx)
+        unreachable!()
     };
     let defs = ctx.top_level.definitions.read();
     let def = defs[zelf_id].read();
-    let TopLevelDef::Class { name: zelf_name, .. } = &*def else { codegen_unreachable!(ctx) };
+    let TopLevelDef::Class { name: zelf_name, .. } = &*def else { unreachable!() };
     let exception_name = format!("{}:{}", ctx.resolver.get_exception_id(zelf_id), zelf_name);
     unsafe {
         let id_ptr = ctx.builder.build_in_bounds_gep(zelf, &[zero, zero], "exn.id").unwrap();
@@ -1370,7 +1360,7 @@ pub fn gen_try<'ctx, 'a, G: CodeGenerator>(
     target: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
     let StmtKind::Try { body, handlers, orelse, finalbody, .. } = &target.node else {
-        codegen_unreachable!(ctx)
+        unreachable!()
     };
 
     // if we need to generate anything related to exception, we must have personality defined
@@ -1447,7 +1437,7 @@ pub fn gen_try<'ctx, 'a, G: CodeGenerator>(
             if let TypeEnum::TObj { obj_id, .. } = &*ctx.unifier.get_ty(type_.custom.unwrap()) {
                 *obj_id
             } else {
-                codegen_unreachable!(ctx)
+                unreachable!()
             };
         let exception_name = format!("{}:{}", ctx.resolver.get_exception_id(obj_id.0), exn_name);
         let exn_id = ctx.resolver.get_string_id(&exception_name);
@@ -1719,23 +1709,6 @@ pub fn gen_return<G: CodeGenerator>(
     } else {
         None
     };
-
-    // Remap boolean return type into i1
-    let value = value.map(|ret_val| {
-        // The "return type" of a sret function is in the first parameter
-        let expected_ty = if ctx.need_sret {
-            func.get_type().get_param_types()[0]
-        } else {
-            func.get_type().get_return_type().unwrap()
-        };
-
-        if matches!(expected_ty, BasicTypeEnum::IntType(ty) if ty.get_bit_width() == 1) {
-            generator.bool_to_i1(ctx, ret_val.into_int_value()).into()
-        } else {
-            ret_val
-        }
-    });
-
     if let Some(return_target) = ctx.return_target {
         if let Some(value) = value {
             ctx.builder.build_store(ctx.return_buffer.unwrap(), value).unwrap();
@@ -1746,6 +1719,25 @@ pub fn gen_return<G: CodeGenerator>(
         ctx.builder.build_store(ctx.return_buffer.unwrap(), value.unwrap()).unwrap();
         ctx.builder.build_return(None).unwrap();
     } else {
+        // Remap boolean return type into i1
+        let value = value.map(|v| {
+            let expected_ty = func.get_type().get_return_type().unwrap();
+            let ret_val = v.as_basic_value_enum();
+
+            if expected_ty.is_int_type() && ret_val.is_int_value() {
+                let ret_type = expected_ty.into_int_type();
+                let ret_val = ret_val.into_int_value();
+
+                if ret_type.get_bit_width() == 1 && ret_val.get_type().get_bit_width() != 1 {
+                    generator.bool_to_i1(ctx, ret_val)
+                } else {
+                    ret_val
+                }
+                .into()
+            } else {
+                ret_val
+            }
+        });
         let value = value.as_ref().map(|v| v as &dyn BasicValue);
         ctx.builder.build_return(value).unwrap();
     }
@@ -1814,30 +1806,7 @@ pub fn gen_stmt<G: CodeGenerator>(
         StmtKind::Try { .. } => gen_try(generator, ctx, stmt)?,
         StmtKind::Raise { exc, .. } => {
             if let Some(exc) = exc {
-                let exn = if let ExprKind::Name { id, .. } = &exc.node {
-                    // Handle "raise Exception" short form
-                    let def_id = ctx.resolver.get_identifier_def(*id).map_err(|e| {
-                        format!("{} (at {})", e.iter().next().unwrap(), exc.location)
-                    })?;
-                    let def = ctx.top_level.definitions.read();
-                    let TopLevelDef::Class { constructor, .. } = *def[def_id.0].read() else {
-                        return Err(format!("Failed to resolve symbol {id} (at {})", exc.location));
-                    };
-
-                    let TypeEnum::TFunc(signature) =
-                        ctx.unifier.get_ty(constructor.unwrap()).as_ref().clone()
-                    else {
-                        return Err(format!("Failed to resolve symbol {id} (at {})", exc.location));
-                    };
-
-                    generator
-                        .gen_call(ctx, None, (&signature, def_id), Vec::default())?
-                        .map(Into::into)
-                } else {
-                    generator.gen_expr(ctx, exc)?
-                };
-
-                let exc = if let Some(v) = exn {
+                let exc = if let Some(v) = generator.gen_expr(ctx, exc)? {
                     v.to_basic_value_enum(ctx, generator, exc.custom.unwrap())?
                 } else {
                     return Ok(());

nac3core/src/toplevel/composer.rs

@@ -23,7 +23,7 @@ impl Default for ComposerConfig {
     }
 }
 
-pub type DefAst = (Arc<RwLock<TopLevelDef>>, Option<Stmt<()>>);
+type DefAst = (Arc<RwLock<TopLevelDef>>, Option<Stmt<()>>);
 pub struct TopLevelComposer {
     // list of top level definitions, same as top level context
     pub definition_ast_list: Vec<DefAst>,
@@ -1822,12 +1822,7 @@ impl TopLevelComposer {
                         if *name != init_str_id {
                             unreachable!("must be init function here")
                         }
-
-                        let all_inited = Self::get_all_assigned_field(
-                            object_id.0,
-                            definition_ast_list,
-                            body.as_slice(),
-                        )?;
+                        let all_inited = Self::get_all_assigned_field(body.as_slice())?;
                         for (f, _, _) in fields {
                             if !all_inited.contains(f) {
                                 return Err(HashSet::from([

nac3core/src/toplevel/helper.rs

@@ -3,7 +3,6 @@ use std::convert::TryInto;
 use crate::symbol_resolver::SymbolValue;
 use crate::toplevel::numpy::unpack_ndarray_var_tys;
 use crate::typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap};
-use ast::ExprKind;
 use nac3parser::ast::{Constant, Location};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
@@ -750,16 +749,7 @@ impl TopLevelComposer {
         )
     }
 
-    /// This function returns the fields that have been initialized in the `__init__` function of a class
-    /// The function takes as input:
-    ///  * `class_id`: The `object_id` of the class whose function is being evaluated (check `TopLevelDef::Class`)
-    ///  * `definition_ast_list`: A list of ast definitions and statements defined in `TopLevelComposer`
-    ///  * `stmts`: The body of function being parsed. Each statment is analyzed to check varaible initialization statements
-    pub fn get_all_assigned_field(
-        class_id: usize,
-        definition_ast_list: &Vec<DefAst>,
-        stmts: &[Stmt<()>],
-    ) -> Result<HashSet<StrRef>, HashSet<String>> {
+    pub fn get_all_assigned_field(stmts: &[Stmt<()>]) -> Result<HashSet<StrRef>, HashSet<String>> {
         let mut result = HashSet::new();
         for s in stmts {
             match &s.node {
@@ -795,138 +785,30 @@ impl TopLevelComposer {
                 // TODO: do not check for For and While?
                 ast::StmtKind::For { body, orelse, .. }
                 | ast::StmtKind::While { body, orelse, .. } => {
-                    result.extend(Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        body.as_slice(),
-                    )?);
-                    result.extend(Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        orelse.as_slice(),
-                    )?);
+                    result.extend(Self::get_all_assigned_field(body.as_slice())?);
+                    result.extend(Self::get_all_assigned_field(orelse.as_slice())?);
                 }
                 ast::StmtKind::If { body, orelse, .. } => {
-                    let inited_for_sure = Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        body.as_slice(),
-                    )?
-                    .intersection(&Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        orelse.as_slice(),
-                    )?)
-                    .copied()
-                    .collect::<HashSet<_>>();
+                    let inited_for_sure = Self::get_all_assigned_field(body.as_slice())?
+                        .intersection(&Self::get_all_assigned_field(orelse.as_slice())?)
+                        .copied()
+                        .collect::<HashSet<_>>();
                     result.extend(inited_for_sure);
                 }
                 ast::StmtKind::Try { body, orelse, finalbody, .. } => {
-                    let inited_for_sure = Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        body.as_slice(),
-                    )?
-                    .intersection(&Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        orelse.as_slice(),
-                    )?)
-                    .copied()
-                    .collect::<HashSet<_>>();
+                    let inited_for_sure = Self::get_all_assigned_field(body.as_slice())?
+                        .intersection(&Self::get_all_assigned_field(orelse.as_slice())?)
+                        .copied()
+                        .collect::<HashSet<_>>();
                     result.extend(inited_for_sure);
-                    result.extend(Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        finalbody.as_slice(),
-                    )?);
+                    result.extend(Self::get_all_assigned_field(finalbody.as_slice())?);
                 }
                 ast::StmtKind::With { body, .. } => {
-                    result.extend(Self::get_all_assigned_field(
-                        class_id,
-                        definition_ast_list,
-                        body.as_slice(),
-                    )?);
-                }
-                // Variables Initialized in function calls
-                ast::StmtKind::Expr { value, .. } => {
-                    let ExprKind::Call { func, .. } = &value.node else {
-                        continue;
-                    };
-                    let ExprKind::Attribute { value, attr, .. } = &func.node else {
-                        continue;
-                    };
-                    let ExprKind::Name { id, .. } = &value.node else {
-                        continue;
-                    };
-                    // Need to consider the two cases:
-                    //  Case 1) Call to class function i.e. id = `self`
-                    //  Case 2) Call to class ancestor function i.e. id = ancestor_name
-                    // We leave checking whether function in case 2 belonged to class ancestor or not to type checker
-                    //
-                    // According to current handling of `self`, function definition are fixed and do not change regardless
-                    // of which object is passed as `self` i.e. virtual polymorphism is not supported
-                    // Therefore, we change class id for case 2 to reflect behavior of our compiler
-
-                    let class_name = if *id == "self".into() {
-                        let ast::StmtKind::ClassDef { name, .. } =
-                            &definition_ast_list[class_id].1.as_ref().unwrap().node
-                        else {
-                            unreachable!()
-                        };
-                        name
-                    } else {
-                        id
-                    };
-
-                    let parent_method = definition_ast_list.iter().find_map(|def| {
-                        let (
-                            class_def,
-                            Some(ast::Located {
-                                node: ast::StmtKind::ClassDef { name, body, .. },
-                                ..
-                            }),
-                        ) = &def
-                        else {
-                            return None;
-                        };
-                        let TopLevelDef::Class { object_id: class_id, .. } = &*class_def.read()
-                        else {
-                            unreachable!()
-                        };
-
-                        if name == class_name {
-                            body.iter().find_map(|m| {
-                                let ast::StmtKind::FunctionDef { name, body, .. } = &m.node else {
-                                    return None;
-                                };
-                                if *name == *attr {
-                                    return Some((body.clone(), class_id.0));
-                                }
-                                None
-                            })
-                        } else {
-                            None
-                        }
-                    });
-
-                    // If method body is none then method does not exist
-                    if let Some((method_body, class_id)) = parent_method {
-                        result.extend(Self::get_all_assigned_field(
-                            class_id,
-                            definition_ast_list,
-                            method_body.as_slice(),
-                        )?);
-                    } else {
-                        return Err(HashSet::from([format!(
-                            "{}.{} not found in class {class_name} at {}",
-                            *id, *attr, value.location
-                        )]));
-                    }
+                    result.extend(Self::get_all_assigned_field(body.as_slice())?);
                 }
                 ast::StmtKind::Pass { .. }
                 | ast::StmtKind::Assert { .. }
-                | ast::StmtKind::AnnAssign { .. } => {}
+                | ast::StmtKind::Expr { .. } => {}
 
                 _ => {
                     unimplemented!()

nac3core/src/typecheck/magic_methods.rs

@@ -520,23 +520,6 @@ pub fn typeof_binop(
         }
 
         Operator::MatMult => {
-            // NOTE: NumPy matmul's LHS and RHS must both be ndarrays. Scalars are not allowed.
-            match (&*unifier.get_ty(lhs), &*unifier.get_ty(rhs)) {
-                (
-                    TypeEnum::TObj { obj_id: lhs_obj_id, .. },
-                    TypeEnum::TObj { obj_id: rhs_obj_id, .. },
-                ) if *lhs_obj_id == primitives.ndarray.obj_id(unifier).unwrap()
-                    && *rhs_obj_id == primitives.ndarray.obj_id(unifier).unwrap() =>
-                {
-                    // LHS and RHS have valid types
-                }
-                _ => {
-                    let lhs_str = unifier.stringify(lhs);
-                    let rhs_str = unifier.stringify(rhs);
-                    return Err(format!("ndarray.__matmul__ only accepts ndarray operands, but left operand has type {lhs_str}, and right operand has type {rhs_str}"));
-                }
-            }
-
             let (_, lhs_ndims) = unpack_ndarray_var_tys(unifier, lhs);
             let lhs_ndims = match &*unifier.get_ty_immutable(lhs_ndims) {
                 TypeEnum::TLiteral { values, .. } => {

nac3core/src/typecheck/type_inferencer/mod.rs

@@ -12,7 +12,6 @@ use super::{
         RecordField, RecordKey, Type, TypeEnum, TypeVar, Unifier, VarMap,
     },
 };
-use crate::toplevel::type_annotation::TypeAnnotation;
 use crate::{
     symbol_resolver::{SymbolResolver, SymbolValue},
     toplevel::{
@@ -103,7 +102,6 @@ pub struct Inferencer<'a> {
 }
 
 type InferenceError = HashSet<String>;
-type OverrideResult = Result<Option<ast::Expr<Option<Type>>>, InferenceError>;
 
 struct NaiveFolder();
 impl Fold<()> for NaiveFolder {
@@ -1713,86 +1711,6 @@ impl<'a> Inferencer<'a> {
         Ok(None)
     }
 
-    /// Checks whether a class method is calling parent function
-    /// Returns [`None`] if its not a call to parent method, otherwise
-    /// returns a new `func` with class name replaced by `self` and method resolved to its `DefinitionID`
-    ///
-    /// e.g.  A.f1(self, ...) returns Some(self.{DefintionID(f1)})
-    fn check_overriding(&mut self, func: &ast::Expr<()>, args: &[ast::Expr<()>]) -> OverrideResult {
-        // `self` must be first argument for call to parent method
-        if let Some(Located { node: ExprKind::Name { id, .. }, .. }) = &args.first() {
-            if *id != "self".into() {
-                return Ok(None);
-            }
-        } else {
-            return Ok(None);
-        }
-
-        let Located {
-            node: ExprKind::Attribute { value, attr: method_name, ctx }, location, ..
-        } = func
-        else {
-            return Ok(None);
-        };
-        let ExprKind::Name { id: class_name, ctx: class_ctx } = &value.node else {
-            return Ok(None);
-        };
-        let zelf = &self.fold_expr(args[0].clone())?;
-
-        // Check whether the method belongs to class ancestors
-        let def_id = self.unifier.get_ty(zelf.custom.unwrap());
-        let TypeEnum::TObj { obj_id, .. } = def_id.as_ref() else { unreachable!() };
-        let defs = self.top_level.definitions.read();
-        let res = {
-            if let TopLevelDef::Class { ancestors, .. } = &*defs[obj_id.0].read() {
-                let res = ancestors.iter().find_map(|f| {
-                    let TypeAnnotation::CustomClass { id, .. } = f else { unreachable!() };
-                    let TopLevelDef::Class { name, methods, .. } = &*defs[id.0].read() else {
-                        unreachable!()
-                    };
-                    // Class names are stored as `__module__.class`
-                    let name = name.to_string();
-                    let (_, name) = name.rsplit_once('.').unwrap();
-                    if name == class_name.to_string() {
-                        return methods.iter().find_map(|f| {
-                            if f.0 == *method_name {
-                                return Some(*f);
-                            }
-                            None
-                        });
-                    }
-                    None
-                });
-                res
-            } else {
-                None
-            }
-        };
-
-        match res {
-            Some(r) => {
-                let mut new_func = func.clone();
-                let mut new_value = value.clone();
-                new_value.node = ExprKind::Name { id: "self".into(), ctx: *class_ctx };
-                new_func.node =
-                    ExprKind::Attribute { value: new_value.clone(), attr: *method_name, ctx: *ctx };
-
-                let mut new_func = self.fold_expr(new_func)?;
-
-                let ExprKind::Attribute { value, .. } = new_func.node else { unreachable!() };
-                new_func.node =
-                    ExprKind::Attribute { value, attr: r.2 .0.to_string().into(), ctx: *ctx };
-                new_func.custom = Some(r.1);
-
-                Ok(Some(new_func))
-            }
-            None => report_error(
-                format!("Ancestor method [{class_name}.{method_name}] should be defined with same decorator as its overridden version").as_str(),
-                *location,
-            ),
-        }
-    }
-
     fn fold_call(
         &mut self,
         location: Location,
@@ -1806,20 +1724,8 @@ impl<'a> Inferencer<'a> {
             return Ok(spec_call_func);
         }
 
-        // Check for call to parent method
-        let override_res = self.check_overriding(&func, &args)?;
-        let is_override = override_res.is_some();
-        let func = if is_override { override_res.unwrap() } else { self.fold_expr(func)? };
-        let func = Box::new(func);
-
-        let mut args =
-            args.into_iter().map(|v| self.fold_expr(v)).collect::<Result<Vec<_>, _>>()?;
-
-        // TODO: Handle passing of self to functions to allow runtime lookup of functions to be called
-        // Currently removing `self` and using compile time function definitions
-        if is_override {
-            args.remove(0);
-        }
+        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
             .into_iter()
             .map(|v| fold::fold_keyword(self, v))

nac3standalone/demo/demo.c

@@ -7,11 +7,11 @@
 #include <string.h>
 
 double dbl_nan(void) {
-    return NAN;
+  return NAN;
 }
 
 double dbl_inf(void) {
-    return INFINITY;
+  return INFINITY;
 }
 
 void output_bool(bool x) {
@@ -19,19 +19,19 @@ void output_bool(bool x) {
 }
 
 void output_int32(int32_t x) {
-    printf("%" PRId32 "\n", x);
+    printf("%"PRId32"\n", x);
 }
 
 void output_int64(int64_t x) {
-    printf("%" PRId64 "\n", x);
+    printf("%"PRId64"\n", x);
 }
 
 void output_uint32(uint32_t x) {
-    printf("%" PRIu32 "\n", x);
+    printf("%"PRIu32"\n", x);
 }
 
 void output_uint64(uint64_t x) {
-    printf("%" PRIu64 "\n", x);
+    printf("%"PRIu64"\n", x);
 }
 
 void output_float64(double x) {
@@ -52,7 +52,7 @@ void output_range(int32_t range[3]) {
 }
 
 void output_asciiart(int32_t x) {
-    static const char* chars = " .,-:;i+hHM$*#@    ";
+    static const char *chars = " .,-:;i+hHM$*#@    ";
     if (x < 0) {
         putchar('\n');
     } else {
@@ -61,12 +61,12 @@ void output_asciiart(int32_t x) {
 }
 
 struct cslice {
-    void* data;
+    void *data;
     size_t len;
 };
 
-void output_int32_list(struct cslice* slice) {
-    const int32_t* data = (int32_t*)slice->data;
+void output_int32_list(struct cslice *slice) {
+    const int32_t *data = (int32_t *) slice->data;
 
     putchar('[');
     for (size_t i = 0; i < slice->len; ++i) {
@@ -80,23 +80,23 @@ void output_int32_list(struct cslice* slice) {
     putchar('\n');
 }
 
-void output_str(struct cslice* slice) {
-    const char* data = (const char*)slice->data;
+void output_str(struct cslice *slice) {
+    const char *data = (const char *) slice->data;
 
     for (size_t i = 0; i < slice->len; ++i) {
         putchar(data[i]);
     }
 }
 
-void output_strln(struct cslice* slice) {
+void output_strln(struct cslice *slice) {
     output_str(slice);
     putchar('\n');
 }
 
-uint64_t dbg_stack_address(__attribute__((unused)) struct cslice* slice) {
+uint64_t dbg_stack_address(__attribute__((unused)) struct cslice *slice) {
     int i;
-    void* ptr = (void*)&i;
-    return (uintptr_t)ptr;
+    void *ptr = (void *) &i;
+    return (uintptr_t) ptr;
 }
 
 uint32_t __nac3_personality(uint32_t state, uint32_t exception_object, uint32_t context) {
@@ -119,12 +119,11 @@ struct Exception {
 
 uint32_t __nac3_raise(struct Exception* e) {
     printf("__nac3_raise called. Exception details:\n");
-    printf("          ID: %" PRIu32 "\n", e->id);
-    printf("    Location: %*s:%" PRIu32 ":%" PRIu32 "\n", (int)e->file.len, (const char*)e->file.data, e->line,
-           e->column);
-    printf("    Function: %*s\n", (int)e->function.len, (const char*)e->function.data);
-    printf("     Message: \"%*s\"\n", (int)e->message.len, (const char*)e->message.data);
-    printf("      Params: {0}=%" PRId64 ", {1}=%" PRId64 ", {2}=%" PRId64 "\n", e->param[0], e->param[1], e->param[2]);
+    printf("          ID: %"PRIu32"\n", e->id);
+    printf("    Location: %*s:%"PRIu32":%"PRIu32"\n" , (int) e->file.len, (const char*) e->file.data, e->line, e->column);
+    printf("    Function: %*s\n" , (int) e->function.len, (const char*) e->function.data);
+    printf("     Message: \"%*s\"\n" , (int) e->message.len, (const char*) e->message.data);
+    printf("      Params: {0}=%"PRId64", {1}=%"PRId64", {2}=%"PRId64"\n", e->param[0], e->param[1], e->param[2]);
     exit(101);
     __builtin_unreachable();
 }

nac3standalone/demo/src/assignment.py

@@ -9,7 +9,6 @@ def output_bool(x: bool):
 def example1():
     x, *ys, z = (1, 2, 3, 4, 5)
     output_int32(x)
-    output_int32(len(ys))
     output_int32(ys[0])
     output_int32(ys[1])
     output_int32(ys[2])
@@ -19,14 +18,12 @@ def example2():
     x, y, *zs = (1, 2, 3, 4, 5)
     output_int32(x)
     output_int32(y)
-    output_int32(len(zs))
     output_int32(zs[0])
     output_int32(zs[1])
     output_int32(zs[2])
 
 def example3():
     *xs, y, z = (1, 2, 3, 4, 5)
-    output_int32(len(xs))
     output_int32(xs[0])
     output_int32(xs[1])
     output_int32(xs[2])
@@ -34,12 +31,6 @@ def example3():
     output_int32(z)
 
 def example4():
-    *xs, y, z = (4, 5)
-    output_int32(len(xs))
-    output_int32(y)
-    output_int32(z)
-
-def example5():
     # Example from: https://docs.python.org/3/reference/simple_stmts.html#assignment-statements
     x = [0, 1]
     i = 0
@@ -53,7 +44,7 @@ class A:
     def __init__(self):
         self.value = 1000
 
-def example6():
+def example5():
     ws = [88, 7, 8]
     a = A()
     x, [y, *ys, a.value], ws[0], (ws[0],) = 1, (2, False, 4, 5), 99, (6,)
@@ -72,5 +63,4 @@ def run() -> int32:
     example3()
     example4()
     example5()
-    example6()
     return 0

nac3standalone/demo/src/inheritance.py

@@ -10,58 +10,23 @@ class A:
     def __init__(self, a: int32):
         self.a = a
     
-    def output_all_fields(self):
-        output_int32(self.a)
+    def f1(self):
+        self.f2()
     
-    def set_a(self, a: int32):
-        self.a = a
+    def f2(self):
+        output_int32(self.a)
 
 class B(A):
     b: int32
 
     def __init__(self, b: int32):
-        A.__init__(self, b + 1)
-        self.set_b(b)
-    
-    def output_parent_fields(self):
-        A.output_all_fields(self)
-
-    def output_all_fields(self):
-        A.output_all_fields(self)
-        output_int32(self.b)
-    
-    def set_b(self, b: int32):
+        self.a = b + 1
         self.b = b
 
-class C(B):
-    c: int32
-
-    def __init__(self, c: int32):
-        B.__init__(self, c + 1)
-        self.c = c
-    
-    def output_parent_fields(self):
-        B.output_all_fields(self)
-
-    def output_all_fields(self):
-        B.output_all_fields(self)
-        output_int32(self.c)
-    
-    def set_c(self, c: int32):
-        self.c = c
 
 def run() -> int32:
-    ccc = C(10)
-    ccc.output_all_fields()
-    ccc.set_a(1)
-    ccc.set_b(2)
-    ccc.set_c(3)
-    ccc.output_all_fields()
-
-    bbb = B(10)
-    bbb.set_a(9)
-    bbb.set_b(8)
-    bbb.output_all_fields()
-    ccc.output_all_fields()
-
+    aaa = A(5)
+    bbb = B(2)
+    aaa.f1()
+    bbb.f1()
     return 0

nac3standalone/src/basic_symbol_resolver.rs

@@ -15,6 +15,7 @@ use std::{collections::HashMap, sync::Arc};
 pub struct ResolverInternal {
     pub id_to_type: Mutex<HashMap<StrRef, Type>>,
     pub id_to_def: Mutex<HashMap<StrRef, DefinitionId>>,
+    pub class_names: Mutex<HashMap<StrRef, Type>>,
     pub module_globals: Mutex<HashMap<StrRef, SymbolValue>>,
     pub str_store: Mutex<HashMap<String, i32>>,
 }

nac3standalone/src/main.rs

@@ -14,6 +14,7 @@ use inkwell::{
     memory_buffer::MemoryBuffer, passes::PassBuilderOptions, support::is_multithreaded, targets::*,
     OptimizationLevel,
 };
+use nac3core::codegen::irrt::setup_irrt_exceptions;
 use nac3core::{
     codegen::{
         concrete_type::ConcreteTypeStore, irrt::load_irrt, CodeGenLLVMOptions,
@@ -306,6 +307,7 @@ fn main() {
     let internal_resolver: Arc<ResolverInternal> = ResolverInternal {
         id_to_type: builtins_ty.into(),
         id_to_def: builtins_def.into(),
+        class_names: Mutex::default(),
         module_globals: Mutex::default(),
         str_store: Mutex::default(),
     }
@@ -316,7 +318,8 @@ fn main() {
     let context = inkwell::context::Context::create();
 
     // Process IRRT
-    let irrt = load_irrt(&context, resolver.as_ref());
+    let irrt = load_irrt(&context);
+    setup_irrt_exceptions(&context, &irrt, resolver.as_ref());
     if emit_llvm {
         irrt.write_bitcode_to_path(Path::new("irrt.bc"));
     }