Fix clippy lints

juntyr · juntyr · commit 9a53d25e320d · 2025-02-09T05:25:27.000Z
diff --git a/examples/lifetime/src/main.rs b/examples/lifetime/src/main.rs
@@ -2,30 +2,30 @@
 
 use lifetime::{kernel, link};
 
-fn main() -> rust_cuda::deps::rustacuda::error::CudaResult<()> {
+fn main() -> rust_cuda::deps::cust::error::CudaResult<()> {
     // Link the lifetime-only-generic CUDA kernel
     struct KernelPtx<'a, 'b>(core::marker::PhantomData<(&'a (), &'b ())>);
     link! { impl kernel<'a, 'b> for KernelPtx }
 
     // Initialize the CUDA API
-    rust_cuda::deps::rustacuda::init(rust_cuda::deps::rustacuda::CudaFlags::empty())?;
+    rust_cuda::deps::cust::init(rust_cuda::deps::cust::CudaFlags::empty())?;
 
     // Get the first CUDA GPU device
-    let device = rust_cuda::deps::rustacuda::device::Device::get_device(0)?;
+    let device = rust_cuda::deps::cust::device::Device::get_device(0)?;
 
     // Create a CUDA context associated to this device
     let _context = rust_cuda::host::CudaDropWrapper::from(
-        rust_cuda::deps::rustacuda::context::Context::create_and_push(
-            rust_cuda::deps::rustacuda::context::ContextFlags::MAP_HOST
-                | rust_cuda::deps::rustacuda::context::ContextFlags::SCHED_AUTO,
+        rust_cuda::deps::cust::context::legacy::Context::create_and_push(
+            rust_cuda::deps::cust::context::legacy::ContextFlags::MAP_HOST
+                | rust_cuda::deps::cust::context::legacy::ContextFlags::SCHED_AUTO,
             device,
         )?,
     );
 
     // Create a new CUDA stream to submit kernels to
     let mut stream =
-        rust_cuda::host::CudaDropWrapper::from(rust_cuda::deps::rustacuda::stream::Stream::new(
-            rust_cuda::deps::rustacuda::stream::StreamFlags::NON_BLOCKING,
+        rust_cuda::host::CudaDropWrapper::from(rust_cuda::deps::cust::stream::Stream::new(
+            rust_cuda::deps::cust::stream::StreamFlags::NON_BLOCKING,
             None,
         )?);
 
@@ -34,8 +34,8 @@ fn main() -> rust_cuda::deps::rustacuda::error::CudaResult<()> {
     // Create a new instance of the CUDA kernel and prepare the launch config
     let mut kernel = rust_cuda::kernel::TypedPtxKernel::<kernel>::new::<KernelPtx>(None);
     let config = rust_cuda::kernel::LaunchConfig {
-        grid: rust_cuda::deps::rustacuda::function::GridSize::x(1),
-        block: rust_cuda::deps::rustacuda::function::BlockSize::x(4),
+        grid: rust_cuda::deps::cust::function::GridSize::x(1),
+        block: rust_cuda::deps::cust::function::BlockSize::x(4),
         ptx_jit: false,
     };
 
diff --git a/rust-cuda-derive/src/rust_to_cuda/field_ty.rs b/rust-cuda-derive/src/rust_to_cuda/field_ty.rs
@@ -1,6 +1,5 @@
 use syn::{parse_quote, spanned::Spanned};
 
-#[expect(clippy::module_name_repetitions)]
 pub enum CudaReprFieldTy {
     SafeDeviceCopy,
     RustToCuda {
diff --git a/rust-cuda-derive/src/rust_to_cuda/mod.rs b/rust-cuda-derive/src/rust_to_cuda/mod.rs
@@ -10,7 +10,7 @@ fn get_cuda_repr_ident(rust_repr_ident: &proc_macro2::Ident) -> proc_macro2::Ide
     format_ident!("{}CudaRepresentation", rust_repr_ident)
 }
 
-#[expect(clippy::module_name_repetitions, clippy::too_many_lines)]
+#[expect(clippy::too_many_lines)]
 pub fn impl_rust_to_cuda(ast: &syn::DeriveInput) -> proc_macro::TokenStream {
     let (mut struct_fields_cuda, struct_semi_cuda) = if let syn::Data::Struct(s) = &ast.data {
         (s.fields.clone(), s.semi_token)
diff --git a/rust-cuda-kernel/src/kernel/link/mod.rs b/rust-cuda-kernel/src/kernel/link/mod.rs
@@ -321,7 +321,8 @@ fn check_kernel_ptx_and_report(
         Ok(None) => (),
         Ok(Some(binary)) => {
             if ptx_lint_levels
-                .get(&PtxLint::DumpAssembly).is_some_and(|level| *level > LintLevel::Allow)
+                .get(&PtxLint::DumpAssembly)
+                .is_some_and(|level| *level > LintLevel::Allow)
             {
                 const HEX: [char; 16] = [
                     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
@@ -335,7 +336,8 @@ fn check_kernel_ptx_and_report(
                 }
 
                 if ptx_lint_levels
-                    .get(&PtxLint::DumpAssembly).is_some_and(|level| *level > LintLevel::Warn)
+                    .get(&PtxLint::DumpAssembly)
+                    .is_some_and(|level| *level > LintLevel::Warn)
                 {
                     emit_call_site_error!(
                         "{} compiled binary:\n{}\n\n{}",
@@ -457,22 +459,27 @@ fn check_kernel_ptx(
             let mut options = options.clone();
 
             if ptx_lint_levels
-                .get(&PtxLint::Verbose).is_some_and(|level| *level > LintLevel::Warn)
+                .get(&PtxLint::Verbose)
+                .is_some_and(|level| *level > LintLevel::Warn)
             {
                 options.push(c"--verbose");
             }
             if ptx_lint_levels
-                .get(&PtxLint::DoublePrecisionUse).is_some_and(|level| *level > LintLevel::Warn)
+                .get(&PtxLint::DoublePrecisionUse)
+                .is_some_and(|level| *level > LintLevel::Warn)
             {
                 options.push(c"--warn-on-double-precision-use");
             }
             if ptx_lint_levels
-                .get(&PtxLint::LocalMemoryUse).is_some_and(|level| *level > LintLevel::Warn)
+                .get(&PtxLint::LocalMemoryUse)
+                .is_some_and(|level| *level > LintLevel::Warn)
             {
                 options.push(c"--warn-on-local-memory-usage");
             }
             if ptx_lint_levels
-                .get(&PtxLint::RegisterSpills).is_some_and(|level| *level > LintLevel::Warn) {
+                .get(&PtxLint::RegisterSpills)
+                .is_some_and(|level| *level > LintLevel::Warn)
+            {
                 options.push(c"--warn-on-spills");
             }
             if ptx_lint_levels
@@ -498,21 +505,26 @@ fn check_kernel_ptx(
         };
 
         if ptx_lint_levels
-            .get(&PtxLint::Verbose).is_some_and(|level| *level > LintLevel::Allow)
+            .get(&PtxLint::Verbose)
+            .is_some_and(|level| *level > LintLevel::Allow)
         {
             options.push(c"--verbose");
         }
         if ptx_lint_levels
-            .get(&PtxLint::DoublePrecisionUse).is_some_and(|level| *level > LintLevel::Allow) {
+            .get(&PtxLint::DoublePrecisionUse)
+            .is_some_and(|level| *level > LintLevel::Allow)
+        {
             options.push(c"--warn-on-double-precision-use");
         }
         if ptx_lint_levels
-            .get(&PtxLint::LocalMemoryUse).is_some_and(|level| *level > LintLevel::Allow)
+            .get(&PtxLint::LocalMemoryUse)
+            .is_some_and(|level| *level > LintLevel::Allow)
         {
             options.push(c"--warn-on-local-memory-usage");
         }
         if ptx_lint_levels
-            .get(&PtxLint::RegisterSpills).is_some_and(|level| *level > LintLevel::Allow)
+            .get(&PtxLint::RegisterSpills)
+            .is_some_and(|level| *level > LintLevel::Allow)
         {
             options.push(c"--warn-on-spills");
         }
diff --git a/src/kernel/mod.rs b/src/kernel/mod.rs
@@ -1,4 +1,3 @@
-use core::str;
 #[cfg(feature = "host")]
 use std::{
     ffi::{CStr, CString},
@@ -309,7 +308,7 @@ impl RawPtxKernel {
         // FIXME: cust's Module::get_function takes a str and turns it back into
         //        a CString immediately
         let function = unsafe { &*std::ptr::from_ref(module.as_ref()) }
-            .get_function(unsafe { str::from_utf8_unchecked(entry_point.to_bytes()) });
+            .get_function(unsafe { core::str::from_utf8_unchecked(entry_point.to_bytes()) });
 
         let function = match function {
             Ok(function) => function,
diff --git a/src/kernel/param.rs b/src/kernel/param.rs
@@ -807,10 +807,7 @@ impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter
         }
     }
 }
-impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed
-    for &mut DeepPerThreadBorrow<T>
-{
-}
+impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed for &mut DeepPerThreadBorrow<T> {}
 
 impl<
         T: Send
diff --git a/src/kernel/ptx_jit/regex.rs b/src/kernel/ptx_jit/regex.rs
@@ -2,7 +2,6 @@ use std::sync::OnceLock;
 
 use regex::bytes::Regex;
 
-#[expect(clippy::module_name_repetitions)]
 pub fn const_marker_regex() -> &'static Regex {
     static CONST_MARKER_REGEX: OnceLock<Regex> = OnceLock::new();
     #[allow(clippy::unwrap_used)]
@@ -12,7 +11,6 @@ pub fn const_marker_regex() -> &'static Regex {
     })
 }
 
-#[expect(clippy::module_name_repetitions)]
 pub fn const_base_register_regex() -> &'static Regex {
     static CONST_BASE_REGISTER_REGEX: OnceLock<Regex> = OnceLock::new();
     #[allow(clippy::unwrap_used)]
@@ -22,7 +20,6 @@ pub fn const_base_register_regex() -> &'static Regex {
     })
 }
 
-#[expect(clippy::module_name_repetitions)]
 pub fn const_load_instruction_regex() -> &'static Regex {
     static CONST_LOAD_INSTRUCTION_REGEX: OnceLock<Regex> = OnceLock::new();
     #[allow(clippy::unwrap_used)]
@@ -54,7 +51,6 @@ pub fn const_load_instruction_regex() -> &'static Regex {
     })
 }
 
-#[expect(clippy::module_name_repetitions)]
 pub fn register_regex() -> &'static Regex {
     static REGISTER_REGEX: OnceLock<Regex> = OnceLock::new();
     #[allow(clippy::unwrap_used)]
diff --git a/src/lend/impls/arc.rs b/src/lend/impls/arc.rs
@@ -30,7 +30,6 @@ use crate::{
 #[doc(hidden)]
 #[repr(transparent)]
 #[derive(TypeLayout)]
-#[expect(clippy::module_name_repetitions)]
 pub struct ArcCudaRepresentation<T: PortableBitSemantics + TypeGraphLayout>(
     DeviceOwnedPointer<_ArcInner<T>>,
 );
diff --git a/src/lend/impls/box.rs b/src/lend/impls/box.rs
@@ -29,7 +29,6 @@ use crate::{
 #[doc(hidden)]
 #[repr(transparent)]
 #[derive(TypeLayout)]
-#[expect(clippy::module_name_repetitions)]
 pub struct BoxCudaRepresentation<T: PortableBitSemantics + TypeGraphLayout>(DeviceOwnedPointer<T>);
 
 unsafe impl<T: PortableBitSemantics + TypeGraphLayout> RustToCuda for Box<T> {
diff --git a/src/lend/impls/boxed_slice.rs b/src/lend/impls/boxed_slice.rs
@@ -26,7 +26,6 @@ use crate::{
 };
 
 #[doc(hidden)]
-#[expect(clippy::module_name_repetitions)]
 #[derive(TypeLayout)]
 #[repr(C)]
 pub struct BoxedSliceCudaRepresentation<T: PortableBitSemantics + TypeGraphLayout> {
diff --git a/src/lend/impls/final.rs b/src/lend/impls/final.rs
@@ -6,7 +6,6 @@ use crate::{
 };
 
 #[doc(hidden)]
-#[expect(clippy::module_name_repetitions)]
 #[derive(const_type_layout::TypeLayout)]
 #[repr(transparent)]
 pub struct FinalCudaRepresentation<T: CudaAsRust>(DeviceAccessible<T>);
diff --git a/src/lend/impls/option.rs b/src/lend/impls/option.rs
@@ -18,7 +18,6 @@ use crate::{
 };
 
 #[doc(hidden)]
-#[expect(clippy::module_name_repetitions)]
 #[derive(TypeLayout)]
 #[repr(C)]
 pub struct OptionCudaRepresentation<T: CudaAsRust> {
diff --git a/src/lend/impls/ref.rs b/src/lend/impls/ref.rs
@@ -27,7 +27,6 @@ use crate::{
 #[doc(hidden)]
 #[repr(transparent)]
 #[derive(TypeLayout)]
-#[expect(clippy::module_name_repetitions)]
 pub struct RefCudaRepresentation<'a, T: 'a + PortableBitSemantics + TypeGraphLayout> {
     data: DeviceConstPointer<T>,
     _marker: PhantomData<&'a T>,
diff --git a/src/lend/impls/ref_mut.rs b/src/lend/impls/ref_mut.rs
@@ -24,7 +24,6 @@ use crate::{
 #[doc(hidden)]
 #[repr(transparent)]
 #[derive(TypeLayout)]
-#[expect(clippy::module_name_repetitions)]
 pub struct RefMutCudaRepresentation<'a, T: 'a + PortableBitSemantics + TypeGraphLayout> {
     data: DeviceMutPointer<T>,
     _marker: PhantomData<&'a mut T>,
diff --git a/src/lend/impls/slice_ref.rs b/src/lend/impls/slice_ref.rs
@@ -25,7 +25,6 @@ use crate::{
 };
 
 #[doc(hidden)]
-#[expect(clippy::module_name_repetitions)]
 #[derive(TypeLayout)]
 #[repr(C)]
 pub struct SliceRefCudaRepresentation<'a, T: 'a + PortableBitSemantics + TypeGraphLayout> {
diff --git a/src/lend/impls/slice_ref_mut.rs b/src/lend/impls/slice_ref_mut.rs
@@ -22,7 +22,6 @@ use crate::{
 };
 
 #[doc(hidden)]
-#[expect(clippy::module_name_repetitions)]
 #[derive(TypeLayout)]
 #[repr(C)]
 pub struct SliceRefMutCudaRepresentation<'a, T: 'a + PortableBitSemantics + TypeGraphLayout> {
diff --git a/src/lib.rs b/src/lib.rs
@@ -29,7 +29,6 @@
 #![feature(negative_impls)]
 #![cfg_attr(all(feature = "device", not(doc)), feature(stdarch_nvptx))]
 #![cfg_attr(feature = "device", feature(asm_experimental_arch))]
-#![cfg_attr(feature = "device", feature(asm_const))]
 #![feature(doc_auto_cfg)]
 #![feature(doc_cfg)]
 #![feature(marker_trait_attr)]
@@ -48,7 +47,6 @@
 #![feature(generic_const_exprs)]
 #![expect(internal_features)]
 #![feature(core_intrinsics)]
-// #![feature(const_intrinsic_compare_bytes)]
 #![doc(html_root_url = "https://juntyr.github.io/rust-cuda/")]
 
 #[cfg(all(feature = "host", feature = "device", not(doc)))]
diff --git a/src/safety/aliasing.rs b/src/safety/aliasing.rs
@@ -1,4 +1,3 @@
-#[expect(clippy::module_name_repetitions)]
 /// Types for which mutable references can be safely shared with each CUDA
 /// thread without breaking Rust's no-mutable-aliasing memory safety
 /// guarantees.
diff --git a/src/safety/portable.rs b/src/safety/portable.rs
@@ -36,7 +36,6 @@ macro_rules! portable_bit_semantics_docs {
 
 #[cfg(not(doc))]
 portable_bit_semantics_docs! {
-    #[expect(clippy::module_name_repetitions)]
     pub trait PortableBitSemantics: sealed::PortableBitSemantics {}
 }
 #[cfg(doc)]
diff --git a/src/utils/async.rs b/src/utils/async.rs
@@ -434,9 +434,7 @@ struct AsyncFuture<'a, 'stream, T: BorrowMut<C::Completed>, C: Completion<T>> {
 }
 
 #[cfg(feature = "host")]
-impl<T: BorrowMut<C::Completed>, C: Completion<T>> Future
-    for AsyncFuture<'_, '_, T, C>
-{
+impl<T: BorrowMut<C::Completed>, C: Completion<T>> Future for AsyncFuture<'_, '_, T, C> {
     type Output = CudaResult<T>;
 
     fn poll(
@@ -517,9 +515,7 @@ impl<'a, 'stream, T: BorrowMut<C::Completed>, C: Completion<T>> IntoFuture
 }
 
 #[cfg(feature = "host")]
-impl<T: BorrowMut<C::Completed>, C: Completion<T>> Drop
-    for AsyncFuture<'_, '_, T, C>
-{
+impl<T: BorrowMut<C::Completed>, C: Completion<T>> Drop for AsyncFuture<'_, '_, T, C> {
     fn drop(&mut self) {
         let Some(mut value) = self.value.take() else {
             return;
diff --git a/src/utils/exchange/buffer/device.rs b/src/utils/exchange/buffer/device.rs
@@ -9,7 +9,6 @@ use crate::{
 
 use super::CudaExchangeItem;
 
-#[expect(clippy::module_name_repetitions)]
 pub struct CudaExchangeBufferDevice<
     T: StackOnly + PortableBitSemantics + TypeGraphLayout,
     const M2D: bool,
diff --git a/src/utils/exchange/buffer/host.rs b/src/utils/exchange/buffer/host.rs
@@ -22,7 +22,6 @@ use crate::{
 
 use super::{common::CudaExchangeBufferCudaRepresentation, CudaExchangeItem};
 
-#[expect(clippy::module_name_repetitions)]
 pub struct CudaExchangeBufferHost<
     T: StackOnly + PortableBitSemantics + TypeGraphLayout,
     const M2D: bool,
diff --git a/src/utils/shared/slice.rs b/src/utils/shared/slice.rs
@@ -2,7 +2,6 @@ use core::alloc::Layout;
 
 use const_type_layout::TypeGraphLayout;
 
-#[expect(clippy::module_name_repetitions)]
 #[repr(transparent)]
 pub struct ThreadBlockSharedSlice<T: 'static + TypeGraphLayout> {
     shared: *mut [T],

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ fn get_cuda_repr_ident(rust_repr_ident: &proc_macro2::Ident) -> proc_macro2::Ide`
`10`	`10`	`format_ident!("{}CudaRepresentation", rust_repr_ident)`
`11`	`11`	`}`
`12`	`12`
`13`		`-#[expect(clippy::module_name_repetitions, clippy::too_many_lines)]`
	`13`	`+#[expect(clippy::too_many_lines)]`
`14`	`14`	`pub fn impl_rust_to_cuda(ast: &syn::DeriveInput) -> proc_macro::TokenStream {`
`15`	`15`	`let (mut struct_fields_cuda, struct_semi_cuda) = if let syn::Data::Struct(s) = &ast.data {`
`16`	`16`	`(s.fields.clone(), s.semi_token)`
Original file line number	Diff line number	Diff line change
`@@ -321,7 +321,8 @@ fn check_kernel_ptx_and_report(`
`321`	`321`	`Ok(None) => (),`
`322`	`322`	`Ok(Some(binary)) => {`
`323`	`323`	`if ptx_lint_levels`
`324`		`- .get(&PtxLint::DumpAssembly).is_some_and(\|level\| *level > LintLevel::Allow)`
	`324`	`+ .get(&PtxLint::DumpAssembly)`
	`325`	`+ .is_some_and(\|level\| *level > LintLevel::Allow)`
`325`	`326`	`{`
`326`	`327`	`const HEX: [char; 16] = [`
`327`	`328`	`'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',`
`@@ -335,7 +336,8 @@ fn check_kernel_ptx_and_report(`
`335`	`336`	`}`
`336`	`337`
`337`	`338`	`if ptx_lint_levels`
`338`		`- .get(&PtxLint::DumpAssembly).is_some_and(\|level\| *level > LintLevel::Warn)`
	`339`	`+ .get(&PtxLint::DumpAssembly)`
	`340`	`+ .is_some_and(\|level\| *level > LintLevel::Warn)`
`339`	`341`	`{`
`340`	`342`	`emit_call_site_error!(`
`341`	`343`	`"{} compiled binary:\n{}\n\n{}",`
`@@ -457,22 +459,27 @@ fn check_kernel_ptx(`
`457`	`459`	`let mut options = options.clone();`
`458`	`460`
`459`	`461`	`if ptx_lint_levels`
`460`		`- .get(&PtxLint::Verbose).is_some_and(\|level\| *level > LintLevel::Warn)`
	`462`	`+ .get(&PtxLint::Verbose)`
	`463`	`+ .is_some_and(\|level\| *level > LintLevel::Warn)`
`461`	`464`	`{`
`462`	`465`	`options.push(c"--verbose");`
`463`	`466`	`}`
`464`	`467`	`if ptx_lint_levels`
`465`		`- .get(&PtxLint::DoublePrecisionUse).is_some_and(\|level\| *level > LintLevel::Warn)`
	`468`	`+ .get(&PtxLint::DoublePrecisionUse)`
	`469`	`+ .is_some_and(\|level\| *level > LintLevel::Warn)`
`466`	`470`	`{`
`467`	`471`	`options.push(c"--warn-on-double-precision-use");`
`468`	`472`	`}`
`469`	`473`	`if ptx_lint_levels`
`470`		`- .get(&PtxLint::LocalMemoryUse).is_some_and(\|level\| *level > LintLevel::Warn)`
	`474`	`+ .get(&PtxLint::LocalMemoryUse)`
	`475`	`+ .is_some_and(\|level\| *level > LintLevel::Warn)`
`471`	`476`	`{`
`472`	`477`	`options.push(c"--warn-on-local-memory-usage");`
`473`	`478`	`}`
`474`	`479`	`if ptx_lint_levels`
`475`		`- .get(&PtxLint::RegisterSpills).is_some_and(\|level\| *level > LintLevel::Warn) {`
	`480`	`+ .get(&PtxLint::RegisterSpills)`
	`481`	`+ .is_some_and(\|level\| *level > LintLevel::Warn)`
	`482`	`+ {`
`476`	`483`	`options.push(c"--warn-on-spills");`
`477`	`484`	`}`
`478`	`485`	`if ptx_lint_levels`
`@@ -498,21 +505,26 @@ fn check_kernel_ptx(`
`498`	`505`	`};`
`499`	`506`
`500`	`507`	`if ptx_lint_levels`
`501`		`- .get(&PtxLint::Verbose).is_some_and(\|level\| *level > LintLevel::Allow)`
	`508`	`+ .get(&PtxLint::Verbose)`
	`509`	`+ .is_some_and(\|level\| *level > LintLevel::Allow)`
`502`	`510`	`{`
`503`	`511`	`options.push(c"--verbose");`
`504`	`512`	`}`
`505`	`513`	`if ptx_lint_levels`
`506`		`- .get(&PtxLint::DoublePrecisionUse).is_some_and(\|level\| *level > LintLevel::Allow) {`
	`514`	`+ .get(&PtxLint::DoublePrecisionUse)`
	`515`	`+ .is_some_and(\|level\| *level > LintLevel::Allow)`
	`516`	`+ {`
`507`	`517`	`options.push(c"--warn-on-double-precision-use");`
`508`	`518`	`}`
`509`	`519`	`if ptx_lint_levels`
`510`		`- .get(&PtxLint::LocalMemoryUse).is_some_and(\|level\| *level > LintLevel::Allow)`
	`520`	`+ .get(&PtxLint::LocalMemoryUse)`
	`521`	`+ .is_some_and(\|level\| *level > LintLevel::Allow)`
`511`	`522`	`{`
`512`	`523`	`options.push(c"--warn-on-local-memory-usage");`
`513`	`524`	`}`
`514`	`525`	`if ptx_lint_levels`
`515`		`- .get(&PtxLint::RegisterSpills).is_some_and(\|level\| *level > LintLevel::Allow)`
	`526`	`+ .get(&PtxLint::RegisterSpills)`
	`527`	`+ .is_some_and(\|level\| *level > LintLevel::Allow)`
`516`	`528`	`{`
`517`	`529`	`options.push(c"--warn-on-spills");`
`518`	`530`	`}`
Original file line number	Diff line number	Diff line change
`@@ -807,10 +807,7 @@ impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter`
`807`	`807`	`}`
`808`	`808`	`}`
`809`	`809`	`}`
`810`		`-impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed`
`811`		`- for &mut DeepPerThreadBorrow<T>`
`812`		`-{`
`813`		`-}`
	`810`	`+impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed for &mut DeepPerThreadBorrow<T> {}`
`814`	`811`
`815`	`812`	`impl<`
`816`	`813`	`T: Send`