refactor: replace as uses with new u32->usize helper

Signed-off-by: Florian Hartung <florian.hartung@dlr.de>

Author: florianhartung

src/core/reader/section_header.rs

@@ -1,5 +1,6 @@
 use crate::core::reader::span::Span;
 use crate::core::reader::WasmReader;
+use crate::core::utils::ToUsizeExt;
 use crate::ValidationError;
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
@@ -53,7 +54,7 @@ impl SectionHeader {
     pub fn read(wasm: &mut WasmReader) -> Result<Self, ValidationError> {
         let ty = SectionTy::read(wasm)?;
         let size: u32 = wasm.read_var_u32()?;
-        let contents_span = wasm.make_span(size as usize)?;
+        let contents_span = wasm.make_span(size.into_usize())?;
 
         Ok(SectionHeader {
             ty,

src/core/reader/types/element.rs

@@ -1,9 +1,10 @@
 use super::global::GlobalType;
 use super::RefType;
-use crate::core::indices::{FuncIdx, TableIdx};
+use crate::core::indices::FuncIdx;
 use crate::core::reader::span::Span;
 use crate::core::reader::types::TableType;
 use crate::core::reader::WasmReader;
+use crate::core::utils::ToUsizeExt;
 use crate::read_constant_expression::read_constant_expression;
 use crate::validation_stack::ValidationStack;
 use crate::{NumType, ValType, ValidationError};
@@ -230,8 +231,8 @@ impl ElemType {
                     // start validating elemmode of form active {table x, offset expr}
                     // 1-2. C.tables[x] must be defined with type: limits t
                     let table_type = tables
-                        .get(x as usize)
-                        .ok_or(ValidationError::InvalidTableIdx(x as TableIdx))?
+                        .get(x.into_usize())
+                        .ok_or(ValidationError::InvalidTableIdx(x.into_usize()))?
                         .et;
                     if table_type != t {
                         return Err(ValidationError::ActiveElementSegmentTypeMismatch);
@@ -325,11 +326,11 @@ fn parse_validate_shortened_initializer_list(
 ) -> Result<ElemItems, ValidationError> {
     wasm.read_vec(|w| {
         let func_idx = w.read_var_u32()?;
-        if num_funcs <= func_idx as usize {
+        if num_funcs <= func_idx.into_usize() {
             // TODO fix error
-            return Err(ValidationError::InvalidFuncIdx(func_idx as usize));
+            return Err(ValidationError::InvalidFuncIdx(func_idx.into_usize()));
         }
-        validation_context_refs.insert(func_idx as FuncIdx);
+        validation_context_refs.insert(func_idx.into_usize());
         Ok(func_idx)
     })
     .map(ElemItems::RefFuncs)

src/core/reader/types/export.rs

@@ -1,6 +1,7 @@
 use crate::core::indices::{FuncIdx, GlobalIdx, MemIdx, TableIdx};
 use crate::core::reader::types::import::ImportDesc;
 use crate::core::reader::WasmReader;
+use crate::core::utils::ToUsizeExt;
 use crate::{ValidationError, ValidationInfo};
 
 use super::ExternType;
@@ -120,7 +121,7 @@ impl ExportDesc {
 impl ExportDesc {
     pub fn read(wasm: &mut WasmReader) -> Result<Self, ValidationError> {
         let desc_id = wasm.read_u8()?;
-        let desc_idx = wasm.read_var_u32()? as usize;
+        let desc_idx = wasm.read_var_u32()?.into_usize();
 
         let desc = match desc_id {
             0x00 => ExportDesc::Func(desc_idx),

src/core/reader/types/import.rs

@@ -1,5 +1,6 @@
 use crate::core::indices::TypeIdx;
 use crate::core::reader::WasmReader;
+use crate::core::utils::ToUsizeExt;
 use crate::{ValidationError, ValidationInfo};
 
 use super::global::GlobalType;
@@ -37,7 +38,7 @@ pub enum ImportDesc {
 impl ImportDesc {
     pub fn read(wasm: &mut WasmReader) -> Result<Self, ValidationError> {
         let desc = match wasm.read_u8()? {
-            0x00 => Self::Func(wasm.read_var_u32()? as TypeIdx),
+            0x00 => Self::Func(wasm.read_var_u32()?.into_usize()),
             // https://webassembly.github.io/spec/core/binary/types.html#table-types
             0x01 => Self::Table(TableType::read(wasm)?),
             0x02 => Self::Mem(MemType::read(wasm)?),

src/core/reader/types/mod.rs

@@ -6,8 +6,8 @@ use alloc::vec::Vec;
 use core::fmt::{Debug, Formatter};
 use global::GlobalType;
 
-use crate::core::indices::TypeIdx;
 use crate::core::reader::WasmReader;
+use crate::core::utils::ToUsizeExt;
 use crate::execution::assert_validated::UnwrapValidatedExt;
 use crate::ValidationError;
 
@@ -162,7 +162,7 @@ pub enum BlockType {
 
 impl BlockType {
     pub fn read(wasm: &mut WasmReader) -> Result<Self, ValidationError> {
-        if wasm.peek_u8()? as i8 == 0x40 {
+        if wasm.peek_u8()? == 0x40 {
             // Empty block type
             let _ = wasm.read_u8().unwrap_validated();
             Ok(BlockType::Empty)
@@ -196,7 +196,7 @@ impl BlockType {
                 },
             }),
             BlockType::Type(type_idx) => {
-                let type_idx = *type_idx as TypeIdx;
+                let type_idx = type_idx.into_usize();
                 func_types
                     .get(type_idx)
                     .cloned()

src/core/reader/types/values.rs

@@ -8,6 +8,7 @@
 use alloc::vec::Vec;
 
 use crate::core::reader::WasmReader;
+use crate::core::utils::ToUsizeExt;
 use crate::ValidationError;
 
 /// Wasm encodes integers according to the LEB128 format, which specifies that
@@ -352,7 +353,7 @@ impl<'wasm> WasmReader<'wasm> {
 
     /// Note: If `Err`, the [WasmReader] object is no longer guaranteed to be in a valid state
     pub fn read_name(&mut self) -> Result<&'wasm str, ValidationError> {
-        let len = self.read_var_u32()? as usize;
+        let len = self.read_var_u32()?.into_usize();
 
         let utf8_str = &self
             .full_wasm_binary
@@ -388,7 +389,7 @@ impl<'wasm> WasmReader<'wasm> {
     {
         let len = self.read_var_u32()?;
         core::iter::repeat_with(|| read_element(self))
-            .take(len as usize)
+            .take(len.into_usize())
             .collect()
     }
 }

src/execution/const_interpreter_loop.rs

@@ -5,12 +5,12 @@ use crate::{
     assert_validated::UnwrapValidatedExt,
     config::Config,
     core::{
-        indices::GlobalIdx,
         reader::{
             span::Span,
             types::{FuncType, ResultType},
             WasmReader,
         },
+        utils::ToUsizeExt,
     },
     unreachable_validated,
     value::{self, Ref},
@@ -51,7 +51,7 @@ pub(crate) fn run_const<T: Config>(
                 break;
             }
             GLOBAL_GET => {
-                let global_idx = wasm.read_var_u32().unwrap_validated() as GlobalIdx;
+                let global_idx = wasm.read_var_u32().unwrap_validated().into_usize();
 
                 //TODO replace double indirection
                 let global = store
@@ -92,7 +92,7 @@ pub(crate) fn run_const<T: Config>(
             }
             REF_FUNC => {
                 // we already checked for the func_idx to be in bounds during validation
-                let func_idx = wasm.read_var_u32().unwrap_validated() as usize;
+                let func_idx = wasm.read_var_u32().unwrap_validated().into_usize();
                 let func_addr = *store
                     .modules
                     .get(module)