Change asserts to debug_assert

compiler/vm/src/heap/object_heap/function.rs

@@ -35,15 +35,15 @@ impl HeapFunction {
         body: InstructionPointer,
     ) -> Self {
         let captured_len = captured.len();
-        assert_eq!(
+        debug_assert_eq!(
             (captured_len << Self::CAPTURED_LEN_SHIFT) >> Self::CAPTURED_LEN_SHIFT,
             captured_len,
             "Function captures too many things.",
         );
 
         let argument_count_shift_for_max_size =
             InlineObject::BITS as usize - Self::CAPTURED_LEN_SHIFT + Self::ARGUMENT_COUNT_SHIFT;
-        assert_eq!(
+        debug_assert_eq!(
             (argument_count << argument_count_shift_for_max_size)
                 >> argument_count_shift_for_max_size,
             argument_count,

compiler/vm/src/heap/object_heap/int.rs

@@ -68,7 +68,7 @@ impl HeapInt {
 
     #[must_use]
     pub fn bit_length(self, heap: &mut Heap) -> Int {
-        assert!(*self.get() >= 0.into());
+        debug_assert!(*self.get() >= 0.into());
         Int::create(heap, true, self.get().bits())
     }
 

compiler/vm/src/heap/object_heap/list.rs

@@ -33,7 +33,7 @@ impl HeapList {
     }
     #[must_use]
     fn create_uninitialized(heap: &mut Heap, is_reference_counted: bool, len: usize) -> Self {
-        assert_eq!(
+        debug_assert_eq!(
             (len << Self::LEN_SHIFT) >> Self::LEN_SHIFT,
             len,
             "List is too long.",
@@ -70,7 +70,7 @@ impl HeapList {
     }
     #[must_use]
     pub fn insert(self, heap: &mut Heap, index: usize, value: InlineObject) -> Self {
-        assert!(index <= self.len());
+        debug_assert!(index <= self.len());
 
         let len = self.len() + 1;
         let new_list = Self::create_uninitialized(heap, true, len);
@@ -91,7 +91,7 @@ impl HeapList {
     }
     #[must_use]
     pub fn remove(self, heap: &mut Heap, index: usize) -> Self {
-        assert!(index < self.len());
+        debug_assert!(index < self.len());
 
         let len = self.len() - 1;
         let new_list = Self::create_uninitialized(heap, true, len);
@@ -111,7 +111,7 @@ impl HeapList {
     }
     #[must_use]
     pub fn replace(self, heap: &mut Heap, index: usize, value: InlineObject) -> Self {
-        assert!(index < self.len());
+        debug_assert!(index < self.len());
 
         let new_list = Self::create(heap, true, self.items());
         unsafe { ptr::write(new_list.content_word_pointer(index).cast().as_ptr(), value) };

compiler/vm/src/heap/object_heap/mod.rs

@@ -145,7 +145,7 @@ impl HeapObject {
     }
     pub(super) fn free(self, heap: &mut Heap) {
         trace!("Freeing object at {self:p}.");
-        assert_eq!(self.reference_count().unwrap_or_default(), 0);
+        debug_assert_eq!(self.reference_count().unwrap_or_default(), 0);
         let data = HeapData::from(self);
         if DEBUG_ALLOCATIONS {
             // No need for pluralization because our heap objects are longer
@@ -306,7 +306,7 @@ impl From<HeapObject> for HeapData {
         let header_word = object.header_word();
         match header_word & HeapObject::KIND_MASK {
             HeapObject::KIND_INT => {
-                assert_eq!(
+                debug_assert_eq!(
                     header_word & !HeapObject::IS_REFERENCE_COUNTED_MASK,
                     HeapObject::KIND_INT,
                 );
@@ -318,7 +318,7 @@ impl From<HeapObject> for HeapData {
             HeapObject::KIND_TEXT => Self::Text(HeapText::new_unchecked(object)),
             HeapObject::KIND_FUNCTION => Self::Function(HeapFunction::new_unchecked(object)),
             HeapObject::KIND_HIR_ID => {
-                assert_eq!(
+                debug_assert_eq!(
                     header_word & !HeapObject::IS_REFERENCE_COUNTED_MASK,
                     HeapObject::KIND_HIR_ID,
                 );

compiler/vm/src/heap/object_heap/struct_.rs

@@ -31,7 +31,7 @@ impl HeapStruct {
         value: &FxHashMap<InlineObject, InlineObject>,
     ) -> Self {
         let len = value.len();
-        assert_eq!(
+        debug_assert_eq!(
             (len << Self::LEN_SHIFT) >> Self::LEN_SHIFT,
             len,
             "Struct is too long.",
@@ -56,7 +56,7 @@ impl HeapStruct {
     }
     #[must_use]
     fn create_uninitialized(heap: &mut Heap, is_reference_counted: bool, len: usize) -> Self {
-        assert_eq!(
+        debug_assert_eq!(
             (len << Self::LEN_SHIFT) >> Self::LEN_SHIFT,
             len,
             "Struct is too long.",
@@ -131,7 +131,7 @@ impl HeapStruct {
     }
     #[must_use]
     pub fn replace_at_index(self, heap: &mut Heap, index: usize, value: InlineObject) -> Self {
-        assert!(index < self.len());
+        debug_assert!(index < self.len());
 
         let struct_ = Self::create_uninitialized(heap, true, self.len());
         unsafe {

compiler/vm/src/heap/object_heap/text.rs

@@ -27,7 +27,7 @@ impl HeapText {
     #[must_use]
     pub fn create(heap: &mut Heap, is_reference_counted: bool, value: &str) -> Self {
         let byte_len = value.len();
-        assert_eq!(
+        debug_assert_eq!(
             (byte_len << Self::BYTE_LEN_SHIFT) >> Self::BYTE_LEN_SHIFT,
             byte_len,
             "Text is too long.",

compiler/vm/src/heap/object_inline/int.rs

@@ -216,7 +216,7 @@ impl InlineObjectTrait for InlineInt {
 #[extension_trait]
 pub impl I64BitLength for i64 {
     fn bit_length(self) -> u32 {
-        assert!(!self.is_negative());
+        debug_assert!(!self.is_negative());
         Self::BITS - self.leading_zeros()
     }
 }

compiler/vm/src/instructions.rs

@@ -261,7 +261,7 @@ impl MachineState {
                 self.run_builtin_function(heap, builtin.get(), arguments, responsible)
             }
             Data::Handle(handle) => {
-                assert_eq!(handle.argument_count(), arguments.len());
+                debug_assert_eq!(handle.argument_count(), arguments.len());
                 InstructionResult::CallHandle(CallHandle {
                     handle,
                     arguments: arguments.to_vec(),
@@ -277,7 +277,7 @@ impl MachineState {
         arguments: &[InlineObject],
         responsible: HirId,
     ) -> InstructionResult {
-        assert_eq!(function.argument_count(), arguments.len());
+        debug_assert_eq!(function.argument_count(), arguments.len());
         if let Some(next_instruction) = self.next_instruction {
             self.call_stack.push(next_instruction);
         }
@@ -299,7 +299,7 @@ impl MachineState {
         unsafe { value.unwrap_unchecked() }
     }
     fn pop_multiple_from_data_stack(&mut self, amount: usize) {
-        assert!(amount <= self.data_stack.len());
+        debug_assert!(amount <= self.data_stack.len());
         self.data_stack.truncate(self.data_stack.len() - amount);
     }
 }