edits

Author: nunoplopes

.github/workflows/format.yml

@@ -11,8 +11,6 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v6
-        with:
-          ref: ${{ github.head_ref || github.ref_name }}
 
       - name: Setup LLVM 22
         uses: ZhongRuoyu/setup-llvm@v0
@@ -64,6 +62,6 @@ jobs:
 
       - name: Check Rust lints
         run: |
-          cargo clippy --manifest-path rules/Cargo.toml --all-targets -- -D clippy::correctness
-          cargo +nightly clippy --manifest-path rule-preprocessor/Cargo.toml --all-targets -- -D clippy::correctness
-          cargo clippy --manifest-path libcc2rs/Cargo.toml --all-targets -- -D clippy::correctness
+          cargo clippy --manifest-path rules/Cargo.toml --all-targets --all-features -- -Dwarnings
+          cargo +nightly clippy --manifest-path rule-preprocessor/Cargo.toml --all-targets --all-features -- -Dwarnings
+          cargo clippy --manifest-path libcc2rs/Cargo.toml --all-targets --all-features -- -Dwarnings

cpp2rust/converter/converter.cpp

@@ -48,10 +48,9 @@ use libc::*;
 extern crate libcc2rs;
 use libcc2rs::*;
 use std::collections::BTreeMap;
-use std::rc::Rc;
-use std::io::{Read, Write};
-use std::io::Seek;
+use std::io::{Read, Write, Seek};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
 )");
 }
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -23,13 +23,12 @@ void ConverterRefCount::EmitFilePreamble() {
   StrCat(R"(
 extern crate libcc2rs;
 use libcc2rs::*;
-use std::collections::BTreeMap;
 use std::cell::RefCell;
-use std::io::{Read, Write};
-use std::rc::{Rc, Weak};
-use std::io::Seek;
-use std::os::fd::AsFd;
+use std::collections::BTreeMap;
+use std::io::{Read, Write, Seek};
 use std::io::prelude::*;
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
 )");
 }
 

libcc2rs/src/compat.rs

@@ -13,6 +13,11 @@ extern "C" {
     fn platform_malloc_size(ptr: *const c_void) -> usize;
 }
 
+/// # Safety
+///
+/// The pointer `ptr` must be a pointer to a block of memory allocated by
+/// the appropriate allocator (e.g., `malloc`).
+// The memory must not have been deallocated.
 pub unsafe fn malloc_usable_size(ptr: *mut c_void) -> usize {
     #[cfg(target_os = "linux")]
     {

libcc2rs/src/dec.rs

@@ -66,6 +66,9 @@ prefix_wrap_dec_impl!(i8, u8, i16, u16, i32, u32, i64, u64, isize, usize);
 prefix_nowrap_dec_impl!(f32, f64);
 
 pub trait UnsafePostfixDec {
+    /// # Safety
+    /// This function decrements a pointer and returns the old value.
+    /// The caller must ensure the pointer is valid and doesn't underflow.
     unsafe fn postfix_dec(&mut self) -> Self;
 }
 
@@ -88,6 +91,9 @@ impl<T> UnsafePostfixDec for *mut T {
 }
 
 pub trait UnsafePrefixDec {
+    /// # Safety
+    /// This function decrements a pointer and returns the new value.
+    /// The caller must ensure the pointer is valid and doesn't underflow.
     unsafe fn prefix_dec(&mut self) -> Self;
 }
 

libcc2rs/src/inc.rs

@@ -77,6 +77,9 @@ postfix_wrap_inc_impl!(i8, u8, i16, u16, i32, u32, i64, u64, isize, usize);
 postfix_nowrap_inc_impl!(f32, f64);
 
 pub trait UnsafePostfixInc {
+    /// # Safety
+    /// This function increments a pointer and returns the old value.
+    /// The caller must ensure the pointer is valid and doesn't overflow.
     unsafe fn postfix_inc(&mut self) -> Self;
 }
 
@@ -99,6 +102,9 @@ impl<T> UnsafePostfixInc for *mut T {
 }
 
 pub trait UnsafePrefixInc {
+    /// # Safety
+    /// This function increments a pointer and returns the new value.
+    /// The caller must ensure the pointer is valid and doesn't overflow.
     unsafe fn prefix_inc(&mut self) -> Self;
 }
 

libcc2rs/src/io.rs

@@ -43,10 +43,18 @@ pub fn cerr() -> Ptr<std::fs::File> {
     SAFE_STDERR.with(AsPointer::as_pointer)
 }
 
+/// # Safety
+///
+/// The caller must ensure that the returned pointer is not used after the
+//  thread finishes.
 pub unsafe fn cout_unsafe() -> *mut std::fs::File {
     UNSAFE_STDOUT.with(UnsafeCell::get)
 }
 
+/// # Safety
+///
+/// The caller must ensure that the returned pointer is not used after the
+//  thread finishes.
 pub unsafe fn cerr_unsafe() -> *mut std::fs::File {
     UNSAFE_STDERR.with(UnsafeCell::get)
 }

libcc2rs/src/rc.rs

@@ -272,6 +272,25 @@ impl<T> Ptr<T> {
         }
     }
 
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        match self.kind {
+            PtrKind::Null => true,
+            PtrKind::StackSingle(_) | PtrKind::HeapSingle(_) => false,
+            PtrKind::Vec(ref weak) => weak
+                .upgrade()
+                .expect("ub: dangling pointer")
+                .borrow()
+                .is_empty(),
+            PtrKind::StackArray(ref weak) | PtrKind::HeapArray(ref weak) => weak
+                .upgrade()
+                .expect("ub: dangling pointer")
+                .borrow()
+                .is_empty(),
+            PtrKind::Reinterpreted(ref data) => self.offset >= data.total_byte_len(),
+        }
+    }
+
     #[inline]
     pub fn offset(&self, offset: isize) -> Self {
         let step = self.elem_step();
@@ -660,7 +679,9 @@ impl<T> std::ops::AddAssign<u64> for Ptr<T> {
     #[inline]
     fn add_assign(&mut self, other: u64) {
         let step = self.elem_step();
-        self.offset = self.offset.wrapping_add((other as usize) * step);
+        self.offset = self
+            .offset
+            .wrapping_add((other as usize).wrapping_mul(step));
     }
 }
 
@@ -670,23 +691,27 @@ impl<T> std::ops::AddAssign<i32> for Ptr<T> {
         let step = self.elem_step();
         self.offset = self
             .offset
-            .wrapping_add(((other as isize) * step as isize) as usize);
+            .wrapping_add(((other as isize).wrapping_mul(step as isize)) as usize);
     }
 }
 
 impl<T> std::ops::AddAssign<u32> for Ptr<T> {
     #[inline]
     fn add_assign(&mut self, other: u32) {
         let step = self.elem_step();
-        self.offset = self.offset.wrapping_add((other as usize) * step);
+        self.offset = self
+            .offset
+            .wrapping_add((other as usize).wrapping_mul(step));
     }
 }
 
 impl<T> std::ops::AddAssign<isize> for Ptr<T> {
     #[inline]
     fn add_assign(&mut self, other: isize) {
         let step = self.elem_step();
-        self.offset = self.offset.wrapping_add((other * step as isize) as usize);
+        self.offset = self
+            .offset
+            .wrapping_add((other.wrapping_mul(step as isize)) as usize);
     }
 }
 
@@ -900,6 +925,7 @@ thread_local! {
 }
 
 impl Ptr<u8> {
+    #[allow(clippy::explicit_counter_loop)]
     pub fn memcpy(&self, src: &Self, len: usize) {
         let mut dst = self.clone();
         let mut i: usize = 0;
@@ -914,6 +940,7 @@ impl Ptr<u8> {
         assert_eq!(i, len, "ub: memcpy");
     }
 
+    #[allow(clippy::explicit_counter_loop)]
     pub fn memset(&self, value: u8, num: usize) {
         let mut dst = self.clone();
         for _ in 0..num {
@@ -922,6 +949,7 @@ impl Ptr<u8> {
         }
     }
 
+    #[allow(clippy::explicit_counter_loop)]
     pub fn memcmp(&self, other: &Self, len: usize) -> i32 {
         let mut a = self.clone();
         let mut b = other.clone();

libcc2rs/src/reinterpret.rs

@@ -99,19 +99,19 @@ fn slice_read_bytes<S: ByteRepr>(slice: &[S], byte_offset: usize, buf: &mut [u8]
 // Only deserializes/reserializes the overlapping elements.
 fn slice_write_bytes<S: ByteRepr>(slice: &mut [S], byte_offset: usize, data: &[u8]) {
     let elem_size = std::mem::size_of::<S>();
+    let mut elem_buf = vec![0u8; elem_size];
     let first_elem = byte_offset / elem_size;
-    let last_elem = (byte_offset + data.len()).div_ceil(elem_size);
-    for elem_idx in first_elem..last_elem {
+    let num_elem = data.len().div_ceil(elem_size);
+    for (elem_idx, elem) in slice.iter_mut().enumerate().skip(first_elem).take(num_elem) {
         let elem_byte_start = elem_idx * elem_size;
-        let mut elem_buf = vec![0u8; elem_size];
-        slice[elem_idx].to_bytes(&mut elem_buf);
+        elem.to_bytes(&mut elem_buf);
         let overlap_start = byte_offset.max(elem_byte_start) - elem_byte_start;
         let overlap_end =
             (byte_offset + data.len()).min(elem_byte_start + elem_size) - elem_byte_start;
         let data_start = byte_offset.max(elem_byte_start) - byte_offset;
         elem_buf[overlap_start..overlap_end]
             .copy_from_slice(&data[data_start..data_start + (overlap_end - overlap_start)]);
-        slice[elem_idx] = S::from_bytes(&elem_buf);
+        *elem = S::from_bytes(&elem_buf);
     }
 }
 

libcc2rs/src/va_args.rs

@@ -1,3 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
 use std::ffi::c_void;
 
 use crate::rc::AnyPtr;