[structural binding][11/N] Replace std::tie with structural binding (pytorch#130830)

Follows  pytorch#130784

Pull Request resolved: pytorch#130830
Approved by: https://github.com/janeyx99

Author: cyyever

aten/src/ATen/native/cuda/Indexing.cu

@@ -1763,8 +1763,7 @@ Tensor index_select_sparse_cuda(const Tensor& self, int64_t dim, const Tensor& i
       return make_output(empty_idx, empty_idx);
     }
 
-    Tensor selected_dim_indices, res_dim_indices;
-    std::tie(selected_dim_indices, res_dim_indices) = [&]() -> std::tuple<Tensor, Tensor> {
+    auto [selected_dim_indices, res_dim_indices] = [&]() -> std::tuple<Tensor, Tensor> {
       auto res_dim_indices = at::empty({res_len}, nneg_index.options());
       auto selected_dim_indices = at::empty_like(res_dim_indices);
       auto selected_dim_indices_offsets = intrsc_counts_nneg_index.cumsum(0)

test/cpp/api/modules.cpp

@@ -314,8 +314,7 @@ TEST_F(ModulesTest, MaxPool1d) {
 TEST_F(ModulesTest, MaxPool1dReturnIndices) {
   MaxPool1d model(MaxPool1dOptions(3).stride(2));
   auto x = torch::ones({1, 1, 5}, torch::requires_grad());
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
 
   ASSERT_EQ(y.dim(), 3);
   ASSERT_TRUE(torch::allclose(y, torch::ones({1, 1, 2})));
@@ -355,8 +354,7 @@ TEST_F(ModulesTest, MaxPool2dUneven) {
 TEST_F(ModulesTest, MaxPool2dReturnIndices) {
   MaxPool2d model(MaxPool2dOptions(3).stride(2));
   auto x = torch::ones({2, 5, 5}, torch::requires_grad());
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
 
   ASSERT_EQ(y.dim(), 3);
   ASSERT_TRUE(torch::allclose(y, torch::ones({2, 2, 2})));
@@ -383,8 +381,7 @@ TEST_F(ModulesTest, MaxPool3d) {
 TEST_F(ModulesTest, MaxPool3dReturnIndices) {
   MaxPool3d model(MaxPool3dOptions(3).stride(2));
   auto x = torch::ones({2, 5, 5, 5}, torch::requires_grad());
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
 
   ASSERT_EQ(y.dim(), 4);
   ASSERT_TRUE(torch::allclose(y, torch::ones({2, 2, 2, 2})));
@@ -467,8 +464,7 @@ TEST_F(ModulesTest, FractionalMaxPool2d) {
 TEST_F(ModulesTest, FractionalMaxPool2dReturnIndices) {
   FractionalMaxPool2d model(FractionalMaxPool2dOptions(3).output_size(2));
   auto x = torch::ones({2, 5, 5}, torch::requires_grad());
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
 
   ASSERT_EQ(y.dim(), 3);
   ASSERT_TRUE(torch::allclose(y, torch::ones({2, 2, 2})));
@@ -494,8 +490,7 @@ TEST_F(ModulesTest, FractionalMaxPool3d) {
 TEST_F(ModulesTest, FractionalMaxPool3dReturnIndices) {
   FractionalMaxPool3d model(FractionalMaxPool3dOptions(3).output_size(2));
   auto x = torch::ones({2, 5, 5, 5}, torch::requires_grad());
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
 
   ASSERT_EQ(y.dim(), 4);
   ASSERT_TRUE(torch::allclose(y, torch::ones({2, 2, 2, 2})));
@@ -655,8 +650,7 @@ TEST_F(ModulesTest, AdaptiveMaxPool1dReturnIndices) {
   AdaptiveMaxPool1d model(3);
   auto x = torch::tensor(
       {{{1, 2, 3, 4, 5}}}, torch::dtype(torch::kFloat).requires_grad(true));
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
 
   ASSERT_EQ(y.dim(), 3);
   ASSERT_TRUE(torch::allclose(y, torch::tensor({{{2, 4, 5}}}, torch::kFloat)));
@@ -712,8 +706,7 @@ TEST_F(ModulesTest, AdaptiveMaxPool2dReturnIndicesEven) {
   AdaptiveMaxPool2d model(3);
   auto x = torch::arange(0., 50);
   x.resize_({2, 5, 5}).set_requires_grad(true);
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
   torch::Tensor s = y.sum();
 
   s.backward();
@@ -746,8 +739,7 @@ TEST_F(ModulesTest, AdaptiveMaxPool2dReturnIndicesUneven) {
   AdaptiveMaxPool2d model(AdaptiveMaxPool2dOptions({3, 2}));
   auto x = torch::arange(0., 40);
   x.resize_({2, 5, 4}).set_requires_grad(true);
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
   torch::Tensor s = y.sum();
 
   s.backward();
@@ -803,8 +795,7 @@ TEST_F(ModulesTest, AdaptiveMaxPool3dReturnIndices) {
   AdaptiveMaxPool3d model(3);
   auto x = torch::arange(0., 64);
   x.resize_({1, 4, 4, 4}).set_requires_grad(true);
-  torch::Tensor y, indices;
-  std::tie(y, indices) = model->forward_with_indices(x);
+  auto [y, indices] = model->forward_with_indices(x);
   torch::Tensor s = y.sum();
 
   s.backward();
@@ -946,8 +937,7 @@ TEST_F(ModulesTest, MaxPool1d_MaxUnpool1d) {
   MaxPool1d pool{MaxPool1dOptions(2).stride(2)};
   MaxUnpool1d unpool{MaxUnpool1dOptions(2).stride(2)};
   auto input = torch::tensor({{{1, 2, 3, 4, 5, 6, 7, 8}}}, torch::kFloat);
-  torch::Tensor output, indices;
-  std::tie(output, indices) = pool->forward_with_indices(input);
+  auto [output, indices] = pool->forward_with_indices(input);
   ASSERT_TRUE(torch::allclose(
       unpool(output, indices),
       torch::tensor({{{0, 2, 0, 4, 0, 6, 0, 8}}}, torch::kFloat)));
@@ -999,8 +989,7 @@ TEST_F(ModulesTest, MaxPool2d_MaxUnpool2d) {
   auto input = torch::tensor(
       {{{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}}},
       torch::kFloat);
-  torch::Tensor output, indices;
-  std::tie(output, indices) = pool->forward_with_indices(input);
+  auto [output, indices] = pool->forward_with_indices(input);
   ASSERT_TRUE(torch::allclose(
       unpool(output, indices),
       torch::tensor(
@@ -1061,8 +1050,7 @@ TEST_F(ModulesTest, MaxPool3d_MaxUnpool3d) {
   MaxPool3d pool{MaxPool3dOptions(3).stride(2)};
   MaxUnpool3d unpool{MaxUnpool3dOptions(3).stride(2)};
   auto input = torch::randn({20, 16, 51, 33, 15});
-  torch::Tensor output, indices;
-  std::tie(output, indices) = pool->forward_with_indices(input);
+  auto [output, indices] = pool->forward_with_indices(input);
   auto unpooled_output = unpool(output, indices);
   ASSERT_EQ(
       unpooled_output.sizes(), std::vector<int64_t>({20, 16, 51, 33, 15}));
@@ -3755,9 +3743,7 @@ void _multihead_attn_test_helper(
             /*dim=*/1);
       }
     }
-    torch::Tensor attn_heads;
-    torch::Tensor ref_attn_weight;
-    std::tie(attn_heads, ref_attn_weight) = _scaled_dot_attn_ref(
+    auto [attn_heads, ref_attn_weight] = _scaled_dot_attn_ref(
         Q_split,
         K_split,
         V_split,

test/cpp/jit/test_autodiff.cpp

@@ -169,8 +169,7 @@ TEST(AutodiffTest, ADFormulas) {
     // Get outputs from the interpreter
     auto tensors_in = fmap(vars_in, cast);
     auto tensor_grads_in = fmap(var_grads_in, cast);
-    tensor_list tensors_out, tensor_grads_out;
-    std::tie(tensors_out, tensor_grads_out) =
+    auto [tensors_out, tensor_grads_out] =
         runGradient(grad_spec, tensors_in, tensor_grads_in);
 
     // Compare results

test/cpp/jit/test_misc.cpp

@@ -170,8 +170,7 @@ TEST(THNNConvTest, Basic) {
       torch::randn_like(output, at::MemoryFormat::Preserve);
 
   // run backward eagerly
-  at::Tensor grad_input, grad_weight, grad_bias;
-  std::tie(grad_input, grad_weight, grad_bias) = at::_slow_conv2d_backward(
+  auto [grad_input, grad_weight, grad_bias] = at::_slow_conv2d_backward(
       grad_output,
       input,
       weight,
@@ -216,8 +215,7 @@ TEST(THNNConvTest, Basic) {
   tensor_grads_in.push_back(grad_output);
 
   // Get outputs from the interpreter
-  tensor_list tensors_out, tensor_grads_out;
-  std::tie(tensors_out, tensor_grads_out) =
+  auto [tensors_out, tensor_grads_out] =
       runGradient(grad_spec, tensors_in, tensor_grads_in);
 
   // prepare expected structs
@@ -255,8 +253,7 @@ TEST(ATenNativeBatchNormTest, Basic) {
   at::Tensor running_var_jit = running_var.clone();
 
   // run forward eagerly
-  at::Tensor output, savemean, saveinvstd;
-  std::tie(output, savemean, saveinvstd) = at::native_batch_norm(
+  auto [output, savemean, saveinvstd] = at::native_batch_norm(
       input,
       weight,
       bias,
@@ -275,12 +272,11 @@ TEST(ATenNativeBatchNormTest, Basic) {
       torch::zeros_like(saveinvstd, at::MemoryFormat::Preserve);
 
   // run backward eagerly
-  at::Tensor grad_input, grad_weight, grad_bias;
   // aten::native_batch_norm_backward(Tensor grad_out, Tensor input, Tensor
   // weight, Tensor running_mean, Tensor running_var, Tensor save_mean, Tensor
   // save_invstd, bool train, float eps, bool[3] output_mask) -> (Tensor,
   // Tensor, Tensor)
-  std::tie(grad_input, grad_weight, grad_bias) = at::native_batch_norm_backward(
+  auto [grad_input, grad_weight, grad_bias] = at::native_batch_norm_backward(
       grad_output,
       input,
       weight,
@@ -341,8 +337,7 @@ TEST(ATenNativeBatchNormTest, Basic) {
   tensor_grads_in.push_back(grad_saveinvstd);
 
   // Get outputs from the interpreter
-  tensor_list tensors_out, tensor_grads_out;
-  std::tie(tensors_out, tensor_grads_out) =
+  auto [tensors_out, tensor_grads_out] =
       runGradient(grad_spec, tensors_in, tensor_grads_in);
 
   // prepare expected structs

test/cpp/tensorexpr/test_external_calls.cpp

@@ -647,10 +647,7 @@ TEST(ExternalCall, BinaryFloat) {
   tests.push_back(
       Test{{100, 200}, {200, 300}, {100, 300}, at::mm, "nnc_aten_mm"});
   for (auto curTest : tests) {
-    std::vector<int64_t> aShape, bShape, resShape;
-    TensorFunc torchFunc;
-    std::string externCallName;
-    std::tie(aShape, bShape, resShape, torchFunc, externCallName) = curTest;
+    auto [aShape, bShape, resShape, torchFunc, externCallName] = curTest;
     auto toExprHandleVec = [](std::vector<int64_t> v) {
       auto intV = std::vector<int>(v.begin(), v.end());
       return std::vector<ExprHandle>(intV.begin(), intV.end());
@@ -730,11 +727,7 @@ TEST(ExternalCall, UnaryFloat) {
                        "nnc_aten_mean",
                        toExprHandleVec({1, /*keepdim=*/0})});
   for (auto curTest : tests) {
-    std::vector<int64_t> aShape, resShape;
-    TensorFunc torchFunc;
-    std::string externCallName;
-    std::vector<ExprHandle> externCallArgs;
-    std::tie(aShape, resShape, torchFunc, externCallName, externCallArgs) =
+    auto [aShape, resShape, torchFunc, externCallName, externCallArgs] =
         curTest;
     BufHandle A("A", toExprHandleVec(aShape), kFloat);
     BufHandle ResultBuf("Result", toExprHandleVec(resShape), kFloat);

torch/csrc/jit/passes/onnx/shape_type_inference.cpp

@@ -386,29 +386,26 @@ void ConvertGraphToONNXProto(
     SymbolDimMap& symbol_dim_map,
     DimSymbolMap& dim_symbol_map,
     int opset_version) {
-  RawDataExportMap export_map;
-  bool val_use_external_data_format;
-  SymbolDimMap new_symbol_dim_map;
-  NodeNameMap node_names;
-  std::tie(
-      model_proto,
-      export_map,
-      new_symbol_dim_map,
-      val_use_external_data_format,
-      node_names) =
-      export_onnx(
-          graph,
-          {},
-          opset_version,
-          {},
-          false,
-          onnx_torch::OperatorExportTypes::ONNX,
-          true,
-          true,
-          {},
-          true,
-          false,
-          std::string());
+  auto
+      [model_proto_tmp,
+       export_map,
+       new_symbol_dim_map,
+       val_use_external_data_format,
+       node_names] =
+          export_onnx(
+              graph,
+              {},
+              opset_version,
+              {},
+              false,
+              onnx_torch::OperatorExportTypes::ONNX,
+              true,
+              true,
+              {},
+              true,
+              false,
+              std::string());
+  model_proto = std::move(model_proto_tmp);
   symbol_dim_map.insert(new_symbol_dim_map.begin(), new_symbol_dim_map.end());
   for (const auto& pair : new_symbol_dim_map) {
     dim_symbol_map[pair.second] = pair.first;