Enable cppcoreguidelines-special-member-functions (#139132)

Fixes #ISSUE_NUMBER

Pull Request resolved: https://github.com/pytorch/pytorch/pull/139132
Approved by: https://github.com/sraikund16

.clang-tidy

@@ -29,7 +29,6 @@ cppcoreguidelines-*,
 -cppcoreguidelines-pro-type-static-cast-downcast,
 -cppcoreguidelines-pro-type-union-access,
 -cppcoreguidelines-pro-type-vararg,
--cppcoreguidelines-special-member-functions,
 -cppcoreguidelines-non-private-member-variables-in-classes,
 -facebook-hte-RelativeInclude,
 hicpp-exception-baseclass,
@@ -64,5 +63,7 @@ readability-string-compare,
 HeaderFilterRegex: '^(aten/|c10/|torch/).*$'
 WarningsAsErrors: '*'
 CheckOptions:
+  cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor: true
+  cppcoreguidelines-special-member-functions.AllowImplicitlyDeletedCopyOrMove: true
   misc-header-include-cycle.IgnoredFilesList: 'format.h;ivalue.h;custom_class.h;Dict.h;List.h;IListRef.h'
 ...

aten/src/ATen/Context.h

@@ -604,6 +604,10 @@ inline void manual_seed(uint64_t seed) {
 //     NoTF32Guard disable_tf32;
 struct TORCH_API NoTF32Guard {
   NoTF32Guard();
+  NoTF32Guard(NoTF32Guard&& other) = delete;
+  NoTF32Guard(const NoTF32Guard&) = delete;
+  NoTF32Guard& operator=(const NoTF32Guard&) = delete;
+  NoTF32Guard& operator=(NoTF32Guard&&) = delete;
   ~NoTF32Guard();
   static bool should_disable_tf32();
 
@@ -613,6 +617,10 @@ struct TORCH_API NoTF32Guard {
 
 struct TORCH_API ROCmBackwardPassGuard {
   ROCmBackwardPassGuard();
+  ROCmBackwardPassGuard(ROCmBackwardPassGuard&& other) = delete;
+  ROCmBackwardPassGuard(const ROCmBackwardPassGuard&) = delete;
+  ROCmBackwardPassGuard& operator=(const ROCmBackwardPassGuard&) = delete;
+  ROCmBackwardPassGuard& operator=(ROCmBackwardPassGuard&&) = delete;
   ~ROCmBackwardPassGuard();
   static bool is_backward_pass();
 };

aten/src/ATen/DynamicLibrary.h

@@ -16,6 +16,8 @@ namespace at {
 
 struct DynamicLibrary {
   AT_DISALLOW_COPY_AND_ASSIGN(DynamicLibrary);
+  DynamicLibrary(DynamicLibrary&& other) = delete;
+  DynamicLibrary& operator=(DynamicLibrary&&) = delete;
 
   TORCH_API DynamicLibrary(
       const char* name,

aten/src/ATen/SparseCsrTensorUtils.h

@@ -155,6 +155,12 @@ class CheckSparseTensorInvariants {
       : old_state(at::globalContext().checkSparseTensorInvariants()) {
     at::globalContext().setCheckSparseTensorInvariants(state);
   }
+  CheckSparseTensorInvariants(CheckSparseTensorInvariants&& other) = delete;
+  CheckSparseTensorInvariants(const CheckSparseTensorInvariants&) = delete;
+  CheckSparseTensorInvariants& operator=(const CheckSparseTensorInvariants&) =
+      delete;
+  CheckSparseTensorInvariants& operator=(CheckSparseTensorInvariants&&) =
+      delete;
 
   ~CheckSparseTensorInvariants() {
     at::globalContext().setCheckSparseTensorInvariants(old_state);

aten/src/ATen/TensorIterator.h

@@ -995,6 +995,7 @@ class TORCH_API TensorIteratorConfig final {
 /// TensorIterator that can use 32-bit indexing. Taken together the splits cover
 /// the original TensorIterator.
 struct TORCH_API SplitUntil32Bit {
+  // NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
   struct TORCH_API iterator {
     iterator() = default;
     iterator(const TensorIteratorBase& iter);

aten/src/ATen/ThreadLocalState.h

@@ -96,6 +96,10 @@ class TORCH_API ThreadLocalStateGuard {
     // set the given state across the thread boundary
     ThreadLocalState::setThreadLocalState(state);
   }
+  ThreadLocalStateGuard(ThreadLocalStateGuard&& other) = delete;
+  ThreadLocalStateGuard(const ThreadLocalStateGuard&) = delete;
+  ThreadLocalStateGuard& operator=(const ThreadLocalStateGuard&) = delete;
+  ThreadLocalStateGuard& operator=(ThreadLocalStateGuard&&) = delete;
 
   ~ThreadLocalStateGuard() {
     // restore previously set variables

aten/src/ATen/core/Dict.h

@@ -206,6 +206,7 @@ template<class Key, class Value> Dict<IValue, IValue> toGenericDict(Dict<Key, Va
  * for the kernel API.
  */
 template<class Key, class Value>
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class Dict final {
 private:
   static_assert((std::is_same_v<IValue, Key> && std::is_same_v<IValue, Value>) || guts::typelist::contains<impl::valid_dict_key_types, Key>::value, "Invalid Key type for Dict. We only support int64_t, double, bool, and string.");

aten/src/ATen/core/PythonFallbackKernel.h

@@ -6,6 +6,10 @@ namespace at::impl {
 
 struct TORCH_API RestorePythonTLSSnapshot {
   RestorePythonTLSSnapshot();
+  RestorePythonTLSSnapshot(RestorePythonTLSSnapshot&& other) = delete;
+  RestorePythonTLSSnapshot(const RestorePythonTLSSnapshot&) = delete;
+  RestorePythonTLSSnapshot& operator=(const RestorePythonTLSSnapshot&) = delete;
+  RestorePythonTLSSnapshot& operator=(RestorePythonTLSSnapshot&&) = delete;
   ~RestorePythonTLSSnapshot();
 
 private:
@@ -18,6 +22,10 @@ private:
 struct TORCH_API MaybeSetTLSOnEntryGuard {
 public:
   MaybeSetTLSOnEntryGuard();
+  MaybeSetTLSOnEntryGuard(MaybeSetTLSOnEntryGuard&& other) = delete;
+  MaybeSetTLSOnEntryGuard(const MaybeSetTLSOnEntryGuard&) = delete;
+  MaybeSetTLSOnEntryGuard& operator=(const MaybeSetTLSOnEntryGuard&) = delete;
+  MaybeSetTLSOnEntryGuard& operator=(MaybeSetTLSOnEntryGuard&&) = delete;
   ~MaybeSetTLSOnEntryGuard();
 
 private:

aten/src/ATen/core/QuantizerBase.h

@@ -40,7 +40,7 @@ struct TORCH_API Quantizer : public c10::intrusive_ptr_target {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
   const ScalarType scalar_type_;
   explicit Quantizer(ScalarType scalar_type) : scalar_type_(scalar_type) {}
-  ~Quantizer() override;
+  ~Quantizer() override = default;
 
   // Copied from torch/csrc/jit/ir/scope.h
   QuantizerPtr intrusive_from_this() {

aten/src/ATen/core/Tensor.h

@@ -4,6 +4,7 @@
 #include <c10/util/Exception.h>
 
 namespace at {
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class TORCH_API OptionalTensorRef {
  public:
   OptionalTensorRef() = default;
@@ -20,6 +21,7 @@ class TORCH_API OptionalTensorRef {
   OptionalTensorRef(const OptionalTensorRef& rhs)
       : ref_(Tensor::unsafe_borrow_t{}, rhs.ref_) {}
 
+  OptionalTensorRef(OptionalTensorRef&& rhs) = default;
   OptionalTensorRef& operator=(OptionalTensorRef rhs) {
     std::swap(ref_, rhs.ref_);
     return *this;
@@ -59,6 +61,10 @@ class TORCH_API TensorRef {
 
   TensorRef(const TensorBase& src)
       : ref_(Tensor::unsafe_borrow_t{}, src) {}
+  TensorRef(TensorRef&& other) = default;
+  TensorRef(const TensorRef&) = default;
+  TensorRef& operator=(const TensorRef&) = default;
+  TensorRef& operator=(TensorRef&&) = default;
 
   const Tensor& operator*() const & {
     return ref_;

aten/src/ATen/core/Vitals.h

@@ -39,6 +39,8 @@ struct TORCH_API TorchVital {
   explicit TorchVital(std::string n) : name(std::move(n)) {}
   TorchVital(const TorchVital&) = default;
   TorchVital(TorchVital&&) = default;
+  TorchVital& operator=(const TorchVital&) = default;
+  TorchVital& operator=(TorchVital&&) = default;
   TorchVital() = delete;
 
   TorchVitalAttr& create(const std::string& attr);
@@ -71,6 +73,7 @@ class TORCH_API APIVitals {
   APIVitals(APIVitals&& other) = delete;
   APIVitals& operator=(const APIVitals&) = delete;
   APIVitals& operator=(APIVitals&&) = delete;
+  ~APIVitals() = default;
 
  private:
   std::unordered_map<std::string, TorchVital> name_map_;

aten/src/ATen/core/dynamic_type.h

@@ -159,6 +159,11 @@ class DynamicType : public SharedType {
   explicit DynamicType(Tag, Arguments);
   explicit DynamicType(Tag, std::string_view, Arguments);
 
+  DynamicType(DynamicType&& other) = delete;
+  DynamicType(const DynamicType&) = delete;
+  DynamicType& operator=(const DynamicType&) = delete;
+  DynamicType& operator=(DynamicType&&) = delete;
+
   TypePtr containedType(size_t) const override;
   size_t containedTypeSize() const override;
   Tag tag() const {

aten/src/ATen/core/jit_type.h

@@ -2204,7 +2204,7 @@ struct TORCH_API InterfaceType : public NamedType {
     return is_module_;
   }
   static const TypeKind Kind = TypeKind::InterfaceType;
-  ~InterfaceType() override;
+  ~InterfaceType() override = default;
  private:
   InterfaceType(QualifiedName name, bool is_module);
   static bool isSubTypeImpl(

aten/src/ATen/core/jit_type_base.h

@@ -227,6 +227,7 @@ struct TORCH_API Type {
     SingletonOrSharedTypePtr(SingletonOrSharedTypePtr&&) noexcept = default;
     SingletonOrSharedTypePtr& operator=(const SingletonOrSharedTypePtr&) = default;
     SingletonOrSharedTypePtr& operator=(SingletonOrSharedTypePtr&&) noexcept = default;
+    ~SingletonOrSharedTypePtr() = default;
 
     T* get() const {
       return repr_.isSharedAndNonNull() ? repr_.shared_.repr_.get() : static_cast<T*>(repr_.rawRepr().first);

aten/src/ATen/core/rref_interface.h

@@ -17,6 +17,7 @@ class C10_EXPORT RRefInterface : public c10::intrusive_ptr_target {
   // counting.
   RRefInterface(const RRefInterface& other) = delete;
   RRefInterface(RRefInterface&& other) = delete;
+  RRefInterface& operator=(const RRefInterface& other) = delete;
   RRefInterface& operator=(RRefInterface&& other) = delete;
 
   ~RRefInterface() override = default;

aten/src/ATen/core/type.cpp

@@ -1037,8 +1037,6 @@ InterfaceType::InterfaceType(QualifiedName name, bool is_module)
       methods_(std::make_shared<std::vector<FunctionSchema>>()),
       is_module_(is_module) {}
 
-InterfaceType::~InterfaceType() = default;
-
 bool containsAnyType(const TypePtr& type) {
   std::vector<TypePtr> to_scan = { type };
   while (!to_scan.empty()) {

aten/src/ATen/functorch/DynamicLayer.cpp

@@ -202,6 +202,8 @@ struct SaveLocalDispatchKeySet {
   }
   SaveLocalDispatchKeySet(const SaveLocalDispatchKeySet&) = delete;
   SaveLocalDispatchKeySet& operator=(const SaveLocalDispatchKeySet&) = delete;
+  SaveLocalDispatchKeySet(SaveLocalDispatchKeySet&&) = delete;
+  SaveLocalDispatchKeySet& operator=(SaveLocalDispatchKeySet&&) = delete;
 };
 
 const std::vector<DynamicLayer>& getDynamicLayerStack() {
@@ -406,6 +408,10 @@ static void dump_local_tls() {
 
 struct WithoutTop {
   WithoutTop();
+  WithoutTop(WithoutTop&& other) = delete;
+  WithoutTop(const WithoutTop&) = delete;
+  WithoutTop& operator=(const WithoutTop&) = delete;
+  WithoutTop& operator=(WithoutTop&&) = delete;
   ~WithoutTop();
   DynamicLayer layer_;
 };

aten/src/ATen/quantized/Quantizer.cpp

@@ -313,8 +313,6 @@ Tensor& PerChannelAffineFloatQParamsQuantizer::dequantize_out(
   return rtensor;
 }
 
-Quantizer::~Quantizer() = default;
-
 C10_EXPORT void set_quantizer_(const Tensor& self, ConstQuantizerPtr quantizer) {
   get_qtensorimpl(self)->set_quantizer_(quantizer);
 }

aten/src/ATen/record_function.h

@@ -353,6 +353,8 @@ struct TORCH_API RecordFunction {
 
   RecordFunction(const RecordFunction&) = delete;
   RecordFunction& operator=(const RecordFunction&) = delete;
+  RecordFunction(RecordFunction&&) = delete;
+  RecordFunction& operator=(RecordFunction&&) = delete;
 
   const char* name() const;
 
@@ -764,6 +766,10 @@ class TORCH_API RecordFunctionGuard {
     enableRecordFunction(is_enabled);
   }
 
+  RecordFunctionGuard(RecordFunctionGuard&& other) = delete;
+  RecordFunctionGuard(const RecordFunctionGuard&) = delete;
+  RecordFunctionGuard& operator=(const RecordFunctionGuard&) = delete;
+  RecordFunctionGuard& operator=(RecordFunctionGuard&&) = delete;
   virtual ~RecordFunctionGuard() {
     enableRecordFunction(prev_value_);
   }

c10/core/impl/PythonDispatcherTLS.h

@@ -16,6 +16,10 @@ struct C10_API DisablePythonDispatcher {
     PythonDispatcherTLS::set_state({});
   }
 
+  DisablePythonDispatcher(DisablePythonDispatcher&& other) = delete;
+  DisablePythonDispatcher(const DisablePythonDispatcher&) = delete;
+  DisablePythonDispatcher& operator=(const DisablePythonDispatcher&) = delete;
+  DisablePythonDispatcher& operator=(DisablePythonDispatcher&&) = delete;
   ~DisablePythonDispatcher() {
     PythonDispatcherTLS::set_state(old_);
   }

c10/test/util/Metaprogramming_test.cpp

@@ -5,7 +5,7 @@
 
 using namespace c10::guts;
 
-// NOLINTBEGIN(modernize*)
+// NOLINTBEGIN(modernize*, cppcoreguidelines-special-member-functions)
 namespace {
 
 namespace test_function_traits {
@@ -302,4 +302,4 @@ TEST(MetaprogrammingTest, TupleMap_canBeUsedWithAutoLambdas) {
 } // namespace test_tuple_map
 
 } // namespace
-// NOLINTEND(modernize*)
+// NOLINTEND(modernize*, cppcoreguidelines-special-member-functions)

c10/test/util/ThreadLocal_test.cpp

@@ -148,6 +148,7 @@ TEST(ThreadLocalTest, TestThreadWithGlobalScopeVar) {
 TEST(ThreadLocalTest, TestObjectsAreReleased) {
   static std::atomic<int> ctors{0};
   static std::atomic<int> dtors{0};
+  // NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
   struct A {
     A() {
       ++ctors;
@@ -183,6 +184,7 @@ TEST(ThreadLocalTest, TestObjectsAreReleased) {
 TEST(ThreadLocalTest, TestObjectsAreReleasedByNonstaticThreadLocal) {
   static std::atomic<int> ctors(0);
   static std::atomic<int> dtors(0);
+  // NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
   struct A {
     A() {
       ++ctors;

c10/test/util/intrusive_ptr_test.cpp

@@ -45,6 +45,7 @@ struct SomeChildClass : SomeBaseClass {
   SomeChildClass(int v) : SomeBaseClass(v) {}
 };
 
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class DestructableMock : public intrusive_ptr_target {
  public:
   DestructableMock(bool* resourcesReleased, bool* wasDestructed)

c10/test/util/logging_test.cpp

@@ -81,6 +81,7 @@ TEST(
 }
 
 namespace {
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 struct Noncopyable {
   int x;
 

c10/test/util/typeid_test.cpp

@@ -70,6 +70,7 @@ TEST(TypeMetaTest, TypeMeta) {
   EXPECT_NE(bar_meta.name().find("TypeMetaTestBar"), c10::string_view::npos);
 }
 
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class ClassAllowAssignment {
  public:
   ClassAllowAssignment() = default;
@@ -78,6 +79,7 @@ class ClassAllowAssignment {
   int x{42};
 };
 
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class ClassNoAssignment {
  public:
   ClassNoAssignment() = default;

c10/util/DynamicCounter.cpp

@@ -52,6 +52,11 @@ struct DynamicCounter::Guard {
     }
   }
 
+  Guard(Guard&& other) = delete;
+  Guard(const Guard&) = delete;
+  Guard& operator=(const Guard&) = delete;
+  Guard& operator=(Guard&&) = delete;
+
   ~Guard() {
     for (const auto& backend : backends_) {
       backend->unregisterCounter(key_);

c10/util/Exception.h

@@ -205,6 +205,10 @@ class C10_API WarningHandlerGuard {
       : prev_handler_(c10::WarningUtils::get_warning_handler()) {
     c10::WarningUtils::set_warning_handler(new_handler);
   }
+  WarningHandlerGuard(WarningHandlerGuard&& other) = delete;
+  WarningHandlerGuard(const WarningHandlerGuard&) = delete;
+  WarningHandlerGuard& operator=(const WarningHandlerGuard&) = delete;
+  WarningHandlerGuard& operator=(WarningHandlerGuard&&) = delete;
   ~WarningHandlerGuard() {
     c10::WarningUtils::set_warning_handler(prev_handler_);
   }

c10/util/LeftRight.h

@@ -18,6 +18,8 @@ struct IncrementRAII final {
   ~IncrementRAII() {
     _counter->fetch_sub(1);
   }
+  IncrementRAII(IncrementRAII&&) = delete;
+  IncrementRAII& operator=(IncrementRAII&&) = delete;
 
  private:
   std::atomic<int32_t>* _counter;
@@ -201,6 +203,7 @@ class RWSafeLeftRightWrapper final {
   RWSafeLeftRightWrapper(RWSafeLeftRightWrapper&&) noexcept = delete;
   RWSafeLeftRightWrapper& operator=(const RWSafeLeftRightWrapper&) = delete;
   RWSafeLeftRightWrapper& operator=(RWSafeLeftRightWrapper&&) noexcept = delete;
+  ~RWSafeLeftRightWrapper() = default;
 
   template <typename F>
   // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward)

c10/util/order_preserving_flat_hash_map.h

@@ -139,6 +139,7 @@ struct KeyOrValueEquality : functor_storage<bool, key_equal> {
 };
 static constexpr int8_t min_lookups = 4;
 template <typename T>
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 struct sherwood_v3_entry {
   // NOLINTNEXTLINE(modernize-use-equals-default)
   sherwood_v3_entry() {}

torch/csrc/distributed/rpc/types.h

@@ -13,6 +13,10 @@ TORCH_API void disableJitRRefPickle();
 
 struct TORCH_API JitRRefPickleGuard {
   JitRRefPickleGuard();
+  JitRRefPickleGuard(JitRRefPickleGuard&& other) = delete;
+  JitRRefPickleGuard(const JitRRefPickleGuard&) = delete;
+  JitRRefPickleGuard& operator=(const JitRRefPickleGuard&) = delete;
+  JitRRefPickleGuard& operator=(JitRRefPickleGuard&&) = delete;
   ~JitRRefPickleGuard();
 };
 

torch/csrc/dynamo/python_compiled_autograd.cpp

@@ -543,6 +543,10 @@ static PyObject* call_end_capture(PyObject* self, const variable_list& inputs) {
 
 struct ClosingTHPObjectPtr : public THPObjectPtr {
   ClosingTHPObjectPtr(PyObject* o) : THPObjectPtr(o) {}
+  ClosingTHPObjectPtr(ClosingTHPObjectPtr&& other) = default;
+  ClosingTHPObjectPtr(const ClosingTHPObjectPtr&) = delete;
+  ClosingTHPObjectPtr& operator=(const ClosingTHPObjectPtr&) = delete;
+  ClosingTHPObjectPtr& operator=(ClosingTHPObjectPtr&&) = default;
   ~ClosingTHPObjectPtr() {
     if (PyErr_Occurred()) {
       // do nothing, do not attempt to close

torch/csrc/inductor/aoti_runner/model_container_runner_cuda.h

@@ -8,6 +8,7 @@ namespace torch::inductor {
 
 // NOTICE: Following APIs are subject to change due to active development
 // We provide NO BC guarantee for these APIs
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class TORCH_API AOTIModelContainerRunnerCuda : public AOTIModelContainerRunner {
  public:
   // @param device_str: cuda device string, e.g. "cuda", "cuda:0"

torch/csrc/lazy/core/ir.cpp

@@ -98,8 +98,6 @@ Node::Node(OpKind op, Shape shape, size_t num_outputs) : Node(op, num_outputs) {
   shapes_.push_back(std::move(shape));
 }
 
-Node::~Node() = default;
-
 // Retrieves the full shape of the IR Node.
 c10::ArrayRef<Shape> Node::shapes() const {
   return shapes_;

torch/csrc/lazy/core/ir.h

@@ -101,7 +101,7 @@ class TORCH_API Node {
   // Construct node with shape and no operands
   Node(OpKind op, Shape shape, size_t num_outputs = 1);
 
-  virtual ~Node();
+  virtual ~Node() = default;
 
   const OpKind& op() const {
     return op_;

torch/csrc/lazy/core/ir_metadata.h

@@ -38,6 +38,10 @@ struct TORCH_API MetaData {
 struct TORCH_API ScopePusher {
   explicit ScopePusher(const std::string& name);
   ~ScopePusher();
+  ScopePusher(ScopePusher&& other) = delete;
+  ScopePusher(const ScopePusher&) = delete;
+  ScopePusher& operator=(const ScopePusher&) = delete;
+  ScopePusher& operator=(ScopePusher&&) = delete;
 
   static void ResetScopes();
 };

torch/csrc/lazy/core/metrics.h

@@ -258,6 +258,10 @@ class TORCH_API TimedSection {
  public:
   explicit TimedSection(Metric* metric) : metric_(metric), start_(NowNs()) {}
 
+  TimedSection(TimedSection&& other) = delete;
+  TimedSection(const TimedSection&) = delete;
+  TimedSection& operator=(const TimedSection&) = delete;
+  TimedSection& operator=(TimedSection&&) = delete;
   ~TimedSection() {
     int64_t now = NowNs();
     metric_->AddSample(now, static_cast<double>(now - start_));

torch/csrc/lazy/core/tensor.h

@@ -42,12 +42,18 @@ class TORCH_API LazyTensor : public c10::intrusive_ptr_target {
     Data(BackendDevice device)
         : device(std::move(device)), unique_id(GetNextTensorId()) {}
 
+    Data(Data&& other) = delete;
+    Data(const Data&) = delete;
+    Data& operator=(const Data&) = delete;
+    Data& operator=(Data&&) = delete;
     virtual ~Data();
 
     BackendDataPtr handle;
     Value ir_value;
     std::optional<at::Tensor> tensor_data;
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
     const BackendDevice device;
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
     const int64_t unique_id = 0;
     size_t generation = 1;
   };
@@ -68,6 +74,8 @@ class TORCH_API LazyTensor : public c10::intrusive_ptr_target {
   LazyTensor() = delete;
   LazyTensor(const LazyTensor&) = default;
   LazyTensor(LazyTensor&&) noexcept = default;
+  LazyTensor& operator=(const LazyTensor&) = default;
+  LazyTensor& operator=(LazyTensor&&) noexcept = default;
 
   ~LazyTensor() override = default;
 

torch/csrc/lazy/core/thread_pool.cpp

@@ -26,6 +26,10 @@ class ThreadPool {
       });
     }
   }
+  ThreadPool(const ThreadPool&) = delete;
+  ThreadPool(ThreadPool&&) = delete;
+  ThreadPool& operator=(const ThreadPool&) = delete;
+  ThreadPool& operator=(ThreadPool&&) = delete;
 
   ~ThreadPool() {
     {

torch/csrc/lazy/core/thread_pool.h

@@ -13,6 +13,7 @@
 
 namespace torch::lazy {
 
+// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions)
 class TORCH_API Completion {
  public:
   class Data;

torch/csrc/monitor/counters.h

@@ -122,6 +122,10 @@ class Stat {
         maxSamples_(maxSamples) {
     detail::registerStat(this);
   }
+  Stat(const Stat&) = delete;
+  Stat(Stat&&) = delete;
+  Stat& operator=(const Stat&) = delete;
+  Stat& operator=(Stat&&) = delete;
 
   virtual ~Stat() {
     {

torch/csrc/profiler/collection.cpp

@@ -402,6 +402,10 @@ struct StealOrDefault {
   explicit StealOrDefault(T& container)
       : container_{container}, it_{container.begin()} {}
 
+  StealOrDefault(const StealOrDefault&) = delete;
+  StealOrDefault(StealOrDefault&&) = delete;
+  StealOrDefault& operator=(const StealOrDefault&) = delete;
+  StealOrDefault& operator=(StealOrDefault&&) = delete;
   ~StealOrDefault() {
     container_.get().clear();
   }

torch/csrc/profiler/orchestration/observer.h

@@ -128,6 +128,10 @@ struct TORCH_API ProfilerConfig {
 // ----------------------------------------------------------------------------
 struct TORCH_API ProfilerStateBase : public c10::MemoryReportingInfoBase {
   explicit ProfilerStateBase(ProfilerConfig config);
+  ProfilerStateBase(const ProfilerStateBase&) = delete;
+  ProfilerStateBase(ProfilerStateBase&&) = delete;
+  ProfilerStateBase& operator=(const ProfilerStateBase&) = delete;
+  ProfilerStateBase& operator=(ProfilerStateBase&&) = delete;
   ~ProfilerStateBase() override;
 
   static ProfilerStateBase* get(bool global);