Fix various clippy lints (tracel-ai#3766)

Author: wingertge

crates/burn-cubecl/src/kernel/conv/conv_transpose2d/col2im.rs

@@ -233,11 +233,6 @@ struct Col2ImArgs {
 }
 
 #[cube(launch_unchecked)]
-#[allow(unknown_lints, reason = "manual_is_multiple_of is from Rust 1.89.0")]
-#[expect(
-    clippy::manual_is_multiple_of,
-    reason = "cubecl cannot expand is_multiple_of"
-)]
 fn col2im_kernel<E: Numeric>(
     columns: &Tensor<E>,
     bias: &Tensor<E>,
@@ -277,7 +272,8 @@ fn col2im_kernel<E: Numeric>(
         for col_x in x_col_start..x_col_end {
             let kernel_x = im_x - col_x * args.stride_w;
 
-            if kernel_y % args.dilation_h == 0 && kernel_x % args.dilation_w == 0 {
+            if kernel_y.is_multiple_of(args.dilation_h) && kernel_x.is_multiple_of(args.dilation_w)
+            {
                 let kernel_y = kernel_y / args.dilation_h;
                 let kernel_x = kernel_x / args.dilation_w;
 

crates/burn-cubecl/src/kernel/conv/conv_transpose2d/transpose_direct.rs

@@ -24,11 +24,6 @@ struct ConvArgs {
 }
 
 #[cube(launch)]
-#[allow(unknown_lints, reason = "manual_is_multiple_of is from Rust 1.89.0")]
-#[expect(
-    clippy::manual_is_multiple_of,
-    reason = "cubecl cannot expand is_multiple_of"
-)]
 fn conv_transpose2d_direct_kernel<E: Numeric>(
     input: &Tensor<E>,
     weight: &Tensor<E>,
@@ -87,7 +82,7 @@ fn conv_transpose2d_direct_kernel<E: Numeric>(
             let numerator_tmp = in_y * args.conv_stride_0;
             let numerator_h = numerator_h_base - numerator_tmp;
 
-            if numerator_h_base >= numerator_tmp && numerator_h % args.dilation_0 == 0 {
+            if numerator_h_base >= numerator_tmp && numerator_h.is_multiple_of(args.dilation_0) {
                 let kernel_y = numerator_h / args.dilation_0;
                 let idx_input_y = in_y * input.stride(2);
                 let idx_weight_ky = kernel_y * weight.stride(2);
@@ -96,7 +91,9 @@ fn conv_transpose2d_direct_kernel<E: Numeric>(
                     let numerator_tmp = in_x * args.conv_stride_1;
                     let numerator_w = numerator_w_base - numerator_tmp;
 
-                    if numerator_w_base >= numerator_tmp && numerator_w % args.dilation_1 == 0 {
+                    if numerator_w_base >= numerator_tmp
+                        && numerator_w.is_multiple_of(args.dilation_1)
+                    {
                         let kernel_x = numerator_w / args.dilation_1;
                         let idx_input_x = in_x * input.stride(3);
                         let idx_weight_kx = kernel_x * weight.stride(3);

crates/burn-cubecl/src/kernel/conv/conv_transpose3d.rs

@@ -27,11 +27,6 @@ struct ConvArgs {
 }
 
 #[cube(launch)]
-#[allow(unknown_lints, reason = "manual_is_multiple_of is from Rust 1.89.0")]
-#[expect(
-    clippy::manual_is_multiple_of,
-    reason = "cubecl cannot expand is_multiple_of"
-)]
 fn conv_transpose3d_kernel<E: Numeric>(
     input: &Tensor<E>,
     weight: &Tensor<E>,
@@ -98,7 +93,7 @@ fn conv_transpose3d_kernel<E: Numeric>(
             let numerator_tmp = in_z * args.conv_stride_0;
             let numerator_d = numerator_d_base - numerator_tmp;
 
-            if numerator_d_base >= numerator_tmp && numerator_d % args.dilation_0 == 0 {
+            if numerator_d_base >= numerator_tmp && numerator_d.is_multiple_of(args.dilation_0) {
                 let kernel_z = numerator_d / args.dilation_0;
                 let index_input_z = in_z * input.stride(2);
                 let index_weight_kz = kernel_z * weight.stride(2);
@@ -107,7 +102,9 @@ fn conv_transpose3d_kernel<E: Numeric>(
                     let numerator_tmp = in_y * args.conv_stride_1;
                     let numerator_h = numerator_h_base - numerator_tmp;
 
-                    if numerator_h_base >= numerator_tmp && numerator_h % args.dilation_1 == 0 {
+                    if numerator_h_base >= numerator_tmp
+                        && numerator_h.is_multiple_of(args.dilation_1)
+                    {
                         let kernel_y = numerator_h / args.dilation_1;
                         let index_input_y = in_y * input.stride(3);
                         let index_weight_ky = kernel_y * weight.stride(3);
@@ -117,7 +114,7 @@ fn conv_transpose3d_kernel<E: Numeric>(
                             let numerator_w = numerator_w_base - numerator_tmp;
 
                             if numerator_w_base >= numerator_tmp
-                                && numerator_w % args.dilation_2 == 0
+                                && numerator_w.is_multiple_of(args.dilation_2)
                             {
                                 let kernel_x = numerator_w / args.dilation_2;
                                 let index_input_x = in_x * input.stride(4);

crates/burn-cubecl/src/kernel/conv/deform_conv_transpose2d.rs

@@ -270,11 +270,6 @@ struct DeformConv2dCol2ImgCoordArgs<F: Float> {
 
 #[expect(clippy::collapsible_if)]
 #[cube(launch_unchecked)]
-#[allow(unknown_lints, reason = "manual_is_multiple_of is from Rust 1.89.0")]
-#[expect(
-    clippy::manual_is_multiple_of,
-    reason = "cubecl cannot expand is_multiple_of"
-)]
 fn deform_col2img_coord_kernel<F: Float>(
     image: &Tensor<F>,
     offset: &Tensor<F>,
@@ -328,7 +323,7 @@ fn deform_col2img_coord_kernel<F: Float>(
     let mask_base_idx = (b * n_offset_groups + offset_group) * kernel_h * kernel_w * out_h * out_w;
 
     let offset_c = c - offset_group * 2 * kernel_h * kernel_w;
-    let is_y_direction = offset_c % 2 == 0;
+    let is_y_direction = offset_c.is_multiple_of(2);
 
     let c_bound = channels_per_offset_group * kernel_h * kernel_w;
 

crates/burn-cubecl/src/kernel/pool/adaptive_avg_pool2d.rs

@@ -64,12 +64,10 @@ fn start_index(output_size_index: u32, output_size: u32, input_size: u32) -> u32
     (output_size_index * input_size) / output_size
 }
 
-#[allow(unknown_lints)] // `manual_div_ceil` only appeared in 1.83
-#[allow(clippy::manual_div_ceil)]
 #[cube]
 fn end_index(output_size_index: u32, output_size: u32, input_size: u32) -> u32 {
     let index = (output_size_index + 1) * input_size;
-    let index = (index + output_size - 1) / output_size;
+    let index = index.div_ceil(output_size);
 
     if input_size < index {
         input_size

crates/burn-cubecl/src/kernel/pool/adaptive_avg_pool2d_backward.rs

@@ -72,12 +72,10 @@ fn start_index(output_size_index: u32, output_size: u32, input_size: u32) -> u32
     (output_size_index * input_size) / output_size
 }
 
-#[allow(unknown_lints)] // `manual_div_ceil` only appeared in 1.83
-#[allow(clippy::manual_div_ceil)]
 #[cube]
 fn end_index(output_size_index: u32, output_size: u32, input_size: u32) -> u32 {
     let index = (output_size_index + 1) * input_size;
-    let index = (index + output_size - 1) / output_size;
+    let index = index.div_ceil(output_size);
 
     if input_size < index {
         input_size

crates/burn-store/src/filter.rs

@@ -465,7 +465,7 @@ mod tests {
     fn container_predicates() {
         // Filter that matches only Linear module weights
         let linear_weights = PathFilter::new().with_predicate(|path, container_path| {
-            container_path.split('.').last() == Some("Linear") && path.ends_with(".weight")
+            container_path.split('.').next_back() == Some("Linear") && path.ends_with(".weight")
         });
 
         assert!(linear_weights.matches_with_container("layer1.weight", "Linear"));
@@ -474,7 +474,7 @@ mod tests {
 
         // Filter for specific container types
         let conv_only = PathFilter::new().with_predicate(|_path, container_path| {
-            let last = container_path.split('.').last();
+            let last = container_path.split('.').next_back();
             last == Some("Conv2d") || last == Some("ConvTranspose2d")
         });
 
@@ -486,7 +486,7 @@ mod tests {
         let combined = PathFilter::new()
             .with_predicate(|path, _container_path| path.starts_with("encoder."))
             .with_predicate(|_path, container_path| {
-                container_path.split('.').last() == Some("BatchNorm2d")
+                container_path.split('.').next_back() == Some("BatchNorm2d")
             });
 
         // Should match either condition (OR logic)
@@ -503,7 +503,8 @@ mod tests {
             let filter = PathFilter::new()
                 .with_regex(r"^encoder\..*")
                 .with_predicate(|path, container_path| {
-                    container_path.split('.').last() == Some("Linear") && path.contains(".bias")
+                    container_path.split('.').next_back() == Some("Linear")
+                        && path.contains(".bias")
                 });
 
             // Matches due to regex
@@ -607,7 +608,7 @@ mod tests {
             // Only weights in Linear layers that are inside blocks
             path.ends_with(".weight")
                 && container_path.contains("Block")
-                && container_path.split('.').last() == Some("Linear")
+                && container_path.split('.').next_back() == Some("Linear")
         });
 
         assert!(

crates/burn-store/src/safetensors/tests/adapter.rs

@@ -34,17 +34,17 @@ fn pytorch_to_burn_adapter_linear_transpose() {
 
     // Load with PyTorchToBurn adapter (will transpose back)
     let mut load_store = SafetensorsStore::from_bytes(None).with_from_adapter(PyTorchToBurnAdapter);
-    if let SafetensorsStore::Memory(ref mut p) = load_store {
-        if let SafetensorsStore::Memory(ref p_save) = save_store {
-            p.set_data(p_save.data().unwrap().as_ref().clone());
-        }
+    if let SafetensorsStore::Memory(ref mut p) = load_store
+        && let SafetensorsStore::Memory(ref p_save) = save_store
+    {
+        p.set_data(p_save.data().unwrap().as_ref().clone());
     }
 
     let mut model2 = TestModel::<TestBackend>::new(&device);
     let result = model2.apply_from(&mut load_store).unwrap();
 
     // Should successfully load all tensors
-    assert!(result.applied.len() > 0);
+    assert!(!result.applied.is_empty());
 
     // Verify the linear weights are the same after round-trip
     let weight1 = model.linear.weight.val().to_data();
@@ -93,17 +93,17 @@ fn pytorch_to_burn_adapter_norm_rename() {
 
     // Load with PyTorchToBurn adapter (will rename weight->gamma, bias->beta)
     let mut load_store = SafetensorsStore::from_bytes(None).with_from_adapter(PyTorchToBurnAdapter);
-    if let SafetensorsStore::Memory(ref mut p) = load_store {
-        if let SafetensorsStore::Memory(ref p_save) = save_store {
-            p.set_data(p_save.data().unwrap().as_ref().clone());
-        }
+    if let SafetensorsStore::Memory(ref mut p) = load_store
+        && let SafetensorsStore::Memory(ref p_save) = save_store
+    {
+        p.set_data(p_save.data().unwrap().as_ref().clone());
     }
 
     let mut model2 = NormModel::<TestBackend>::new(&device);
     let result = model2.apply_from(&mut load_store).unwrap();
 
     // Should load successfully
-    assert!(result.applied.len() > 0);
+    assert!(!result.applied.is_empty());
 
     // Verify data is preserved
     let gamma1 = model.norm_gamma.val().to_data().to_vec::<f32>().unwrap();
@@ -126,17 +126,17 @@ fn no_adapter_preserves_original() {
 
     // Load without adapter
     let mut load_store = SafetensorsStore::from_bytes(None);
-    if let SafetensorsStore::Memory(ref mut p) = load_store {
-        if let SafetensorsStore::Memory(ref p_save) = save_store {
-            p.set_data(p_save.data().unwrap().as_ref().clone());
-        }
+    if let SafetensorsStore::Memory(ref mut p) = load_store
+        && let SafetensorsStore::Memory(ref p_save) = save_store
+    {
+        p.set_data(p_save.data().unwrap().as_ref().clone());
     }
 
     let mut model2 = TestModel::<TestBackend>::new(&device);
     let result = model2.apply_from(&mut load_store).unwrap();
 
     assert!(result.is_success());
-    assert!(result.applied.len() > 0);
+    assert!(!result.applied.is_empty());
 
     // Verify data is exactly the same
     let weight1 = model.linear.weight.val().to_data();
@@ -187,5 +187,5 @@ fn adapter_with_pytorch_import() {
 
     // Should load some tensors (fc1 if it exists in the file)
     // This mainly tests that the adapter works with real PyTorch files
-    assert!(result.applied.len() > 0 || result.missing.len() > 0);
+    assert!(!result.applied.is_empty() || !result.missing.is_empty());
 }

crates/burn-store/src/safetensors/tests/error_handling.rs

@@ -23,12 +23,12 @@ fn shape_mismatch_errors() {
 
     // Load without validation - should return errors in the result
     let mut load_store = SafetensorsStore::from_bytes(None).validate(false); // Disable validation to get errors in result
-    if let SafetensorsStore::Memory(ref mut p) = load_store {
-        if let SafetensorsStore::Memory(ref p_save) = save_store {
-            // Get Arc and extract data
-            let data_arc = p_save.data().unwrap();
-            p.set_data(data_arc.as_ref().clone());
-        }
+    if let SafetensorsStore::Memory(ref mut p) = load_store
+        && let SafetensorsStore::Memory(ref p_save) = save_store
+    {
+        // Get Arc and extract data
+        let data_arc = p_save.data().unwrap();
+        p.set_data(data_arc.as_ref().clone());
     }
 
     let result = incompatible_module.apply_from(&mut load_store).unwrap();
@@ -38,12 +38,12 @@ fn shape_mismatch_errors() {
 
     // Try again with validation enabled - should return Err
     let mut load_store_with_validation = SafetensorsStore::from_bytes(None).validate(true);
-    if let SafetensorsStore::Memory(ref mut p) = load_store_with_validation {
-        if let SafetensorsStore::Memory(ref p_save) = save_store {
-            // Get Arc and extract data
-            let data_arc = p_save.data().unwrap();
-            p.set_data(data_arc.as_ref().clone());
-        }
+    if let SafetensorsStore::Memory(ref mut p) = load_store_with_validation
+        && let SafetensorsStore::Memory(ref p_save) = save_store
+    {
+        // Get Arc and extract data
+        let data_arc = p_save.data().unwrap();
+        p.set_data(data_arc.as_ref().clone());
     }
 
     let validation_result = incompatible_module.apply_from(&mut load_store_with_validation);

crates/burn-store/src/safetensors/tests/filtering.rs

@@ -17,18 +17,18 @@ fn filtered_export_import() {
 
     // Import filtered tensors - need to allow partial since we only saved encoder tensors
     let mut load_store = SafetensorsStore::from_bytes(None).allow_partial(true);
-    if let SafetensorsStore::Memory(ref mut p) = load_store {
-        if let SafetensorsStore::Memory(ref p_save) = save_store {
-            // Get Arc and extract data
-            let data_arc = p_save.data().unwrap();
-            p.set_data(data_arc.as_ref().clone());
-        }
+    if let SafetensorsStore::Memory(ref mut p) = load_store
+        && let SafetensorsStore::Memory(ref p_save) = save_store
+    {
+        // Get Arc and extract data
+        let data_arc = p_save.data().unwrap();
+        p.set_data(data_arc.as_ref().clone());
     }
     let result = module2.apply_from(&mut load_store).unwrap();
 
     assert!(result.is_success());
     assert_eq!(result.applied.len(), 3); // encoder.weight, encoder.bias, encoder.norm
-    assert!(result.missing.len() > 0); // decoder and layers tensors are missing
+    assert!(!result.missing.is_empty()); // decoder and layers tensors are missing
 }
 
 #[test]