Update to experimental cust fork

juntyr · juntyr · commit 64e2331adae4 · 2025-02-08T21:41:43.000Z
diff --git a/Cargo.toml b/Cargo.toml
@@ -28,9 +28,9 @@ kernel = ["dep:rust-cuda-kernel"]
 [dependencies]
 const-type-layout = { version = "0.3.2", default-features = false, features = ["derive"] }
 # FIXME: cust fails to compile without the `bytemuck` feature
-cust = { version = "0.3.2", default-features = false, features = ["bytemuck"], optional = true }
-cust_core = { version = "0.1", default-features = false }
-cust_derive = { version = "0.2", default-features = false, optional = true }
+cust = { git = "https://github.com/juntyr/Rust-GPU-CUDA.git", rev = "5365c14", version = "0.3.2", default-features = false, features = ["bytemuck"], optional = true }
+cust_core = { git = "https://github.com/juntyr/Rust-GPU-CUDA.git", rev = "5365c14", version = "0.1", default-features = false }
+cust_derive = { git = "https://github.com/juntyr/Rust-GPU-CUDA.git", rev = "5365c14", version = "0.2", default-features = false, optional = true }
 final = { version = "0.1.1", default-features = false, optional = true }
 oneshot = { version = "0.1", default-features = false, features = ["std", "async"], optional = true }
 regex = { version = "1.10", default-features = false, optional = true }
diff --git a/examples/print/src/main.rs b/examples/print/src/main.rs
@@ -15,9 +15,9 @@ fn main() -> rust_cuda::deps::cust::error::CudaResult<()> {
 
     // Create a CUDA context associated to this device
     let _context = rust_cuda::host::CudaDropWrapper::from(
-        rust_cuda::deps::cust::context::Context::create_and_push(
-            rust_cuda::deps::cust::context::ContextFlags::MAP_HOST
-                | rust_cuda::deps::cust::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,
         )?,
     );
diff --git a/rust-cuda-kernel/src/kernel/link/mod.rs b/rust-cuda-kernel/src/kernel/link/mod.rs
@@ -211,6 +211,7 @@ fn extract_ptx_kernel_layout(kernel_ptx: &mut String) -> proc_macro2::TokenStrea
             );
         }
 
+        #[allow(clippy::literal_string_with_formatting_args)] // false positive
         if type_layout_metas
             .insert(String::from(param), bytes)
             .is_some()
@@ -341,8 +342,7 @@ fn check_kernel_ptx_and_report(
         Ok(None) => (),
         Ok(Some(binary)) => {
             if ptx_lint_levels
-                .get(&PtxLint::DumpAssembly)
-                .map_or(false, |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',
@@ -355,8 +355,7 @@ fn check_kernel_ptx_and_report(
                 }
 
                 if ptx_lint_levels
-                    .get(&PtxLint::DumpAssembly)
-                    .map_or(false, |level| *level > LintLevel::Warn)
+                    .get(&PtxLint::DumpAssembly).is_some_and(|level| *level > LintLevel::Warn)
                 {
                     emit_call_site_error!(
                         "{} compiled binary:\n{}\n\n{}",
@@ -475,27 +474,22 @@ fn check_kernel_ptx(
             let mut options = options.clone();
 
             if ptx_lint_levels
-                .get(&PtxLint::Verbose)
-                .map_or(false, |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)
-                .map_or(false, |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)
-                .map_or(false, |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)
-                .map_or(false, |level| *level > LintLevel::Warn)
-            {
+                .get(&PtxLint::RegisterSpills).is_some_and(|level| *level > LintLevel::Warn) {
                 options.push(c"--warn-on-spills");
             }
             if ptx_lint_levels
@@ -519,26 +513,21 @@ fn check_kernel_ptx(
         };
 
         if ptx_lint_levels
-            .get(&PtxLint::Verbose)
-            .map_or(false, |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)
-            .map_or(false, |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)
-            .map_or(false, |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)
-            .map_or(false, |level| *level > LintLevel::Allow)
+            .get(&PtxLint::RegisterSpills).is_some_and(|level| *level > LintLevel::Allow)
         {
             options.push(c"--warn-on-spills");
         }
diff --git a/rust-cuda-kernel/src/kernel/lints.rs b/rust-cuda-kernel/src/kernel/lints.rs
@@ -180,7 +180,7 @@ pub trait NestedMetaParser {
     ) -> syn::Result<()>;
 }
 
-impl<'a> NestedMetaParser for syn::meta::ParseNestedMeta<'a> {
+impl NestedMetaParser for syn::meta::ParseNestedMeta<'_> {
     fn path(&self) -> &syn::Path {
         &self.path
     }
diff --git a/rust-toolchain b/rust-toolchain
@@ -1,5 +1,5 @@
 [toolchain]
-# Pin to final 1.81.0 nightly
-channel = "nightly-2024-07-21"
+# Pin to final 1.85.0 nightly
+channel = "nightly-2025-01-03"
 components = [ "cargo", "rustfmt", "clippy", "llvm-bitcode-linker", "llvm-tools" ]
-targets = [ "x86_64-unknown-linux-gnu", "nvptx64-nvidia-cuda" ]
+targets = [ "nvptx64-nvidia-cuda" ]
diff --git a/src/host/mod.rs b/src/host/mod.rs
@@ -35,15 +35,15 @@ pub struct Stream<'stream> {
     _brand: InvariantLifetime<'stream>,
 }
 
-impl<'stream> Deref for Stream<'stream> {
+impl Deref for Stream<'_> {
     type Target = cust::stream::Stream;
 
     fn deref(&self) -> &Self::Target {
         self.stream
     }
 }
 
-impl<'stream> Stream<'stream> {
+impl Stream<'_> {
     /// Create a new uniquely branded [`Stream`], which can bind async
     /// operations to the [`Stream`] that they are computed on.
     ///
@@ -152,6 +152,7 @@ macro_rules! impl_sealed_drop_value {
 impl_sealed_drop_value!(Module);
 impl_sealed_drop_value!(cust::stream::Stream);
 impl_sealed_drop_value!(Context);
+impl_sealed_drop_value!(cust::context::legacy::Context);
 impl_sealed_drop_value!(Event);
 
 #[expect(clippy::module_name_repetitions)]
@@ -271,13 +272,13 @@ pub struct HostAndDeviceConstRef<'a, T: PortableBitSemantics + TypeGraphLayout>
     host_ref: &'a T,
 }
 
-impl<'a, T: PortableBitSemantics + TypeGraphLayout> Clone for HostAndDeviceConstRef<'a, T> {
+impl<T: PortableBitSemantics + TypeGraphLayout> Clone for HostAndDeviceConstRef<'_, T> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<'a, T: PortableBitSemantics + TypeGraphLayout> Copy for HostAndDeviceConstRef<'a, T> {}
+impl<T: PortableBitSemantics + TypeGraphLayout> Copy for HostAndDeviceConstRef<'_, T> {}
 
 impl<'a, T: PortableBitSemantics + TypeGraphLayout> HostAndDeviceConstRef<'a, T> {
     /// # Errors
diff --git a/src/kernel/mod.rs b/src/kernel/mod.rs
@@ -7,12 +7,11 @@ use std::{
     ptr::NonNull,
 };
 
-use cust::module::{ModuleJitOption, OptLevel};
 #[cfg(feature = "host")]
 use cust::{
     error::{CudaError, CudaResult},
     function::Function,
-    module::Module,
+    module::{Module, ModuleJitOption, OptLevel},
 };
 
 #[cfg(feature = "kernel")]
@@ -226,7 +225,7 @@ macro_rules! impl_launcher_launch {
 }
 
 #[cfg(feature = "host")]
-impl<'stream, 'kernel, Kernel> Launcher<'stream, 'kernel, Kernel> {
+impl<'stream, Kernel> Launcher<'stream, '_, Kernel> {
     impl_launcher_launch! { launch0() => with0_async => launch0_async }
 
     impl_launcher_launch! { launch1(
diff --git a/src/kernel/param.rs b/src/kernel/param.rs
@@ -157,6 +157,7 @@ impl<
 {
 }
 
+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]
 impl<
         'a,
         T: Sync + crate::safety::StackOnly + crate::safety::PortableBitSemantics + TypeGraphLayout,
@@ -244,9 +245,8 @@ impl<
     }
 }
 impl<
-        'a,
         T: Sync + crate::safety::StackOnly + crate::safety::PortableBitSemantics + TypeGraphLayout,
-    > sealed::Sealed for &'a PerThreadShallowCopy<T>
+    > sealed::Sealed for &PerThreadShallowCopy<T>
 {
 }
 
@@ -342,9 +342,8 @@ impl<
     }
 }
 impl<
-        'a,
         T: Sync + crate::safety::StackOnly + crate::safety::PortableBitSemantics + TypeGraphLayout,
-    > sealed::Sealed for &'a PtxJit<PerThreadShallowCopy<T>>
+    > sealed::Sealed for &PtxJit<PerThreadShallowCopy<T>>
 {
 }
 
@@ -374,6 +373,7 @@ impl<
     }
 }
 
+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]
 impl<
         'a,
         T: Sync
@@ -467,13 +467,12 @@ impl<
     }
 }
 impl<
-        'a,
         T: crate::safety::StackOnly
             + Sync
             + crate::safety::PortableBitSemantics
             + TypeGraphLayout
             + InteriorMutableSync,
-    > sealed::Sealed for &'a ShallowInteriorMutable<T>
+    > sealed::Sealed for &ShallowInteriorMutable<T>
 {
 }
 
@@ -618,6 +617,7 @@ impl<
 {
 }
 
+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]
 impl<'a, T: Sync + RustToCuda> CudaKernelParameter for &'a DeepPerThreadBorrow<T> {
     #[cfg(feature = "host")]
     type AsyncHostType<'stream, 'b>
@@ -707,8 +707,9 @@ impl<'a, T: Sync + RustToCuda> CudaKernelParameter for &'a DeepPerThreadBorrow<T
         }
     }
 }
-impl<'a, T: Sync + RustToCuda> sealed::Sealed for &'a DeepPerThreadBorrow<T> {}
+impl<T: Sync + RustToCuda> sealed::Sealed for &DeepPerThreadBorrow<T> {}
 
+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]
 impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter
     for &'a mut DeepPerThreadBorrow<T>
 {
@@ -806,8 +807,8 @@ impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter
         }
     }
 }
-impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed
-    for &'a mut DeepPerThreadBorrow<T>
+impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed
+    for &mut DeepPerThreadBorrow<T>
 {
 }
 
@@ -994,7 +995,7 @@ impl<'a, T: Sync + RustToCuda> CudaKernelParameter for &'a PtxJit<DeepPerThreadB
         }
     }
 }
-impl<'a, T: Sync + RustToCuda> sealed::Sealed for &'a PtxJit<DeepPerThreadBorrow<T>> {}
+impl<T: Sync + RustToCuda> sealed::Sealed for &PtxJit<DeepPerThreadBorrow<T>> {}
 
 impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter
     for &'a mut PtxJit<DeepPerThreadBorrow<T>>
@@ -1090,8 +1091,8 @@ impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter
         }
     }
 }
-impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed
-    for &'a mut PtxJit<DeepPerThreadBorrow<T>>
+impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed
+    for &mut PtxJit<DeepPerThreadBorrow<T>>
 {
 }
 
@@ -1135,7 +1136,7 @@ mod private_shared {
     }
 }
 
-impl<'a, T: 'static> CudaKernelParameter for &'a mut crate::utils::shared::ThreadBlockShared<T> {
+impl<T: 'static> CudaKernelParameter for &mut crate::utils::shared::ThreadBlockShared<T> {
     #[cfg(feature = "host")]
     type AsyncHostType<'stream, 'b>
         = &'b mut crate::utils::shared::ThreadBlockShared<T>
@@ -1218,10 +1219,10 @@ impl<'a, T: 'static> CudaKernelParameter for &'a mut crate::utils::shared::Threa
         inner.with(&mut param)
     }
 }
-impl<'a, T: 'static> sealed::Sealed for &'a mut crate::utils::shared::ThreadBlockShared<T> {}
+impl<T: 'static> sealed::Sealed for &mut crate::utils::shared::ThreadBlockShared<T> {}
 
-impl<'a, T: 'static + PortableBitSemantics + TypeGraphLayout> CudaKernelParameter
-    for &'a mut crate::utils::shared::ThreadBlockSharedSlice<T>
+impl<T: 'static + PortableBitSemantics + TypeGraphLayout> CudaKernelParameter
+    for &mut crate::utils::shared::ThreadBlockSharedSlice<T>
 {
     #[cfg(feature = "host")]
     type AsyncHostType<'stream, 'b>
@@ -1307,7 +1308,7 @@ impl<'a, T: 'static + PortableBitSemantics + TypeGraphLayout> CudaKernelParamete
         }
     }
 }
-impl<'a, T: 'static + PortableBitSemantics + TypeGraphLayout> sealed::Sealed
-    for &'a mut crate::utils::shared::ThreadBlockSharedSlice<T>
+impl<T: 'static + PortableBitSemantics + TypeGraphLayout> sealed::Sealed
+    for &mut crate::utils::shared::ThreadBlockSharedSlice<T>
 {
 }
diff --git a/src/lend/impls/mod.rs b/src/lend/impls/mod.rs
@@ -1,5 +1,5 @@
 mod arc;
-mod arced_slice;
+// mod arced_slice;
 mod r#box;
 mod boxed_slice;
 #[cfg(feature = "final")]
diff --git a/src/lend/impls/ref.rs b/src/lend/impls/ref.rs
@@ -71,7 +71,7 @@ unsafe impl<'a, T: PortableBitSemantics + TypeGraphLayout> RustToCuda for &'a T
     }
 }
 
-unsafe impl<'a, T: PortableBitSemantics + TypeGraphLayout> RustToCudaAsync for &'a T {
+unsafe impl<T: PortableBitSemantics + TypeGraphLayout> RustToCudaAsync for &T {
     #[cfg(all(feature = "host", not(doc)))]
     type CudaAllocationAsync = CombinedCudaAlloc<
         CudaDropWrapper<LockedBox<DeviceCopyWithPortableBitSemantics<ManuallyDrop<T>>>>,
diff --git a/src/lend/impls/slice_ref.rs b/src/lend/impls/slice_ref.rs
@@ -74,6 +74,7 @@ unsafe impl<'a, T: PortableBitSemantics + TypeGraphLayout> RustToCuda for &'a [T
     }
 }
 
+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]
 unsafe impl<'a, T: PortableBitSemantics + TypeGraphLayout> RustToCudaAsync for &'a [T] {
     #[cfg(all(feature = "host", not(doc)))]
     type CudaAllocationAsync = CombinedCudaAlloc<
diff --git a/src/lib.rs b/src/lib.rs
@@ -55,7 +55,7 @@
 #![feature(generic_const_exprs)]
 #![expect(internal_features)]
 #![feature(core_intrinsics)]
-#![feature(const_intrinsic_compare_bytes)]
+// #![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
@@ -38,23 +38,21 @@
 pub unsafe trait SafeMutableAliasing {}
 
 unsafe impl<
-        'a,
         T: crate::safety::StackOnly
             + crate::safety::PortableBitSemantics
             + const_type_layout::TypeGraphLayout,
         const STRIDE: usize,
     > SafeMutableAliasing
-    for crate::utils::aliasing::SplitSliceOverCudaThreadsConstStride<&'a mut [T], STRIDE>
+    for crate::utils::aliasing::SplitSliceOverCudaThreadsConstStride<&mut [T], STRIDE>
 {
 }
 
 unsafe impl<
-        'a,
         T: crate::safety::StackOnly
             + crate::safety::PortableBitSemantics
             + const_type_layout::TypeGraphLayout,
     > SafeMutableAliasing
-    for crate::utils::aliasing::SplitSliceOverCudaThreadsDynamicStride<&'a mut [T]>
+    for crate::utils::aliasing::SplitSliceOverCudaThreadsDynamicStride<&mut [T]>
 {
 }
 
diff --git a/src/utils/async.rs b/src/utils/async.rs
diff --git a/src/utils/exchange/wrapper.rs b/src/utils/exchange/wrapper.rs
diff --git a/src/utils/ffi.rs b/src/utils/ffi.rs

Original file line number	Diff line number	Diff line change
`@@ -211,6 +211,7 @@ fn extract_ptx_kernel_layout(kernel_ptx: &mut String) -> proc_macro2::TokenStrea`
`211`	`211`	`);`
`212`	`212`	`}`
`213`	`213`
	`214`	`+ #[allow(clippy::literal_string_with_formatting_args)] // false positive`
`214`	`215`	`if type_layout_metas`
`215`	`216`	`.insert(String::from(param), bytes)`
`216`	`217`	`.is_some()`
`@@ -341,8 +342,7 @@ fn check_kernel_ptx_and_report(`
`341`	`342`	`Ok(None) => (),`
`342`	`343`	`Ok(Some(binary)) => {`
`343`	`344`	`if ptx_lint_levels`
`344`		`- .get(&PtxLint::DumpAssembly)`
`345`		`- .map_or(false, \|level\| *level > LintLevel::Allow)`
	`345`	`+ .get(&PtxLint::DumpAssembly).is_some_and(\|level\| *level > LintLevel::Allow)`
`346`	`346`	`{`
`347`	`347`	`const HEX: [char; 16] = [`
`348`	`348`	`'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',`
`@@ -355,8 +355,7 @@ fn check_kernel_ptx_and_report(`
`355`	`355`	`}`
`356`	`356`
`357`	`357`	`if ptx_lint_levels`
`358`		`- .get(&PtxLint::DumpAssembly)`
`359`		`- .map_or(false, \|level\| *level > LintLevel::Warn)`
	`358`	`+ .get(&PtxLint::DumpAssembly).is_some_and(\|level\| *level > LintLevel::Warn)`
`360`	`359`	`{`
`361`	`360`	`emit_call_site_error!(`
`362`	`361`	`"{} compiled binary:\n{}\n\n{}",`
`@@ -475,27 +474,22 @@ fn check_kernel_ptx(`
`475`	`474`	`let mut options = options.clone();`
`476`	`475`
`477`	`476`	`if ptx_lint_levels`
`478`		`- .get(&PtxLint::Verbose)`
`479`		`- .map_or(false, \|level\| *level > LintLevel::Warn)`
	`477`	`+ .get(&PtxLint::Verbose).is_some_and(\|level\| *level > LintLevel::Warn)`
`480`	`478`	`{`
`481`	`479`	`options.push(c"--verbose");`
`482`	`480`	`}`
`483`	`481`	`if ptx_lint_levels`
`484`		`- .get(&PtxLint::DoublePrecisionUse)`
`485`		`- .map_or(false, \|level\| *level > LintLevel::Warn)`
	`482`	`+ .get(&PtxLint::DoublePrecisionUse).is_some_and(\|level\| *level > LintLevel::Warn)`
`486`	`483`	`{`
`487`	`484`	`options.push(c"--warn-on-double-precision-use");`
`488`	`485`	`}`
`489`	`486`	`if ptx_lint_levels`
`490`		`- .get(&PtxLint::LocalMemoryUse)`
`491`		`- .map_or(false, \|level\| *level > LintLevel::Warn)`
	`487`	`+ .get(&PtxLint::LocalMemoryUse).is_some_and(\|level\| *level > LintLevel::Warn)`
`492`	`488`	`{`
`493`	`489`	`options.push(c"--warn-on-local-memory-usage");`
`494`	`490`	`}`
`495`	`491`	`if ptx_lint_levels`
`496`		`- .get(&PtxLint::RegisterSpills)`
`497`		`- .map_or(false, \|level\| *level > LintLevel::Warn)`
`498`		`- {`
	`492`	`+ .get(&PtxLint::RegisterSpills).is_some_and(\|level\| *level > LintLevel::Warn) {`
`499`	`493`	`options.push(c"--warn-on-spills");`
`500`	`494`	`}`
`501`	`495`	`if ptx_lint_levels`
`@@ -519,26 +513,21 @@ fn check_kernel_ptx(`
`519`	`513`	`};`
`520`	`514`
`521`	`515`	`if ptx_lint_levels`
`522`		`- .get(&PtxLint::Verbose)`
`523`		`- .map_or(false, \|level\| *level > LintLevel::Allow)`
	`516`	`+ .get(&PtxLint::Verbose).is_some_and(\|level\| *level > LintLevel::Allow)`
`524`	`517`	`{`
`525`	`518`	`options.push(c"--verbose");`
`526`	`519`	`}`
`527`	`520`	`if ptx_lint_levels`
`528`		`- .get(&PtxLint::DoublePrecisionUse)`
`529`		`- .map_or(false, \|level\| *level > LintLevel::Allow)`
`530`		`- {`
	`521`	`+ .get(&PtxLint::DoublePrecisionUse).is_some_and(\|level\| *level > LintLevel::Allow) {`
`531`	`522`	`options.push(c"--warn-on-double-precision-use");`
`532`	`523`	`}`
`533`	`524`	`if ptx_lint_levels`
`534`		`- .get(&PtxLint::LocalMemoryUse)`
`535`		`- .map_or(false, \|level\| *level > LintLevel::Allow)`
	`525`	`+ .get(&PtxLint::LocalMemoryUse).is_some_and(\|level\| *level > LintLevel::Allow)`
`536`	`526`	`{`
`537`	`527`	`options.push(c"--warn-on-local-memory-usage");`
`538`	`528`	`}`
`539`	`529`	`if ptx_lint_levels`
`540`		`- .get(&PtxLint::RegisterSpills)`
`541`		`- .map_or(false, \|level\| *level > LintLevel::Allow)`
	`530`	`+ .get(&PtxLint::RegisterSpills).is_some_and(\|level\| *level > LintLevel::Allow)`
`542`	`531`	`{`
`543`	`532`	`options.push(c"--warn-on-spills");`
`544`	`533`	`}`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ pub trait NestedMetaParser {`
`180`	`180`	`) -> syn::Result<()>;`
`181`	`181`	`}`
`182`	`182`
`183`		`-impl<'a> NestedMetaParser for syn::meta::ParseNestedMeta<'a> {`
	`183`	`+impl NestedMetaParser for syn::meta::ParseNestedMeta<'_> {`
`184`	`184`	`fn path(&self) -> &syn::Path {`
`185`	`185`	`&self.path`
`186`	`186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,15 +35,15 @@ pub struct Stream<'stream> {`
`35`	`35`	`_brand: InvariantLifetime<'stream>,`
`36`	`36`	`}`
`37`	`37`
`38`		`-impl<'stream> Deref for Stream<'stream> {`
	`38`	`+impl Deref for Stream<'_> {`
`39`	`39`	`type Target = cust::stream::Stream;`
`40`	`40`
`41`	`41`	`fn deref(&self) -> &Self::Target {`
`42`	`42`	`self.stream`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`-impl<'stream> Stream<'stream> {`
	`46`	`+impl Stream<'_> {`
`47`	`47`	/// Create a new uniquely branded [`Stream`], which can bind async
`48`	`48`	/// operations to the [`Stream`] that they are computed on.
`49`	`49`	`///`
`@@ -152,6 +152,7 @@ macro_rules! impl_sealed_drop_value {`
`152`	`152`	`impl_sealed_drop_value!(Module);`
`153`	`153`	`impl_sealed_drop_value!(cust::stream::Stream);`
`154`	`154`	`impl_sealed_drop_value!(Context);`
	`155`	`+impl_sealed_drop_value!(cust::context::legacy::Context);`
`155`	`156`	`impl_sealed_drop_value!(Event);`
`156`	`157`
`157`	`158`	`#[expect(clippy::module_name_repetitions)]`
`@@ -271,13 +272,13 @@ pub struct HostAndDeviceConstRef<'a, T: PortableBitSemantics + TypeGraphLayout>`
`271`	`272`	`host_ref: &'a T,`
`272`	`273`	`}`
`273`	`274`
`274`		`-impl<'a, T: PortableBitSemantics + TypeGraphLayout> Clone for HostAndDeviceConstRef<'a, T> {`
	`275`	`+impl<T: PortableBitSemantics + TypeGraphLayout> Clone for HostAndDeviceConstRef<'_, T> {`
`275`	`276`	`fn clone(&self) -> Self {`
`276`	`277`	`*self`
`277`	`278`	`}`
`278`	`279`	`}`
`279`	`280`
`280`		`-impl<'a, T: PortableBitSemantics + TypeGraphLayout> Copy for HostAndDeviceConstRef<'a, T> {}`
	`281`	`+impl<T: PortableBitSemantics + TypeGraphLayout> Copy for HostAndDeviceConstRef<'_, T> {}`
`281`	`282`
`282`	`283`	`impl<'a, T: PortableBitSemantics + TypeGraphLayout> HostAndDeviceConstRef<'a, T> {`
`283`	`284`	`/// # Errors`
Original file line number	Diff line number	Diff line change
`@@ -157,6 +157,7 @@ impl<`
`157`	`157`	`{`
`158`	`158`	`}`
`159`	`159`
	`160`	`+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]`
`160`	`161`	`impl<`
`161`	`162`	`'a,`
`162`	`163`	`T: Sync + crate::safety::StackOnly + crate::safety::PortableBitSemantics + TypeGraphLayout,`
`@@ -244,9 +245,8 @@ impl<`
`244`	`245`	`}`
`245`	`246`	`}`
`246`	`247`	`impl<`
`247`		`- 'a,`
`248`	`248`	`T: Sync + crate::safety::StackOnly + crate::safety::PortableBitSemantics + TypeGraphLayout,`
`249`		`- > sealed::Sealed for &'a PerThreadShallowCopy<T>`
	`249`	`+ > sealed::Sealed for &PerThreadShallowCopy<T>`
`250`	`250`	`{`
`251`	`251`	`}`
`252`	`252`
`@@ -342,9 +342,8 @@ impl<`
`342`	`342`	`}`
`343`	`343`	`}`
`344`	`344`	`impl<`
`345`		`- 'a,`
`346`	`345`	`T: Sync + crate::safety::StackOnly + crate::safety::PortableBitSemantics + TypeGraphLayout,`
`347`		`- > sealed::Sealed for &'a PtxJit<PerThreadShallowCopy<T>>`
	`346`	`+ > sealed::Sealed for &PtxJit<PerThreadShallowCopy<T>>`
`348`	`347`	`{`
`349`	`348`	`}`
`350`	`349`
`@@ -374,6 +373,7 @@ impl<`
`374`	`373`	`}`
`375`	`374`	`}`
`376`	`375`
	`376`	`+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]`
`377`	`377`	`impl<`
`378`	`378`	`'a,`
`379`	`379`	`T: Sync`
`@@ -467,13 +467,12 @@ impl<`
`467`	`467`	`}`
`468`	`468`	`}`
`469`	`469`	`impl<`
`470`		`- 'a,`
`471`	`470`	`T: crate::safety::StackOnly`
`472`	`471`	`+ Sync`
`473`	`472`	`+ crate::safety::PortableBitSemantics`
`474`	`473`	`+ TypeGraphLayout`
`475`	`474`	`+ InteriorMutableSync,`
`476`		`- > sealed::Sealed for &'a ShallowInteriorMutable<T>`
	`475`	`+ > sealed::Sealed for &ShallowInteriorMutable<T>`
`477`	`476`	`{`
`478`	`477`	`}`
`479`	`478`
`@@ -618,6 +617,7 @@ impl<`
`618`	`617`	`{`
`619`	`618`	`}`
`620`	`619`
	`620`	`+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]`
`621`	`621`	`impl<'a, T: Sync + RustToCuda> CudaKernelParameter for &'a DeepPerThreadBorrow<T> {`
`622`	`622`	`#[cfg(feature = "host")]`
`623`	`623`	`type AsyncHostType<'stream, 'b>`
`@@ -707,8 +707,9 @@ impl<'a, T: Sync + RustToCuda> CudaKernelParameter for &'a DeepPerThreadBorrow<T`
`707`	`707`	`}`
`708`	`708`	`}`
`709`	`709`	`}`
`710`		`-impl<'a, T: Sync + RustToCuda> sealed::Sealed for &'a DeepPerThreadBorrow<T> {}`
	`710`	`+impl<T: Sync + RustToCuda> sealed::Sealed for &DeepPerThreadBorrow<T> {}`
`711`	`711`
	`712`	`+#[cfg_attr(feature = "device", expect(clippy::needless_lifetimes))]`
`712`	`713`	`impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter`
`713`	`714`	`for &'a mut DeepPerThreadBorrow<T>`
`714`	`715`	`{`
`@@ -806,8 +807,8 @@ impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter`
`806`	`807`	`}`
`807`	`808`	`}`
`808`	`809`	`}`
`809`		`-impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed`
`810`		`- for &'a mut DeepPerThreadBorrow<T>`
	`810`	`+impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed`
	`811`	`+ for &mut DeepPerThreadBorrow<T>`
`811`	`812`	`{`
`812`	`813`	`}`
`813`	`814`
`@@ -994,7 +995,7 @@ impl<'a, T: Sync + RustToCuda> CudaKernelParameter for &'a PtxJit<DeepPerThreadB`
`994`	`995`	`}`
`995`	`996`	`}`
`996`	`997`	`}`
`997`		`-impl<'a, T: Sync + RustToCuda> sealed::Sealed for &'a PtxJit<DeepPerThreadBorrow<T>> {}`
	`998`	`+impl<T: Sync + RustToCuda> sealed::Sealed for &PtxJit<DeepPerThreadBorrow<T>> {}`
`998`	`999`
`999`	`1000`	`impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter`
`1000`	`1001`	`for &'a mut PtxJit<DeepPerThreadBorrow<T>>`
`@@ -1090,8 +1091,8 @@ impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> CudaKernelParameter`
`1090`	`1091`	`}`
`1091`	`1092`	`}`
`1092`	`1093`	`}`
`1093`		`-impl<'a, T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed`
`1094`		`- for &'a mut PtxJit<DeepPerThreadBorrow<T>>`
	`1094`	`+impl<T: Sync + RustToCuda + SafeMutableAliasing> sealed::Sealed`
	`1095`	`+ for &mut PtxJit<DeepPerThreadBorrow<T>>`
`1095`	`1096`	`{`
`1096`	`1097`	`}`
`1097`	`1098`
`@@ -1135,7 +1136,7 @@ mod private_shared {`
`1135`	`1136`	`}`
`1136`	`1137`	`}`
`1137`	`1138`
`1138`		`-impl<'a, T: 'static> CudaKernelParameter for &'a mut crate::utils::shared::ThreadBlockShared<T> {`
	`1139`	`+impl<T: 'static> CudaKernelParameter for &mut crate::utils::shared::ThreadBlockShared<T> {`
`1139`	`1140`	`#[cfg(feature = "host")]`
`1140`	`1141`	`type AsyncHostType<'stream, 'b>`
`1141`	`1142`	`= &'b mut crate::utils::shared::ThreadBlockShared<T>`
`@@ -1218,10 +1219,10 @@ impl<'a, T: 'static> CudaKernelParameter for &'a mut crate::utils::shared::Threa`
`1218`	`1219`	`inner.with(&mut param)`
`1219`	`1220`	`}`
`1220`	`1221`	`}`
`1221`		`-impl<'a, T: 'static> sealed::Sealed for &'a mut crate::utils::shared::ThreadBlockShared<T> {}`
	`1222`	`+impl<T: 'static> sealed::Sealed for &mut crate::utils::shared::ThreadBlockShared<T> {}`
`1222`	`1223`
`1223`		`-impl<'a, T: 'static + PortableBitSemantics + TypeGraphLayout> CudaKernelParameter`
`1224`		`- for &'a mut crate::utils::shared::ThreadBlockSharedSlice<T>`
	`1224`	`+impl<T: 'static + PortableBitSemantics + TypeGraphLayout> CudaKernelParameter`
	`1225`	`+ for &mut crate::utils::shared::ThreadBlockSharedSlice<T>`
`1225`	`1226`	`{`
`1226`	`1227`	`#[cfg(feature = "host")]`
`1227`	`1228`	`type AsyncHostType<'stream, 'b>`
`@@ -1307,7 +1308,7 @@ impl<'a, T: 'static + PortableBitSemantics + TypeGraphLayout> CudaKernelParamete`
`1307`	`1308`	`}`
`1308`	`1309`	`}`
`1309`	`1310`	`}`
`1310`		`-impl<'a, T: 'static + PortableBitSemantics + TypeGraphLayout> sealed::Sealed`
`1311`		`- for &'a mut crate::utils::shared::ThreadBlockSharedSlice<T>`
	`1311`	`+impl<T: 'static + PortableBitSemantics + TypeGraphLayout> sealed::Sealed`
	`1312`	`+ for &mut crate::utils::shared::ThreadBlockSharedSlice<T>`
`1312`	`1313`	`{`
`1313`	`1314`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ unsafe impl<'a, T: PortableBitSemantics + TypeGraphLayout> RustToCuda for &'a T`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`-unsafe impl<'a, T: PortableBitSemantics + TypeGraphLayout> RustToCudaAsync for &'a T {`
	`74`	`+unsafe impl<T: PortableBitSemantics + TypeGraphLayout> RustToCudaAsync for &T {`
`75`	`75`	`#[cfg(all(feature = "host", not(doc)))]`
`76`	`76`	`type CudaAllocationAsync = CombinedCudaAlloc<`
`77`	`77`	`CudaDropWrapper<LockedBox<DeviceCopyWithPortableBitSemantics<ManuallyDrop<T>>>>,`