core: irrt ndarray setup

nac3core/irrt/irrt/ndarray/ndarray.hpp

@@ -0,0 +1,134 @@
+#pragma once
+
+#include <irrt/int_defs.hpp>
+#include <irrt/ndarray/ndarray_util.hpp>
+
+namespace {
+
+// The NDArray object. `SizeT` is the *signed* size type of this ndarray.
+//
+// NOTE: The order of fields is IMPORTANT. DON'T TOUCH IT
+//
+// Some resources you might find helpful:
+// - The official numpy implementations:
+//   - https://github.com/numpy/numpy/blob/735a477f0bc2b5b84d0e72d92f224bde78d4e069/doc/source/reference/c-api/types-and-structures.rst
+// - On strides (about reshaping, slicing, C-contagiousness, etc)
+//   - https://ajcr.net/stride-guide-part-1/.
+//   - https://ajcr.net/stride-guide-part-2/.
+//   - https://ajcr.net/stride-guide-part-3/.
+template <typename SizeT>
+struct NDArray {
+    // The underlying data this `ndarray` is pointing to.
+    //
+    // NOTE: Formally this should be of type `void *`, but clang
+    // translates `void *` to `i8 *` when run with `-S -emit-llvm`,
+    // so we will put `uint8_t *` here for clarity.
+    //
+    // This pointer should point to the first element of the ndarray directly
+    uint8_t *data;
+
+    // The number of bytes of a single element in `data`.
+    //
+    // The `SizeT` is treated as `unsigned`.
+    SizeT itemsize;
+
+    // The number of dimensions of this shape.
+    //
+    // The `SizeT` is treated as `unsigned`.
+    SizeT ndims;
+
+    // Array shape, with length equal to `ndims`.
+    //
+    // The `SizeT` is treated as `unsigned`.
+    //
+    // NOTE: `shape` can contain 0.
+    //   (those appear when the user makes an out of bounds slice into an ndarray, e.g., `np.zeros((3, 3))[400:].shape == (0, 3)`)
+    SizeT *shape;
+
+    // Array strides (stride value is in number of bytes, NOT number of elements), with length equal to `ndims`.
+    //
+    // The `SizeT` is treated as `signed`.
+    //
+    // NOTE: `strides` can have negative numbers.
+    //   (those appear when there is a slice with a negative step, e.g., `my_array[::-1]`)
+    SizeT *strides;
+
+    // Calculate the size/# of elements of an `ndarray`.
+    // This function corresponds to `np.size(<ndarray>)` or `ndarray.size`
+    SizeT size() {
+        return ndarray_util::calc_size_from_shape(ndims, shape);
+    }
+
+    // Calculate the number of bytes of its content of an `ndarray` *in its view*.
+    // This function corresponds to `ndarray.nbytes`
+    SizeT nbytes() {
+        return this->size() * itemsize;
+    }
+
+    // Set the strides of the ndarray with `ndarray_util::set_strides_by_shape`
+    void set_strides_by_shape() {
+        ndarray_util::set_strides_by_shape(itemsize, ndims, strides, shape);
+    }
+
+    uint8_t* get_pelement_by_indices(const SizeT *indices) {
+        uint8_t* element = data;
+        for (SizeT dim_i = 0; dim_i < ndims; dim_i++)
+            element += indices[dim_i] * strides[dim_i];
+        return element;
+    }
+
+    uint8_t* get_nth_pelement(SizeT nth) {
+        SizeT* indices = (SizeT*) __builtin_alloca(sizeof(SizeT) * this->ndims);
+        ndarray_util::set_indices_by_nth(this->ndims, this->shape, indices, nth);
+        return get_pelement_by_indices(indices);
+    }
+
+    // Get the pointer to the nth element of the ndarray as if it were flattened.
+    uint8_t* checked_get_nth_pelement(ErrorContext* errctx, SizeT nth) {
+        SizeT arr_size = this->size();
+        if (!(0 <= nth && nth < arr_size)) {
+            errctx->set_error(
+                errctx->error_ids->index_error,
+                "index {0} is out of bounds, valid range is {1} <= index < {2}",
+                nth, 0, arr_size
+            );
+            return 0;
+        }
+        return get_nth_pelement(nth);
+    }
+};
+}
+
+extern "C" {
+uint32_t __nac3_ndarray_size(NDArray<int32_t>* ndarray) {
+    return ndarray->size();
+}
+
+uint64_t __nac3_ndarray_size64(NDArray<int64_t>* ndarray) {
+    return ndarray->size();
+}
+
+uint32_t __nac3_ndarray_nbytes(NDArray<int32_t>* ndarray) {
+    return ndarray->nbytes();
+}
+
+uint64_t __nac3_ndarray_nbytes64(NDArray<int64_t>* ndarray) {
+    return ndarray->nbytes();
+}
+
+void __nac3_ndarray_util_assert_shape_no_negative(ErrorContext* errctx, int32_t ndims, int32_t* shape) {
+    ndarray_util::assert_shape_no_negative(errctx, ndims, shape);
+}
+
+void __nac3_ndarray_util_assert_shape_no_negative64(ErrorContext* errctx, int64_t ndims, int64_t* shape) {
+    ndarray_util::assert_shape_no_negative(errctx, ndims, shape);
+}
+
+void __nac3_ndarray_set_strides_by_shape(NDArray<int32_t>* ndarray) {
+    ndarray->set_strides_by_shape();
+}
+
+void __nac3_ndarray_set_strides_by_shape64(NDArray<int64_t>* ndarray) {
+    ndarray->set_strides_by_shape();
+}
+}

nac3core/irrt/irrt/ndarray/ndarray_util.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <irrt/int_defs.hpp>
+
+namespace {
+namespace ndarray_util {
+
+// Throw an error if there is an axis with negative dimension
+template <typename SizeT>
+void assert_shape_no_negative(ErrorContext* errctx, SizeT ndims, const SizeT* shape) {
+    for (SizeT axis = 0; axis < ndims; axis++) {
+        if (shape[axis] < 0) {
+            errctx->set_error(
+                errctx->error_ids->value_error,
+                "negative dimensions are not allowed; axis {0} has dimension {1}",
+                axis, shape[axis]
+            );
+            return;
+        }
+    }
+}
+
+// Compute the size/# of elements of an ndarray given its 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];
+    return size;
+}
+
+// Compute the strides of an ndarray given an ndarray `shape`
+// and assuming that the ndarray is *fully C-contagious*.
+//
+// You might want to read up on https://ajcr.net/stride-guide-part-1/.
+template <typename SizeT>
+void set_strides_by_shape(SizeT itemsize, SizeT ndims, SizeT* dst_strides, const SizeT* shape) {
+    SizeT stride_product = 1;
+    for (SizeT i = 0; i < ndims; i++) {
+        int axis = ndims - i - 1;
+        dst_strides[axis] = stride_product * itemsize;
+        stride_product *= shape[axis];
+    }
+}
+
+template <typename SizeT>
+void set_indices_by_nth(SizeT ndims, const SizeT* shape, SizeT* indices, SizeT nth) {
+    for (int32_t i = 0; i < ndims; i++) {
+        int32_t axis = ndims - i - 1;
+        int32_t dim = shape[axis];
+
+        indices[axis] = nth % dim;
+        nth /= dim;
+    }
+}
+
+template <typename SizeT>
+bool can_broadcast_shape_to(
+    const SizeT target_ndims,
+    const SizeT *target_shape,
+    const SizeT src_ndims,
+    const SizeT *src_shape
+) {
+    /*
+        // See https://numpy.org/doc/stable/user/basics.broadcasting.html
+
+        This function handles this example:
+        ```
+        Image  (3d array): 256 x 256 x 3
+        Scale  (1d array):             3
+        Result (3d array): 256 x 256 x 3
+        ```
+
+        Other interesting examples to consider:
+        - `can_broadcast_shape_to([3], [1, 1, 1, 1, 3]) == true`
+        - `can_broadcast_shape_to([3], [3, 1]) == false`
+        - `can_broadcast_shape_to([256, 256, 3], [256, 1, 3]) == true`
+
+        In cases when the shapes contain zero(es):
+        - `can_broadcast_shape_to([0], [1]) == true`
+        - `can_broadcast_shape_to([0], [2]) == false`
+        - `can_broadcast_shape_to([0, 4, 0, 0], [1]) == true`
+        - `can_broadcast_shape_to([0, 4, 0, 0], [1, 1, 1, 1]) == true`
+        - `can_broadcast_shape_to([0, 4, 0, 0], [1, 4, 1, 1]) == true`
+        - `can_broadcast_shape_to([4, 3], [0, 3]) == false`
+        - `can_broadcast_shape_to([4, 3], [0, 0]) == false`
+    */
+
+    // This is essentially doing the following in Python:
+    // `for target_dim, src_dim in itertools.zip_longest(target_shape[::-1], src_shape[::-1], fillvalue=1)`
+    for (SizeT i = 0; i < max(target_ndims, src_ndims); i++) {
+        SizeT target_axis = target_ndims - i - 1;
+        SizeT src_axis = src_ndims - i - 1;
+
+        bool target_dim_exists = target_axis >= 0;
+        bool src_dim_exists = src_axis >= 0;
+
+        SizeT target_dim = target_dim_exists ? target_shape[target_axis] : 1;
+        SizeT src_dim = src_dim_exists ? src_shape[src_axis] : 1;
+
+        bool ok = src_dim == 1 || target_dim == src_dim;
+        if (!ok) return false;
+    }
+
+    return true;
+}
+}
+}

nac3core/irrt/irrt_everything.hpp

@@ -3,4 +3,5 @@
 #include <irrt/core.hpp>
 #include <irrt/error_context.hpp>
 #include <irrt/int_defs.hpp>
-#include <irrt/utils.hpp>
+#include <irrt/utils.hpp>
+#include <irrt/ndarray/ndarray.hpp>

nac3core/src/codegen/irrt/classes.rs

@@ -1,6 +1,11 @@
-use inkwell::types::{BasicTypeEnum, IntType};
+use inkwell::types::IntType;
 
-use crate::codegen::optics::{AddressLens, FieldBuilder, GepGetter, IntLens, StructureOptic};
+use crate::codegen::{
+    optics::{
+        Address, AddressLens, ArraySlice, FieldBuilder, GepGetter, IntLens, Optic, StructureOptic,
+    },
+    CodeGenContext,
+};
 
 #[derive(Debug, Clone)]
 pub struct StrLens<'ctx> {
@@ -36,13 +41,18 @@ pub struct NpArrayFields<'ctx> {
     pub strides: GepGetter<AddressLens<IntLens<'ctx>>>,
 }
 
+// Note: NpArrayLens's ElementOptic is purely for type-safety and type-guidances
+// The underlying LLVM ndarray doesn't care, it only holds an opaque (uint8_t*) pointer to the elements.
 #[derive(Debug, Clone, Copy)]
-pub struct NpArrayLens<'ctx> {
+pub struct NpArrayLens<'ctx, ElementOptic> {
     pub size_type: IntType<'ctx>,
-    pub elem_type: BasicTypeEnum<'ctx>,
+    pub element_optic: ElementOptic,
 }
 
-impl<'ctx> StructureOptic<'ctx> for NpArrayLens<'ctx> {
+// NDArray is *frequently* used, so here is a type alias
+pub type NpArray<'ctx, ElementOptic> = Address<'ctx, NpArrayLens<'ctx, ElementOptic>>;
+
+impl<'ctx, ElementOptic: Optic<'ctx>> StructureOptic<'ctx> for NpArrayLens<'ctx, ElementOptic> {
     type Fields = NpArrayFields<'ctx>;
 
     fn struct_name(&self) -> &'static str {
@@ -63,6 +73,21 @@ impl<'ctx> StructureOptic<'ctx> for NpArrayLens<'ctx> {
     }
 }
 
+// Other convenient utilities for NpArray
+impl<'ctx, ElementOptic: Optic<'ctx>> NpArray<'ctx, ElementOptic> {
+    pub fn shape_array(&self, ctx: &CodeGenContext<'ctx, '_>) -> ArraySlice<'ctx, IntLens<'ctx>> {
+        let ndims = self.focus(ctx, |fields| &fields.ndims).load(ctx, "ndims");
+        let shape_base_ptr = self.focus(ctx, |fields| &fields.shape).load(ctx, "shape");
+        ArraySlice { num_elements: ndims, base: shape_base_ptr }
+    }
+
+    pub fn strides_array(&self, ctx: &CodeGenContext<'ctx, '_>) -> ArraySlice<'ctx, IntLens<'ctx>> {
+        let ndims = self.focus(ctx, |fields| &fields.ndims).load(ctx, "ndims");
+        let strides_base_ptr = self.focus(ctx, |fields| &fields.strides).load(ctx, "strides");
+        ArraySlice { num_elements: ndims, base: strides_base_ptr }
+    }
+}
+
 pub struct IrrtStringFields<'ctx> {
     pub buffer: GepGetter<AddressLens<IntLens<'ctx>>>,
     pub capacity: GepGetter<IntLens<'ctx>>,

nac3core/src/codegen/irrt/mod.rs

@@ -1,5 +1,6 @@
 use crate::typecheck::typedef::Type;
 
+pub mod numpy;
 mod test;
 
 use super::{

nac3core/src/codegen/irrt/new.rs

@@ -19,7 +19,8 @@ fn get_size_variant(ty: IntType) -> SizeVariant {
     }
 }
 
-fn get_sized_dependent_function_name(ty: IntType, fn_name: &str) -> String {
+#[must_use]
+pub fn get_sized_dependent_function_name(ty: IntType, fn_name: &str) -> String {
     let mut fn_name = fn_name.to_owned();
     match get_size_variant(ty) {
         SizeVariant::Bits32 => {

nac3core/src/codegen/irrt/numpy.rs

@@ -0,0 +1,354 @@
+use std::marker::PhantomData;
+
+use inkwell::{
+    types::BasicType,
+    values::{BasicValueEnum, IntValue},
+};
+
+use crate::{
+    codegen::{
+        classes::{ListValue, UntypedArrayLikeAccessor},
+        optics::{Address, AddressLens, ArraySlice, IntLens, Ixed, Optic},
+        stmt::gen_for_callback_incrementing,
+        CodeGenContext, CodeGenerator,
+    },
+    typecheck::typedef::{Type, TypeEnum},
+};
+
+use super::{
+    classes::{ErrorContextLens, NpArray, NpArrayLens},
+    new::{
+        check_error_context, get_sized_dependent_function_name, prepare_error_context,
+        FunctionBuilder,
+    },
+};
+
+type ProducerWriteToArray<'ctx, G, ElementOptic> = Box<
+    dyn Fn(
+            &mut G,
+            &mut CodeGenContext<'ctx, '_>,
+            &ArraySlice<'ctx, ElementOptic>,
+        ) -> Result<(), String>
+        + 'ctx,
+>;
+
+struct Producer<'ctx, G: CodeGenerator + ?Sized, ElementOptic> {
+    pub count: IntValue<'ctx>,
+    pub write_to_array: ProducerWriteToArray<'ctx, G, ElementOptic>,
+}
+
+/// TODO: UPDATE DOCUMENTATION
+/// LLVM-typed implementation for generating a [`Producer`] that sets a list of ints.
+///
+/// * `elem_ty` - The element type of the `NDArray`.
+/// * `shape` - The `shape` parameter used to construct the `NDArray`.
+///
+/// ### Notes on `shape`
+///
+/// Just like numpy, the `shape` argument can be:
+///   1. A list of `int32`;   e.g., `np.empty([600, 800, 3])`
+///   2. A tuple of `int32`;  e.g., `np.empty((600, 800, 3))`
+///   3. A scalar `int32`;     e.g., `np.empty(3)`, this is functionally equivalent to `np.empty([3])`
+///
+/// See also [`typecheck::type_inferencer::fold_numpy_function_call_shape_argument`] to
+/// learn how `shape` gets from being a Python user expression to here.
+fn parse_input_shape_arg<'ctx, G>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    shape: BasicValueEnum<'ctx>,
+    shape_ty: Type,
+) -> Producer<'ctx, G, IntLens<'ctx>>
+where
+    G: CodeGenerator + ?Sized,
+{
+    let size_type = generator.get_size_type(ctx.ctx);
+
+    match &*ctx.unifier.get_ty(shape_ty) {
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // 1. A list of ints; e.g., `np.empty([600, 800, 3])`
+
+            // A list has to be a PointerValue
+            let shape_list = ListValue::from_ptr_val(shape.into_pointer_value(), size_type, None);
+
+            // Create `Producer`
+            let ndims = shape_list.load_size(ctx, Some("count"));
+            Producer {
+                count: ndims,
+                write_to_array: Box::new(move |ctx, generator, dst_array| {
+                    // Basically iterate through the list and write to `dst_slice` accordingly
+                    let init_val = size_type.const_zero();
+                    let max_val = (ndims, false);
+                    let incr_val = size_type.const_int(1, false);
+                    gen_for_callback_incrementing(
+                        ctx,
+                        generator,
+                        init_val,
+                        max_val,
+                        |generator, ctx, _hooks, axis| {
+                            // Get the dimension at `axis`
+                            let dim =
+                                shape_list.data().get(ctx, generator, &axis, None).into_int_value();
+
+                            // Cast `dim` to SizeT
+                            let dim = ctx
+                                .builder
+                                .build_int_s_extend_or_bit_cast(dim, size_type, "dim_casted")
+                                .unwrap();
+
+                            // Write
+                            dst_array.ix(ctx, axis, "dim").store(ctx, &dim);
+                            Ok(())
+                        },
+                        incr_val,
+                    )
+                }),
+            }
+        }
+        TypeEnum::TTuple { ty: tuple_types } => {
+            // 2. A tuple of ints; e.g., `np.empty((600, 800, 3))`
+
+            // Get the length/size of the tuple, which also happens to be the value of `ndims`.
+            let ndims = tuple_types.len();
+
+            // A tuple has to be a StructValue
+            // Read [`codegen::expr::gen_expr`] to see how `nac3core` translates a Python tuple into LLVM.
+            let shape_tuple = shape.into_struct_value();
+
+            Producer {
+                count: size_type.const_int(ndims as u64, false),
+                write_to_array: Box::new(move |_generator, ctx, dst_array| {
+                    for axis in 0..ndims {
+                        // Get the dimension at `axis`
+                        let dim = ctx
+                            .builder
+                            .build_extract_value(
+                                shape_tuple,
+                                axis as u32,
+                                format!("dim{axis}").as_str(),
+                            )
+                            .unwrap()
+                            .into_int_value();
+
+                        // Cast `dim` to SizeT
+                        let dim = ctx
+                            .builder
+                            .build_int_s_extend_or_bit_cast(dim, size_type, "dim_casted")
+                            .unwrap();
+
+                        // Write
+                        dst_array
+                            .ix(ctx, size_type.const_int(axis as u64, false), "dim")
+                            .store(ctx, &dim);
+                    }
+                    Ok(())
+                }),
+            }
+        }
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.int32.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // 3. A scalar int; e.g., `np.empty(3)`, this is functionally equivalent to `np.empty([3])`
+
+            // The value has to be an integer
+            let shape_int = shape.into_int_value();
+
+            Producer {
+                count: size_type.const_int(1, false),
+                write_to_array: Box::new(move |_generator, ctx, dst_array| {
+                    // Cast `shape_int` to SizeT
+                    let dim = ctx
+                        .builder
+                        .build_int_s_extend_or_bit_cast(shape_int, size_type, "dim_casted")
+                        .unwrap();
+
+                    // Write
+                    dst_array
+                        .ix(ctx, size_type.const_zero() /* Only index 0 is set */, "dim")
+                        .store(ctx, &dim);
+
+                    Ok(())
+                }),
+            }
+        }
+        _ => panic!("parse_input_shape_arg encountered unknown type"),
+    }
+}
+
+pub fn alloca_ndarray<'ctx, G, ElementOptic: Optic<'ctx>>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    element_optic: ElementOptic,
+    ndims: IntValue<'ctx>,
+    name: &str,
+) -> Result<NpArray<'ctx, ElementOptic>, String>
+where
+    G: CodeGenerator + ?Sized,
+{
+    let size_type = generator.get_size_type(ctx.ctx);
+
+    let itemsize = element_optic.get_llvm_type(ctx.ctx).size_of().unwrap();
+    let itemsize =
+        ctx.builder.build_int_s_extend_or_bit_cast(itemsize, size_type, "itemsize").unwrap();
+
+    let shape = ctx.builder.build_array_alloca(size_type, ndims, "shape").unwrap();
+    let strides = ctx.builder.build_array_alloca(size_type, ndims, "strides").unwrap();
+
+    let ndarray = NpArrayLens { size_type, element_optic }.alloca(ctx, name);
+
+    // Set ndims, itemsize; and allocate shape and store on the stack
+    ndarray.focus(ctx, |fields| &fields.ndims).store(ctx, &ndims);
+    ndarray.focus(ctx, |fields| &fields.itemsize).store(ctx, &itemsize);
+    ndarray
+        .focus(ctx, |fields| &fields.shape)
+        .store(ctx, &Address { addressee_optic: IntLens(size_type), address: shape });
+    ndarray
+        .focus(ctx, |fields| &fields.strides)
+        .store(ctx, &Address { addressee_optic: IntLens(size_type), address: strides });
+
+    Ok(ndarray)
+}
+
+enum NDArrayInitMode<'ctx, G: CodeGenerator + ?Sized> {
+    NDim { ndim: IntValue<'ctx>, _phantom: PhantomData<&'ctx G> },
+    Shape { shape: Producer<'ctx, G, IntLens<'ctx>> },
+    ShapeAndAllocaData { shape: Producer<'ctx, G, IntLens<'ctx>> },
+}
+
+/// TODO: DOCUMENT ME
+fn alloca_ndarray_and_init<'ctx, G, ElementOptic: Optic<'ctx>>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    element_optic: ElementOptic,
+    init_mode: NDArrayInitMode<'ctx, G>,
+    name: &str,
+) -> Result<NpArray<'ctx, ElementOptic>, String>
+where
+    G: CodeGenerator + ?Sized,
+{
+    // It is implemented verbosely in order to make the initialization modes super clear in their intent.
+    match init_mode {
+        NDArrayInitMode::NDim { ndim: ndims, _phantom } => {
+            let ndarray = alloca_ndarray(generator, ctx, element_optic, ndims, name)?;
+            Ok(ndarray)
+        }
+        NDArrayInitMode::Shape { shape } => {
+            let ndims = shape.count;
+            let ndarray = alloca_ndarray(generator, ctx, element_optic, ndims, name)?;
+
+            // Fill `ndarray.shape`
+            (shape.write_to_array)(generator, ctx, &ndarray.shape_array(ctx))?;
+
+            // Check if `shape` has bad inputs
+            call_nac3_ndarray_util_assert_shape_no_negative(
+                generator,
+                ctx,
+                ndims,
+                &ndarray.focus(ctx, |fields| &fields.shape).load(ctx, "shape"),
+            );
+
+            // NOTE: DO NOT DO `set_strides_by_shape` HERE.
+            // Simply this is because we specified that `SetShape` wouldn't do `set_strides_by_shape`
+
+            Ok(ndarray)
+        }
+        NDArrayInitMode::ShapeAndAllocaData { shape } => {
+            let ndims = shape.count;
+            let ndarray = alloca_ndarray(generator, ctx, element_optic, ndims, name)?;
+
+            // Fill `ndarray.shape`
+            (shape.write_to_array)(generator, ctx, &ndarray.shape_array(ctx))?;
+
+            // Check if `shape` has bad inputs
+            call_nac3_ndarray_util_assert_shape_no_negative(
+                generator,
+                ctx,
+                ndims,
+                &ndarray.focus(ctx, |fields| &fields.shape).load(ctx, "shape"),
+            );
+
+            // Now we populate `ndarray.data` by alloca-ing.
+            // But first, we need to know the size of the ndarray to know how many elements to alloca,
+            // since calculating nbytes of an ndarray requires `ndarray.shape` to be set.
+            let ndarray_nbytes = call_nac3_ndarray_nbytes(generator, ctx, &ndarray);
+
+            // Alloca `data` and assign it to `ndarray.data`
+            let data_ptr =
+                ctx.builder.build_array_alloca(ctx.ctx.i8_type(), ndarray_nbytes, "data").unwrap();
+            ndarray.focus(ctx, |fields| &fields.data).store(
+                ctx,
+                &Address { addressee_optic: IntLens::int8(ctx.ctx), address: data_ptr },
+            );
+
+            // Finally, do `set_strides_by_shape`
+            // Check out https://ajcr.net/stride-guide-part-1/ to see what numpy "strides" are.
+            call_nac3_ndarray_set_strides_by_shape(generator, ctx, &ndarray);
+
+            Ok(ndarray)
+        }
+    }
+}
+
+fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndims: IntValue<'ctx>,
+    shape: &Address<'ctx, IntLens<'ctx>>,
+) {
+    let size_type = generator.get_size_type(ctx.ctx);
+
+    let errctx = prepare_error_context(ctx);
+    FunctionBuilder::begin(
+        ctx,
+        &get_sized_dependent_function_name(
+            size_type,
+            "__nac3_ndarray_util_assert_shape_no_negative",
+        ),
+    )
+    .arg("errctx", &AddressLens(ErrorContextLens), &errctx)
+    .arg("ndims", &IntLens(size_type), &ndims)
+    .arg("shape", &AddressLens(IntLens(size_type)), shape)
+    .returning_void();
+    check_error_context(generator, ctx, &errctx);
+}
+
+fn call_nac3_ndarray_set_strides_by_shape<
+    'ctx,
+    G: CodeGenerator + ?Sized,
+    ElementOptic: Optic<'ctx>,
+>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: &NpArray<'ctx, ElementOptic>,
+) {
+    let size_type = generator.get_size_type(ctx.ctx);
+
+    FunctionBuilder::begin(
+        ctx,
+        &get_sized_dependent_function_name(
+            size_type,
+            "__nac3_ndarray_util_assert_shape_no_negative",
+        ),
+    )
+    .arg("ndarray", &AddressLens(ndarray.addressee_optic.clone()), ndarray)
+    .returning_void();
+}
+
+fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized, ElementOptic: Optic<'ctx>>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray: &NpArray<'ctx, ElementOptic>,
+) -> IntValue<'ctx> {
+    let size_type = generator.get_size_type(ctx.ctx);
+
+    FunctionBuilder::begin(
+        ctx,
+        &get_sized_dependent_function_name(
+            size_type,
+            "__nac3_ndarray_util_assert_shape_no_negative",
+        ),
+    )
+    .arg("ndarray", &AddressLens(ndarray.addressee_optic.clone()), ndarray)
+    .returning("nbytes", &IntLens(size_type))
+}

nac3core/src/codegen/optics.rs

@@ -58,6 +58,23 @@ pub trait SizedIntLens<'ctx>: Optic<'ctx, Value = IntValue<'ctx>> {}
 #[derive(Debug, Clone, Copy)]
 pub struct IntLens<'ctx>(pub IntType<'ctx>);
 
+impl<'ctx> IntLens<'ctx> {
+    #[must_use]
+    pub fn int8(ctx: &'ctx Context) -> IntLens<'ctx> {
+        IntLens(ctx.i8_type())
+    }
+
+    #[must_use]
+    pub fn int32(ctx: &'ctx Context) -> IntLens<'ctx> {
+        IntLens(ctx.i32_type())
+    }
+
+    #[must_use]
+    pub fn int64(ctx: &'ctx Context) -> IntLens<'ctx> {
+        IntLens(ctx.i64_type())
+    }
+}
+
 impl<'ctx> Optic<'ctx> for IntLens<'ctx> {
     type Value = IntValue<'ctx>;
 
@@ -111,7 +128,7 @@ impl<'ctx, AddresseeOptic> Address<'ctx, AddresseeOptic> {
     }
 
     pub fn cast_to_opaque(&self, ctx: &CodeGenContext<'ctx, '_>) -> Address<'ctx, IntLens<'ctx>> {
-        self.cast_to(ctx, IntLens(ctx.ctx.i8_type()))
+        self.cast_to(ctx, IntLens::int8(ctx.ctx))
     }
 }
 
@@ -126,7 +143,7 @@ pub struct AddressLens<AddresseeOptic>(pub AddresseeOptic);
 
 impl<AddresseeOptic> AddressLens<AddresseeOptic> {
     pub fn new_opaque<'ctx>(&self, ctx: &CodeGenContext<'ctx, '_>) -> AddressLens<IntLens<'ctx>> {
-        AddressLens(IntLens(ctx.ctx.i8_type()))
+        AddressLens(IntLens::int8(ctx.ctx))
     }
 }