These changes were created by running cargo fix --edition

NOTE: I attempted to run flatc to re-generate the flatbuffer generated files but it did not do the updates for 2024 edition.

Updated manually for review feedback
Signed-off-by: Simon Davies <[email protected]>

Author: simongdavies

src/hyperlight_common/src/flatbuffers/hyperlight/generated/error_code_generated.rs

@@ -124,16 +124,20 @@ impl<'a> flatbuffers::Follow<'a> for ErrorCode {
     type Inner = Self;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = flatbuffers::read_scalar_at::<u64>(buf, loc);
-        Self(b)
+        unsafe {
+            let b = flatbuffers::read_scalar_at::<u64>(buf, loc);
+            Self(b)
+        }
     }
 }
 
 impl flatbuffers::Push for ErrorCode {
     type Output = ErrorCode;
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        flatbuffers::emplace_scalar::<u64>(dst, self.0);
+        unsafe {
+            flatbuffers::emplace_scalar::<u64>(dst, self.0);
+        }
     }
 }
 

src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCall<'a> {
     type Inner = FunctionCall<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }
@@ -290,14 +292,14 @@ pub fn size_prefixed_root_as_function_call_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `FunctionCall`.
 pub unsafe fn root_as_function_call_unchecked(buf: &[u8]) -> FunctionCall {
-    flatbuffers::root_unchecked::<FunctionCall>(buf)
+    unsafe { flatbuffers::root_unchecked::<FunctionCall>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed FunctionCall and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `FunctionCall`.
 pub unsafe fn size_prefixed_root_as_function_call_unchecked(buf: &[u8]) -> FunctionCall {
-    flatbuffers::size_prefixed_root_unchecked::<FunctionCall>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<FunctionCall>(buf) }
 }
 #[inline]
 pub fn finish_function_call_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(

src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_result_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCallResult<'a> {
     type Inner = FunctionCallResult<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }
@@ -513,7 +515,7 @@ pub fn size_prefixed_root_as_function_call_result_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `FunctionCallResult`.
 pub unsafe fn root_as_function_call_result_unchecked(buf: &[u8]) -> FunctionCallResult {
-    flatbuffers::root_unchecked::<FunctionCallResult>(buf)
+    unsafe { flatbuffers::root_unchecked::<FunctionCallResult>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed FunctionCallResult and returns it.
@@ -522,7 +524,7 @@ pub unsafe fn root_as_function_call_result_unchecked(buf: &[u8]) -> FunctionCall
 pub unsafe fn size_prefixed_root_as_function_call_result_unchecked(
     buf: &[u8],
 ) -> FunctionCallResult {
-    flatbuffers::size_prefixed_root_unchecked::<FunctionCallResult>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<FunctionCallResult>(buf) }
 }
 #[inline]
 pub fn finish_function_call_result_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(

src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_type_generated.rs

@@ -66,16 +66,20 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCallType {
     type Inner = Self;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
-        Self(b)
+        unsafe {
+            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            Self(b)
+        }
     }
 }
 
 impl flatbuffers::Push for FunctionCallType {
     type Output = FunctionCallType;
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        flatbuffers::emplace_scalar::<u8>(dst, self.0);
+        unsafe {
+            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+        }
     }
 }
 

src/hyperlight_common/src/flatbuffers/hyperlight/generated/guest_error_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for GuestError<'a> {
     type Inner = GuestError<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }
@@ -192,14 +194,14 @@ pub fn size_prefixed_root_as_guest_error_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `GuestError`.
 pub unsafe fn root_as_guest_error_unchecked(buf: &[u8]) -> GuestError {
-    flatbuffers::root_unchecked::<GuestError>(buf)
+    unsafe { flatbuffers::root_unchecked::<GuestError>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed GuestError and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `GuestError`.
 pub unsafe fn size_prefixed_root_as_guest_error_unchecked(buf: &[u8]) -> GuestError {
-    flatbuffers::size_prefixed_root_unchecked::<GuestError>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<GuestError>(buf) }
 }
 #[inline]
 pub fn finish_guest_error_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(

src/hyperlight_common/src/flatbuffers/hyperlight/generated/guest_log_data_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for GuestLogData<'a> {
     type Inner = GuestLogData<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }
@@ -288,14 +290,14 @@ pub fn size_prefixed_root_as_guest_log_data_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `GuestLogData`.
 pub unsafe fn root_as_guest_log_data_unchecked(buf: &[u8]) -> GuestLogData {
-    flatbuffers::root_unchecked::<GuestLogData>(buf)
+    unsafe { flatbuffers::root_unchecked::<GuestLogData>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed GuestLogData and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `GuestLogData`.
 pub unsafe fn size_prefixed_root_as_guest_log_data_unchecked(buf: &[u8]) -> GuestLogData {
-    flatbuffers::size_prefixed_root_unchecked::<GuestLogData>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<GuestLogData>(buf) }
 }
 #[inline]
 pub fn finish_guest_log_data_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(

src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlbool_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for hlbool<'a> {
     type Inner = hlbool<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }

src/hyperlight_common/src/flatbuffers/hyperlight/generated/hldouble_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for hldouble<'a> {
     type Inner = hldouble<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }

src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlfloat_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for hlfloat<'a> {
     type Inner = hlfloat<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }

src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlint_generated.rs

@@ -21,8 +21,10 @@ impl<'a> flatbuffers::Follow<'a> for hlint<'a> {
     type Inner = hlint<'a>;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+        unsafe {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
         }
     }
 }