Run clang-format over more files (#10689)

We were already running it over most `*.c` files and other ones but
forgot the `*.hh` and `*.cc` extensions which are being used for C++
bindings, so add those in and then run the formatter.

Author: alexcrichton

.github/workflows/main.yml

@@ -80,7 +80,7 @@ jobs:
       with:
         submodules: true
     - run: |
-        git ls-files '*.h' '*.c' '*.cpp' | \
+        git ls-files '*.h' '*.c' '*.cpp' '*.hh' '*.cc' | \
           grep -v wasmtime-platform.h | \
           grep -v wasm.h | \
           xargs clang-format-18 --dry-run --Werror --verbose

crates/c-api/include/wasmtime.hh

@@ -310,11 +310,13 @@ public:
                 bool> = true>
   Result<std::monostate> func_new(std::string_view module,
                                   std::string_view name, const FuncType &ty,
-                                  F&& f) {
+                                  F &&f) {
 
     auto *error = wasmtime_linker_define_func(
         ptr.get(), module.data(), module.length(), name.data(), name.length(),
-        ty.ptr.get(), Func::raw_callback<std::remove_reference_t<F>>, std::make_unique<std::remove_reference_t<F>>(std::forward<F>(f)).release(),
+        ty.ptr.get(), Func::raw_callback<std::remove_reference_t<F>>,
+        std::make_unique<std::remove_reference_t<F>>(std::forward<F>(f))
+            .release(),
         Func::raw_finalize<std::remove_reference_t<F>>);
 
     if (error != nullptr) {
@@ -330,15 +332,17 @@ public:
             std::enable_if_t<WasmHostFunc<F>::Params::valid, bool> = true,
             std::enable_if_t<WasmHostFunc<F>::Results::valid, bool> = true>
   Result<std::monostate> func_wrap(std::string_view module,
-                                   std::string_view name, F&& f) {
+                                   std::string_view name, F &&f) {
     using HostFunc = WasmHostFunc<F>;
     auto params = HostFunc::Params::types();
     auto results = HostFunc::Results::types();
     auto ty = FuncType::from_iters(params, results);
     auto *error = wasmtime_linker_define_func_unchecked(
         ptr.get(), module.data(), module.length(), name.data(), name.length(),
         ty.ptr.get(), Func::raw_callback_unchecked<std::remove_reference_t<F>>,
-        std::make_unique<std::remove_reference_t<F>>(std::forward<F>(f)).release(), Func::raw_finalize<std::remove_reference_t<F>>);
+        std::make_unique<std::remove_reference_t<F>>(std::forward<F>(f))
+            .release(),
+        Func::raw_finalize<std::remove_reference_t<F>>);
 
     if (error != nullptr) {
       return Error(error);

crates/c-api/include/wasmtime/config.hh

@@ -368,29 +368,31 @@ public:
     wasmtime_config_wasm_memory64_set(ptr.get(), enable);
   }
 
-  /// \brief Configures whether the WebAssembly Garbage Collection proposal will be enabled
+  /// \brief Configures whether the WebAssembly Garbage Collection proposal will
+  /// be enabled
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_gc
-  void wasm_gc(bool enable) {
-    wasmtime_config_wasm_gc_set(ptr.get(), enable);
-  }
+  void wasm_gc(bool enable) { wasmtime_config_wasm_gc_set(ptr.get(), enable); }
 
-  /// \brief Configures whether the WebAssembly function references proposal will be enabled
+  /// \brief Configures whether the WebAssembly function references proposal
+  /// will be enabled
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_function_references
   void wasm_function_references(bool enable) {
     wasmtime_config_wasm_function_references_set(ptr.get(), enable);
   }
 
-  /// \brief Configures whether the WebAssembly wide arithmetic proposal will be enabled
+  /// \brief Configures whether the WebAssembly wide arithmetic proposal will be
+  /// enabled
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_wide_arithmetic
   void wasm_wide_arithmetic(bool enable) {
     wasmtime_config_wasm_wide_arithmetic_set(ptr.get(), enable);
   }
 
 #ifdef WASMTIME_FEATURE_COMPONENT_MODEL
-  /// \brief Configures whether the WebAssembly component model proposal will be enabled
+  /// \brief Configures whether the WebAssembly component model proposal will be
+  /// enabled
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.wasm_component_model
   void wasm_component_model(bool enable) {
@@ -399,7 +401,8 @@ public:
 #endif // WASMTIME_FEATURE_COMPONENT_MODEL
 
 #ifdef WASMTIME_FEATURE_PARALLEL_COMPILATION
-  /// \brief Configure whether wasmtime should compile a module using multiple threads.
+  /// \brief Configure whether wasmtime should compile a module using multiple
+  /// threads.
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.parallel_compilation
   void parallel_compilation(bool enable) {
@@ -468,7 +471,8 @@ public:
     wasmtime_config_memory_reservation_set(ptr.get(), size);
   }
 
-  /// \brief Configures the size of the bytes to reserve beyond the end of linear memory to grow into.
+  /// \brief Configures the size of the bytes to reserve beyond the end of
+  /// linear memory to grow into.
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.memory_reservation_for_growth
   void memory_reservation_for_growth(size_t size) {
@@ -482,7 +486,8 @@ public:
     wasmtime_config_memory_guard_size_set(ptr.get(), size);
   }
 
-  /// \brief Configures whether the base pointer of linear memory is allowed to move.
+  /// \brief Configures whether the base pointer of linear memory is allowed to
+  /// move.
   ///
   /// https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.memory_may_move
   void memory_may_move(bool enable) {
@@ -535,13 +540,13 @@ public:
 #endif // WASMTIME_FEATURE_CACHE
 
 private:
-  template <typename T>
-  static void raw_finalize(void *env) {
+  template <typename T> static void raw_finalize(void *env) {
     std::unique_ptr<T> ptr(reinterpret_cast<T *>(env));
   }
 
   template <typename M>
-  static uint8_t *raw_get_memory(void *env, size_t *byte_size, size_t *byte_capacity) {
+  static uint8_t *raw_get_memory(void *env, size_t *byte_size,
+                                 size_t *byte_capacity) {
     M *memory = reinterpret_cast<M *>(env);
     return memory->get_memory(byte_size, byte_capacity);
   }
@@ -556,19 +561,16 @@ private:
   }
 
   template <typename T>
-  static wasmtime_error_t *raw_new_memory(
-    void *env, const wasm_memorytype_t *ty, size_t minimum, size_t maximum,
-    size_t reserved_size_in_bytes, size_t guard_size_in_bytes,
-    wasmtime_linear_memory_t *memory_ret)
-  {
+  static wasmtime_error_t *
+  raw_new_memory(void *env, const wasm_memorytype_t *ty, size_t minimum,
+                 size_t maximum, size_t reserved_size_in_bytes,
+                 size_t guard_size_in_bytes,
+                 wasmtime_linear_memory_t *memory_ret) {
     using Memory = typename T::Memory;
     T *creator = reinterpret_cast<T *>(env);
-    Result<Memory> result = creator->new_memory(
-        MemoryType::Ref(ty),
-        minimum,
-        maximum,
-        reserved_size_in_bytes,
-        guard_size_in_bytes);
+    Result<Memory> result =
+        creator->new_memory(MemoryType::Ref(ty), minimum, maximum,
+                            reserved_size_in_bytes, guard_size_in_bytes);
     if (!result) {
       return result.err().release();
     }
@@ -581,22 +583,19 @@ private:
   }
 
 public:
-
   /// \brief Configures a custom memory creator for this configuration and
   /// eventual Engine.
   ///
   /// This can be used to use `creator` to allocate linear memories for the
   /// engine that this configuration will be used for.
-  template<typename T>
-  void host_memory_creator(T creator) {
+  template <typename T> void host_memory_creator(T creator) {
     wasmtime_memory_creator_t config = {0};
-    config.env =  std::make_unique<T>(creator).release();
+    config.env = std::make_unique<T>(creator).release();
     config.finalizer = raw_finalize<T>;
     config.new_memory = raw_new_memory<T>;
     wasmtime_config_host_memory_creator_set(ptr.get(), &config);
   }
 
-
 #ifdef WASMTIME_FEATURE_POOLING_ALLOCATOR
   /// \brief Enables and configures the pooling allocation strategy.
   ///

crates/c-api/include/wasmtime/engine.hh

@@ -61,4 +61,3 @@ public:
 } // namespace wasmtime
 
 #endif // WASMTIME_ENGINE_HH
-

crates/c-api/include/wasmtime/error.hh

@@ -62,9 +62,7 @@ public:
   Trace trace() const;
 
   /// Release ownership of this error, acquiring the underlying C raw pointer.
-  wasmtime_error_t *release() {
-    return ptr.release();
-  }
+  wasmtime_error_t *release() { return ptr.release(); }
 };
 
 /// \brief Used to print an error.

crates/c-api/include/wasmtime/extern.hh

@@ -5,8 +5,8 @@
 #ifndef WASMTIME_EXTERN_HH
 #define WASMTIME_EXTERN_HH
 
-#include <wasmtime/extern.h>
 #include <variant>
+#include <wasmtime/extern.h>
 
 namespace wasmtime {
 

crates/c-api/include/wasmtime/func.hh

@@ -11,8 +11,8 @@
 #include <wasmtime/span.hh>
 #include <wasmtime/store.hh>
 #include <wasmtime/trap.hh>
-#include <wasmtime/types/val.hh>
 #include <wasmtime/types/func.hh>
+#include <wasmtime/types/val.hh>
 #include <wasmtime/val.hh>
 
 namespace wasmtime {
@@ -49,7 +49,9 @@ namespace detail {
 
 /// A "trait" for native types that correspond to WebAssembly types for use with
 /// `Func::wrap` and `TypedFunc::call`
-template <typename T> struct WasmType { static const bool valid = false; };
+template <typename T> struct WasmType {
+  static const bool valid = false;
+};
 
 /// Helper macro to define `WasmType` definitions for primitive types like
 /// int32_t and such.
@@ -577,11 +579,11 @@ public:
         storage;
     wasmtime_val_raw_t *ptr = storage.data();
     if (ptr == nullptr)
-      ptr = reinterpret_cast<wasmtime_val_raw_t*>(alignof(wasmtime_val_raw_t));
+      ptr = reinterpret_cast<wasmtime_val_raw_t *>(alignof(wasmtime_val_raw_t));
     WasmTypeList<Params>::store(cx, ptr, params);
     wasm_trap_t *trap = nullptr;
-    auto *error = wasmtime_func_call_unchecked(
-        cx.raw_context(), &f.func, ptr, storage.size(), &trap);
+    auto *error = wasmtime_func_call_unchecked(cx.raw_context(), &f.func, ptr,
+                                               storage.size(), &trap);
     if (error != nullptr) {
       return TrapError(Error(error));
     }

crates/c-api/include/wasmtime/module.hh

@@ -188,4 +188,3 @@ public:
 } // namespace wasmtime
 
 #endif // WASMTIME_MODULE_HH
-

crates/c-api/include/wasmtime/span.hh

@@ -99,4 +99,3 @@ private:
 } // namespace wasmtime
 
 #endif // WASMTIME_SPAN_HH
-

crates/c-api/include/wasmtime/types/memory.hh

@@ -120,34 +120,34 @@ public:
     Builder() : _min(0), _memory64(false), _shared(false) {}
 
     /// \brief Configure the minimum size, in pages, of linear memory.
-    Builder& min(uint64_t min) {
+    Builder &min(uint64_t min) {
       _min = min;
       return *this;
     }
 
     /// \brief Configure the maximal size, in pages, of linear memory.
-    Builder& max(std::optional<uint64_t> max) {
+    Builder &max(std::optional<uint64_t> max) {
       _max = max;
       return *this;
     }
 
     /// \brief Configure whether this is a 64-bit linear memory.
-    Builder& memory64(bool enable) {
+    Builder &memory64(bool enable) {
       _memory64 = enable;
       return *this;
     }
 
     /// \brief Configure whether this is a shared linear memory.
-    Builder& shared(bool enable) {
+    Builder &shared(bool enable) {
       _shared = enable;
       return *this;
     }
 
     /// \brief Construct the final `MemoryType` value.
     MemoryType build() const {
-      return MemoryType(wasmtime_memorytype_new(
-            _min, _max.has_value(), _max.has_value() ? *_max : 0,
-            _memory64, _shared));
+      return MemoryType(wasmtime_memorytype_new(_min, _max.has_value(),
+                                                _max.has_value() ? *_max : 0,
+                                                _memory64, _shared));
     }
   };
 };