[CI][CLANG-FORMAT] Switch to clang-20-format

This keeps it in line with upstream dpc++. Also fixed up other issues
with lit python formatting to fit with dpc++

Author: Colin Davidson

.clang-format

@@ -1,19 +1,2 @@
 ---
-Language:        Cpp
-BasedOnStyle:  Google
-Standard: Cpp11
-IncludeBlocks:   Regroup
-IncludeCategories:
-  - Regex:           '^<.*\.(h|hpp)>'
-    Priority:        1
-  - Regex:           '^<.*'
-    Priority:        2
-  - Regex:           '.*'
-    Priority:        3
-DerivePointerAlignment: false
-QualifierAlignment: Left
-PointerAlignment: Right
-Macros:
-  - CL_LAMBDA_CALLBACK=[[]]
-  - VK_LAMBDA_CALLBACK=[[]]
-...
+BasedOnStyle: LLVM

.github/workflows/run_ock_internal_tests.yml

@@ -172,11 +172,11 @@ jobs:
 
       - name: setup-ubuntu-clang-format
         run:
-          pip install clang-format==19.1.0
+          pip install clang-format==20.1.8
 
       - name: run clang-format
         run: |
-          # we've installed clang-format-19 in the docker via pip, which just installs it as clang-format,
+          # we've installed clang-format-20 in the docker via pip, which just installs it as clang-format,
           # so just use clang-format-diff and -b clang-format directly
           git fetch origin ${{ github.base_ref }}
           git diff --no-color origin/${{ github.base_ref }} | \

CMakeLists.txt

@@ -197,11 +197,12 @@ find_package(PythonInterp 3.6 REQUIRED)
 # which perform static analysis and style checking on source files.
 # When updating the version here, also update that used in the merge request
 # config
-find_package(ClangTools 19 COMPONENTS clang-format clang-tidy)
+find_package(ClangTools 19 COMPONENTS clang-tidy)
 if(TARGET ClangTools::clang-tidy)
   ca_option(CA_CLANG_TIDY_FLAGS STRING
-    "Semi-color separated list of clang-tidy flags" "")
+    "Semi-colon separated list of clang-tidy flags" "")
 endif()
+find_package(ClangTools 20 COMPONENTS clang-format)
 
 # Find the operating systems threading library.
 find_package(Threads REQUIRED)

README.md

@@ -45,13 +45,13 @@ To install the dependencies on Ubuntu, open the terminal and run:
 
 ### Recommended packages
 * [Ninja](https://ninja-build.org/)
-* [clang-format](https://clang.llvm.org/docs/ClangFormat.html) 16
+* [clang-format](https://clang.llvm.org/docs/ClangFormat.html) 20
 * [lit](https://llvm.org/docs/CommandGuide/lit.html)
 
 To install the recommended packages, run:
 ```sh
    $ sudo apt install -y ninja-build doxygen python3-pip
-   $ sudo pip3 install lit virtualenv cmakelint clang-format==19.1.0
+   $ sudo pip3 install lit virtualenv cmakelint clang-format==20.1.8
 ```
 
 ### Compiling oneAPI Construction Kit

clik/external/hal_cpu/include/device/kernel_if.h

@@ -83,7 +83,6 @@ static uintptr_t start_dma(void *dst, const void *src, size_t size_in_bytes,
   return xfer_id;
 }
 
-static void wait_dma(uintptr_t xfer_id, struct exec_state *e) { /* No-op */
-}
+static void wait_dma(uintptr_t xfer_id, struct exec_state *e) { /* No-op */ }
 
 #endif  // _HAL_CPU_KERNEL_IF_H

clik/external/hal_cpu/source/hal_main.cpp

@@ -57,7 +57,7 @@ class cpu_hal_platform : public hal::hal_t {
 
   cpu_hal_platform() {
     hal_device_info = &cpu_hal::setup_cpu_hal_device_info();
- 
+
     static constexpr uint32_t implemented_api_version = 6;
     static_assert(implemented_api_version == hal_t::api_version,
                   "Implemented API version for CPU HAL does not match hal.h");

modules/cargo/include/cargo/allocator.h

@@ -58,9 +58,8 @@ void free(void *pointer);
 /// defined.
 ///
 /// @tparam T Type of object to allocate.
-template <class T>
-class mallocator {
- public:
+template <class T> class mallocator {
+public:
   using value_type = T;
   using size_type = size_t;
 
@@ -87,8 +86,7 @@ class mallocator {
   ///
   /// @return A constructed `value_type` pointer on success, or `nullptr`
   /// otherwise.
-  template <class... Args>
-  value_type *create(Args &&...args) {
+  template <class... Args> value_type *create(Args &&...args) {
     value_type *object = static_cast<T *>(cargo::alloc(sizeof(T), alignof(T)));
     new (object) value_type(std::forward<Args>(args)...);
     return object;
@@ -113,9 +111,8 @@ class mallocator {
 /// number of contained elements.
 ///
 /// @tparam T Type of the object to allocate.
-template <class T>
-class nullacator {
- public:
+template <class T> class nullacator {
+public:
   using value_type = T;
   using size_type = size_t;
 
@@ -132,10 +129,7 @@ class nullacator {
   /// @tparam Args Constructor argument parameter type pack.
   ///
   /// @return Returns a `nullptr`, always.
-  template <class... Args>
-  value_type *create(Args &&...) {
-    return nullptr;
-  }
+  template <class... Args> value_type *create(Args &&...) { return nullptr; }
 
   /// @brief Destroy and free a constructed object.
   void destroy(value_type *) {}
@@ -159,9 +153,8 @@ class nullacator {
 /// ```
 ///
 /// @tparam T Type of the object to delete.
-template <class T>
-class deleter {
- public:
+template <class T> class deleter {
+public:
   /// @brief Destroy and deallocate object.
   ///
   /// @param ptr Pointer to object to be destroyed.
@@ -172,6 +165,6 @@ class deleter {
 };
 
 /// @}
-}  // namespace cargo
+} // namespace cargo
 
-#endif  // CARGO_ALLOCATOR_H_INCLUDED
+#endif // CARGO_ALLOCATOR_H_INCLUDED

modules/cargo/include/cargo/argument_parser.h

@@ -57,22 +57,22 @@ namespace cargo {
 
 /// @brief Description of an argument used with `cargo::argument_parser`.
 class argument {
- public:
+public:
   /// @brief Parse result, used in `cargo::argument_parser::parse_args`.
   enum class parse : uint32_t {
-    NOT_FOUND,   ///< Given argument was not found.
-    INVALID,     ///< Given argument is invalid.
-    INCOMPLETE,  ///< Given argument requires further parsing.
-    COMPLETE,    ///< Given argument parsing completed.
+    NOT_FOUND,  ///< Given argument was not found.
+    INVALID,    ///< Given argument is invalid.
+    INCOMPLETE, ///< Given argument requires further parsing.
+    COMPLETE,   ///< Given argument parsing completed.
   };
 
   /// @brief Type to store the bitset of parsing options.
   using option_bitset = uint8_t;
   /// @brief Enumeration of argument parsing options.
   enum option : uint8_t {
-    NONE = 0,                ///< No optional behavior enabled.
-    STORE_TRUE = 0x1 << 1,   ///< Store `bool` argument as `true`.
-    STORE_FALSE = 0x1 << 2,  ///< Store `bool` argument as `false`.
+    NONE = 0,               ///< No optional behavior enabled.
+    STORE_TRUE = 0x1 << 1,  ///< Store `bool` argument as `true`.
+    STORE_FALSE = 0x1 << 2, ///< Store `bool` argument as `false`.
   };
 
   /// @brief Function type for custom handlers.
@@ -107,8 +107,7 @@ class argument {
            cargo::array_view<cargo::string_view> choices,
            cargo::string_view &storage,
            cargo::argument::option_bitset options = NONE)
-      : Name(name),
-        Variant(ChoiceT{std::addressof(storage), choices}),
+      : Name(name), Variant(ChoiceT{std::addressof(storage), choices}),
         Options(options) {}
 
   /// @brief Construct an append value argument.
@@ -132,9 +131,8 @@ class argument {
   argument(cargo::string_view name, custom_handler_function &&parse_argument,
            custom_handler_function &&parse_value,
            cargo::argument::option_bitset options = NONE)
-      : Name(name),
-        Variant(
-            CustomHandlerT{std::move(parse_argument), std::move(parse_value)}),
+      : Name(name), Variant(CustomHandlerT{std::move(parse_argument),
+                                           std::move(parse_value)}),
         Options(options) {}
 
   /// @brief Parse a given argument, used by `cargo::argument_parser`.
@@ -146,9 +144,9 @@ class argument {
   /// @retval `INCOMPLETE` argument was found, requires a value.
   /// @retval `NOT_FOUND` argument was not found.
   /// @retval `INVALID` invalid argument, value not found.
-  [[nodiscard]] cargo::error_or<cargo::argument::parse> parse_arg(
-      cargo::string_view arg) {
-    if (Name == arg) {  // "<name> <value>"
+  [[nodiscard]] cargo::error_or<cargo::argument::parse>
+  parse_arg(cargo::string_view arg) {
+    if (Name == arg) { // "<name> <value>"
       if (auto *Bool = isType<BOOL>()) {
         **Bool = (STORE_FALSE & Options) ? false : true;
         return cargo::argument::parse::COMPLETE;
@@ -160,7 +158,7 @@ class argument {
         return CustomHandler->ParseArgument(arg);
       }
     }
-    if (arg.starts_with(Name)) {  // "<name><value>"
+    if (arg.starts_with(Name)) { // "<name><value>"
       auto value = arg.substr(Name.size(), cargo::string_view::npos);
       if (!value) {
         return cargo::argument::parse::NOT_FOUND;
@@ -180,8 +178,8 @@ class argument {
   /// @return Returns an error from `cargo::small_vector` or the parse result.
   /// @retval `COMPLETE` argument was found with no further action required.
   /// @retval `INVALID` invalid argument, value not found.
-  [[nodiscard]] cargo::error_or<cargo::argument::parse> parse_value(
-      cargo::string_view value) {
+  [[nodiscard]] cargo::error_or<cargo::argument::parse>
+  parse_value(cargo::string_view value) {
     if (isType<BOOL>()) {
       return cargo::argument::parse::INVALID;
     }
@@ -210,7 +208,7 @@ class argument {
     return cargo::argument::parse::COMPLETE;
   }
 
- private:
+private:
   enum TypeT : uint8_t {
     BOOL,
     VALUE,
@@ -234,8 +232,7 @@ class argument {
   std::variant<BoolT, ValueT, ChoiceT, ValuesT, CustomHandlerT> Variant;
   option_bitset Options;
 
-  template <TypeT Type>
-  auto isType() -> decltype(std::get_if<Type>(&Variant)) {
+  template <TypeT Type> auto isType() -> decltype(std::get_if<Type>(&Variant)) {
     return std::get_if<Type>(&Variant);
   }
 
@@ -287,9 +284,8 @@ enum argument_parser_option : uint8_t {
 ///   return error;
 /// }
 /// ```
-template <size_t N, size_t NP = 1, size_t NU = 1>
-class argument_parser {
- public:
+template <size_t N, size_t NP = 1, size_t NU = 1> class argument_parser {
+public:
   /// @brief Construct the argument parser.
   ///
   /// @param options Bitset of cargo::argument_parser_option values.
@@ -313,8 +309,8 @@ class argument_parser {
   /// @retval `cargo::success` parsing was successful.
   /// @retval `cargo::bad_argument` an invalid argument was found.
   /// @retval `cargo::bad_alloc` allocation failure.
-  [[nodiscard]] cargo::result parse_args(
-      cargo::array_view<cargo::string_view> args) {
+  [[nodiscard]] cargo::result
+  parse_args(cargo::array_view<cargo::string_view> args) {
     if (0 == args.size()) {
       return cargo::success;
     }
@@ -336,30 +332,30 @@ class argument_parser {
           return result.error();
         }
         switch (*result) {
+        case cargo::argument::parse::COMPLETE:
+          goto next_argument;
+        case cargo::argument::parse::INCOMPLETE: {
+          if (end == iter + 1) {
+            return cargo::bad_argument;
+          }
+          iter++;
+          auto result = Arg.parse_value(*iter);
+          if (!result) {
+            return result.error();
+          }
+          switch (*result) {
           case cargo::argument::parse::COMPLETE:
             goto next_argument;
-          case cargo::argument::parse::INCOMPLETE: {
-            if (end == iter + 1) {
-              return cargo::bad_argument;
-            }
-            iter++;
-            auto result = Arg.parse_value(*iter);
-            if (!result) {
-              return result.error();
-            }
-            switch (*result) {
-              case cargo::argument::parse::COMPLETE:
-                goto next_argument;
-              case cargo::argument::parse::INCOMPLETE:
-              case cargo::argument::parse::INVALID:
-              case cargo::argument::parse::NOT_FOUND:
-                return cargo::bad_argument;
-            }
-          } break;
+          case cargo::argument::parse::INCOMPLETE:
           case cargo::argument::parse::INVALID:
-            return cargo::bad_argument;
           case cargo::argument::parse::NOT_FOUND:
-            continue;
+            return cargo::bad_argument;
+          }
+        } break;
+        case cargo::argument::parse::INVALID:
+          return cargo::bad_argument;
+        case cargo::argument::parse::NOT_FOUND:
+          continue;
         }
       }
       if (AcceptPositionalArgs && arg == "--") {
@@ -440,14 +436,14 @@ class argument_parser {
     return UnrecognizedArgs;
   }
 
- private:
+private:
   cargo::small_vector<argument, N> Args;
   cargo::small_vector<cargo::string_view, NP> PositionalArgs;
   cargo::small_vector<cargo::string_view, NU> UnrecognizedArgs;
   argument_parser_option_bitset Options;
 };
 
 /// @}
-}  // namespace cargo
+} // namespace cargo
 
-#endif  // CARGO_ARGUMENT_PARSER_H_INCLUDED
+#endif // CARGO_ARGUMENT_PARSER_H_INCLUDED