use u32 instead of usize for memory offsets/sizes to avoid i32->usize casts (#16)

crates/it-lilo/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "it-lilo"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Fluence Labs"]
 description = "Defines some helper utils for lifting/lowering IT"
 edition = "2018"
@@ -12,7 +12,7 @@ path = "src/lib.rs"
 
 [dependencies]
 fluence-it-types = { path = "../it-types/", version = "0.3.0" }
-it-memory-traits = { path = "../it-memory-traits", version = "0.1.0" }
+it-memory-traits = { path = "../it-memory-traits", version = "0.2.0" }
 
 paste = "1.0.5"
 thiserror = "1.0.24"

crates/it-lilo/src/lifter/lift_array.rs

@@ -27,8 +27,8 @@ use it_memory_traits::{SequentialMemoryView, SequentialReader};
 pub fn array_lift_memory<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
     lifter: &ILifter<'_, R, MV>,
     value_type: &IType,
-    offset: usize,
-    elements_count: usize,
+    offset: u32,
+    elements_count: u32,
 ) -> LiResult<IValue> {
     if elements_count == 0 {
         return Ok(IValue::Array(vec![]));
@@ -63,10 +63,10 @@ pub fn array_lift_memory<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'
 
 fn read_string_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
     lifter: &ILifter<'_, R, MV>,
-    offset: usize,
-    elements_count: usize,
+    offset: u32,
+    elements_count: u32,
 ) -> LiResult<Vec<IValue>> {
-    let mut result = Vec::with_capacity(elements_count);
+    let mut result = Vec::with_capacity(elements_count as usize);
     let seq_reader = lifter
         .reader
         .sequential_reader(offset, ser_type_size(&IType::String) * elements_count)?;
@@ -75,7 +75,7 @@ fn read_string_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
         let offset = seq_reader.read_u32();
         let size = seq_reader.read_u32();
 
-        let raw_str = lifter.reader.read_raw_u8_array(offset as _, size as _)?;
+        let raw_str = lifter.reader.read_raw_u8_array(offset, size)?;
         let str = String::from_utf8(raw_str)?;
         result.push(IValue::String(str));
     }
@@ -86,10 +86,10 @@ fn read_string_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
 fn read_array_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
     lifter: &ILifter<'_, R, MV>,
     ty: &IType,
-    offset: usize,
-    elements_count: usize,
+    offset: u32,
+    elements_count: u32,
 ) -> LiResult<Vec<IValue>> {
-    let mut result = Vec::with_capacity(elements_count);
+    let mut result = Vec::with_capacity(elements_count as usize);
     let seq_reader = lifter
         .reader
         .sequential_reader(offset, ser_type_size(ty) * elements_count)?;
@@ -98,7 +98,7 @@ fn read_array_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
         let offset = seq_reader.read_u32();
         let size = seq_reader.read_u32();
 
-        let array = array_lift_memory(lifter, ty, offset as _, size as _)?;
+        let array = array_lift_memory(lifter, ty, offset, size)?;
         result.push(array);
     }
 
@@ -108,10 +108,10 @@ fn read_array_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
 fn read_record_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
     lifter: &ILifter<'_, R, MV>,
     record_type_id: u64,
-    offset: usize,
-    elements_count: usize,
+    offset: u32,
+    elements_count: u32,
 ) -> LiResult<Vec<IValue>> {
-    let mut result = Vec::with_capacity(elements_count);
+    let mut result = Vec::with_capacity(elements_count as usize);
     let seq_reader = lifter
         .reader
         .sequential_reader(offset, ser_type_size(&IType::Record(0)) * elements_count)?;
@@ -120,7 +120,7 @@ fn read_record_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
         let offset = seq_reader.read_u32();
         let record_ty = lifter.resolver.resolve_record(record_type_id)?;
 
-        let record = record_lift_memory(lifter, &record_ty, offset as _)?;
+        let record = record_lift_memory(lifter, &record_ty, offset)?;
         result.push(record);
     }
 

crates/it-lilo/src/lifter/lift_record.rs

@@ -30,7 +30,7 @@ use it_memory_traits::{SequentialMemoryView, SequentialReader};
 pub fn record_lift_memory<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
     lifter: &ILifter<'_, R, MV>,
     record_type: &IRecordType,
-    offset: usize,
+    offset: u32,
 ) -> LiResult<IValue> {
     let mut values = Vec::with_capacity(record_type.fields.len());
 
@@ -75,7 +75,7 @@ fn read_string<MV: for<'a> SequentialMemoryView<'a>>(
     let offset = seq_reader.read_u32();
     let size = seq_reader.read_u32();
 
-    let string_mem = reader.read_raw_u8_array(offset as _, size as _)?;
+    let string_mem = reader.read_raw_u8_array(offset, size)?;
 
     let string = String::from_utf8(string_mem)?;
     Ok(string)
@@ -88,7 +88,7 @@ fn read_byte_array<MV: for<'a> SequentialMemoryView<'a>>(
     let offset = seq_reader.read_u32();
     let size = seq_reader.read_u32();
 
-    let array = reader.read_raw_u8_array(offset as _, size as _)?;
+    let array = reader.read_raw_u8_array(offset, size)?;
 
     Ok(IValue::ByteArray(array))
 }
@@ -101,7 +101,7 @@ fn read_array<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
     let offset = seq_reader.read_u32();
     let size = seq_reader.read_u32();
 
-    super::array_lift_memory(lifter, value_type, offset as _, size as _)
+    super::array_lift_memory(lifter, value_type, offset, size)
 }
 
 fn read_record<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
@@ -113,5 +113,5 @@ fn read_record<R: RecordResolvable, MV: for<'a> SequentialMemoryView<'a>>(
 
     let record_type = lifter.resolver.resolve_record(record_type_id)?;
 
-    record_lift_memory(lifter, &record_type, offset as _)
+    record_lift_memory(lifter, &record_type, offset)
 }

crates/it-lilo/src/lifter/macros.rs

@@ -122,12 +122,12 @@ macro_rules! read_array_ty {
     ($func_name:ident, $ty:ident, $ity:ident) => {
         pub fn $func_name(
             &self,
-            offset: usize,
-            elements_count: usize,
+            offset: u32,
+            elements_count: u32,
         ) -> super::LiResult<Vec<crate::IValue>> {
-            let reader =
-                self.sequential_reader(offset, std::mem::size_of::<$ty>() * elements_count)?;
-            let mut result = Vec::with_capacity(elements_count);
+            let reader = self
+                .sequential_reader(offset, (std::mem::size_of::<$ty>() as u32) * elements_count)?;
+            let mut result = Vec::with_capacity(elements_count as usize);
 
             for _ in 0..elements_count {
                 let value = paste::paste! { reader.[<read_ $ty>]()};

crates/it-lilo/src/lifter/memory_reader.rs

@@ -34,16 +34,16 @@ impl<MV: for<'a> SequentialMemoryView<'a>> MemoryReader<MV> {
     /// checks assuming that reader is well-formed.
     pub fn sequential_reader(
         &self,
-        offset: usize,
-        size: usize,
+        offset: u32,
+        size: u32,
     ) -> LiResult<<MV as SequentialMemoryView<'_>>::SR> {
         let seq_reader = self.view.sequential_reader(offset, size)?;
         Ok(seq_reader)
     }
 
-    pub fn read_raw_u8_array(&self, offset: usize, elements_count: usize) -> LiResult<Vec<u8>> {
+    pub fn read_raw_u8_array(&self, offset: u32, elements_count: u32) -> LiResult<Vec<u8>> {
         let reader = self.sequential_reader(offset, elements_count)?;
-        let mut result = Vec::with_capacity(elements_count);
+        let mut result = Vec::with_capacity(elements_count as usize);
 
         for _ in 0..elements_count {
             let value = reader.read_u8();
@@ -53,9 +53,9 @@ impl<MV: for<'a> SequentialMemoryView<'a>> MemoryReader<MV> {
         Ok(result)
     }
 
-    pub fn read_bool_array(&self, offset: usize, elements_count: usize) -> LiResult<Vec<IValue>> {
+    pub fn read_bool_array(&self, offset: u32, elements_count: u32) -> LiResult<Vec<IValue>> {
         let reader = self.sequential_reader(offset, elements_count)?;
-        let mut result = Vec::with_capacity(elements_count);
+        let mut result = Vec::with_capacity(elements_count as usize);
 
         for _ in 0..elements_count {
             let value = reader.read_u8();

crates/it-lilo/src/lowerer/lower_array.rs

@@ -24,12 +24,12 @@ use crate::IValue;
 use it_memory_traits::{SequentialMemoryView, SequentialWriter};
 
 pub struct LoweredArray {
-    pub offset: usize,
-    pub size: usize,
+    pub offset: u32,
+    pub size: u32,
 }
 
 impl LoweredArray {
-    pub fn new(offset: usize, size: usize) -> Self {
+    pub fn new(offset: u32, size: u32) -> Self {
         Self { offset, size }
     }
 
@@ -93,6 +93,6 @@ pub fn array_lower_memory<A: Allocatable, MV: for<'a> SequentialMemoryView<'a>>(
     }
 
     let offset = seq_writer.start_offset();
-    let lowered_array = LoweredArray::new(offset as _, elements_count as _);
+    let lowered_array = LoweredArray::new(offset, elements_count);
     Ok(lowered_array)
 }

crates/it-lilo/src/lowerer/lower_record.rs

@@ -26,7 +26,7 @@ use it_memory_traits::SequentialMemoryView;
 pub fn record_lower_memory<A: Allocatable, MV: for<'a> SequentialMemoryView<'a>>(
     lowerer: &ILowerer<'_, A, MV>,
     values: NEVec<IValue>,
-) -> LoResult<i32> {
+) -> LoResult<u32> {
     let average_field_size = 4;
     // TODO: avoid this additional allocation after fixing github.com/fluencelabs/fce/issues/77
     let mut result: Vec<u8> = Vec::with_capacity(average_field_size * values.len());
@@ -47,13 +47,13 @@ pub fn record_lower_memory<A: Allocatable, MV: for<'a> SequentialMemoryView<'a>>
             IValue::F32(value) => result.extend_from_slice(&value.to_le_bytes()),
             IValue::F64(value) => result.extend_from_slice(&value.to_le_bytes()),
             IValue::String(value) => {
-                let offset = lowerer.writer.write_bytes(value.as_bytes())? as u32;
+                let offset = lowerer.writer.write_bytes(value.as_bytes())?;
 
                 result.extend_from_slice(&offset.to_le_bytes());
                 result.extend_from_slice(&(value.len() as u32).to_le_bytes());
             }
             IValue::ByteArray(value) => {
-                let offset = lowerer.writer.write_bytes(&value)? as u32;
+                let offset = lowerer.writer.write_bytes(&value)?;
 
                 result.extend_from_slice(&offset.to_le_bytes());
                 result.extend_from_slice(&(value.len() as u32).to_le_bytes());
@@ -62,12 +62,12 @@ pub fn record_lower_memory<A: Allocatable, MV: for<'a> SequentialMemoryView<'a>>
             IValue::Array(values) => {
                 let LoweredArray { offset, size } = super::array_lower_memory(lowerer, values)?;
 
-                result.extend_from_slice(&(offset as u32).to_le_bytes());
-                result.extend_from_slice(&(size as u32).to_le_bytes());
+                result.extend_from_slice(&(offset).to_le_bytes());
+                result.extend_from_slice(&(size).to_le_bytes());
             }
 
             IValue::Record(values) => {
-                let offset = record_lower_memory(lowerer, values)? as u32;
+                let offset = record_lower_memory(lowerer, values)?;
 
                 result.extend_from_slice(&offset.to_le_bytes());
             }
@@ -76,5 +76,5 @@ pub fn record_lower_memory<A: Allocatable, MV: for<'a> SequentialMemoryView<'a>>
 
     let result_pointer = lowerer.writer.write_bytes(&result)?;
 
-    Ok(result_pointer as _)
+    Ok(result_pointer)
 }

crates/it-lilo/src/lowerer/memory_writer.rs

@@ -31,9 +31,9 @@ impl<'i, A: Allocatable, MV: for<'a> SequentialMemoryView<'a>> MemoryWriter<'i,
         Ok(writer)
     }
 
-    pub fn write_bytes(&self, bytes: &[u8]) -> LoResult<usize> {
+    pub fn write_bytes(&self, bytes: &[u8]) -> LoResult<u32> {
         let byte_type_tag = type_tag_form_itype(&crate::IType::U8);
-        let seq_writer = self.sequential_writer(bytes.len() as _, byte_type_tag)?;
+        let seq_writer = self.sequential_writer(bytes.len() as u32, byte_type_tag)?;
         seq_writer.write_bytes(bytes);
 
         Ok(seq_writer.start_offset())
@@ -45,7 +45,7 @@ impl<'i, A: Allocatable, MV: for<'a> SequentialMemoryView<'a>> MemoryWriter<'i,
         type_tag: u32,
     ) -> LoResult<<MV as SequentialMemoryView<'_>>::SW> {
         let offset = self.heap_manager.allocate(size, type_tag)?;
-        let seq_writer = self.view.sequential_writer(offset, size as usize)?;
+        let seq_writer = self.view.sequential_writer(offset, size)?;
         Ok(seq_writer)
     }
 }

crates/it-lilo/src/traits/allocatable.rs

@@ -19,7 +19,7 @@ use thiserror::Error as ThisError;
 pub const DEFAULT_MEMORY_INDEX: usize = 0;
 
 pub trait Allocatable {
-    fn allocate(&self, size: u32, type_tag: u32) -> Result<usize, AllocatableError>;
+    fn allocate(&self, size: u32, type_tag: u32) -> Result<u32, AllocatableError>;
 }
 
 #[derive(Debug, ThisError)]

crates/it-lilo/src/utils.rs

@@ -19,8 +19,8 @@ use crate::IType;
 use crate::IValue;
 
 /// Size of a value in a serialized view.
-pub fn ser_type_size(ty: &IType) -> usize {
-    const WASM_POINTER_SIZE: usize = 4;
+pub fn ser_type_size(ty: &IType) -> u32 {
+    const WASM_POINTER_SIZE: u32 = 4;
 
     match ty {
         IType::Boolean | IType::S8 | IType::U8 => 1,
@@ -46,7 +46,7 @@ pub fn ser_value_size(value: &IValue) -> u32 {
 }
 
 /// Returns the record size in bytes.
-pub fn record_size(record_type: &IRecordType) -> usize {
+pub fn record_size(record_type: &IRecordType) -> u32 {
     record_type
         .fields
         .iter()

crates/it-memory-traits/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "it-memory-traits"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Fluence Labs"]
 description = "Defines traits that IT uses for accessing memory"
 edition = "2018"

crates/it-memory-traits/src/errors.rs

@@ -20,8 +20,8 @@ use thiserror::Error as ThisError;
 pub enum MemoryAccessError {
     #[error("Out-of-bound Wasm memory access: offset {offset}, size {size}, while memory_size {memory_size}")]
     OutOfBounds {
-        offset: usize,
-        size: usize,
-        memory_size: usize,
+        offset: u32,
+        size: u32,
+        memory_size: u32,
     },
 }

crates/it-memory-traits/src/lib.rs

@@ -48,7 +48,7 @@ pub trait SequentialReader {
 }
 
 pub trait SequentialWriter {
-    fn start_offset(&self) -> usize;
+    fn start_offset(&self) -> u32;
 
     // specialization of write_array for u8
     fn write_u8(&self, value: u8);
@@ -65,17 +65,9 @@ pub trait SequentialMemoryView<'s> {
     type SR: SequentialReader + 's;
     type SW: SequentialWriter + 's;
 
-    fn sequential_writer(
-        &'s self,
-        offset: usize,
-        size: usize,
-    ) -> Result<Self::SW, MemoryAccessError>;
+    fn sequential_writer(&'s self, offset: u32, size: u32) -> Result<Self::SW, MemoryAccessError>;
 
-    fn sequential_reader(
-        &'s self,
-        offset: usize,
-        size: usize,
-    ) -> Result<Self::SR, MemoryAccessError>;
+    fn sequential_reader(&'s self, offset: u32, size: u32) -> Result<Self::SR, MemoryAccessError>;
 }
 
 pub trait Memory<View>