fix lints

Author: huy209vn

crates/cubecl-std/src/tests/tensor/permute.rs

@@ -18,7 +18,8 @@ pub fn test_permute_2d_transpose<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![height, width], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input = TensorHandle::<R>::new_contiguous(vec![height, width], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[1, 0]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -60,7 +61,8 @@ pub fn test_permute_3d_batch_transpose<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![batch, height, width], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input = TensorHandle::<R>::new_contiguous(vec![batch, height, width], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[0, 2, 1]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -105,7 +107,8 @@ pub fn test_permute_3d_complex<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![dim0, dim1, dim2], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input = TensorHandle::<R>::new_contiguous(vec![dim0, dim1, dim2], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[2, 0, 1]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -141,7 +144,8 @@ pub fn test_permute_3d_complex<R: Runtime, C: Float + CubeElement>(
 pub fn test_permute_empty<R: Runtime, C: Float + CubeElement>(device: &R::Device) {
     let client = R::client(device);
 
-    let input = TensorHandle::<R, C>::empty(&client, vec![0, 5]);
+    let dtype = C::as_type_native().unwrap();
+    let input = TensorHandle::<R>::empty(&client, vec![0, 5], dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[1, 0]);
 
     assert_eq!(output.shape, vec![5, 0]);
@@ -152,7 +156,8 @@ pub fn test_permute_single_element<R: Runtime, C: Float + CubeElement>(device: &
     let client = R::client(device);
 
     let handle = client.create(C::as_bytes(&[C::from(42.0).unwrap()]));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![1, 1], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input = TensorHandle::<R>::new_contiguous(vec![1, 1], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[1, 0]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -180,7 +185,9 @@ pub fn test_permute_4d_last_two_transpose<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![batch, channels, height, width], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input =
+        TensorHandle::<R>::new_contiguous(vec![batch, channels, height, width], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[0, 1, 3, 2]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -235,7 +242,9 @@ pub fn test_permute_4d_complex<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![batch, channels, height, width], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input =
+        TensorHandle::<R>::new_contiguous(vec![batch, channels, height, width], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[0, 3, 1, 2]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -288,7 +297,9 @@ pub fn test_permute_channel_shuffle<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![batch, channels, height, width], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input =
+        TensorHandle::<R>::new_contiguous(vec![batch, channels, height, width], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[0, 2, 3, 1]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -341,7 +352,9 @@ pub fn test_permute_attention_transpose<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![batch, heads, seq_len, head_dim], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input =
+        TensorHandle::<R>::new_contiguous(vec![batch, heads, seq_len, head_dim], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[0, 2, 1, 3]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(
@@ -393,7 +406,8 @@ pub fn test_permute_small_transpose<R: Runtime, C: Float + CubeElement>(
     let input_data: Vec<C> = (0..numel).map(|i| C::from(i as f32).unwrap()).collect();
 
     let handle = client.create(C::as_bytes(&input_data));
-    let input = TensorHandle::<R, C>::new_contiguous(vec![size, size], handle);
+    let dtype = C::as_type_native().unwrap();
+    let input = TensorHandle::<R>::new_contiguous(vec![size, size], handle, dtype);
     let output = tensor::permute::launch_alloc(&client, &input, &[1, 0]);
 
     let actual = client.read_one_tensor(output.handle.clone().copy_descriptor(