linting

Author: BujSet

kernels/portable/cpu/op__to_dim_order_copy.cpp

@@ -55,16 +55,14 @@ Tensor& _to_dim_order_copy_out(
   }
 
   // @lint-ignore CLANGTIDY facebook-hte-CArray
-  static constexpr const char op_name[] = "dim_order_ops::_to_dim_order_copy.out";
+  static constexpr const char op_name[] =
+      "dim_order_ops::_to_dim_order_copy.out";
 
   ET_SWITCH_REALHBBF16_TYPES(self.scalar_type(), ctx, op_name, CTYPE_IN, [&] {
-    ET_SWITCH_REALHBBF16_TYPES(
-        out.scalar_type(),
-        ctx,
-        op_name,
-        CTYPE_OUT,
-        [&] { _to_dim_order_copy_impl<CTYPE_IN, CTYPE_OUT>(self, out); });
-      });
+    ET_SWITCH_REALHBBF16_TYPES(out.scalar_type(), ctx, op_name, CTYPE_OUT, [&] {
+      _to_dim_order_copy_impl<CTYPE_IN, CTYPE_OUT>(self, out);
+    });
+  });
 
   return out;
 }

kernels/portable/cpu/op_avg_pool2d.cpp

@@ -71,53 +71,52 @@ Tensor& avg_pool2d_out(
   // @lint-ignore CLANGTIDY facebook-hte-CArray
   static constexpr const char op_name[] = "avg_pool2d.out";
 
-  ET_SWITCH_FLOATHBF16_TYPES_AND(
-      Long, in_type, ctx, op_name, CTYPE, [&]() {
-        if (divisor_override.has_value()) {
-          int64_t divisor = divisor_override.value();
-          // If divisor_override is specified, then we don't need to use `count`
-          // in the calculation. Simply sum x / divisor to get the output.
-          apply_kernel_2d_reduce_then_map_fn<CTYPE>(
-              [](const CTYPE in_val,
-                 int64_t in_idx,
-                 CTYPE accum,
-                 int64_t accum_idx) {
-                // Average pooling does not track indexes, so return 0 for
-                // accum_idx
-                return std::tuple<CTYPE, int64_t>(in_val + accum, 0);
-              },
-              [divisor](const int64_t count, const CTYPE accum) {
-                return accum / static_cast<CTYPE>(divisor);
-              },
-              count_include_pad,
-              in,
-              kernel_size,
-              stride,
-              padding,
-              {},
-              out);
-        } else {
-          apply_kernel_2d_reduce_then_map_fn<CTYPE>(
-              [](const CTYPE in_val,
-                 int64_t in_idx,
-                 CTYPE accum,
-                 int64_t accum_idx) {
-                // Average pooling does not track indexes, so return 0 for
-                // accum_idx
-                return std::tuple<CTYPE, int64_t>(in_val + accum, 0);
-              },
-              [](const int64_t count, const CTYPE accum) {
-                return accum / static_cast<CTYPE>(count);
-              },
-              count_include_pad,
-              in,
-              kernel_size,
-              stride,
-              padding,
-              {},
-              out);
-        }
-      });
+  ET_SWITCH_FLOATHBF16_TYPES_AND(Long, in_type, ctx, op_name, CTYPE, [&]() {
+    if (divisor_override.has_value()) {
+      int64_t divisor = divisor_override.value();
+      // If divisor_override is specified, then we don't need to use `count`
+      // in the calculation. Simply sum x / divisor to get the output.
+      apply_kernel_2d_reduce_then_map_fn<CTYPE>(
+          [](const CTYPE in_val,
+             int64_t in_idx,
+             CTYPE accum,
+             int64_t accum_idx) {
+            // Average pooling does not track indexes, so return 0 for
+            // accum_idx
+            return std::tuple<CTYPE, int64_t>(in_val + accum, 0);
+          },
+          [divisor](const int64_t count, const CTYPE accum) {
+            return accum / static_cast<CTYPE>(divisor);
+          },
+          count_include_pad,
+          in,
+          kernel_size,
+          stride,
+          padding,
+          {},
+          out);
+    } else {
+      apply_kernel_2d_reduce_then_map_fn<CTYPE>(
+          [](const CTYPE in_val,
+             int64_t in_idx,
+             CTYPE accum,
+             int64_t accum_idx) {
+            // Average pooling does not track indexes, so return 0 for
+            // accum_idx
+            return std::tuple<CTYPE, int64_t>(in_val + accum, 0);
+          },
+          [](const int64_t count, const CTYPE accum) {
+            return accum / static_cast<CTYPE>(count);
+          },
+          count_include_pad,
+          in,
+          kernel_size,
+          stride,
+          padding,
+          {},
+          out);
+    }
+  });
 
   return out;
 }

kernels/portable/cpu/op_diagonal_copy.cpp

@@ -98,7 +98,6 @@ Tensor& diagonal_copy_out(
       InvalidArgument,
       out);
 
-
   // @lint-ignore CLANGTIDY facebook-hte-CArray
   static constexpr const char op_name[] = "diagonal_copy.out";
 

kernels/portable/cpu/op_embedding.cpp

@@ -119,10 +119,9 @@ Tensor& embedding_out(
   // @lint-ignore CLANGTIDY facebook-hte-CArray
   static constexpr const char op_name[] = "op_embedding.out";
 
-  ET_SWITCH_TWO_TYPES(
-      Long, Int, ix_type, ctx, op_name, CTYPE, [&]() {
-        embedding_kernel<CTYPE>(ctx, weight, indices, out);
-      });
+  ET_SWITCH_TWO_TYPES(Long, Int, ix_type, ctx, op_name, CTYPE, [&]() {
+    embedding_kernel<CTYPE>(ctx, weight, indices, out);
+  });
 
   return out;
 }