Merge branch 'main' into cleanup

Author: elibol

.github/workflows/pr.yml

@@ -54,3 +54,27 @@ jobs:
         run: |
           source "${HOME}/.cargo/env"
           cargo build
+
+      - name: Format check
+        env:
+          CUDA_TOOLKIT_PATH: /usr/local/cuda-13
+          CUDA_TILE_USE_LLVM_INSTALL_DIR: /usr/lib/llvm-21
+        run: |
+          source "${HOME}/.cargo/env"
+          cargo fmt -- --check
+
+      - name: Clippy
+        env:
+          CUDA_TOOLKIT_PATH: /usr/local/cuda-13
+          CUDA_TILE_USE_LLVM_INSTALL_DIR: /usr/lib/llvm-21
+        run: |
+          source "${HOME}/.cargo/env"
+          cargo clippy
+
+      - name: Test (compile only)
+        env:
+          CUDA_TOOLKIT_PATH: /usr/local/cuda-13
+          CUDA_TILE_USE_LLVM_INSTALL_DIR: /usr/lib/llvm-21
+        run: |
+          source "${HOME}/.cargo/env"
+          cargo test --no-run

cuda-tile-rs/examples/build_translate_basic.rs

@@ -4,14 +4,14 @@
  */
 
 use cuda_tile_rs::util::{operation_parse, parse_named_attr};
-use melior::Context;
 use melior::dialect::DialectRegistry;
 use melior::ir::attribute::{StringAttribute, TypeAttribute};
 use melior::ir::r#type::FunctionType;
 use melior::ir::{
     Attribute, Block, BlockLike, Identifier, Location, Region, RegionLike, Type, Value, ValueLike,
 };
 use melior::utility::{register_all_dialects, register_all_llvm_translations};
+use melior::Context;
 use std::error::Error;
 use std::process::Command;
 

cuda-tile-rs/src/cuda_tile_c_bindings.rs

@@ -201,7 +201,7 @@ unsafe extern "C" {
 unsafe extern "C" {
     #[doc = " Returns a cuda_tile RoundingModeAttr with the given rounding mode string."]
     pub fn mlirCudaTileRoundingModeAttrGet(ctx: MlirContext, value: MlirStringRef)
-    -> MlirAttribute;
+        -> MlirAttribute;
 }
 unsafe extern "C" {
     #[doc = " Returns the rounding mode string of the given cuda_tile RoundingModeAttr."]
@@ -287,7 +287,7 @@ unsafe extern "C" {
 unsafe extern "C" {
     #[doc = " Returns a cuda_tile PaddingValueAttr with the given padding value string."]
     pub fn mlirCudaTilePaddingValueAttrGet(ctx: MlirContext, value: MlirStringRef)
-    -> MlirAttribute;
+        -> MlirAttribute;
 }
 unsafe extern "C" {
     #[doc = " Returns the padding value string of the given cuda_tile PaddingValueAttr."]

cuda-tile-rs/src/lib.rs

@@ -80,13 +80,13 @@ mod tests {
 
     use crate::cuda_tile::{self};
     use crate::util::{attribute_parse, operation_parse, type_parse};
-    use melior::Context;
     use melior::dialect::DialectRegistry;
-    use melior::ir::RegionLike;
     use melior::ir::attribute::StringAttribute;
     use melior::ir::operation::{OperationBuilder, OperationLike};
+    use melior::ir::RegionLike;
     use melior::ir::{Attribute, Block, Identifier, Location, Module, Region};
     use melior::utility::{register_all_dialects, register_all_llvm_translations};
+    use melior::Context;
 
     static TEST_MUTEX: Mutex<()> = Mutex::new(());
     static REGISTER_GLOBALS: Once = Once::new();

cuda-tile-rs/src/util.rs

@@ -4,9 +4,9 @@
  */
 
 use melior::{
-    Context, StringRef,
-    ir::{Attribute, Identifier, Operation, Type, operation::OperationLike},
+    ir::{operation::OperationLike, Attribute, Identifier, Operation, Type},
     pass::PassManager,
+    Context, StringRef,
 };
 use mlir_sys::mlirPassManagerRunOnOp;
 use mlir_sys::{mlirAttributeParseGet, mlirOperationCreateParse};

cutile-macro/src/kernel_launcher_generator.rs

@@ -1029,6 +1029,12 @@ pub fn infer_shape_params_from_tensor_type(
                             // This might make sense for a small tensor.
                             required_generics.expressions.insert(last_ident.clone(), Some(format!("{var_name}.shape.iter().map(|x| x.to_string()).collect::<Vec<String>>()")));
                         }
+                        SupportedGenericType::ConstScalar => {
+                            return type_path.err(
+                                "Unexpected constant scalar type in tensor generic argument.",
+                            );
+                        }
+                        SupportedGenericType::Unknown => {}
                     }
                     SupportedGenericType::ConstScalar => {
                         return type_path
@@ -1087,6 +1093,7 @@ pub fn infer_shape_params_from_tensor_type(
                                                     )),
                                                 );
                                             }
+                                            SupportedGenericType::Unknown => {}
                                         }
                                         SupportedGenericType::Unknown => {}
                                     }

cutile-macro/src/types.rs

@@ -1146,34 +1146,32 @@ impl Iterator for ConstGenericArrayTypeListIterator {
                 }
             }
             Some(Ok(self.state.clone()))
+        } else if self.done {
+            None
         } else {
-            if self.done {
-                None
-            } else {
-                for _i in 0..self.iterators.len() {
-                    // Traverse in reverse to remain consistent with traversal order of individual ConstGenericArrayIterator.
-                    // The traversal is a mixed-radix counter.
-                    // We're done when the most significant position is None.
-                    let i = (self.iterators.len() - 1) - _i;
-                    let iter = &mut self.iterators[i];
-                    let item: Option<ConstGenericArrayType> = iter.next();
-                    match item {
-                        Some(item) => {
-                            self.state[i] = item;
-                            break;
-                        }
-                        None => {
-                            if i == 0 {
-                                self.done = true;
-                                return None;
-                            }
-                            self.iterators[i] = iter.renew();
-                            self.state[i] = self.iterators[i].next().unwrap();
+            for _i in 0..self.iterators.len() {
+                // Traverse in reverse to remain consistent with traversal order of individual ConstGenericArrayIterator.
+                // The traversal is a mixed-radix counter.
+                // We're done when the most significant position is None.
+                let i = (self.iterators.len() - 1) - _i;
+                let iter = &mut self.iterators[i];
+                let item: Option<ConstGenericArrayType> = iter.next();
+                match item {
+                    Some(item) => {
+                        self.state[i] = item;
+                        break;
+                    }
+                    None => {
+                        if i == 0 {
+                            self.done = true;
+                            return None;
                         }
+                        self.iterators[i] = iter.renew();
+                        self.state[i] = self.iterators[i].next().unwrap();
                     }
                 }
-                Some(Ok(self.state.clone()))
             }
+            Some(Ok(self.state.clone()))
         }
     }
 }