[base] Remove pre-c++11 restrictions of macros

Before the existence of "= delete", we were enforcing that the
DISALLOW_* macros were used in the private: section of classes only.
This is not needed any more, hence remove the comment on the macros.

Also, introduce macros for making types move-only, and use them
instead of our special macro in wasm.

R=bmeurer@chromium.org
CC=titzer@chromium.org

Change-Id: Iceba456fb0a32ae67defe16e35b865db8c8da500
Reviewed-on: https://chromium-review.googlesource.com/577687
Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#46773}

src/base/macros.h

@@ -102,28 +102,34 @@ V8_INLINE Dest bit_cast(Source const& source) {
   return dest;
 }
 
+// Explicitly declare the assignment operator as deleted.
+#define DISALLOW_ASSIGN(TypeName) TypeName& operator=(const TypeName&) = delete;
 
-// Put this in the private: declarations for a class to be unassignable.
-#define DISALLOW_ASSIGN(TypeName) void operator=(const TypeName&)
-
-
-// A macro to disallow the evil copy constructor and operator= functions
-// This should be used in the private: declarations for a class
+// Explicitly declare the copy constructor and assignment operator as deleted.
 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
   TypeName(const TypeName&) = delete;      \
-  void operator=(const TypeName&) = delete
+  DISALLOW_ASSIGN(TypeName)
 
-
-// A macro to disallow all the implicit constructors, namely the
+// Explicitly declare all implicit constructors as deleted, namely the
 // default constructor, copy constructor and operator= functions.
-//
-// This should be used in the private: declarations for a class
-// that wants to prevent anyone from instantiating it. This is
-// especially useful for classes containing only static methods.
+// This is especially useful for classes containing only static methods.
 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
   TypeName() = delete;                           \
   DISALLOW_COPY_AND_ASSIGN(TypeName)
 
+// Disallow copying a type, but provide default construction, move construction
+// and move assignment. Especially useful for move-only structs.
+#define MOVE_ONLY_WITH_DEFAULT_CONSTRUCTORS(TypeName) \
+  TypeName() = default;                               \
+  MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(TypeName)
+
+// Disallow copying a type, and only provide move construction and move
+// assignment. Especially useful for move-only structs.
+#define MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(TypeName) \
+  TypeName(TypeName&&) = default;                  \
+  TypeName& operator=(TypeName&&) = default;       \
+  DISALLOW_COPY_AND_ASSIGN(TypeName)
+
 // A macro to disallow the dynamic allocation.
 // This should be used in the private: declarations for a class
 // Declaring operator new and delete as deleted is not spec compliant.

src/wasm/wasm-debug.cc

@@ -94,6 +94,8 @@ class InterpreterHandle;
 InterpreterHandle* GetInterpreterHandle(WasmDebugInfo* debug_info);
 
 class InterpreterHandle {
+  MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(InterpreterHandle);
+
   WasmInstance instance_;
   WasmInterpreter interpreter_;
   Isolate* isolate_;

src/wasm/wasm-module.h

@@ -34,15 +34,6 @@ class CallDescriptor;
 namespace wasm {
 class ErrorThrower;
 
-// Use this in the private section to mark a struct move-only.
-#define WASM_MOVE_ONLY_STRUCT(name) \
- public:                            \
-  name() = default;                 \
-  name(name&&) = default;           \
-                                    \
- private:                           \
-  DISALLOW_COPY_AND_ASSIGN(name)
-
 enum WasmExternalKind {
   kExternalFunction = 0,
   kExternalTable = 1,
@@ -143,6 +134,8 @@ struct WasmDataSegment {
 
 // Static representation of a wasm indirect call table.
 struct WasmIndirectFunctionTable {
+  MOVE_ONLY_WITH_DEFAULT_CONSTRUCTORS(WasmIndirectFunctionTable);
+
   uint32_t min_size = 0;  // minimum table size.
   uint32_t max_size = 0;  // maximum table size.
   bool has_max = false;   // true if there is a maximum size.
@@ -151,22 +144,18 @@ struct WasmIndirectFunctionTable {
   bool imported = false;        // true if imported.
   bool exported = false;        // true if exported.
   SignatureMap map;             // canonicalizing map for sig indexes.
-
- private:
-  WASM_MOVE_ONLY_STRUCT(WasmIndirectFunctionTable);
 };
 
 // Static representation of how to initialize a table.
 struct WasmTableInit {
+  MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(WasmTableInit);
+
   WasmTableInit(uint32_t table_index, WasmInitExpr offset)
       : table_index(table_index), offset(offset) {}
 
   uint32_t table_index;
   WasmInitExpr offset;
   std::vector<uint32_t> entries;
-
- private:
-  WASM_MOVE_ONLY_STRUCT(WasmTableInit);
 };
 
 // Static representation of a wasm import.
@@ -190,6 +179,8 @@ struct ModuleWireBytes;
 
 // Static representation of a module.
 struct V8_EXPORT_PRIVATE WasmModule {
+  MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(WasmModule);
+
   static const uint32_t kPageSize = 0x10000;    // Page size, 64kb.
   static const uint32_t kMinMemPages = 1;       // Minimum memory size = 64kb
 
@@ -228,14 +219,14 @@ struct V8_EXPORT_PRIVATE WasmModule {
  private:
   // TODO(kschimpf) - Encapsulate more fields.
   ModuleOrigin origin_ = kWasmOrigin;  // origin of the module
-
-  DISALLOW_COPY_AND_ASSIGN(WasmModule);
 };
 
 typedef Managed<WasmModule> WasmModuleWrapper;
 
 // An instantiated wasm module, including memory, function table, etc.
 struct WasmInstance {
+  MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(WasmInstance);
+
   const WasmModule* module;  // static representation of the module.
   // -- Heap allocated --------------------------------------------------------
   Handle<Context> context;               // JavaScript native context.
@@ -271,9 +262,6 @@ struct WasmInstance {
       code = handle(*code, isolate);
     }
   }
-
- private:
-  WASM_MOVE_ONLY_STRUCT(WasmInstance);
 };
 
 // Interface to the storage (wire bytes) of a wasm module.
@@ -336,6 +324,8 @@ struct V8_EXPORT_PRIVATE ModuleWireBytes {
 // Interface provided to the decoder/graph builder which contains only
 // minimal information about the globals, functions, and function tables.
 struct V8_EXPORT_PRIVATE ModuleEnv {
+  MOVE_ONLY_NO_DEFAULT_CONSTRUCTOR(ModuleEnv);
+
   ModuleEnv(const WasmModule* module, WasmInstance* instance)
       : module(module),
         instance(instance),
@@ -392,9 +382,6 @@ struct V8_EXPORT_PRIVATE ModuleEnv {
     DCHECK_NOT_NULL(instance);
     return instance->function_code[index];
   }
-
- private:
-  WASM_MOVE_ONLY_STRUCT(ModuleEnv);
 };
 
 // A ModuleEnv together with ModuleWireBytes.
@@ -573,8 +560,6 @@ void ValidateOrphanedInstance(Isolate* isolate,
                               Handle<WasmInstanceObject> instance);
 }  // namespace testing
 
-#undef WASM_MOVE_ONLY_STRUCT
-
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8