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

Fixes #ISSUE_NUMBER

Pull Request resolved: pytorch#141644
Approved by: https://github.com/ezyang

Co-authored-by: Eli Uriegas <[email protected]>

Author: 2 people

aten/src/ATen/MatrixRef.h

@@ -92,8 +92,8 @@ class MatrixRef {
   /// The declaration here is extra complicated so that "arrayRef = {}"
   /// continues to select the move assignment operator.
   template <typename U>
-  // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
   std::enable_if_t<std::is_same_v<U, T>, MatrixRef<T>>& operator=(
+      // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)
       U&& Temporary) = delete;
 
   /// Disallow accidental assignment from a temporary.

aten/src/ATen/cuda/CUDABlas.cpp

@@ -106,6 +106,7 @@ static hipblasStatus_t rocBLASStatusToHIPStatus(rocblas_status error)
 namespace {
 
 static cublasOperation_t _cublasOpFromChar(char op) {
+  // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
   switch (op) {
     case 'n':
     case 'N':

test/cpp/api/optim.cpp

@@ -8,17 +8,16 @@
 
 #include <cmath>
 #include <cstdlib>
-#include <functional>
 #include <iostream>
 #include <memory>
-#include <random>
+#include <utility>
 #include <vector>
 
 using namespace torch::nn;
 using namespace torch::optim;
 
 template <typename OptimizerClass, typename Options>
-bool test_optimizer_xor(Options options) {
+static bool test_optimizer_xor(Options options) {
   torch::manual_seed(0);
 
   Sequential model(
@@ -30,9 +29,9 @@ bool test_optimizer_xor(Options options) {
   const int64_t kBatchSize = 200;
   const int64_t kMaximumNumberOfEpochs = 3000;
 
-  OptimizerClass optimizer(model->parameters(), options);
+  OptimizerClass optimizer(model->parameters(), std::move(options));
 
-  float running_loss = 1;
+  double running_loss = 1;
   int epoch = 0;
   while (running_loss > 0.1) {
     auto inputs = torch::empty({kBatchSize, 2});
@@ -46,8 +45,8 @@ bool test_optimizer_xor(Options options) {
 
     auto step = [&](OptimizerClass& optimizer,
                     Sequential model,
-                    torch::Tensor inputs,
-                    torch::Tensor labels) {
+                    const torch::Tensor& inputs,
+                    const torch::Tensor& labels) {
       auto closure = [&]() {
         optimizer.zero_grad();
         auto x = model->forward(inputs);
@@ -60,11 +59,10 @@ bool test_optimizer_xor(Options options) {
 
     torch::Tensor loss = step(optimizer, model, inputs, labels);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-narrowing-conversions,cppcoreguidelines-avoid-magic-numbers,bugprone-narrowing-conversions)
-    running_loss = running_loss * 0.99 + loss.item<float>() * 0.01;
+    running_loss = running_loss * 0.99 + loss.item<double>() * 0.01;
     if (epoch > kMaximumNumberOfEpochs) {
       std::cout << "Loss is too high after epoch " << epoch << ": "
-                << running_loss << std::endl;
+                << running_loss << '\n';
       return false;
     }
     epoch++;
@@ -73,18 +71,18 @@ bool test_optimizer_xor(Options options) {
 }
 
 template <typename Parameters>
-void assign_parameter(
+static void assign_parameter(
     const Parameters& parameters,
     const char* name,
-    torch::Tensor new_tensor) {
+    const torch::Tensor& new_tensor) {
   auto parameter = parameters[name];
   parameter.set_requires_grad(false);
   parameter.flatten().copy_(new_tensor);
   parameter.set_requires_grad(true);
 }
 
 template <typename OptimizerClass, typename Options>
-void check_exact_values(
+static void check_exact_values(
     Options options,
     std::vector<std::vector<torch::Tensor>> expected_parameters) {
   const size_t kIterations = 1001;
@@ -119,7 +117,7 @@ void check_exact_values(
   assign_parameter(
       parameters, "2.bias", torch::tensor({-0.0711}, torch::kFloat64));
 
-  auto optimizer = OptimizerClass(parameters.values(), options);
+  auto optimizer = OptimizerClass(parameters.values(), std::move(options));
   torch::Tensor input =
       torch::tensor({0.1, 0.2, 0.3, 0.4, 0.5, 0.6}, torch::kFloat64)
           .reshape({3, 2});
@@ -145,8 +143,7 @@ void check_exact_values(
             expected_parameters.at(i / kSampleEvery).at(p).to(torch::kFloat64);
         if (!computed.allclose(expected, /*rtol=*/1e-3, /*atol=*/5e-4)) {
           std::cout << "Iteration " << i << ": " << computed
-                    << " != " << expected << " (parameter " << p << ")"
-                    << std::endl;
+                    << " != " << expected << " (parameter " << p << ")" << '\n';
           ASSERT_TRUE(false);
         }
       }
@@ -166,8 +163,7 @@ TEST(OptimTest, OptimizerAccessors) {
   ASSERT_TRUE(options == options_);
   // test for param_groups() with non-const reference return
   auto& params_groups = optimizer.param_groups();
-  // NOLINTNEXTLINE(modernize-use-emplace)
-  params_groups.push_back(OptimizerParamGroup(params));
+  params_groups.emplace_back(params);
   auto& params_1 = params_groups[1].params();
   for (const auto i : c10::irange(params_1.size())) {
     torch::equal(params[i], params_1[i]);
@@ -204,7 +200,7 @@ TEST(OptimTest, OptimizerAccessors) {
 
 struct MyOptimizerOptions
     : public OptimizerCloneableOptions<MyOptimizerOptions> {
-  MyOptimizerOptions(double lr = 1.0) : lr_(lr){};
+  MyOptimizerOptions(double lr = 1.0) : lr_(lr) {}
   TORCH_ARG(double, lr) = 1.0;
 };
 
@@ -216,27 +212,24 @@ TEST(OptimTest, OldInterface) {
     }
     explicit MyOptimizer(
         std::vector<at::Tensor> params,
-        MyOptimizerOptions defaults = {})
-        : // NOLINTNEXTLINE(performance-move-const-arg)
-          Optimizer(
-              {std::move(OptimizerParamGroup(params))},
+        const MyOptimizerOptions& defaults = {})
+        : Optimizer(
+              std::move(params),
               std::make_unique<MyOptimizerOptions>(defaults)) {}
   };
   std::vector<torch::Tensor> parameters = {
       torch::ones({2, 3}), torch::zeros({2, 3}), torch::rand({2, 3})};
   {
     MyOptimizer optimizer(parameters);
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    size_t size;
+    size_t size = 0;
     OLD_INTERFACE_WARNING_CHECK(size = optimizer.size());
     ASSERT_EQ(size, parameters.size());
   }
   {
     std::vector<at::Tensor> params;
     MyOptimizer optimizer(params);
 
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    size_t size;
+    size_t size = 0;
     OLD_INTERFACE_WARNING_CHECK(size = optimizer.size());
     ASSERT_EQ(size, 0);
 
@@ -255,8 +248,7 @@ TEST(OptimTest, OldInterface) {
     Linear linear(3, 4);
     MyOptimizer optimizer(linear->parameters());
 
-    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
-    size_t size;
+    size_t size = 0;
     OLD_INTERFACE_WARNING_CHECK(size = optimizer.size());
     ASSERT_EQ(size, linear->parameters().size());
   }
@@ -480,7 +472,7 @@ TEST(OptimTest, AddParameter_LBFGS) {
 
 // Check whether the learning rate of the parameter groups in the optimizer are
 // the same as the expected learning rates given in the epoch:learning rate map
-void check_lr_change(
+static void check_lr_change(
     Optimizer& optimizer,
     LRScheduler& lr_scheduler,
     std::map<unsigned, double> expected_epoch_lrs) {
@@ -512,7 +504,7 @@ void check_lr_change(
 // Very similar to check_lr_change, but for ReduceLROnPlateauScheduler
 // which does not inherit from LRScheduler and requires a metrics
 // input to step().
-void check_lr_change_for_reduce_on_plateau(
+static void check_lr_change_for_reduce_on_plateau(
     Optimizer& optimizer,
     ReduceLROnPlateauScheduler& lr_scheduler,
     std::map<unsigned, double> expected_epoch_lrs) {

torch/csrc/CudaIPCTypes.cpp

@@ -36,6 +36,10 @@ struct CudaIPCGlobalEntities {
   CudaIPCGlobalEntities() {
     alive = true;
   }
+  CudaIPCGlobalEntities(const CudaIPCGlobalEntities&) = delete;
+  CudaIPCGlobalEntities(CudaIPCGlobalEntities&&) = delete;
+  CudaIPCGlobalEntities& operator=(const CudaIPCGlobalEntities&) = delete;
+  CudaIPCGlobalEntities& operator=(CudaIPCGlobalEntities&&) = delete;
   ~CudaIPCGlobalEntities() {
     CudaIPCSentDataLimbo_.collect();
     safe_clean_current_file();
@@ -202,6 +206,7 @@ CudaIPCSentData::~CudaIPCSentData() {
       }
       cuda_ipc_global_entities.sync_events_used_--;
     }
+    // NOLINTNEXTLINE(bugprone-empty-catch)
   } catch (...) { /* No throw */
   }
 #endif

torch/csrc/Generator.cpp

@@ -30,7 +30,7 @@ using namespace torch;
 
 PyObject* THPGeneratorClass = nullptr;
 
-PyObject* THPGenerator_initDefaultGenerator(const at::Generator& cdata) {
+PyObject* THPGenerator_initDefaultGenerator(at::Generator cdata) {
   auto type = (PyTypeObject*)THPGeneratorClass;
   auto self = THPObjectPtr{type->tp_alloc(type, 0)};
   if (!self)
@@ -401,8 +401,7 @@ PyObject* THPGenerator_Wrap(const Generator& gen) {
     return obj;
   }
 
-  return THPGenerator_NewWithVar(
-      (PyTypeObject*)THPGeneratorClass, std::move(gen));
+  return THPGenerator_NewWithVar((PyTypeObject*)THPGeneratorClass, gen);
 }
 
 at::Generator THPGenerator_Unwrap(PyObject* state) {

torch/csrc/Generator.h

@@ -14,7 +14,7 @@ struct THPGenerator {
 // is borrowed. The caller should ensure that the at::Generator object lifetime
 // last at least as long as the Python wrapper.
 TORCH_PYTHON_API PyObject* THPGenerator_initDefaultGenerator(
-    const at::Generator& cdata);
+    at::Generator cdata);
 
 #define THPGenerator_Check(obj) PyObject_IsInstance(obj, THPGeneratorClass)
 

torch/csrc/PyInterpreter.cpp

@@ -159,6 +159,10 @@ class PyInterpreterHolder {
         is_main_interpreter_(
             at::impl::PythonOpRegistrationTrampoline::registerInterpreter(
                 impl_)) {}
+  PyInterpreterHolder(const PyInterpreterHolder&) = delete;
+  PyInterpreterHolder(PyInterpreterHolder&&) = delete;
+  PyInterpreterHolder& operator=(const PyInterpreterHolder&) = delete;
+  PyInterpreterHolder& operator=(PyInterpreterHolder&&) = delete;
   // NB: intentionally leaks the PyInterpreter, as there may still be
   // references to it that are live, living in objects that aren't being
   // destructed while Python is being cleaned up.

torch/csrc/api/include/torch/cuda.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#include <torch/csrc/Export.h>
+#include <c10/core/Device.h>
+#include <c10/macros/Export.h>
 
-#include <cstddef>
 #include <cstdint>
 
 namespace torch::cuda {
 
 /// Returns the number of CUDA devices available.
-size_t TORCH_API device_count();
+c10::DeviceIndex TORCH_API device_count();
 
 /// Returns true if at least one CUDA device is available.
 bool TORCH_API is_available();

torch/csrc/api/include/torch/data/dataloader/base.h

@@ -37,6 +37,10 @@ class DataLoaderBase {
         main_thread_dataset_(std::move(main_thread_dataset)),
         sequencer_(new_sequencer()) {}
 
+  DataLoaderBase(const DataLoaderBase&) = delete;
+  DataLoaderBase(DataLoaderBase&&) = delete;
+  DataLoaderBase& operator=(const DataLoaderBase&) = delete;
+  DataLoaderBase& operator=(DataLoaderBase&&) = delete;
   // NOLINTNEXTLINE(bugprone-exception-escape)
   virtual ~DataLoaderBase() {
     join();

torch/csrc/api/include/torch/nn/modules/container/any_value.h

@@ -21,6 +21,7 @@ class AnyValue {
   /// behavior of move for `std::unique_ptr`.
   AnyValue(AnyValue&&) = default;
   AnyValue& operator=(AnyValue&&) = default;
+  ~AnyValue() = default;
 
   /// Copy construction and assignment is allowed.
   AnyValue(const AnyValue& other) : content_(other.content_->clone()) {}
@@ -89,6 +90,8 @@ class AnyValue {
         : type_info(type_info_) {}
     Placeholder(const Placeholder&) = default;
     Placeholder(Placeholder&&) = default;
+    Placeholder& operator=(const Placeholder&) = delete;
+    Placeholder& operator=(Placeholder&&) = delete;
     virtual ~Placeholder() = default;
     virtual std::unique_ptr<Placeholder> clone() const {
       TORCH_CHECK(false, "clone() should only be called on `AnyValue::Holder`");