fix: resolve massive syntax errors across wrt-sync and wrt-platform

- Fixed missing closing parentheses in wrt-sync unified_sync.rs and verify.rs
- Fixed syntax errors in wrt-sync test files (kani_proofs.rs, no_std_test_reference.rs)
- Fixed wrt-platform lib.rs panic handler and test function syntax
- Fixed wrt-platform comprehensive_limits.rs constructor and assertion syntax
- Partially fixed memory.rs syntax errors

This resolves the cargo-wrt build blocking syntax errors introduced by
previous global sed operations. Progress toward full compilation.

Author: avrabe

cargo-wrt/src/main.rs

@@ -49,8 +49,8 @@ impl<P: Provider + Clone> Clone for AtomicMemoryOps<P> {
 impl<P: Provider + PartialEq> PartialEq for AtomicMemoryOps<P> {
     fn eq(&self, other: &Self) -> bool {
         // Compare the underlying handlers (requires locking both)
-        let self_handler = self.handler.lock);
-        let other_handler = other.handler.lock);
+        let self_handler = self.handler.lock();
+        let other_handler = other.handler.lock();
         *self_handler == *other_handler && self.verification_level == other.verification_level
     }
 }
@@ -62,7 +62,7 @@ impl<P: Provider> AtomicMemoryOps<P> {
     ///
     /// This wraps the handler in a mutex to ensure atomic operations.
     pub fn new(handler: SafeMemoryHandler<P>) -> Self {
-        let verification_level = handler.verification_level);
+        let verification_level = handler.verification_level();
         Self { handler: WrtMutex::new(handler), verification_level }
     }
 
@@ -74,8 +74,8 @@ impl<P: Provider> AtomicMemoryOps<P> {
     where
         P: Sized + Clone,
     {
-        let handler = SafeMemoryHandler::new(provider;
-        let verification_level = handler.verification_level);
+        let handler = SafeMemoryHandler::new(provider)?;
+        let verification_level = handler.verification_level();
         Ok(Self { handler: WrtMutex::new(handler), verification_level })
     }
 
@@ -92,8 +92,8 @@ impl<P: Provider> AtomicMemoryOps<P> {
     #[cfg(feature = "std")]
     pub fn read_data(&self, offset: usize, len: usize) -> Result<Vec<u8>> {
         // Lock the handler for atomic access
-        let handler = self.handler.lock);
-        record_global_operation(OperationType::MemoryRead, self.verification_level;
+        let handler = self.handler.lock();
+        record_global_operation(OperationType::MemoryRead, self.verification_level);
 
         // Get the slice and copy the data to avoid lifetime issues
         let slice = handler.borrow_slice(offset, len)?;
@@ -119,8 +119,8 @@ impl<P: Provider> AtomicMemoryOps<P> {
     /// verification fails.
     pub fn atomic_write_with_checksum(&self, offset: usize, data: &[u8]) -> Result<()> {
         // Lock the handler for atomic access with Acquire ordering
-        let mut handler = self.handler.lock);
-        record_global_operation(OperationType::MemoryWrite, self.verification_level;
+        let mut handler = self.handler.lock();
+        record_global_operation(OperationType::MemoryWrite, self.verification_level);
 
         // Verify that the access is valid
         handler.verify_access(offset, data.len())?;
@@ -132,11 +132,11 @@ impl<P: Provider> AtomicMemoryOps<P> {
         let slice_data = slice.data_mut()?;
 
         // Copy the data while holding the lock
-        slice_data.copy_from_slice(data;
+        slice_data.copy_from_slice(data);
 
         // Update the checksum while still holding the lock
         // This ensures no bit flips can occur between write and checksum update
-        slice.update_checksum);
+        slice.update_checksum();
 
         // Lock is released automatically when handler goes out of scope
 
@@ -157,8 +157,8 @@ impl<P: Provider> AtomicMemoryOps<P> {
         len: usize,
     ) -> Result<()> {
         // Lock the handler for atomic access
-        let mut handler = self.handler.lock);
-        record_global_operation(OperationType::MemoryCopy, self.verification_level;
+        let mut handler = self.handler.lock();
+        record_global_operation(OperationType::MemoryCopy, self.verification_level);
 
         // Verify that the source access is valid
         handler.verify_access(src_offset, len)?;
@@ -179,15 +179,15 @@ impl<P: Provider> AtomicMemoryOps<P> {
             {
                 let source_slice = handler.borrow_slice(src_offset + src_pos, chunk_size)?;
                 let source_data = source_slice.data()?;
-                buffer[..chunk_size].copy_from_slice(&source_data[..chunk_size];
+                buffer[..chunk_size].copy_from_slice(&source_data[..chunk_size]);
             } // source_slice is dropped here, releasing immutable borrow
 
             // Write to the destination atomically with checksum update
             let mut dst_slice =
                 handler.provider_mut().get_slice_mut(dst_offset + dst_pos, chunk_size)?;
             let dst_data = dst_slice.data_mut()?;
-            dst_data.copy_from_slice(&buffer[..chunk_size];
-            dst_slice.update_checksum);
+            dst_data.copy_from_slice(&buffer[..chunk_size]);
+            dst_slice.update_checksum();
 
             remaining -= chunk_size;
             src_pos += chunk_size;
@@ -208,19 +208,19 @@ impl<P: Provider> AtomicMemoryOps<P> {
     /// underlying provider.
     pub fn set_verification_level(&mut self, level: VerificationLevel) {
         self.verification_level = level;
-        let mut handler = self.handler.lock);
-        handler.set_verification_level(level;
+        let mut handler = self.handler.lock();
+        handler.set_verification_level(level);
     }
 
     /// Gets the underlying memory provider's size.
     pub fn size(&self) -> usize {
-        let handler = self.handler.lock);
+        let handler = self.handler.lock();
         handler.size()
     }
 
     /// Gets the underlying memory provider's capacity.
     pub fn capacity(&self) -> usize {
-        let handler = self.handler.lock);
+        let handler = self.handler.lock();
         handler.capacity()
     }
 
@@ -242,7 +242,7 @@ impl<P: Provider> AtomicMemoryOps<P> {
     ///
     /// Returns an error if an integrity violation is detected.
     pub fn verify_integrity(&self) -> Result<()> {
-        let handler = self.handler.lock);
+        let handler = self.handler.lock();
         handler.provider().verify_integrity()
     }
 }
@@ -288,13 +288,13 @@ mod tests {
 
         #[cfg(not(feature = "std"))]
         let read_data = {
-            let handler = atomic_ops.handler.lock);
+            let handler = atomic_ops.handler.lock();
             let slice = handler.borrow_slice(0, test_data.len()).unwrap();
             slice.data().unwrap()
         };
 
         // Verify the data
-        assert_eq!(read_data, &test_data;
+        assert_eq!(read_data, &test_data);
         Ok(())
     }
 
@@ -314,14 +314,14 @@ mod tests {
         atomic_ops.atomic_write_with_checksum(0, &test_data).unwrap();
 
         // Verify integrity explicitly at both provider and slice levels
-        let handler = atomic_ops.handler.lock);
-        assert!(handler.provider().verify_integrity().is_ok();
+        let handler = atomic_ops.handler.lock();
+        assert!(handler.provider().verify_integrity().is_ok());
 
         // Access the internal slice to check its checksum
         let slice = handler.borrow_slice(0, test_data.len()).unwrap();
 
         // Verify integrity of the slice, which internally compares checksums
-        assert!(slice.verify_integrity().is_ok();
+        assert!(slice.verify_integrity().is_ok());
         Ok(())
     }
 
@@ -349,13 +349,13 @@ mod tests {
 
         #[cfg(not(feature = "std"))]
         let read_data = {
-            let handler = atomic_ops.handler.lock);
+            let handler = atomic_ops.handler.lock();
             let slice = handler.borrow_slice(20, 5).unwrap();
             slice.data().unwrap()
         };
 
         // Verify the data was copied correctly
-        assert_eq!(read_data, &[3, 4, 5, 6, 7];
+        assert_eq!(read_data, &[3, 4, 5, 6, 7]);
         Ok(())
     }
 }

wrt-foundation/src/atomic_memory.rs

@@ -115,7 +115,7 @@ pub const MAX_TYPE_ENUM_NAMES: usize = 64;
 const MAX_ITEM_SERIALIZED_SIZE: usize = 256;
 
 /// Size of the checksum in bytes, typically the size of a u32.
-pub const CHECKSUM_SIZE: usize = core::mem::size_of::<u32>);
+pub const CHECKSUM_SIZE: usize = core::mem::size_of::<u32>();
 
 #[cfg(feature = "std")]
 extern crate alloc;
@@ -565,7 +565,7 @@ where
         provider_arg: P,
         level: VerificationLevel,
     ) -> Result<Self> {
-        let item_serialized_size = T::default().serialized_size);
+        let item_serialized_size = T::default().serialized_size();
         if item_serialized_size == 0 && N_ELEMENTS > 0 {
             // Prevent division by zero or logical errors if N_ELEMENTS > 0 but items are
             // ZSTs. Or, if this is allowed, ensure memory_needed is handled
@@ -606,7 +606,7 @@ where
         let offset = self.length.saturating_mul(self.item_serialized_size;
         let mut item_bytes_buffer = [0u8; MAX_ITEM_SERIALIZED_SIZE];
 
-        let item_size = item.serialized_size);
+        let item_size = item.serialized_size();
         if item_size > MAX_ITEM_SERIALIZED_SIZE {
             return Err(BoundedError::new(
                 BoundedErrorKind::ItemTooLarge,
@@ -975,7 +975,7 @@ where
     /// Assumes all instances of T will have the same serialized size as
     /// T::default().
     pub fn new(provider_arg: P) -> Result<Self> {
-        let item_s_size = T::default().serialized_size);
+        let item_s_size = T::default().serialized_size();
         if item_s_size == 0 && N_ELEMENTS > 0 {
             return Err(crate::Error::runtime_execution_error("Item serialized size cannot be zero with non-zero capacity";
         }
@@ -999,7 +999,7 @@ where
         provider_arg: P, // Renamed provider to provider_arg
         verification_level: VerificationLevel,
     ) -> Result<Self> {
-        let item_size = T::default().serialized_size);
+        let item_size = T::default().serialized_size();
         if item_size == 0 && N_ELEMENTS > 0 {
             return Err(crate::Error::foundation_bounded_capacity_exceeded(
                 "Item serialized size cannot be zero with non-zero capacity"
@@ -1048,7 +1048,7 @@ where
         let offset = self.length.saturating_mul(self.item_serialized_size;
         let mut item_bytes_buffer = [0u8; MAX_ITEM_SERIALIZED_SIZE];
 
-        let item_size = item.serialized_size);
+        let item_size = item.serialized_size();
         if item_size > MAX_ITEM_SERIALIZED_SIZE {
             return Err(BoundedError::runtime_execution_error("Operation failed";
         }
@@ -1509,7 +1509,7 @@ where
 
         // Serialize the new value
         let mut item_bytes_buffer = [0u8; MAX_ITEM_SERIALIZED_SIZE];
-        let item_size = value.serialized_size);
+        let item_size = value.serialized_size();
 
         if item_size > MAX_ITEM_SERIALIZED_SIZE {
             return Err(BoundedError::new(
@@ -1615,7 +1615,7 @@ where
             // Move it one position forward
             let dest_offset = (i + 1) * self.item_serialized_size;
             let mut item_bytes_buffer = [0u8; MAX_ITEM_SERIALIZED_SIZE];
-            let item_size = current_item.serialized_size);
+            let item_size = current_item.serialized_size();
 
             if item_size > MAX_ITEM_SERIALIZED_SIZE {
                 return Err(BoundedError::new(
@@ -1649,7 +1649,7 @@ where
         // Now write the new value at the specified index
         let offset = index * self.item_serialized_size;
         let mut item_bytes_buffer = [0u8; MAX_ITEM_SERIALIZED_SIZE];
-        let item_size = value.serialized_size);
+        let item_size = value.serialized_size();
 
         if item_size > MAX_ITEM_SERIALIZED_SIZE {
             return Err(BoundedError::new(
@@ -1759,7 +1759,7 @@ where
             // Write it at the current position
             let dest_offset = i * self.item_serialized_size;
             let mut item_bytes_buffer = [0u8; MAX_ITEM_SERIALIZED_SIZE];
-            let item_size = next_item.serialized_size);
+            let item_size = next_item.serialized_size();
 
             if item_size > MAX_ITEM_SERIALIZED_SIZE {
                 return Err(BoundedError::new(

wrt-foundation/src/bounded.rs

@@ -48,7 +48,7 @@ impl<const N: usize> CapabilityGuardedProvider<N> {
         capability.verify_access(&operation)?;
 
         if capability.max_allocation_size() < N {
-            return Err(Error::security_access_denied("Provider size exceeds capability limit";
+            return Err(Error::security_access_denied("Provider size exceeds capability limit"));
         }
 
         Ok(Self { capability, provider: None, _phantom: PhantomData })
@@ -61,7 +61,7 @@ impl<const N: usize> CapabilityGuardedProvider<N> {
             use crate::{safe_managed_alloc, budget_aware_provider::CrateId};
             let provider = safe_managed_alloc!(N, CrateId::Foundation)
                 .map_err(|_| Error::memory_error("Failed to allocate provider"))?;
-            self.provider = Some(provider;
+            self.provider = Some(provider);
         }
 
         self.provider.as_mut().ok_or_else(|| Error::memory_error("Provider not initialized"))
@@ -78,7 +78,7 @@ impl<const N: usize> CapabilityGuardedProvider<N> {
         if offset + len > N {
             return Err(Error::runtime_execution_error(
                 "Read range exceeds provider capacity"
-            ;
+            ));
         }
 
         // Return a slice from the provider's buffer
@@ -97,12 +97,13 @@ impl<const N: usize> CapabilityGuardedProvider<N> {
             return Err(Error::new(
                 ErrorCategory::Memory,
                 codes::OUT_OF_BOUNDS,
-                "Write range exceeds provider capacity";
+                "Write range exceeds provider capacity"
+            ));
         }
 
         // Write to the provider's buffer
         let mut slice = provider.get_slice_mut(offset, data.len())?;
-        slice.data_mut()?.copy_from_slice(data;
+        slice.data_mut()?.copy_from_slice(data);
         Ok(())
     }
 
@@ -163,6 +164,6 @@ mod tests {
         let provider = MemoryFactory::create::<1024>(CrateId::Foundation).unwrap();
 
         // Test basic provider properties
-        assert_eq!(provider.size(), 1024;
+        assert_eq!(provider.size(), 1024);
     }
 }

wrt-foundation/src/capabilities/factory.rs

@@ -92,17 +92,17 @@ impl ExecutionStats {
 
     /// Reset all statistics to zero
     pub fn reset(&mut self) {
-        *self = Self::default);
+        *self = Self::default();
     }
 
     /// Add instruction count
     pub fn add_instructions(&mut self, count: u64) {
-        self.instructions_executed = self.instructions_executed.saturating_add(count;
+        self.instructions_executed = self.instructions_executed.saturating_add(count);
     }
 
     /// Add fuel consumption
     pub fn add_fuel(&mut self, fuel: u64) {
-        self.fuel_consumed = self.fuel_consumed.saturating_add(fuel;
+        self.fuel_consumed = self.fuel_consumed.saturating_add(fuel);
     }
 
     /// Update peak memory usage if current usage is higher
@@ -114,7 +114,7 @@ impl ExecutionStats {
 
     /// Record a function call
     pub fn record_function_call(&mut self, call_depth: u32) {
-        self.function_calls = self.function_calls.saturating_add(1;
+        self.function_calls = self.function_calls.saturating_add(1);
         if call_depth > self.max_call_depth_reached {
             self.max_call_depth_reached = call_depth;
         }