Bug 1613985 - Use default for equivalent-to-default constructors/destructors in mfbt. r=froydnj

Differential Revision: https://phabricator.services.mozilla.com/D62542

Author: sigiesec

mfbt/Array.h

@@ -28,7 +28,7 @@ class Array {
   using ElementType = T;
   static constexpr size_t Length = _Length;
 
-  Array() {}
+  Array() = default;
 
   template <typename... Args>
   MOZ_IMPLICIT constexpr Array(Args&&... aArgs)

mfbt/Atomics.h

@@ -160,7 +160,7 @@ struct AutoRecordAtomicAccess;
 template <>
 struct AutoRecordAtomicAccess<recordreplay::Behavior::DontPreserve> {
   explicit AutoRecordAtomicAccess(const void* aValue) {}
-  ~AutoRecordAtomicAccess() {}
+  ~AutoRecordAtomicAccess() = default;
 };
 
 template <>

mfbt/DebugOnly.h

@@ -41,7 +41,7 @@ class MOZ_STACK_CLASS DebugOnly {
 #ifdef DEBUG
   T value;
 
-  DebugOnly() {}
+  DebugOnly() = default;
   MOZ_IMPLICIT DebugOnly(const T& aOther) : value(aOther) {}
   DebugOnly(const DebugOnly& aOther) : value(aOther.value) {}
   DebugOnly& operator=(const T& aRhs) {
@@ -65,7 +65,7 @@ class MOZ_STACK_CLASS DebugOnly {
   const T& operator->() const { return value; }
 
 #else
-  DebugOnly() {}
+  DebugOnly() = default;
   MOZ_IMPLICIT DebugOnly(const T&) {}
   DebugOnly(const DebugOnly&) {}
   DebugOnly& operator=(const T&) { return *this; }
@@ -79,7 +79,7 @@ class MOZ_STACK_CLASS DebugOnly {
 #endif
 
   /*
-   * DebugOnly must always have a destructor or else it will
+   * DebugOnly must always have a user-defined destructor or else it will
    * generate "unused variable" warnings, exactly what it's intended
    * to avoid!
    */

mfbt/EnumeratedArray.h

@@ -50,7 +50,7 @@ class EnumeratedArray {
   ArrayType mArray;
 
  public:
-  EnumeratedArray() {}
+  EnumeratedArray() = default;
 
   template <typename... Args>
   MOZ_IMPLICIT constexpr EnumeratedArray(Args&&... aArgs)

mfbt/HashTable.h

@@ -178,11 +178,8 @@ class HashMap {
   explicit HashMap(uint32_t aLen) : mImpl(AllocPolicy(), aLen) {}
 
   // HashMap is movable.
-  HashMap(HashMap&& aRhs) : mImpl(std::move(aRhs.mImpl)) {}
-  void operator=(HashMap&& aRhs) {
-    MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited");
-    mImpl = std::move(aRhs.mImpl);
-  }
+  HashMap(HashMap&& aRhs) = default;
+  HashMap& operator=(HashMap&& aRhs) = default;
 
   // -- Status and sizing ----------------------------------------------------
 
@@ -463,11 +460,8 @@ class HashSet {
   explicit HashSet(uint32_t aLen) : mImpl(AllocPolicy(), aLen) {}
 
   // HashSet is movable.
-  HashSet(HashSet&& aRhs) : mImpl(std::move(aRhs.mImpl)) {}
-  void operator=(HashSet&& aRhs) {
-    MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited");
-    mImpl = std::move(aRhs.mImpl);
-  }
+  HashSet(HashSet&& aRhs) = default;
+  HashSet& operator=(HashSet&& aRhs) = default;
 
   // -- Status and sizing ----------------------------------------------------
 
@@ -911,13 +905,8 @@ class HashMapEntry {
       : key_(std::forward<KeyInput>(aKey)),
         value_(std::forward<ValueInput>(aValue)) {}
 
-  HashMapEntry(HashMapEntry&& aRhs)
-      : key_(std::move(aRhs.key_)), value_(std::move(aRhs.value_)) {}
-
-  void operator=(HashMapEntry&& aRhs) {
-    key_ = std::move(aRhs.key_);
-    value_ = std::move(aRhs.value_);
-  }
+  HashMapEntry(HashMapEntry&& aRhs) = default;
+  HashMapEntry& operator=(HashMapEntry&& aRhs) = default;
 
   using KeyType = Key;
   using ValueType = Value;
@@ -1514,13 +1503,14 @@ class HashTable : private AllocPolicy {
 
   // HashTable is movable
   HashTable(HashTable&& aRhs) : AllocPolicy(std::move(aRhs)) { moveFrom(aRhs); }
-  void operator=(HashTable&& aRhs) {
+  HashTable& operator=(HashTable&& aRhs) {
     MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited");
     if (mTable) {
       destroyTable(*this, mTable, capacity());
     }
     AllocPolicy::operator=(std::move(aRhs));
     moveFrom(aRhs);
+    return *this;
   }
 
  private:

mfbt/JSONWriter.h

@@ -110,7 +110,7 @@ namespace mozilla {
 class JSONWriteFunc {
  public:
   virtual void Write(const char* aStr) = 0;
-  virtual ~JSONWriteFunc() {}
+  virtual ~JSONWriteFunc() = default;
 };
 
 // Ideally this would be within |EscapedString| but when compiling with GCC

mfbt/LinkedList.h

@@ -620,10 +620,7 @@ class AutoCleanLinkedList : public LinkedList<T> {
  public:
   ~AutoCleanLinkedList() { clear(); }
 
-  AutoCleanLinkedList& operator=(AutoCleanLinkedList&& aOther) {
-    LinkedList<T>::operator=(std::forward<LinkedList<T>>(aOther));
-    return *this;
-  }
+  AutoCleanLinkedList& operator=(AutoCleanLinkedList&& aOther) = default;
 
   void clear() {
     while (ClientType element = this->popFirst()) {

mfbt/Opaque.h

@@ -26,7 +26,7 @@ class Opaque final {
   T mValue;
 
  public:
-  Opaque() {}
+  Opaque() = default;
   explicit Opaque(T aValue) : mValue(aValue) {}
 
   bool operator==(const Opaque& aOther) const {

mfbt/Pair.h

@@ -142,20 +142,10 @@ struct Pair : private detail::PairHelper<A, B> {
   Pair(AArg&& aA, BArg&& aB)
       : Base(std::forward<AArg>(aA), std::forward<BArg>(aB)) {}
 
-  Pair(Pair&& aOther)
-      : Base(std::move(aOther.first()), std::move(aOther.second())) {}
-
+  Pair(Pair&& aOther) = default;
   Pair(const Pair& aOther) = default;
 
-  Pair& operator=(Pair&& aOther) {
-    MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
-
-    first() = std::move(aOther.first());
-    second() = std::move(aOther.second());
-
-    return *this;
-  }
-
+  Pair& operator=(Pair&& aOther) = default;
   Pair& operator=(const Pair& aOther) = default;
 
   /** The A instance. */

mfbt/RecordReplay.cpp

@@ -138,7 +138,7 @@ void Initialize(int aArgc, char* aArgv[]) {
 // Record/replay API functions can't GC, but we can't use
 // JS::AutoSuppressGCAnalysis here due to linking issues.
 struct AutoSuppressGCAnalysis {
-  AutoSuppressGCAnalysis() {}
+  AutoSuppressGCAnalysis() = default;
   ~AutoSuppressGCAnalysis() {
 #ifdef DEBUG
     // Need nontrivial destructor.

mfbt/RollingMean.h

@@ -44,15 +44,7 @@ class RollingMean {
     MOZ_ASSERT(aMaxValues > 0);
   }
 
-  RollingMean& operator=(RollingMean&& aOther) {
-    MOZ_ASSERT(this != &aOther, "self-assignment is forbidden");
-    this->~RollingMean();
-    new (this) RollingMean(aOther.mMaxValues);
-    mInsertIndex = aOther.mInsertIndex;
-    mTotal = aOther.mTotal;
-    mValues.swap(aOther.mValues);
-    return *this;
-  }
+  RollingMean& operator=(RollingMean&& aOther) = default;
 
   /**
    * Insert a value into the rolling mean.

mfbt/Scoped.h

@@ -174,10 +174,8 @@ class MOZ_NON_TEMPORARY_CLASS Scoped {
       Super::operator=(aRhs);                                                 \
       return *this;                                                           \
     }                                                                         \
-    name& operator=(name&& aRhs) {                                            \
-      Super::operator=(std::move(aRhs));                                      \
-      return *this;                                                           \
-    }                                                                         \
+    name& operator=(name&& aRhs) = default;                                   \
+                                                                              \
     explicit name(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM)                       \
         : Super(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT) {}            \
     explicit name(Resource aRhs MOZ_GUARD_OBJECT_NOTIFIER_PARAM)              \
@@ -186,8 +184,8 @@ class MOZ_NON_TEMPORARY_CLASS Scoped {
         : Super(std::move(aRhs) MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) {} \
                                                                               \
    private:                                                                   \
-    explicit name(name&) = delete;                                            \
-    name& operator=(name&) = delete;                                          \
+    explicit name(const name&) = delete;                                      \
+    name& operator=(const name&) = delete;                                    \
   };
 
 /*

mfbt/Span.h

@@ -260,7 +260,7 @@ class extent_type {
 
   static_assert(Ext >= 0, "A fixed-size Span must be >= 0 in size.");
 
-  constexpr extent_type() {}
+  constexpr extent_type() = default;
 
   template <index_type Other>
   constexpr MOZ_IMPLICIT extent_type(extent_type<Other> ext) {

mfbt/ThreadSafeWeakPtr.h

@@ -258,21 +258,13 @@ class ThreadSafeWeakPtr {
   typedef typename T::ThreadSafeWeakReference ThreadSafeWeakReference;
 
  public:
-  ThreadSafeWeakPtr() {}
+  ThreadSafeWeakPtr() = default;
 
-  ThreadSafeWeakPtr& operator=(const ThreadSafeWeakPtr& aOther) {
-    mRef = aOther.mRef;
-    return *this;
-  }
-
-  ThreadSafeWeakPtr(const ThreadSafeWeakPtr& aOther) : mRef(aOther.mRef) {}
-
-  ThreadSafeWeakPtr& operator=(ThreadSafeWeakPtr&& aOther) {
-    mRef = aOther.mRef.forget();
-    return *this;
-  }
+  ThreadSafeWeakPtr& operator=(const ThreadSafeWeakPtr& aOther) = default;
+  ThreadSafeWeakPtr(const ThreadSafeWeakPtr& aOther) = default;
 
-  ThreadSafeWeakPtr(ThreadSafeWeakPtr&& aOther) : mRef(aOther.mRef.forget()) {}
+  ThreadSafeWeakPtr& operator=(ThreadSafeWeakPtr&& aOther) = default;
+  ThreadSafeWeakPtr(ThreadSafeWeakPtr&& aOther) = default;
 
   ThreadSafeWeakPtr& operator=(const RefPtr<T>& aOther) {
     if (aOther) {

mfbt/UniquePtr.h

@@ -474,7 +474,7 @@ class UniquePtr<T[], D> {
 template <typename T>
 class DefaultDelete {
  public:
-  constexpr DefaultDelete() {}
+  constexpr DefaultDelete() = default;
 
   template <typename U>
   MOZ_IMPLICIT DefaultDelete(
@@ -492,7 +492,7 @@ class DefaultDelete {
 template <typename T>
 class DefaultDelete<T[]> {
  public:
-  constexpr DefaultDelete() {}
+  constexpr DefaultDelete() = default;
 
   void operator()(T* aPtr) const {
     static_assert(sizeof(T) > 0, "T must be complete");

mfbt/tests/TestRollingMean.cpp

@@ -32,7 +32,7 @@ class MyClass {
 
 class RollingMeanSuite {
  public:
-  RollingMeanSuite() {}
+  RollingMeanSuite() = default;
 
   void runTests() {
     testZero();

mfbt/tests/TestSPSCQueue.cpp

@@ -23,7 +23,7 @@ using namespace mozilla;
 template <typename T>
 class SequenceGenerator {
  public:
-  SequenceGenerator() {}
+  SequenceGenerator() = default;
   void Get(T* aElements, size_t aCount) {
     for (size_t i = 0; i < aCount; i++) {
       aElements[i] = static_cast<T>(mIndex);
@@ -40,7 +40,7 @@ class SequenceGenerator {
 template <typename T>
 class SequenceVerifier {
  public:
-  SequenceVerifier() {}
+  SequenceVerifier() = default;
   void Check(T* aElements, size_t aCount) {
     for (size_t i = 0; i < aCount; i++) {
       if (aElements[i] != static_cast<T>(mIndex)) {

mfbt/tests/TestTypeTraits.cpp

@@ -168,7 +168,7 @@ struct NE1 {
 };
 struct NE2 : virtual E1 {};
 struct NE3 : E2 {
-  virtual ~NE3() {}
+  virtual ~NE3() = default;
 };
 struct NE4 {
   virtual void f() {}
@@ -258,13 +258,13 @@ struct TrivialCtor1 {
 };
 
 struct DefaultCtor0 {
-  DefaultCtor0() {}
+  DefaultCtor0() = default;
 };
 struct DefaultCtor1 {
   DefaultCtor1() = default;
 };
 struct DefaultCtor2 {
-  DefaultCtor2() {}
+  DefaultCtor2() = default;
   explicit DefaultCtor2(int) {}
 };
 
@@ -276,7 +276,7 @@ struct NoDefaultCtor1 {
 };
 
 class PrivateCtor0 {
-  PrivateCtor0() {}
+  PrivateCtor0() = default;
 };
 class PrivateCtor1 {
   PrivateCtor1() = default;

mfbt/tests/TestUniquePtr.cpp

@@ -77,7 +77,7 @@ static void TestDeleterType() {
   typedef int* Ptr;
   struct Deleter {
     typedef Ptr pointer;
-    Deleter() {}
+    Deleter() = default;
     void operator()(int* p) { delete p; }
   };
   UniquePtr<Ptr, Deleter> u(new int, Deleter());
@@ -216,7 +216,7 @@ static size_t FreeClassCounter = 0;
 
 struct FreeClass {
  public:
-  FreeClass() {}
+  FreeClass() = default;
 
   void operator()(int* aPtr) {
     FreeClassCounter++;
@@ -366,7 +366,7 @@ static bool TestFunctionReferenceDeleter() {
 
 template <typename T>
 struct AppendNullptrTwice {
-  AppendNullptrTwice() {}
+  AppendNullptrTwice() = default;
 
   bool operator()(Vector<T>& vec) {
     CHECK(vec.append(nullptr));
@@ -481,8 +481,8 @@ static bool TestArray() {
 }
 
 struct Q {
-  Q() {}
-  Q(const Q&) {}
+  Q() = default;
+  Q(const Q&) = default;
 
   Q(Q&, char) {}
 

mfbt/tests/gtest/TestMozDbg.cpp

@@ -24,14 +24,11 @@ using namespace mozilla;
 struct Number {
   explicit Number(int aValue) : mValue(aValue) {}
 
-  Number(const Number& aOther) : mValue(aOther.mValue) {}
+  Number(const Number& aOther) = default;
 
   Number(Number&& aOther) : mValue(aOther.mValue) { aOther.mValue = 0; }
 
-  Number& operator=(const Number& aOther) {
-    mValue = aOther.mValue;
-    return *this;
-  }
+  Number& operator=(const Number& aOther) = default;
 
   Number& operator=(Number&& aOther) {
     mValue = aOther.mValue;
@@ -53,10 +50,7 @@ struct MoveOnly {
 
   MoveOnly(MoveOnly&& aOther) : mValue(aOther.mValue) { aOther.mValue = 0; }
 
-  MoveOnly& operator=(MoveOnly& aOther) {
-    mValue = aOther.mValue;
-    return *this;
-  }
+  MoveOnly& operator=(MoveOnly& aOther) = default;
 
   MoveOnly& operator=(MoveOnly&& aOther) {
     mValue = aOther.mValue;