From 059b130afff1d7fb0c2939432548c52b633534bf Mon Sep 17 00:00:00 2001 From: lyken Date: Sun, 14 Jul 2024 17:05:45 +0800 Subject: [PATCH] WIP 6 --- nac3core/src/codegen/irrt/numpy.rs | 18 ++--- nac3core/src/codegen/irrt/util.rs | 4 +- nac3core/src/codegen/mod.rs | 3 +- nac3core/src/codegen/numpy_new.rs | 91 ++++++++++++++++++++++++ nac3core/src/codegen/optics/address.rs | 71 ++++++++++++------ nac3core/src/codegen/optics/core.rs | 16 ++--- nac3core/src/codegen/optics/gep.rs | 10 +-- nac3core/src/codegen/optics/int.rs | 12 ++-- nac3core/src/codegen/optics/slice.rs | 6 +- nac3core/src/codegen/optics/structure.rs | 14 ++-- 10 files changed, 182 insertions(+), 63 deletions(-) create mode 100644 nac3core/src/codegen/numpy_new.rs diff --git a/nac3core/src/codegen/irrt/numpy.rs b/nac3core/src/codegen/irrt/numpy.rs index 9a16c85f..f1714c1b 100644 --- a/nac3core/src/codegen/irrt/numpy.rs +++ b/nac3core/src/codegen/irrt/numpy.rs @@ -2,7 +2,7 @@ use std::marker::PhantomData; use inkwell::{ types::{BasicType, BasicTypeEnum, IntType}, - values::{BasicValueEnum, IntValue}, + values::{BasicValueEnum, IntValue, PointerValue}, }; use crate::codegen::optics::*; @@ -95,7 +95,7 @@ struct Producer<'ctx, G: CodeGenerator + ?Sized, ElementOptic> { /// /// 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>( +pub fn parse_input_shape_arg<'ctx, G>( generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, shape: BasicValueEnum<'ctx>, @@ -258,14 +258,14 @@ where Ok(ndarray_ptr) } -enum NDArrayInitMode<'ctx, G: CodeGenerator + ?Sized> { - NDim { ndim: IntValue<'ctx>, _phantom: PhantomData<&'ctx G> }, +pub enum NDArrayInitMode<'ctx, G: CodeGenerator + ?Sized> { + NDim { ndim: IntValue<'ctx> }, Shape { shape: Producer<'ctx, G, IntLens<'ctx>> }, ShapeAndAllocaData { shape: Producer<'ctx, G, IntLens<'ctx>> }, } /// TODO: DOCUMENT ME -fn alloca_ndarray_and_init<'ctx, G>( +pub fn alloca_ndarray_and_init<'ctx, G>( generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, elem_type: BasicTypeEnum<'ctx>, @@ -277,7 +277,7 @@ where { // It is implemented verbosely in order to make the initialization modes super clear in their intent. match init_mode { - NDArrayInitMode::NDim { ndim: ndims, _phantom } => { + NDArrayInitMode::NDim { ndim } => { let ndarray = alloca_ndarray(generator, ctx, elem_type, ndims, name)?; Ok(ndarray) } @@ -397,11 +397,11 @@ fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>( .returning("nbytes", &IntLens(size_type)) } -fn call_nac3_ndarray_fill_generic<'ctx, G: CodeGenerator + ?Sized>( +pub fn call_nac3_ndarray_fill_generic<'ctx, G: CodeGenerator + ?Sized>( generator: &mut G, ctx: &mut CodeGenContext<'ctx, '_>, ndarray_ptr: &Address<'ctx, NpArrayLens<'ctx>>, - fill_value_ptr: &Address<'ctx, IntLens<'ctx>>, + fill_value_ptr: PointerValue<'ctx>, ) { let size_type = generator.get_size_type(ctx.ctx); @@ -410,6 +410,6 @@ fn call_nac3_ndarray_fill_generic<'ctx, G: CodeGenerator + ?Sized>( &get_sized_dependent_function_name(size_type, "__nac3_ndarray_fill_generic"), ) .arg("ndarray", &AddressLens(NpArrayLens { size_type }), ndarray_ptr) - .arg("pvalue", &opaque_address_lens(ctx.ctx), fill_value_ptr) + .arg("pvalue", &OpaqueAddressLens, fill_value_ptr) .returning_void(); } diff --git a/nac3core/src/codegen/irrt/util.rs b/nac3core/src/codegen/irrt/util.rs index 1a9c448a..9c476800 100644 --- a/nac3core/src/codegen/irrt/util.rs +++ b/nac3core/src/codegen/irrt/util.rs @@ -43,13 +43,13 @@ impl<'ctx, 'a> FunctionBuilder<'ctx, 'a> { // The name is for self-documentation #[must_use] - pub fn arg>(mut self, _name: &'static str, optic: &S, arg: &S::Value) -> Self { + pub fn arg>(mut self, _name: &'static str, optic: &S, arg: &S::MemoryValue) -> Self { self.arguments .push((optic.get_llvm_type(self.ctx.ctx).into(), arg.get_llvm_value().into())); self } - pub fn returning>(self, name: &'static str, return_prism: &S) -> S::Value { + pub fn returning>(self, name: &'static str, return_prism: &S) -> S::MemoryValue { let (param_tys, param_vals): (Vec<_>, Vec<_>) = self.arguments.into_iter().unzip(); let function = self.ctx.module.get_function(self.fn_name).unwrap_or_else(|| { diff --git a/nac3core/src/codegen/mod.rs b/nac3core/src/codegen/mod.rs index 7f38e43c..5b8694bf 100644 --- a/nac3core/src/codegen/mod.rs +++ b/nac3core/src/codegen/mod.rs @@ -26,7 +26,7 @@ use inkwell::{ use irrt::error_context::StrLens; use itertools::Itertools; use nac3parser::ast::{Location, Stmt, StrRef}; -use optics::Optic as _; +use optics::MemoryOptic as _; use parking_lot::{Condvar, Mutex}; use std::collections::{HashMap, HashSet}; use std::sync::{ @@ -44,6 +44,7 @@ mod generator; pub mod irrt; pub mod llvm_intrinsics; pub mod numpy; +pub mod numpy_new; pub mod optics; pub mod stmt; diff --git a/nac3core/src/codegen/numpy_new.rs b/nac3core/src/codegen/numpy_new.rs new file mode 100644 index 00000000..23dd4a2a --- /dev/null +++ b/nac3core/src/codegen/numpy_new.rs @@ -0,0 +1,91 @@ +use inkwell::values::{BasicValueEnum, PointerValue}; +use nac3parser::ast::StrRef; + +use crate::{ + codegen::optics::build_opaque_alloca, symbol_resolver::ValueEnum, toplevel::DefinitionId, typecheck::typedef::{FunSignature, Type} +}; + +use super::{ + irrt::{ + self, + numpy::{alloca_ndarray_and_init, parse_input_shape_arg, NDArrayInitMode, NpArrayLens}, + }, + optics::Address, + CodeGenContext, CodeGenerator, +}; + +/// LLVM-typed implementation for generating the implementation for constructing an empty `NDArray`. +fn call_ndarray_empty_impl<'ctx, G>( + generator: &mut G, + ctx: &mut CodeGenContext<'ctx, '_>, + elem_ty: Type, + shape: BasicValueEnum<'ctx>, + shape_ty: Type, + name: &str, +) -> Result>, String> +where + G: CodeGenerator + ?Sized, +{ + let elem_type = ctx.get_llvm_type(generator, elem_ty); + let shape = parse_input_shape_arg(generator, ctx, shape, shape_ty); + let ndarray_ptr = alloca_ndarray_and_init( + generator, + ctx, + elem_type, + NDArrayInitMode::ShapeAndAllocaData { shape }, + name, + )?; + Ok(ndarray_ptr) +} + +fn call_ndarray_fill_impl<'ctx, G>( + generator: &mut G, + ctx: &mut CodeGenContext<'ctx, '_>, + elem_ty: Type, + shape: BasicValueEnum<'ctx>, + shape_ty: Type, + fill_value: BasicValueEnum<'ctx>, + name: &str, +) -> Result>, String> +where + G: CodeGenerator + ?Sized, +{ + let ndarray_ptr = call_ndarray_empty_impl(generator, ctx, elem_ty, shape, shape_ty, name)?; + + // NOTE: fill_value's type is not checked!! + let fill_value_ptr = build_opaque_alloca(ctx, fill_value.get_type(), name); + fill_value_ptr.store(ctx, ); + // let fill_value_ptr = ctx.builder.build_alloca(, "fill_value_ptr").unwrap(); + // ctx.builder.build_store(fill_value_ptr, fill_value); + + // let ok = irrt::numpy::call_nac3_ndarray_fill_generic(generator, ctx, ndarray_ptr, Address { fill_value_ptr } ); + todo!() + Ok(ndarray_ptr) +} + +/// Generates LLVM IR for `np.empty`. +pub fn gen_ndarray_empty<'ctx, G>( + context: &mut CodeGenContext<'ctx, '_>, + obj: &Option<(Type, ValueEnum<'ctx>)>, + fun: (&FunSignature, DefinitionId), + args: &[(Option, ValueEnum<'ctx>)], + generator: &mut dyn CodeGenerator, +) -> Result, String> { + assert!(obj.is_none()); + assert_eq!(args.len(), 1); + + // Parse arguments + let shape_ty = fun.0.args[0].ty; + let shape = args[0].1.clone().to_basic_value_enum(context, generator, shape_ty)?; + + // Implementation + let ndarray_ptr = call_ndarray_empty_impl( + generator, + context, + context.primitives.float, + shape, + shape_ty, + "empty_ndarray", + )?; + Ok(ndarray_ptr.address) +} diff --git a/nac3core/src/codegen/optics/address.rs b/nac3core/src/codegen/optics/address.rs index c27ce20d..297c2b06 100644 --- a/nac3core/src/codegen/optics/address.rs +++ b/nac3core/src/codegen/optics/address.rs @@ -7,10 +7,7 @@ use inkwell::{ use crate::codegen::CodeGenContext; -use super::{ - core::{MemoryGetter, MemorySetter, Optic, OpticValue, Prism}, - int::IntLens, -}; +use super::core::{MemoryGetter, MemoryOptic, MemorySetter, OpticValue, Prism}; #[derive(Debug, Clone)] pub struct Address<'ctx, AddresseeOptic> { @@ -19,7 +16,7 @@ pub struct Address<'ctx, AddresseeOptic> { } impl<'ctx, AddresseeOptic> Address<'ctx, AddresseeOptic> { - pub fn cast_to>( + pub fn cast_to>( &self, ctx: &CodeGenContext<'ctx, '_>, new_optic: S, @@ -30,8 +27,8 @@ impl<'ctx, AddresseeOptic> Address<'ctx, AddresseeOptic> { Address { addressee_optic: new_optic, address: casted_address } } - pub fn cast_to_opaque(&self, ctx: &CodeGenContext<'ctx, '_>) -> Address<'ctx, IntLens<'ctx>> { - self.cast_to(ctx, IntLens::int8(ctx.ctx)) + pub fn cast_to_opaque(&self) -> OpaqueAddress<'ctx> { + OpaqueAddress(self.address) } } @@ -44,21 +41,16 @@ impl<'ctx, AddresseeOptic> OpticValue<'ctx> for Address<'ctx, AddresseeOptic> { #[derive(Debug, Clone)] pub struct AddressLens(pub AddresseeOptic); -#[must_use] -pub fn opaque_address_lens(ctx: &Context) -> AddressLens> { - AddressLens(IntLens::int8(ctx)) -} - -impl<'ctx, AddresseeOptic: Optic<'ctx>> Optic<'ctx> for AddressLens { - type Value = Address<'ctx, AddresseeOptic>; +impl<'ctx, AddresseeOptic: MemoryOptic<'ctx>> MemoryOptic<'ctx> for AddressLens { + type MemoryValue = Address<'ctx, AddresseeOptic>; fn get_llvm_type(&self, ctx: &'ctx Context) -> BasicTypeEnum<'ctx> { self.0.get_llvm_type(ctx).ptr_type(AddressSpace::default()).as_basic_type_enum() } } -impl<'ctx, AddresseeOptic: Optic<'ctx>> Prism<'ctx> for AddressLens { - fn review>(&self, value: V) -> Self::Value { +impl<'ctx, AddresseeOptic: MemoryOptic<'ctx>> Prism<'ctx> for AddressLens { + fn review>(&self, value: V) -> Self::MemoryValue { Address { addressee_optic: self.0.clone(), address: value.as_any_value_enum().into_pointer_value(), @@ -66,23 +58,23 @@ impl<'ctx, AddresseeOptic: Optic<'ctx>> Prism<'ctx> for AddressLens> MemoryGetter<'ctx> for AddressLens { +impl<'ctx, AddressesOptic: MemoryOptic<'ctx>> MemoryGetter<'ctx> for AddressLens { fn get( &self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, name: &str, - ) -> Self::Value { + ) -> Self::MemoryValue { self.review(ctx.builder.build_load(pointer, name).unwrap()) } } -impl<'ctx, AddressesOptic: Optic<'ctx>> MemorySetter<'ctx> for AddressLens { +impl<'ctx, AddressesOptic: MemoryOptic<'ctx>> MemorySetter<'ctx> for AddressLens { fn set( &self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, - value: &Self::Value, + value: &Self::MemoryValue, ) { ctx.builder.build_store(pointer, value.address).unwrap(); } @@ -90,14 +82,49 @@ impl<'ctx, AddressesOptic: Optic<'ctx>> MemorySetter<'ctx> for AddressLens> Address<'ctx, AddresseeOptic> { - pub fn load(&self, ctx: &CodeGenContext<'ctx, '_>, name: &str) -> AddresseeOptic::Value { + pub fn load(&self, ctx: &CodeGenContext<'ctx, '_>, name: &str) -> AddresseeOptic::MemoryValue { self.addressee_optic.get(ctx, self.address, name) } } // To make [`Address`] convenient to use impl<'ctx, AddresseeOptic: MemorySetter<'ctx>> Address<'ctx, AddresseeOptic> { - pub fn store(&self, ctx: &CodeGenContext<'ctx, '_>, value: &AddresseeOptic::Value) { + pub fn store(&self, ctx: &CodeGenContext<'ctx, '_>, value: &AddresseeOptic::MemoryValue) { self.addressee_optic.set(ctx, self.address, value); } } + +#[derive(Debug, Clone, Copy)] +pub struct OpaqueAddress<'ctx>(pub PointerValue<'ctx>); + +impl<'ctx> OpaqueAddress<'ctx> { + pub fn cast_to>( + &self, + ctx: &'ctx CodeGenContext, + addressee_optic: AddresseeOptic, + name: &str, + ) -> Address<'ctx, AddresseeOptic> { + let ptr = ctx.builder.build_pointer_cast( + self.0, + addressee_optic.get_llvm_type(ctx.ctx).ptr_type(AddressSpace::default()), + name, + ); + Address { addressee_optic, address: ptr } + } +} + +#[derive(Debug, Clone, Copy)] +pub struct OpaqueAddressLens; + +impl<'ctx> MemoryOptic<'ctx> for OpaqueAddressLens { + type MemoryValue = BasicValueEnum<'ctx>; + + fn get_llvm_type(&self, ctx: &'ctx Context) -> BasicTypeEnum<'ctx> { + ctx.i8_type().ptr_type(AddressSpace::default()).as_basic_type_enum() + } +} + +impl<'ctx> OpaqueAddress<'ctx> { + pub fn store(&self, ctx: &CodeGenContext<'ctx, '_>, value: BasicValueEnum<'ctx>) { + } +} diff --git a/nac3core/src/codegen/optics/core.rs b/nac3core/src/codegen/optics/core.rs index 1b3e1794..01405674 100644 --- a/nac3core/src/codegen/optics/core.rs +++ b/nac3core/src/codegen/optics/core.rs @@ -21,8 +21,8 @@ impl<'ctx, T: BasicValue<'ctx>> OpticValue<'ctx> for T { } // TODO: The interface is unintuitive -pub trait Optic<'ctx>: Clone { - type Value: OpticValue<'ctx>; +pub trait MemoryOptic<'ctx>: Clone { + type MemoryValue: OpticValue<'ctx>; fn get_llvm_type(&self, ctx: &'ctx Context) -> BasicTypeEnum<'ctx>; @@ -32,20 +32,20 @@ pub trait Optic<'ctx>: Clone { } } -pub trait Prism<'ctx>: Optic<'ctx> { +pub trait Prism<'ctx>: MemoryOptic<'ctx> { // TODO: Return error if `review` fails - fn review>(&self, value: V) -> Self::Value; + fn review>(&self, value: V) -> Self::MemoryValue; } -pub trait MemoryGetter<'ctx>: Optic<'ctx> { +pub trait MemoryGetter<'ctx>: MemoryOptic<'ctx> { fn get( &self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, name: &str, - ) -> Self::Value; + ) -> Self::MemoryValue; } -pub trait MemorySetter<'ctx>: Optic<'ctx> { - fn set(&self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, value: &Self::Value); +pub trait MemorySetter<'ctx>: MemoryOptic<'ctx> { + fn set(&self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, value: &Self::MemoryValue); } diff --git a/nac3core/src/codegen/optics/gep.rs b/nac3core/src/codegen/optics/gep.rs index b6633870..4b103364 100644 --- a/nac3core/src/codegen/optics/gep.rs +++ b/nac3core/src/codegen/optics/gep.rs @@ -9,7 +9,7 @@ use crate::codegen::CodeGenContext; use super::{ address::Address, - core::{MemoryGetter, Optic}, + core::{MemoryGetter, MemoryOptic}, }; // ((Memory, Pointer) -> ElementOptic::Value*) @@ -23,21 +23,21 @@ pub struct GepGetter { pub element_optic: ElementOptic, } -impl<'ctx, ElementOptic: Optic<'ctx>> Optic<'ctx> for GepGetter { - type Value = Address<'ctx, ElementOptic>; +impl<'ctx, ElementOptic: MemoryOptic<'ctx>> MemoryOptic<'ctx> for GepGetter { + type MemoryValue = Address<'ctx, ElementOptic>; fn get_llvm_type(&self, ctx: &'ctx Context) -> BasicTypeEnum<'ctx> { self.element_optic.get_llvm_type(ctx).ptr_type(AddressSpace::default()).as_basic_type_enum() } } -impl<'ctx, ElementOptic: Optic<'ctx>> MemoryGetter<'ctx> for GepGetter { +impl<'ctx, ElementOptic: MemoryOptic<'ctx>> MemoryGetter<'ctx> for GepGetter { fn get( &self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, name: &str, - ) -> Self::Value { + ) -> Self::MemoryValue { let llvm_i32 = ctx.ctx.i32_type(); // TODO: I think I'm not supposed to *just* use i32 for GEP like that let element_ptr = unsafe { ctx.builder diff --git a/nac3core/src/codegen/optics/int.rs b/nac3core/src/codegen/optics/int.rs index 852fbf0d..0a7f407a 100644 --- a/nac3core/src/codegen/optics/int.rs +++ b/nac3core/src/codegen/optics/int.rs @@ -6,7 +6,7 @@ use inkwell::{ use crate::codegen::CodeGenContext; -use super::core::{MemoryGetter, MemorySetter, Optic, Prism}; +use super::core::{MemoryGetter, MemorySetter, MemoryOptic, Prism}; // NOTE: I wanted to make Int8Lens, Int16Lens, Int32Lens, with all // having the trait IsIntLens, and implement `impl Optic for T`, @@ -31,8 +31,8 @@ impl<'ctx> IntLens<'ctx> { } } -impl<'ctx> Optic<'ctx> for IntLens<'ctx> { - type Value = IntValue<'ctx>; +impl<'ctx> MemoryOptic<'ctx> for IntLens<'ctx> { + type MemoryValue = IntValue<'ctx>; fn get_llvm_type(&self, _ctx: &'ctx Context) -> BasicTypeEnum<'ctx> { self.0.as_basic_type_enum() @@ -40,7 +40,7 @@ impl<'ctx> Optic<'ctx> for IntLens<'ctx> { } impl<'ctx> Prism<'ctx> for IntLens<'ctx> { - fn review>(&self, value: V) -> Self::Value { + fn review>(&self, value: V) -> Self::MemoryValue { let int = value.as_any_value_enum().into_int_value(); debug_assert_eq!(int.get_type().get_bit_width(), self.0.get_bit_width()); int @@ -53,13 +53,13 @@ impl<'ctx> MemoryGetter<'ctx> for IntLens<'ctx> { ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, name: &str, - ) -> Self::Value { + ) -> Self::MemoryValue { self.review(ctx.builder.build_load(pointer, name).unwrap()) } } impl<'ctx> MemorySetter<'ctx> for IntLens<'ctx> { - fn set(&self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, int: &Self::Value) { + fn set(&self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, int: &Self::MemoryValue) { debug_assert_eq!(int.get_type().get_bit_width(), self.0.get_bit_width()); ctx.builder.build_store(pointer, int.as_basic_value_enum()).unwrap(); } diff --git a/nac3core/src/codegen/optics/slice.rs b/nac3core/src/codegen/optics/slice.rs index 8f1f4d60..edda531d 100644 --- a/nac3core/src/codegen/optics/slice.rs +++ b/nac3core/src/codegen/optics/slice.rs @@ -1,5 +1,5 @@ use super::{ - core::Optic, + core::MemoryOptic, ixed::{BoundedIxed, Ixed}, }; @@ -14,7 +14,7 @@ pub struct ArraySlice<'ctx, ElementOptic> { pub base: Address<'ctx, ElementOptic>, } -impl<'ctx, ElementOptic: Optic<'ctx>> Ixed<'ctx, ElementOptic> for ArraySlice<'ctx, ElementOptic> { +impl<'ctx, ElementOptic: MemoryOptic<'ctx>> Ixed<'ctx, ElementOptic> for ArraySlice<'ctx, ElementOptic> { fn ix( &self, ctx: &CodeGenContext<'ctx, '_>, @@ -27,7 +27,7 @@ impl<'ctx, ElementOptic: Optic<'ctx>> Ixed<'ctx, ElementOptic> for ArraySlice<'c } } -impl<'ctx, ElementOptic: Optic<'ctx>> BoundedIxed<'ctx, ElementOptic> +impl<'ctx, ElementOptic: MemoryOptic<'ctx>> BoundedIxed<'ctx, ElementOptic> for ArraySlice<'ctx, ElementOptic> { fn num_elements(&self, _ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> { diff --git a/nac3core/src/codegen/optics/structure.rs b/nac3core/src/codegen/optics/structure.rs index a1e334f9..c8e9b2cb 100644 --- a/nac3core/src/codegen/optics/structure.rs +++ b/nac3core/src/codegen/optics/structure.rs @@ -9,7 +9,7 @@ use crate::codegen::CodeGenContext; use super::{ address::Address, - core::{MemoryGetter, MemorySetter, Optic, OpticValue}, + core::{MemoryGetter, MemorySetter, MemoryOptic, OpticValue}, gep::GepGetter, }; @@ -40,8 +40,8 @@ impl<'ctx, StructOptic> OpticValue<'ctx> for OpticalStructValue<'ctx, StructOpti } // TODO: check StructType -impl<'ctx, T: StructureOptic<'ctx>> Optic<'ctx> for T { - type Value = OpticalStructValue<'ctx, Self>; +impl<'ctx, T: StructureOptic<'ctx>> MemoryOptic<'ctx> for T { + type MemoryValue = OpticalStructValue<'ctx, Self>; fn get_llvm_type(&self, ctx: &'ctx Context) -> BasicTypeEnum<'ctx> { let mut builder = FieldBuilder::new(ctx, self.struct_name()); @@ -59,7 +59,7 @@ impl<'ctx, T: StructureOptic<'ctx>> MemoryGetter<'ctx> for T { ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, name: &str, - ) -> Self::Value { + ) -> Self::MemoryValue { OpticalStructValue { optic: self.clone(), llvm: ctx.builder.build_load(pointer, name).unwrap().into_struct_value(), @@ -72,14 +72,14 @@ impl<'ctx, T: StructureOptic<'ctx>> MemorySetter<'ctx> for T { &self, ctx: &CodeGenContext<'ctx, '_>, pointer: PointerValue<'ctx>, - value: &Self::Value, + value: &Self::MemoryValue, ) { ctx.builder.build_store(pointer, value.llvm).unwrap(); } } impl<'ctx, AddresseeOptic: StructureOptic<'ctx>> Address<'ctx, AddresseeOptic> { - pub fn focus>( + pub fn focus>( &self, ctx: &CodeGenContext<'ctx, '_>, get_field_gep_fn: GetFieldGepFn, @@ -121,7 +121,7 @@ impl<'ctx> FieldBuilder<'ctx> { index } - pub fn add_field>( + pub fn add_field>( &mut self, name: &'static str, element_optic: ElementOptic,