[15/N] Fix extra warnings brought by clang-tidy-17 (pytorch#143100)

Fixes #ISSUE_NUMBER

Pull Request resolved: pytorch#143100
Approved by: https://github.com/Skylion007

Author: cyyever

aten/src/ATen/functorch/BatchRulesBinaryOps.cpp

@@ -313,7 +313,7 @@ static Tensor rrelu_with_noise_batch(
   auto [noise_value, noise_bdim] = unwrapTensorAtLevel(noise, cur_level);
   TORCH_CHECK(!noise_bdim.has_value(), "vmap: Attempted to vmap over 'noise' in torch.rrelu_with_noise. This is not supported.");
   auto res = rrelu_with_noise_batch_rule(self_value, self_bdim, noise_value, noise_bdim, lower, upper, training, std::move(generator));
-  return makeBatched(std::get<0>(res), std::get<1>(res), cur_level);
+  return makeBatched(std::move(std::get<0>(res)), std::get<1>(res), cur_level);
 }
 
 static std::tuple<Tensor, std::optional<int64_t>> log_sigmoid_backward_batch_rule(

aten/src/ATen/functorch/BatchRulesHelper.cpp

@@ -199,7 +199,7 @@ std::tuple<Tensor, Tensor> _binary_pointwise_helper(
   tensor_ = maybePadToLogicalRank(tensor_, tensor_batch_dim, max_logical_rank);
   other_ = maybePadToLogicalRank(other_, other_batch_dim, max_logical_rank);
 
-  return std::make_tuple(tensor_, other_);
+  return std::make_tuple(std::move(tensor_), std::move(other_));
 }
 
 } // namespace at::functorch

aten/src/ATen/functorch/BatchRulesLinearAlgebra.cpp

@@ -213,7 +213,7 @@ struct LinalgCheckMatrixUnaryRuleHelper<op_name, F, Func, typelist<A, T...>> {
       T... extra_args) {
     auto tensor_ = check_and_reshape_input(tensor, batch_dim);
     auto res = Func(std::move(tensor_), std::forward<T>(extra_args)...);
-    return std::make_tuple(std::get<0>(res), 0, std::get<1>(res), 0, std::get<2>(res), 0, std::get<3>(res), 0);
+    return std::make_tuple(std::move(std::get<0>(res)), 0, std::move(std::get<1>(res)), 0, std::move(std::get<2>(res)), 0, std::get<3>(res), 0);
   }
 };
 
@@ -279,8 +279,8 @@ threeOutputs linalg_lu_unpack_batch_rule(
     LU_bdim = 0;
   }
 
-  const auto res = at::lu_unpack(LU_, pivots_, unpack_data, unpack_pivots);
-  return std::make_tuple(std::get<0>(res), 0, std::get<1>(res), 0, std::get<2>(res), 0);
+  auto res = at::lu_unpack(LU_, pivots_, unpack_data, unpack_pivots);
+  return std::make_tuple(std::move(std::get<0>(res)), 0, std::move(std::get<1>(res)), 0, std::move(std::get<2>(res)), 0);
 }
 
 oneOutput linalg_lu_solve_batch_rule(

aten/src/ATen/native/quantized/FakeQuantPerChannelAffine.cpp

@@ -36,9 +36,9 @@ Tensor fake_quantize_per_channel_affine(
     int64_t axis,
     int64_t quant_min,
     int64_t quant_max) {
-  const auto res = at::fake_quantize_per_channel_affine_cachemask(
+  auto res = at::fake_quantize_per_channel_affine_cachemask(
       self, scale, zero_point, axis, quant_min, quant_max);
-  return std::get<0>(res);
+  return std::get<0>(std::move(res));
 }
 
 std::tuple<Tensor, Tensor> fake_quantize_per_channel_affine_cachemask(

aten/src/ATen/native/quantized/FakeQuantPerTensorAffine.cpp

@@ -34,9 +34,9 @@ Tensor fake_quantize_per_tensor_affine(
     int64_t zero_point,
     int64_t quant_min,
     int64_t quant_max) {
-  const auto res = at::fake_quantize_per_tensor_affine_cachemask(
+  auto res = at::fake_quantize_per_tensor_affine_cachemask(
       self, scale, zero_point, quant_min, quant_max);
-  return std::get<0>(res);
+  return std::get<0>(std::move(res));
 }
 
 Tensor fake_quantize_per_tensor_affine(
@@ -45,9 +45,9 @@ Tensor fake_quantize_per_tensor_affine(
     const Tensor& zero_point,
     int64_t quant_min,
     int64_t quant_max) {
-  const auto res = at::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams(
+  auto res = at::_fake_quantize_per_tensor_affine_cachemask_tensor_qparams(
       self, scale, zero_point, at::ones(1, self.options().dtype(at::kLong)), quant_min, quant_max);
-  return std::get<0>(res);
+  return std::get<0>(std::move(res));
 }
 
 /* Fake-quantizes the 'inputs' tensor, saving a mask for the backward pass.

aten/src/ATen/native/quantized/cpu/conv_serialization.h

@@ -86,7 +86,7 @@ using ConvParamsSerializationTypeV3 = std::tuple<
 // Parses any historical conv packed params format into
 // the current format.
 template <uint32_t kSpatialDim>
-ConvParamsSerializationTypeV3 parse_conv_serialized_state(c10::IValue v) {
+ConvParamsSerializationTypeV3 parse_conv_serialized_state(const c10::IValue& v) {
 
   // determine the version based on IValue contents
   int version = -1;
@@ -131,15 +131,15 @@ ConvParamsSerializationTypeV3 parse_conv_serialized_state(c10::IValue v) {
         dilation_x_kSpatialDim.size() + kSpatialDim + 3);
     config_vals.push_back(kSpatialDim);
     for (const auto i : c10::irange(stride_x_kSpatialDim.size())) {
-      auto stride = stride_x_kSpatialDim.get(i);
+      auto const & stride = stride_x_kSpatialDim.get(i);
       config_vals.push_back(stride[0].item<int16_t>());
     }
     for (const auto i : c10::irange(padding_x_kSpatialDim.size())) {
-      auto padding = padding_x_kSpatialDim.get(i);
+      auto const &padding = padding_x_kSpatialDim.get(i);
       config_vals.push_back(padding[0].item<int16_t>());
     }
     for (const auto i : c10::irange(dilation_x_kSpatialDim.size())) {
-      auto dilation = dilation_x_kSpatialDim.get(i);
+      auto const &dilation = dilation_x_kSpatialDim.get(i);
       config_vals.push_back(dilation[0].item<int16_t>());
     }
     // output_padding does not exist in v1, so we fill in a default value
@@ -283,13 +283,13 @@ ConvParamsSerializationTypeV3 serialize_conv(
 template <uint32_t kSpatialDim>
 c10::intrusive_ptr<ConvPackedParamsBase<kSpatialDim>> deserialize_conv(
     ConvParamsSerializationTypeV3 state) {
-  auto [version, config_vals, tensors] = state;
+  auto & [version, config_vals, tensors] = state;
   TORCH_INTERNAL_ASSERT(version == 3, "Unexpected serialized qconv version: ", version);
 
   TORCH_CHECK(tensors.size() == 3, "Wrong number of tensors", tensors.size());
-  std::optional<at::Tensor> weight = tensors[1];
-  std::optional<at::Tensor> bias = tensors[2];
-  TORCH_INTERNAL_ASSERT(weight, "Weight should always be present in serialized qconv.");
+  auto & weight = tensors[1];
+  auto & bias = tensors[2];
+  TORCH_INTERNAL_ASSERT(weight.has_value(), "Weight should always be present in serialized qconv.");
 
   torch::List<int64_t> stride, padding, output_padding, dilation;
   // skip kSpatialDim
@@ -340,8 +340,8 @@ c10::intrusive_ptr<ConvPackedParamsBase<kSpatialDim>> deserialize_conv(
         weight.value(), transpose, groups, output_padding);
     if (use_onednn) {
       return PackedConvWeightsOnednn<kSpatialDim>::prepack(
-        weight.value(),
-        bias,
+        std::move(weight.value()),
+        std::move(bias),
         stride,
         padding,
         output_padding,
@@ -352,8 +352,8 @@ c10::intrusive_ptr<ConvPackedParamsBase<kSpatialDim>> deserialize_conv(
     }
 #endif
     return PackedConvWeight<kSpatialDim>::prepack(
-      weight.value(),
-      bias,
+      std::move(weight.value()),
+      std::move(bias),
       stride,
       padding,
       output_padding,
@@ -367,8 +367,8 @@ c10::intrusive_ptr<ConvPackedParamsBase<kSpatialDim>> deserialize_conv(
 #ifdef USE_FBGEMM
   if (ctx.qEngine() == at::QEngine::FBGEMM) {
     return PackedConvWeight<kSpatialDim>::prepack(
-      weight.value(),
-      bias,
+      std::move(weight.value()),
+      std::move(bias),
       stride,
       padding,
       output_padding,
@@ -385,8 +385,8 @@ c10::intrusive_ptr<ConvPackedParamsBase<kSpatialDim>> deserialize_conv(
         "prepack/__setstate__: QNNPACK only supports Conv2d "
         "now.");
     return PackedConvWeightsQnnp<kSpatialDim>::prepack(
-      weight.value(),
-      bias,
+      std::move(weight.value()),
+      std::move(bias),
       stride,
       padding,
       output_padding,
@@ -399,8 +399,8 @@ c10::intrusive_ptr<ConvPackedParamsBase<kSpatialDim>> deserialize_conv(
 #if AT_MKLDNN_ENABLED()
   if (ctx.qEngine() == at::QEngine::ONEDNN) {
     return PackedConvWeightsOnednn<kSpatialDim>::prepack(
-      weight.value(),
-      bias,
+      std::move(weight.value()),
+      std::move(bias),
       stride,
       padding,
       output_padding,

aten/src/ATen/native/quantized/cpu/fused_obs_fake_quant.cpp

@@ -235,7 +235,7 @@ at::Tensor fused_moving_avg_obs_fake_quant(
   if (self.sym_numel() == 0) {
     return self.clone();
   }
-  const auto res = at::_fused_moving_avg_obs_fq_helper(
+  auto res = at::_fused_moving_avg_obs_fq_helper(
       self,
       observer_on,
       fake_quant_on,
@@ -249,6 +249,6 @@ at::Tensor fused_moving_avg_obs_fake_quant(
       ch_axis,
       per_row_fake_quant,
       symmetric_quant);
-  return std::get<0>(res);
+  return std::get<0>(std::move(res));
 }
 } // namespace at::native

torch/csrc/jit/python/pybind_utils.h

@@ -79,6 +79,10 @@ class ToIValueAllowNumbersAsTensors {
 // type of its field 'torch::jit::PythonFunctionGuard::func_'
 struct VISIBILITY_HIDDEN PythonFunctionGuard {
   explicit PythonFunctionGuard(py::function func) : func_(std::move(func)) {}
+  PythonFunctionGuard(const PythonFunctionGuard&) = delete;
+  PythonFunctionGuard(PythonFunctionGuard&&) = delete;
+  PythonFunctionGuard& operator=(const PythonFunctionGuard&) = delete;
+  PythonFunctionGuard& operator=(PythonFunctionGuard&&) = delete;
 
   ~PythonFunctionGuard() {
     pybind11::gil_scoped_acquire ag;
@@ -112,6 +116,9 @@ struct VISIBILITY_HIDDEN PythonFutureWrapper
 
   explicit PythonFutureWrapper(const PythonFutureWrapper&) = delete;
   PythonFutureWrapper& operator=(const PythonFutureWrapper&) = delete;
+  PythonFutureWrapper(PythonFutureWrapper&&) = default;
+  PythonFutureWrapper& operator=(PythonFutureWrapper&&) = default;
+  ~PythonFutureWrapper() = default;
 
   bool done() {
     return fut->completed();
@@ -275,6 +282,9 @@ struct VISIBILITY_HIDDEN PythonAwaitWrapper
 
   explicit PythonAwaitWrapper(const PythonAwaitWrapper&) = delete;
   PythonAwaitWrapper& operator=(const PythonAwaitWrapper&) = delete;
+  PythonAwaitWrapper(PythonAwaitWrapper&&) = default;
+  PythonAwaitWrapper& operator=(PythonAwaitWrapper&&) = default;
+  ~PythonAwaitWrapper() = default;
 
   py::object wait() {
     py::gil_scoped_acquire acquire;
@@ -390,6 +400,7 @@ inline InferredType tryToInferType(py::handle input) {
     return InferredType(FloatType::get());
   } else if (PyComplex_CheckExact(input.ptr())) {
     return InferredType(ComplexType::get());
+    // NOLINTNEXTLINE(bugprone-branch-clone)
   } else if (py::isinstance<py::bytes>(input)) {
     // NOTE: We may need a ByteType in the future
     return InferredType(StringType::get());
@@ -855,9 +866,9 @@ inline py::object getScriptedClassOrError(const c10::NamedTypePtr& classType) {
 
 struct VISIBILITY_HIDDEN tuple_slice {
   /*implicit*/ tuple_slice(py::tuple tup_)
-      : tup(std::move(tup_)), b(0), e(tup.size()) {}
+      : tup(std::move(tup_)), b(0), e(static_cast<int64_t>(tup.size())) {}
   tuple_slice(py::tuple tup_, int64_t b_)
-      : tup(std::move(tup_)), b(b_), e(tup.size()) {}
+      : tup(std::move(tup_)), b(b_), e(static_cast<int64_t>(tup.size())) {}
   tuple_slice(py::tuple tup_, int64_t b_, int64_t e_)
       : tup(std::move(tup_)), b(b_), e(e_) {}
   py::detail::tuple_iterator begin() const {
@@ -1064,6 +1075,7 @@ inline Stack createStackForSchema(
   return stack;
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
 inline py::object createPyObjectForStack(Stack&& stack) {
   if (stack.empty()) {
     return py::none();

torch/csrc/profiler/util.cpp

@@ -541,7 +541,7 @@ std::unordered_map<std::string, std::string> saveNcclMeta(
       }
     }
     if (config.introspectOutputs) {
-      const auto outputs = fn.outputs();
+      const auto& outputs = fn.outputs();
       auto num_outputs = fn.num_outputs();
       if (checkFunctionOutputsForLogging(fn)) {
         // need to account for Stack mode where the outputs are at the end.