Enable allow_attributes_without_reason (#11195)

* Enable `allow_attributes_without_reason`

This commit enables the `clippy::allow_attributes_without_reason` for
the `wasmtime` crate which previously forcibly allowed it. The reason
this was allowed was that when the workspace was first migrated the
Wasmtime crate had too many instances that I was willing to fix. I've
now come back around and tried to fix everything.

In short: ideally delete `#[allow]`, otherwise use `#[expect]`,
otherwise use `#[allow]`.

prtest:full

* Adjust some directives

* Fix some warnings

* Fix stack switching size tests on unix

* Don't have a conditional `Drop` impl

* Force `testing_freelist` method to be used

Too lazy to write `#[cfg]`, but not too lazy to write a test.

Author: alexcrichton

crates/wasmtime/src/config.rs

@@ -2281,17 +2281,16 @@ impl Config {
 
         match &self.allocation_strategy {
             InstanceAllocationStrategy::OnDemand => {
-                #[allow(unused_mut)]
-                let mut allocator = Box::new(OnDemandInstanceAllocator::new(
+                let mut _allocator = Box::new(OnDemandInstanceAllocator::new(
                     self.mem_creator.clone(),
                     stack_size,
                     stack_zeroing,
                 ));
                 #[cfg(feature = "async")]
                 if let Some(stack_creator) = &self.stack_creator {
-                    allocator.set_stack_creator(stack_creator.clone());
+                    _allocator.set_stack_creator(stack_creator.clone());
                 }
-                Ok(allocator)
+                Ok(_allocator)
             }
             #[cfg(feature = "pooling-allocator")]
             InstanceAllocationStrategy::Pooling(config) => {
@@ -2317,7 +2316,7 @@ impl Config {
         #[cfg(feature = "gc")]
         #[cfg_attr(
             not(any(feature = "gc-null", feature = "gc-drc")),
-            allow(unused_variables, unreachable_code)
+            expect(unreachable_code, reason = "definitions known to be dummy")
         )]
         {
             Ok(Some(match self.collector.try_not_auto()? {
@@ -3571,7 +3570,10 @@ fn detect_host_feature(feature: &str) -> Option<bool> {
         };
     }
 
-    #[allow(unreachable_code)]
+    #[allow(
+        unreachable_code,
+        reason = "reachable or not depending on if a target above matches"
+    )]
     {
         let _ = feature;
         return None;

crates/wasmtime/src/engine.rs

@@ -761,25 +761,6 @@ impl Engine {
         crate::compile::HashedEngineCompileEnv(self)
     }
 
-    /// Executes `f1` and `f2` in parallel if parallel compilation is enabled at
-    /// both runtime and compile time, otherwise runs them synchronously.
-    #[allow(dead_code)] // only used for the component-model feature right now
-    pub(crate) fn join_maybe_parallel<T, U>(
-        &self,
-        f1: impl FnOnce() -> T + Send,
-        f2: impl FnOnce() -> U + Send,
-    ) -> (T, U)
-    where
-        T: Send,
-        U: Send,
-    {
-        if self.config().parallel_compilation {
-            #[cfg(feature = "parallel-compilation")]
-            return rayon::join(f1, f2);
-        }
-        (f1(), f2())
-    }
-
     /// Returns the required alignment for a code image, if we
     /// allocate in a way that is not a system `mmap()` that naturally
     /// aligns it.

crates/wasmtime/src/lib.rs

@@ -284,15 +284,14 @@
 // here to get warnings in all configurations of Wasmtime.
 #![cfg_attr(
     any(not(feature = "runtime"), not(feature = "std")),
-    allow(dead_code, unused_imports)
+    expect(dead_code, unused_imports, reason = "list not burned down yet")
 )]
 // Allow broken links when the default features is disabled because most of our
 // documentation is written for the "one build" of the `main` branch which has
 // most features enabled. This will present warnings in stripped-down doc builds
 // and will prevent the doc build from failing.
 #![cfg_attr(feature = "default", warn(rustdoc::broken_intra_doc_links))]
 #![no_std]
-#![expect(clippy::allow_attributes_without_reason, reason = "crate not migrated")]
 #![expect(unsafe_op_in_unsafe_fn, reason = "crate isn't migrated yet")]
 
 #[cfg(feature = "std")]
@@ -333,7 +332,7 @@ pub(crate) use hashbrown::{hash_map, hash_set};
 #[macro_export]
 macro_rules! map_maybe_uninit {
     ($maybe_uninit:ident $($field:tt)*) => ({
-        #[allow(unused_unsafe)]
+        #[allow(unused_unsafe, reason = "macro-generated code")]
         {
             unsafe {
                 use $crate::MaybeUninitExt;
@@ -391,7 +390,6 @@ mod sync_std;
 #[cfg(feature = "std")]
 use sync_std as sync;
 
-#[cfg_attr(feature = "std", allow(dead_code))]
 mod sync_nostd;
 #[cfg(not(feature = "std"))]
 use sync_nostd as sync;

crates/wasmtime/src/profiling_agent/jitdump.rs

@@ -17,6 +17,7 @@ use object::elf;
 use std::process;
 use std::sync::Mutex;
 use target_lexicon::Architecture;
+use wasmtime_environ::Unsigned;
 use wasmtime_jit_debug::perf_jitdump::*;
 
 /// Interface for driving the creation of jitdump files
@@ -54,8 +55,7 @@ impl ProfilingAgent for JitDumpAgent {
         let mut jitdump_file = JITDUMP_FILE.lock().unwrap();
         let jitdump_file = jitdump_file.as_mut().unwrap();
         let timestamp = jitdump_file.get_time_stamp();
-        #[allow(trivial_numeric_casts)]
-        let tid = rustix::thread::gettid().as_raw_nonzero().get() as u32;
+        let tid = rustix::thread::gettid().as_raw_nonzero().get().unsigned();
         if let Err(err) = jitdump_file.dump_code_load_record(&name, code, timestamp, self.pid, tid)
         {
             println!("Jitdump: write_code_load_failed_record failed: {err:?}\n");

crates/wasmtime/src/runtime/component/bindgen_examples/mod.rs

@@ -40,7 +40,10 @@
 //! [`wit_parser::Resolve::push_dir`]: https://docs.rs/wit-parser/latest/wit_parser/struct.Resolve.html#method.push_dir
 //! [open an issue]: https://github.com/bytecodealliance/wasmtime/issues/new
 
-#![allow(missing_docs)]
+#![expect(
+    missing_docs,
+    reason = "bindgen-generated types known to not have docs"
+)]
 
 // This "hack" will shadow the `bindgen` macro in general and be inherited to
 // following modules by default. This enables documenting sources as-is while

crates/wasmtime/src/runtime/component/component.rs

@@ -466,7 +466,7 @@ impl Component {
         &self.inner.static_modules[idx]
     }
 
-    #[cfg_attr(not(feature = "profiling"), allow(dead_code))]
+    #[cfg(feature = "profiling")]
     pub(crate) fn static_modules(&self) -> impl Iterator<Item = &Module> {
         self.inner.static_modules.values()
     }

crates/wasmtime/src/runtime/component/concurrent.rs

@@ -25,7 +25,7 @@ pub(crate) use futures_and_streams::{
 
 mod futures_and_streams;
 
-#[allow(dead_code)]
+#[expect(dead_code, reason = "to be used soon")]
 pub enum Status {
     Starting = 0,
     Started = 1,

crates/wasmtime/src/runtime/component/func/options.rs

@@ -49,7 +49,10 @@ pub struct Options {
     async_: bool,
 
     /// The callback for an async-lifted export, if specified.
-    #[cfg_attr(not(feature = "component-model-async"), expect(unused))]
+    #[cfg_attr(
+        not(feature = "component-model-async"),
+        expect(unused, reason = "to be used soon")
+    )]
     callback: Option<NonNull<VMFuncRef>>,
 }
 

crates/wasmtime/src/runtime/component/func/typed.rs

@@ -1006,7 +1006,7 @@ macro_rules! integers {
 
         unsafe impl Lower for $primitive {
             #[inline]
-            #[allow(trivial_numeric_casts)]
+            #[allow(trivial_numeric_casts, reason = "macro-generated code")]
             fn linear_lower_to_flat<T>(
                 &self,
                 _cx: &mut LowerContext<'_, T>,
@@ -1071,7 +1071,11 @@ macro_rules! integers {
 
         unsafe impl Lift for $primitive {
             #[inline]
-            #[allow(trivial_numeric_casts, clippy::cast_possible_truncation)]
+            #[allow(
+                trivial_numeric_casts,
+                clippy::cast_possible_truncation,
+                reason = "macro-generated code"
+            )]
             fn linear_lift_from_flat(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
                 debug_assert!(matches!(ty, InterfaceType::$ty));
                 Ok(src.$get() as $primitive)
@@ -2645,7 +2649,7 @@ where
 ///
 /// Uses default type parameters to have fields be zero-sized and not present
 /// in memory for smaller tuple values.
-#[allow(non_snake_case)]
+#[expect(non_snake_case, reason = "more amenable to macro-generated code")]
 #[doc(hidden)]
 #[derive(Clone, Copy)]
 #[repr(C)]
@@ -2691,7 +2695,7 @@ pub struct TupleLower<
 
 macro_rules! impl_component_ty_for_tuples {
     ($n:tt $($t:ident)*) => {
-        #[allow(non_snake_case)]
+        #[allow(non_snake_case, reason = "macro-generated code")]
         unsafe impl<$($t,)*> ComponentType for ($($t,)*)
             where $($t: ComponentType),*
         {
@@ -2718,7 +2722,7 @@ macro_rules! impl_component_ty_for_tuples {
             }
         }
 
-        #[allow(non_snake_case)]
+        #[allow(non_snake_case, reason = "macro-generated code")]
         unsafe impl<$($t,)*> Lower for ($($t,)*)
             where $($t: Lower),*
         {
@@ -2762,7 +2766,7 @@ macro_rules! impl_component_ty_for_tuples {
             }
         }
 
-        #[allow(non_snake_case)]
+        #[allow(non_snake_case, reason = "macro-generated code")]
         unsafe impl<$($t,)*> Lift for ($($t,)*)
             where $($t: Lift),*
         {
@@ -2799,7 +2803,7 @@ macro_rules! impl_component_ty_for_tuples {
             }
         }
 
-        #[allow(non_snake_case)]
+        #[allow(non_snake_case, reason = "macro-generated code")]
         unsafe impl<$($t,)*> ComponentNamedList for ($($t,)*)
             where $($t: ComponentType),*
         {}

crates/wasmtime/src/runtime/component/mod.rs

@@ -97,8 +97,10 @@
 //!
 //! See the docs for [`bindgen!`] for more information on how to use it.
 
-// rustdoc appears to lie about a warning above, so squelch it for now.
-#![allow(rustdoc::redundant_explicit_links)]
+#![allow(
+    rustdoc::redundant_explicit_links,
+    reason = "rustdoc appears to lie about a warning above, so squelch it for now"
+)]
 
 mod component;
 #[cfg(feature = "component-model-async")]