[JIT] clang-format JIT code (pytorch#35115)

Summary:
Pull Request resolved: pytorch#35115

This commit runs the newly added tools/clang_format.py on the JIT
codebase and includes all of the formatting changes thus produced.

Testing:
Ran the script, CI.

Test Plan: Imported from OSS

Reviewed By: eellison

Differential Revision: D20568523

Pulled By: SplitInfinity

fbshipit-source-id: e09bdb982ccf090eecfb7c7b461b8d0681eef82b

Author: Meghan Lele

Diff for: test/cpp/jit/test_alias_analysis.cpp

@@ -1,9 +1,9 @@
 #include <torch/csrc/autograd/generated/variable_factories.h>
 #include <torch/csrc/jit/ir/irparser.h>
 #include "test/cpp/jit/test_base.h"
-#include "torch/csrc/jit/runtime/custom_operator.h"
-#include "torch/csrc/jit/ir/alias_analysis.h"
 #include "torch/csrc/jit/frontend/ir_emitter.h"
+#include "torch/csrc/jit/ir/alias_analysis.h"
+#include "torch/csrc/jit/runtime/custom_operator.h"
 #include "torch/csrc/utils/memory.h"
 
 namespace torch {
@@ -391,32 +391,30 @@ void testAliasAnalysis() {
   }
 
   // test none value does not have writers
-  {
-    {
-      auto graph = std::make_shared<Graph>();
-      std::unordered_map<std::string, Value*> vmap;
-      parseIR(
-          R"IR(
+  {{auto graph = std::make_shared<Graph>();
+  std::unordered_map<std::string, Value*> vmap;
+  parseIR(
+      R"IR(
     graph():
       %opt : Tensor? = prim::Constant()
       %out : Tensor = prim::unchecked_unwrap_optional(%opt)
       %ret.2 : Tensor = aten::div(%out, %out, %out)
       return (%opt, %out, %ret.2)
       )IR",
-          &*graph,
-          vmap);
+      &*graph,
+      vmap);
 
-      AliasDb aliasDb(graph);
-      AT_ASSERT(!aliasDb.hasWriters(vmap["opt"]->node()));
-    }
-  }
+  AliasDb aliasDb(graph);
+  AT_ASSERT(!aliasDb.hasWriters(vmap["opt"]->node()));
+}
+} // namespace jit
 
-  // test safeToIntroduceAliasingRelationship
-  {
-    auto graph = std::make_shared<Graph>();
-    std::unordered_map<std::string, Value*> vmap;
-    parseIR(
-        R"IR(
+// test safeToIntroduceAliasingRelationship
+{
+  auto graph = std::make_shared<Graph>();
+  std::unordered_map<std::string, Value*> vmap;
+  parseIR(
+      R"IR(
   graph(%x : Tensor):
       %3 : int = prim::Constant[value=1]()
       %2 : int = prim::Constant[value=0]()
@@ -428,31 +426,33 @@ void testAliasAnalysis() {
       %14 : (Tensor, Tensor) = prim::TupleConstruct(%b, %c)
       return (%14)
     )IR",
-        &*graph,
-        vmap);
-
-    AliasDb aliasDb(graph);
-    // x, b, c escape scope, so we can't introduce an aliasing relationship
-    TORCH_INTERNAL_ASSERT(!aliasDb.safeToChangeAliasingRelationship(vmap["x"], vmap["b"]));
-    TORCH_INTERNAL_ASSERT(
-        !aliasDb.safeToChangeAliasingRelationship(vmap["b"], vmap["x"]));
-    TORCH_INTERNAL_ASSERT(
-        !aliasDb.safeToChangeAliasingRelationship(vmap["b"], vmap["c"]));
-    TORCH_INTERNAL_ASSERT(
-        !aliasDb.safeToChangeAliasingRelationship(vmap["c"], vmap["b"]));
-
-    // e aliases the wildcard set because it's contained in a list
-    TORCH_INTERNAL_ASSERT(
-        !aliasDb.safeToChangeAliasingRelationship(vmap["e"], vmap["x"]));
-    TORCH_INTERNAL_ASSERT(
-        !aliasDb.safeToChangeAliasingRelationship(vmap["x"], vmap["e"]));
-
-    // d is a temporary with no writers, safe to change aliasing relationship here
-    TORCH_INTERNAL_ASSERT(aliasDb.safeToChangeAliasingRelationship(vmap["c"], vmap["d"]));
-    TORCH_INTERNAL_ASSERT(
-        aliasDb.safeToChangeAliasingRelationship(vmap["d"], vmap["c"]));
-  }
+      &*graph,
+      vmap);
+
+  AliasDb aliasDb(graph);
+  // x, b, c escape scope, so we can't introduce an aliasing relationship
+  TORCH_INTERNAL_ASSERT(
+      !aliasDb.safeToChangeAliasingRelationship(vmap["x"], vmap["b"]));
+  TORCH_INTERNAL_ASSERT(
+      !aliasDb.safeToChangeAliasingRelationship(vmap["b"], vmap["x"]));
+  TORCH_INTERNAL_ASSERT(
+      !aliasDb.safeToChangeAliasingRelationship(vmap["b"], vmap["c"]));
+  TORCH_INTERNAL_ASSERT(
+      !aliasDb.safeToChangeAliasingRelationship(vmap["c"], vmap["b"]));
+
+  // e aliases the wildcard set because it's contained in a list
+  TORCH_INTERNAL_ASSERT(
+      !aliasDb.safeToChangeAliasingRelationship(vmap["e"], vmap["x"]));
+  TORCH_INTERNAL_ASSERT(
+      !aliasDb.safeToChangeAliasingRelationship(vmap["x"], vmap["e"]));
+
+  // d is a temporary with no writers, safe to change aliasing relationship here
+  TORCH_INTERNAL_ASSERT(
+      aliasDb.safeToChangeAliasingRelationship(vmap["c"], vmap["d"]));
+  TORCH_INTERNAL_ASSERT(
+      aliasDb.safeToChangeAliasingRelationship(vmap["d"], vmap["c"]));
 }
+} // namespace torch
 
 void testWriteTracking() {
   RegisterOperators reg({Operator(
@@ -720,7 +720,8 @@ graph():
     %d : Tensor[] = prim::ListConstruct(%y)
     return (%c, %d)
     )IR",
-        &*graph, vmap);
+        &*graph,
+        vmap);
 
     AliasDb aliasDb(graph);
     auto x = vmap["x"];
@@ -1179,11 +1180,10 @@ void testAliasRegistration() {
     auto a = graph->addInput();
     graph->insert(rand_op, {a});
 
-    // Registration time is okay, but throw exception when fetch from registration.
+    // Registration time is okay, but throw exception when fetch from
+    // registration.
     expectThrows<c10::Error>(
-        [&graph] {
-          AliasDb aliasDb(graph);
-        },
+        [&graph] { AliasDb aliasDb(graph); },
         "Tried to register operator foo::rand3(Tensor(a) arg1) -> (Tensor(b)) with aliasing information in the schema but without AliasAnalysisKind::FROM_SCHEMA");
   }
   {
@@ -1199,11 +1199,10 @@ void testAliasRegistration() {
     auto a = graph->addInput();
     graph->insert(rand_op, {a});
 
-    // Registration time is okay, but throw exception when fetch from registration.
+    // Registration time is okay, but throw exception when fetch from
+    // registration.
     expectThrows<c10::Error>(
-        [&graph] {
-          AliasDb aliasDb(graph);
-        },
+        [&graph] { AliasDb aliasDb(graph); },
         "Tried to register operator foo::rand4(Tensor(a) arg1) -> (Tensor(a)) with aliasing information in the schema but without AliasAnalysisKind::FROM_SCHEMA");
   }
   {
@@ -1301,38 +1300,34 @@ void testAliasRegistration() {
     auto registry = torch::RegisterOperators().op(
         "foo::rand11(Tensor(a) arg1) -> Tensor(a)",
         torch::RegisterOperators::options()
-            .catchAllKernel(
-                [](at::Tensor t) -> at::Tensor { return t * 2; })
+            .catchAllKernel([](at::Tensor t) -> at::Tensor { return t * 2; })
             .aliasAnalysis(AliasAnalysisKind::PURE_FUNCTION));
     const auto rand_op = Symbol::fromQualString("foo::rand11");
     auto graph = std::make_shared<Graph>();
     auto a = graph->addInput();
     graph->insert(rand_op, {a});
 
-    // Registration time is okay, but throw exception when fetch from registration.
+    // Registration time is okay, but throw exception when fetch from
+    // registration.
     expectThrows<c10::Error>(
-        [&graph] {
-          AliasDb aliasDb(graph);
-        },
+        [&graph] { AliasDb aliasDb(graph); },
         "Tried to register operator foo::rand11(Tensor(a) arg1) -> (Tensor(a)) with aliasing information in the schema but without AliasAnalysisKind::FROM_SCHEMA");
   }
   {
     auto registry = torch::RegisterOperators().op(
         "foo::rand12(Tensor(a) arg1) -> Tensor(b)",
         torch::RegisterOperators::options()
-            .catchAllKernel(
-                [](at::Tensor t) -> at::Tensor { return t * 2; })
+            .catchAllKernel([](at::Tensor t) -> at::Tensor { return t * 2; })
             .aliasAnalysis(AliasAnalysisKind::PURE_FUNCTION));
     const auto rand_op = Symbol::fromQualString("foo::rand12");
     auto graph = std::make_shared<Graph>();
     auto a = graph->addInput();
     graph->insert(rand_op, {a});
 
-    // Registration time is okay, but throw exception when fetch from registration.
+    // Registration time is okay, but throw exception when fetch from
+    // registration.
     expectThrows<c10::Error>(
-        [&graph] {
-          AliasDb aliasDb(graph);
-        },
+        [&graph] { AliasDb aliasDb(graph); },
         "Tried to register operator foo::rand12(Tensor(a) arg1) -> (Tensor(b)) with aliasing information in the schema but without AliasAnalysisKind::FROM_SCHEMA");
   }
 }

Diff for: test/cpp/jit/test_argument_spec.cpp

@@ -29,7 +29,10 @@ bool isEqual(const ArgumentInfo& ti, const autograd::Variable& v) {
       ti.type() == v.scalar_type() && ti.dim() == v.dim();
 }
 
-autograd::Variable var(at::TensorOptions t, at::IntArrayRef sizes, bool requires_grad) {
+autograd::Variable var(
+    at::TensorOptions t,
+    at::IntArrayRef sizes,
+    bool requires_grad) {
   return autograd::make_variable(at::rand(sizes, t), requires_grad);
 }
 autograd::Variable undef() {
@@ -157,7 +160,6 @@ void testArgumentSpec() {
                             undef()});
   list2[1].toTensor().transpose_(0, 1);
 
-
   ArgumentSpec a = arg_spec_creator.create(true, list);
   ArgumentSpec b = arg_spec_creator.create(true, list);
   ASSERT_EQ(a.hashCode(), b.hashCode());

Diff for: test/cpp/jit/test_autodiff.cpp

@@ -1,7 +1,6 @@
 #include "test/cpp/jit/test_base.h"
 #include "test/cpp/jit/test_utils.h"
-#include "torch/csrc/jit/runtime/argument_spec.h"
-#include "torch/csrc/jit/runtime/autodiff.h"
+#include "torch/csrc/jit/frontend/tracer.h"
 #include "torch/csrc/jit/passes/common_subexpression_elimination.h"
 #include "torch/csrc/jit/passes/constant_propagation.h"
 #include "torch/csrc/jit/passes/create_autodiff_subgraphs.h"
@@ -11,7 +10,8 @@
 #include "torch/csrc/jit/passes/requires_grad_analysis.h"
 #include "torch/csrc/jit/passes/shape_analysis.h"
 #include "torch/csrc/jit/passes/utils/subgraph_utils.h"
-#include "torch/csrc/jit/frontend/tracer.h"
+#include "torch/csrc/jit/runtime/argument_spec.h"
+#include "torch/csrc/jit/runtime/autodiff.h"
 
 #include <ATen/ATen.h>
 #include "torch/csrc/autograd/engine.h"
@@ -28,8 +28,15 @@ using var_meta_list = std::vector<var_meta_type>;
 using test_fn_type = std::function<variable_list(const variable_list&)>;
 
 struct ADTestSpec {
-  ADTestSpec(const char* name, var_meta_list input_meta, test_fn_type test_fn, float clampMax = -1.0f)
-      : name(name), input_meta(input_meta), test_fn(test_fn), clampMax(clampMax) {}
+  ADTestSpec(
+      const char* name,
+      var_meta_list input_meta,
+      test_fn_type test_fn,
+      float clampMax = -1.0f)
+      : name(name),
+        input_meta(input_meta),
+        test_fn(test_fn),
+        clampMax(clampMax) {}
 
   variable_list operator()(const variable_list& inputs) const {
     return test_fn(inputs);
@@ -39,7 +46,8 @@ struct ADTestSpec {
     std::vector<Variable> out;
     for (const auto& m : input_meta) {
       if (clampMax > 0.0f) {
-        out.push_back(torch::randn(m, at::requires_grad(true)).clamp(-clampMax, clampMax));
+        out.push_back(torch::randn(m, at::requires_grad(true))
+                          .clamp(-clampMax, clampMax));
         continue;
       }
       out.push_back(torch::randn(m, at::requires_grad(true)));
@@ -63,7 +71,9 @@ variable_list grad(
     const variable_list& outputs,
     const variable_list& inputs,
     const variable_list& grad_outputs) {
-  const auto get_edge = [](const Variable& v) { return torch::autograd::impl::gradient_edge(v); };
+  const auto get_edge = [](const Variable& v) {
+    return torch::autograd::impl::gradient_edge(v);
+  };
   auto& engine = torch::autograd::Engine::get_default_engine();
   return engine.execute(
       fmap(outputs, get_edge),
@@ -74,7 +84,9 @@ variable_list grad(
 }
 
 void testADFormulas() {
-  const auto cast = [](const Variable& v) { return static_cast<at::Tensor>(v); };
+  const auto cast = [](const Variable& v) {
+    return static_cast<at::Tensor>(v);
+  };
 
   using VL = variable_list;
   const var_meta_list binary_pointwise = {{2, 3, 4, 5}, {2, 3, 4, 5}};
@@ -97,7 +109,8 @@ void testADFormulas() {
       // to set a minimum on gradient absolute values
       {"tanh",
        unary_pointwise,
-       [](const VL& v) -> VL { return {v[0].tanh()}; }, 3.0f},
+       [](const VL& v) -> VL { return {v[0].tanh()}; },
+       3.0f},
       {"t", unary_pointwise_2d, [](const VL& v) -> VL { return {v[0].t()}; }},
       {"view",
        unary_pointwise_2d,
@@ -133,15 +146,15 @@ void testADFormulas() {
 
     // Trace and differentiate the op
     auto graph = tracer::trace(
-      fmap<IValue>(vars_in),
-      [&test](Stack in) -> Stack {
-        auto ivalue_inps = fmap(in, [](const IValue& v){
-          return Variable(v.toTensor());
-        });
-        return fmap<IValue>(test(ivalue_inps));
-      },
-      [](const Variable& var) { return "";}
-    ).first->graph;
+                     fmap<IValue>(vars_in),
+                     [&test](Stack in) -> Stack {
+                       auto ivalue_inps = fmap(in, [](const IValue& v) {
+                         return Variable(v.toTensor());
+                       });
+                       return fmap<IValue>(test(ivalue_inps));
+                     },
+                     [](const Variable& var) { return ""; })
+                     .first->graph;
     EliminateDeadCode(graph); // Tracing of some ops depends on the DCE trick
     ConstantPropagation(graph);
     auto grad_spec = differentiate(graph);
@@ -164,22 +177,24 @@ void testADFormulas() {
 void testDifferentiate() {
   // Note: can't use IRParser for this test due to issue #23989
   auto graph = std::make_shared<Graph>();
-  const auto type = TensorType::create(at::ScalarType::Float, at::kCPU, {2, 3, 4}, {12, 4, 1});
+  const auto type = TensorType::create(
+      at::ScalarType::Float, at::kCPU, {2, 3, 4}, {12, 4, 1});
 
   // Builds graph a * b * a + b
   auto* a = graph->addInput()->setType(type);
   auto* b = graph->addInput()->setType(type);
   auto* cOne = graph->insertConstant(1);
 
-  auto* ab = graph->insertNode(graph->create(aten::mul, /*num_outputs =*/ 1));
+  auto* ab = graph->insertNode(graph->create(aten::mul, /*num_outputs =*/1));
   ab->addInput(a);
   ab->addInput(b);
 
-  auto* aba = graph->insertNode(graph->create(aten::mul, /*num_outputs =*/ 1));
+  auto* aba = graph->insertNode(graph->create(aten::mul, /*num_outputs =*/1));
   aba->addInput(ab->output());
   aba->addInput(a);
 
-  auto* abaplusb = graph->insertNode(graph->create(aten::add, /*num_outputs =*/ 1));
+  auto* abaplusb =
+      graph->insertNode(graph->create(aten::add, /*num_outputs =*/1));
   abaplusb->addInput(aba->output());
   abaplusb->addInput(b);
   abaplusb->addInput(cOne);

Diff for: test/cpp/jit/test_class_import.cpp

@@ -2,8 +2,8 @@
 #include <test/cpp/jit/test_utils.h>
 
 #include <ATen/core/qualified_name.h>
-#include <torch/csrc/jit/serialization/import_source.h>
 #include <torch/csrc/jit/frontend/resolver.h>
+#include <torch/csrc/jit/serialization/import_source.h>
 #include <torch/torch.h>
 
 namespace torch {
@@ -40,9 +40,7 @@ static void import_libs(
   SourceImporter si(
       cu,
       &tensor_table,
-      [&](const std::string& name) -> std::shared_ptr<Source> {
-        return src;
-      },
+      [&](const std::string& name) -> std::shared_ptr<Source> { return src; },
       /*version=*/2);
   si.loadNamedType(QualifiedName(class_name));
 }

Diff for: test/cpp/jit/test_custom_class.cpp

@@ -138,7 +138,6 @@ torch::RegisterOperators& register_take_instance() {
 
 static auto& ensure_take_instance_registered = register_take_instance();
 
-
 } // namespace
 
 void testTorchbindIValueAPI() {