[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
taichi-dev · Jan 1, 2024 · 2010298 · 2010298
1 parent 412316c
commit 2010298
Show file tree

Hide file tree

Showing 14 changed files with 84 additions and 40 deletions.
diff --git a/taichi/analysis/gen_offline_cache_key.cpp b/taichi/analysis/gen_offline_cache_key.cpp
@@ -630,7 +630,9 @@ class ASTSerializer : public IRVisitor, public ExpressionVisitor {
   }
 
 #define DEFINE_EMIT_ENUM(EnumType) \
-  void emit(EnumType type) { emit_pod(type); }
+  void emit(EnumType type) {       \
+    emit_pod(type);                \
+  }
 
   DEFINE_EMIT_ENUM(ExprOpCode);
   DEFINE_EMIT_ENUM(StmtOpCode);

diff --git a/taichi/codegen/spirv/kernel_utils.h b/taichi/codegen/spirv/kernel_utils.h
@@ -315,8 +315,8 @@ class KernelContextAttributes {
   /**
    * Get all argpacks.
    */
-  inline const std::vector<std::pair<std::vector<int>, const Type *>>
-      &argpack_types() const {
+  inline const std::vector<std::pair<std::vector<int>, const Type *>> &
+  argpack_types() const {
     return argpack_types_;
   }
 

diff --git a/taichi/common/dict.h b/taichi/common/dict.h
@@ -188,8 +188,8 @@ class Dict {
   }
 
   template <typename T>
-  std::enable_if_t<std::is_reference<T>::value, std::remove_reference_t<T>>
-      &get(std::string key) const {
+  std::enable_if_t<std::is_reference<T>::value, std::remove_reference_t<T>> &
+  get(std::string key) const {
     return *get_ptr<std::remove_reference_t<T>>(key);
   }
 

diff --git a/taichi/common/interface.h b/taichi/common/interface.h
@@ -325,8 +325,12 @@ class InterfaceHolder {
     }                                                                \
   } ImplementationInjector_##base_class_name##class_name##instance;
 
-#define TI_NAME(alias)                                                        \
-  virtual std::string get_name() const override { return get_name_static(); } \
-  static std::string get_name_static() { return alias; }
+#define TI_NAME(alias)                            \
+  virtual std::string get_name() const override { \
+    return get_name_static();                     \
+  }                                               \
+  static std::string get_name_static() {          \
+    return alias;                                 \
+  }
 
 }  // namespace taichi
diff --git a/taichi/ir/expression.h b/taichi/ir/expression.h
@@ -175,7 +175,9 @@ class ExpressionVisitor {
   bool invoke_default_visitor_{false};
 };
 
-#define TI_DEFINE_ACCEPT_FOR_EXPRESSION \
-  void accept(ExpressionVisitor *visitor) override { visitor->visit(this); }
+#define TI_DEFINE_ACCEPT_FOR_EXPRESSION              \
+  void accept(ExpressionVisitor *visitor) override { \
+    visitor->visit(this);                            \
+  }
 
 }  // namespace taichi::lang
diff --git a/taichi/ir/expression_ops.h b/taichi/ir/expression_ops.h
@@ -12,19 +12,25 @@
   Expr expr_##opname(const Expr &expr) {                             \
     return Expr::make<UnaryOpExpression>(UnaryOpType::opname, expr); \
   }                                                                  \
-  Expr operator op(const Expr &expr) { return expr_##opname(expr); }
+  Expr operator op(const Expr &expr) {                               \
+    return expr_##opname(expr);                                      \
+  }
 
 #define DEFINE_EXPRESSION_FUNC_UNARY(opname)                         \
   Expr opname(const Expr &expr) {                                    \
     return Expr::make<UnaryOpExpression>(UnaryOpType::opname, expr); \
   }                                                                  \
-  Expr expr_##opname(const Expr &expr) { return opname(expr); }
+  Expr expr_##opname(const Expr &expr) {                             \
+    return opname(expr);                                             \
+  }
 
 #define DEFINE_EXPRESSION_OP_BINARY(op, opname)                            \
   Expr operator op(const Expr &lhs, const Expr &rhs) {                     \
     return Expr::make<BinaryOpExpression>(BinaryOpType::opname, lhs, rhs); \
   }                                                                        \
-  Expr expr_##opname(const Expr &lhs, const Expr &rhs) { return lhs op rhs; }
+  Expr expr_##opname(const Expr &lhs, const Expr &rhs) {                   \
+    return lhs op rhs;                                                     \
+  }
 
 #define DEFINE_EXPRESSION_FUNC_BINARY(opname)                              \
   Expr opname(const Expr &lhs, const Expr &rhs) {                          \

diff --git a/taichi/ir/ir.cpp b/taichi/ir/ir.cpp
@@ -61,8 +61,10 @@ class StatementTypeNameVisitor : public IRVisitor {
   StatementTypeNameVisitor() {
   }
 
-#define PER_STATEMENT(x) \
-  void visit(x *stmt) override { type_name = #x; }
+#define PER_STATEMENT(x)         \
+  void visit(x *stmt) override { \
+    type_name = #x;              \
+  }
 #include "taichi/inc/statements.inc.h"
 
 #undef PER_STATEMENT

diff --git a/taichi/ir/ir.h b/taichi/ir/ir.h
@@ -268,8 +268,10 @@ class IRNode {
   std::unique_ptr<IRNode> clone();
 };
 
-#define TI_DEFINE_ACCEPT \
-  void accept(IRVisitor *visitor) override { visitor->visit(this); }
+#define TI_DEFINE_ACCEPT                     \
+  void accept(IRVisitor *visitor) override { \
+    visitor->visit(this);                    \
+  }
 
 #define TI_DEFINE_CLONE                                             \
   std::unique_ptr<Stmt> clone() const override {                    \

diff --git a/taichi/program/field_info.h b/taichi/program/field_info.h
@@ -13,10 +13,14 @@ enum class FieldSource : int {
   HostMappedPtr = 1,
 };
 
-#define DEFINE_PROPERTY(Type, name)                          \
-  Type name;                                                 \
-  void set_##name(const Type &new_name) { name = new_name; } \
-  Type get_##name() { return name; }
+#define DEFINE_PROPERTY(Type, name)       \
+  Type name;                              \
+  void set_##name(const Type &new_name) { \
+    name = new_name;                      \
+  }                                       \
+  Type get_##name() {                     \
+    return name;                          \
+  }
 
 struct FieldInfo {
   DEFINE_PROPERTY(bool, valid)

diff --git a/taichi/rhi/public_device.h b/taichi/rhi/public_device.h
@@ -55,7 +55,9 @@ constexpr size_t kBufferSizeEntireSize = std::numeric_limits<size_t>::max();
   inline name operator&(name a, name b) {      \
     return static_cast<name>(int(a) & int(b)); \
   }                                            \
-  inline bool operator&&(name a, name b) { return (int(a) & int(b)) != 0; }
+  inline bool operator&&(name a, name b) {     \
+    return (int(a) & int(b)) != 0;             \
+  }
 
 enum class BlendOp : uint32_t { add, subtract, reverse_subtract, min, max };
 

diff --git a/taichi/rhi/vulkan/vulkan_device.h b/taichi/rhi/vulkan/vulkan_device.h
@@ -322,8 +322,8 @@ class VulkanPipeline : public Pipeline {
     return graphics_pipeline_template_ != nullptr;
   }
 
-  std::unordered_map<uint32_t, VulkanResourceSet>
-      &get_resource_set_templates() {
+  std::unordered_map<uint32_t, VulkanResourceSet> &
+  get_resource_set_templates() {
     return set_templates_;
   }
 

diff --git a/taichi/runtime/llvm/runtime_module/atomic.h b/taichi/runtime/llvm/runtime_module/atomic.h
@@ -36,14 +36,20 @@ DEFINE_ATOMIC_OP_INTRINSIC(xor, i64)
 DEFINE_ATOMIC_OP_INTRINSIC(xor, u32)
 DEFINE_ATOMIC_OP_INTRINSIC(xor, u64)
 
-#define DEFINE_ADD(T) \
-  T add_##T(T a, T b) { return a + b; }
+#define DEFINE_ADD(T)   \
+  T add_##T(T a, T b) { \
+    return a + b;       \
+  }
 
-#define DEFINE_MIN(T) \
-  T min_##T(T a, T b) { return b > a ? a : b; }
+#define DEFINE_MIN(T)     \
+  T min_##T(T a, T b) {   \
+    return b > a ? a : b; \
+  }
 
-#define DEFINE_MAX(T) \
-  T max_##T(T a, T b) { return b < a ? a : b; }
+#define DEFINE_MAX(T)     \
+  T max_##T(T a, T b) {   \
+    return b < a ? a : b; \
+  }
 
 #define DEFINE_ATOMIC_OP_COMP_EXCH(OP, T)                                     \
   T atomic_##OP##_##T(volatile T *dest, T inc) {                              \

diff --git a/taichi/runtime/llvm/runtime_module/runtime.cpp b/taichi/runtime/llvm/runtime_module/runtime.cpp
@@ -55,10 +55,16 @@ __asm__(".symver expf,expf@GLIBC_2.2.5");
 #endif
 
 // For accessing struct fields
-#define STRUCT_FIELD(S, F)                                             \
-  extern "C" decltype(S::F) S##_get_##F(S *s) { return s->F; }         \
-  extern "C" decltype(S::F) *S##_get_ptr_##F(S *s) { return &(s->F); } \
-  extern "C" void S##_set_##F(S *s, decltype(S::F) f) { s->F = f; }
+#define STRUCT_FIELD(S, F)                              \
+  extern "C" decltype(S::F) S##_get_##F(S *s) {         \
+    return s->F;                                        \
+  }                                                     \
+  extern "C" decltype(S::F) *S##_get_ptr_##F(S *s) {    \
+    return &(s->F);                                     \
+  }                                                     \
+  extern "C" void S##_set_##F(S *s, decltype(S::F) f) { \
+    s->F = f;                                           \
+  }
 
 #define STRUCT_FIELD_ARRAY(S, F)                                             \
   extern "C" std::remove_all_extents_t<decltype(S::F)> S##_get_##F(S *s,     \
@@ -159,9 +165,13 @@ std::size_t taichi_strlen(const char *str) {
   return len;
 }
 
-#define DEFINE_UNARY_REAL_FUNC(F)          \
-  f32 F##_f32(f32 x) { return std::F(x); } \
-  f64 F##_f64(f64 x) { return std::F(x); }
+#define DEFINE_UNARY_REAL_FUNC(F) \
+  f32 F##_f32(f32 x) {            \
+    return std::F(x);             \
+  }                               \
+  f64 F##_f64(f64 x) {            \
+    return std::F(x);             \
+  }
 
 DEFINE_UNARY_REAL_FUNC(exp)
 DEFINE_UNARY_REAL_FUNC(log)

diff --git a/taichi/util/bit.h b/taichi/util/bit.h
@@ -78,9 +78,13 @@ constexpr int bit_length() {
   return std::is_same<T, bool>() ? 1 : sizeof(T) * 8;
 }
 
-#define TI_BIT_FIELD(T, name, start)                                           \
-  T get_##name() const { return (T)Base::get<start, bit::bit_length<T>()>(); } \
-  void set_##name(const T &val) { Base::set<start, bit::bit_length<T>()>(val); }
+#define TI_BIT_FIELD(T, name, start)                    \
+  T get_##name() const {                                \
+    return (T)Base::get<start, bit::bit_length<T>()>(); \
+  }                                                     \
+  void set_##name(const T &val) {                       \
+    Base::set<start, bit::bit_length<T>()>(val);        \
+  }
 
 template <typename T, int N>
 TI_FORCE_INLINE constexpr T product(const std::array<T, N> arr) {