Fix style check for Rust 1.80 (#1178)

Author: qinsoon

.github/scripts/ci-style.sh

@@ -6,11 +6,6 @@ export RUSTFLAGS="-D warnings -A unknown-lints"
 cargo fmt -- --check
 cargo fmt --manifest-path=macros/Cargo.toml -- --check
 
-# All versions of Clippy randomly crash on Darwin.  We disable Clippy tests for Darwin for now.
-if [[ $(uname) == "Darwin" ]]; then
-    exit 0
-fi
-
 # Workaround the clippy issue on Rust 1.72: https://github.com/mmtk/mmtk-core/issues/929.
 # If we are not testing with Rust 1.72, or there is no problem running the following clippy checks, we can remove this export.
 CLIPPY_VERSION=$(cargo clippy --version)

.github/workflows/api-check.yml

@@ -35,9 +35,9 @@ jobs:
       - run: cargo +nightly --version
 
       - name: Install cargo-public-api
-        run: cargo install cargo-public-api
+        run: cargo +nightly install cargo-public-api
       - name: API Diff
-        run: cargo public-api diff origin/${GITHUB_BASE_REF}..${{ github.event.pull_request.head.sha }} --deny=all
+        run: cargo +nightly public-api diff origin/${GITHUB_BASE_REF}..${{ github.event.pull_request.head.sha }} --deny=all
 
   check-api-migration-update:
     needs: check-public-api-changes

Cargo.toml

@@ -45,6 +45,7 @@ pfm = { version = "0.1.1", optional = true }
 portable-atomic = "1.4.3"
 probe = "0.5"
 regex = "1.7.0"
+rustversion = "1.0"
 spin = "0.9.5"
 static_assertions = "1.1.0"
 strum = "0.26.2"

src/lib.rs

@@ -33,8 +33,6 @@ extern crate strum_macros;
 extern crate lazy_static;
 #[macro_use]
 extern crate log;
-#[cfg(target = "x86_64-unknown-linux-gnu")]
-extern crate atomic;
 extern crate atomic_traits;
 extern crate crossbeam;
 extern crate num_cpus;

src/memory_manager.rs

@@ -644,6 +644,7 @@ pub fn find_object_from_internal_pointer<VM: VMBinding>(
 /// -   only MMTk can allocate into, or
 /// -   only MMTk's delegated memory allocator (such as a malloc implementation) can allocate into
 ///     for allocation requests from MMTk.
+///
 /// Return false otherwise.  This function never panics.
 ///
 /// Particularly, if this function returns true, `object` cannot be an object allocated by the VM

src/mmtk.rs

@@ -257,13 +257,13 @@ impl<VM: VMBinding> MMTK<VM> {
     /// requires the users to do some preparation before calling it.
     ///
     /// -   **Multi-threading**:  If `fork()` is called when the process has multiple threads, it
-    /// will only duplicate the current thread into the child process, and the child process can
-    /// only call async-signal-safe functions, notably `exec()`.  For VMs that that use
-    /// multi-process concurrency, it is imperative that when calling `fork()`, only one thread may
-    /// exist in the process.
+    ///     will only duplicate the current thread into the child process, and the child process can
+    ///     only call async-signal-safe functions, notably `exec()`.  For VMs that that use
+    ///     multi-process concurrency, it is imperative that when calling `fork()`, only one thread may
+    ///     exist in the process.
     ///
     /// -   **File descriptors**: The child process inherits copies of the parent's set of open
-    /// file descriptors.  This may or may not be desired depending on use cases.
+    ///     file descriptors.  This may or may not be desired depending on use cases.
     ///
     /// This function helps VMs that use `fork()` for multi-process concurrency.  It instructs all
     /// GC threads to save their contexts and return from their entry-point functions.  Currently,

src/util/heap/blockpageresource.rs

@@ -402,8 +402,8 @@ impl<B: Region> BlockPool<B> {
 
     /// Iterate all the blocks in the BlockQueue
     pub fn iterate_blocks(&self, f: &mut impl FnMut(B)) {
-        for array in &*self.head_global_freed_blocks.read() {
-            array.iterate_blocks(f)
+        if let Some(array) = &*self.head_global_freed_blocks.read() {
+            array.iterate_blocks(f);
         }
         for array in &*self.global_freed_blocks.read() {
             array.iterate_blocks(f);

src/util/heap/monotonepageresource.rs

@@ -85,7 +85,7 @@ impl<VM: VMBinding> PageResource<VM> for MonotonePageResource<VM> {
             sync.cursor, sync.sentinel, sync.current_chunk
         );
 
-        if cfg!(debug = "true") {
+        if cfg!(debug_assertions) {
             /*
              * Cursor should always be zero, or somewhere in the current chunk.  If we have just
              * allocated exactly enough pages to exhaust the current chunk, then cursor can point

src/util/malloc/library.rs

@@ -1,14 +1,8 @@
 // Export one of the malloc libraries.
 
-#[cfg(feature = "malloc_hoard")]
-pub use self::hoard::*;
 #[cfg(feature = "malloc_jemalloc")]
 pub use self::jemalloc::*;
-#[cfg(not(any(
-    feature = "malloc_jemalloc",
-    feature = "malloc_mimalloc",
-    feature = "malloc_hoard",
-)))]
+#[cfg(not(any(feature = "malloc_jemalloc", feature = "malloc_mimalloc",)))]
 pub use self::libc_malloc::*;
 #[cfg(feature = "malloc_mimalloc")]
 pub use self::mimalloc::*;
@@ -48,24 +42,8 @@ mod mimalloc {
     pub use mimalloc_sys::mi_malloc_usable_size as malloc_usable_size;
 }
 
-#[cfg(feature = "malloc_hoard")]
-mod hoard {
-    // Normal 4K page
-    pub const LOG_BYTES_IN_MALLOC_PAGE: u8 = crate::util::constants::LOG_BYTES_IN_PAGE;
-    // ANSI C
-    pub use hoard_sys::{calloc, free, malloc, realloc};
-    // Posix
-    pub use hoard_sys::posix_memalign;
-    // GNU
-    pub use hoard_sys::malloc_usable_size;
-}
-
 /// If no malloc lib is specified, use the libc implementation
-#[cfg(not(any(
-    feature = "malloc_jemalloc",
-    feature = "malloc_mimalloc",
-    feature = "malloc_hoard",
-)))]
+#[cfg(not(any(feature = "malloc_jemalloc", feature = "malloc_mimalloc",)))]
 mod libc_malloc {
     // Normal 4K page
     pub const LOG_BYTES_IN_MALLOC_PAGE: u8 = crate::util::constants::LOG_BYTES_IN_PAGE;

src/util/malloc/malloc_ms_util.rs

@@ -77,10 +77,6 @@ pub fn alloc<VM: VMBinding>(size: usize, align: usize, offset: usize) -> (Addres
         debug_assert!(address.is_aligned_to(align));
     } else if align > 16 && offset == 0 {
         address = align_alloc(size, align);
-        #[cfg(feature = "malloc_hoard")]
-        {
-            is_offset_malloc = true;
-        }
         debug_assert!(
             address.is_aligned_to(align),
             "Address: {:x} is not aligned to the given alignment: {}",