Applying clang-tidy modernize-use-equals-default over LLDB

[shafik]

Summary

Applied modernize-use-equals-default clang-tidy check over LLDB.

This check is already present in the lldb/.clang-tidy config.

[shafik]

We sure do have a lot of CommandOptions classes out there.

lldb/source/Core/Value.cpp

667 ↗

(On Diff #415958)

I have to look into why we return a const & here. We do this in a few other places too.

[JDevlieghere]

LGTM

[labath]

lldb/source/Core/Value.cpp

667 ↗

(On Diff #415958)

I don't think there's a good reason for that. Most people aren't aware that built-in assignment operators return lvalues. And some of the people who are aware of that think that it's a bad idea, so they make sure their operators don't do it...

lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp

16–17

Why suppress this?

lldb/source/Target/ExecutionContext.cpp

415–416

You may need to manually delete this line to get sensible clang-formatting.

[labath]

(Please run clang-format before submitting)

[shafik]

lldb/source/Core/Value.cpp

667 ↗

(On Diff #415958)

It produced build errors, so some of the users are relying on this. I didn't want to plumb into this since it was orthogonal to the change.

lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp

16–17

I wanted to preserve the comment since someone thought it was important.

[labath]

lldb/source/Core/Value.cpp

667 ↗

(On Diff #415958)

I was curious to see what kind of errors could be produced by that change -- I didn't get any, so I committed (c484857b2e77721a4235b0e2d53d335c09fc6af3) my version. :)

lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp

16–17

In that case, maybe you can just put the comment next to the =default clause. Now, this is beginning to look like there is something very subtle going on -- subtle enough to confuse the clang-tidy check. Which, of course, isn't true...

[shafik]

lldb/source/Core/Value.cpp

667 ↗

(On Diff #415958)

I see that, I am not sure what I did wrong that I got a bunch of errors the other day.

[shafik]

• Rebased
• Applied clang-format
• Address Pavel's comment

lldb/source/API/SBMemoryRegionInfoList.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 class MemoryRegionInfoListImpl {
 public:
   MemoryRegionInfoListImpl() : m_regions() {}
 
-  MemoryRegionInfoListImpl(const MemoryRegionInfoListImpl &rhs)
-      : m_regions(rhs.m_regions) {}
+  MemoryRegionInfoListImpl(const MemoryRegionInfoListImpl &rhs) = default;
 
   MemoryRegionInfoListImpl &operator=(const MemoryRegionInfoListImpl &rhs) {
     if (this == &rhs)
       return *this;
     m_regions = rhs.m_regions;
     return *this;
   }
 

lldb/source/API/SBQueue.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb_private {
 
 class QueueImpl {
 public:
-  QueueImpl() {}
+  QueueImpl() = default;
 
   QueueImpl(const lldb::QueueSP &queue_sp) { m_queue_wp = queue_sp; }
 
   QueueImpl(const QueueImpl &rhs) {
     if (&rhs == this)
       return;
     m_queue_wp = rhs.m_queue_wp;
     m_threads = rhs.m_threads;

lldb/source/API/SBValue.cpp

if (in_valobj_sp) {
       if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
                lldb::eNoDynamicValues, false))) {
         if (!m_name.IsEmpty())
           m_valobj_sp->SetName(m_name);
       }
     }
   }
 
-  ValueImpl(const ValueImpl &rhs)
-      : m_valobj_sp(rhs.m_valobj_sp), m_use_dynamic(rhs.m_use_dynamic),
-        m_use_synthetic(rhs.m_use_synthetic), m_name(rhs.m_name) {}
+  ValueImpl(const ValueImpl &rhs) = default;
 
   ValueImpl &operator=(const ValueImpl &rhs) {
     if (this != &rhs) {
       m_valobj_sp = rhs.m_valobj_sp;
       m_use_dynamic = rhs.m_use_dynamic;
       m_use_synthetic = rhs.m_use_synthetic;
       m_name = rhs.m_name;
     }

lldb/source/API/SBValueList.cpp

 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 class ValueListImpl {
 public:
-  ValueListImpl() {}
+  ValueListImpl() = default;
 
-  ValueListImpl(const ValueListImpl &rhs) : m_values(rhs.m_values) {}
+  ValueListImpl(const ValueListImpl &rhs) = default;
 
   ValueListImpl &operator=(const ValueListImpl &rhs) {
     if (this == &rhs)
       return *this;
     m_values = rhs.m_values;
     return *this;
   }
 

lldb/source/Commands/CommandObjectBreakpoint.cpp

public:
   BreakpointOptions m_bp_opts;
 };
 
 #define LLDB_OPTIONS_breakpoint_dummy
 #include "CommandOptions.inc"
 
 class BreakpointDummyOptionGroup : public OptionGroup {
 public:
-  BreakpointDummyOptionGroup() {}
+  BreakpointDummyOptionGroup() = default;
 
   ~BreakpointDummyOptionGroup() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_breakpoint_dummy_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
public:
   }
 
   ~CommandObjectBreakpointSet() override = default;
 
   Options *GetOptions() override { return &m_all_options; }
 
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option =
           g_breakpoint_set_options[option_idx].short_option;
public:
   }
 
   ~CommandObjectBreakpointList() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandObjectBreakpointClear(CommandInterpreter &interpreter)
                             "breakpoint clear <cmd-options>") {}
 
   ~CommandObjectBreakpointClear() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eBreakpointCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
public:
   OptionValueString m_help_string;
 };
 
 #define LLDB_OPTIONS_breakpoint_access
 #include "CommandOptions.inc"
 
 class BreakpointAccessOptionGroup : public OptionGroup {
 public:
-  BreakpointAccessOptionGroup() {}
+  BreakpointAccessOptionGroup() = default;
 
   ~BreakpointAccessOptionGroup() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_breakpoint_access_options);
   }
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                         ExecutionContext *execution_context) override {
CommandObjectBreakpointRead(CommandInterpreter &interpreter)
                             nullptr) {}
 
   ~CommandObjectBreakpointRead() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eBreakpointCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

for (BreakpointOptions &bp_options : bp_options_vec) {
       cmd_data->stop_on_error = m_options.m_stop_on_error;
 
       bp_options.SetCommandDataCallback(cmd_data);
     }
   }
 
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option =
           g_breakpoint_command_add_options[option_idx].short_option;
public:
   }
 
   ~CommandObjectBreakpointCommandDelete() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Commands/CommandObjectCommands.cpp

static const char *g_python_command_instructions =
     "Enter your Python command(s). Type 'DONE' to end.\n"
     "You must define a Python function with this signature:\n"
     "def my_command_impl(debugger, args, result, internal_dict):\n";
 
 class CommandObjectCommandsAlias : public CommandObjectRaw {
 protected:
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_alias_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
void AddRegexCommandToInterpreter() {
     }
   }
 
 private:
   std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_up;
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandCompletions::InvokeCommonCompletionCallbacks(
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::CompleteModifiableCmdPathArgs(m_interpreter, request,
                                                       opt_element_vector);
   }
 
 protected:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CommandCompletions::CompleteModifiableCmdPathArgs(m_interpreter, request,
                                                       opt_element_vector);
   }
 
 protected:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Commands/CommandObjectExpression.cpp

 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-CommandObjectExpression::CommandOptions::CommandOptions() {}
+CommandObjectExpression::CommandOptions::CommandOptions() = default;
 
 CommandObjectExpression::CommandOptions::~CommandOptions() = default;
 
 static constexpr OptionEnumValueElement g_description_verbosity_type[] = {
     {
         eLanguageRuntimeDescriptionDisplayVerbosityCompact,
         "compact",
         "Only show the description string",

lldb/source/Commands/CommandObjectFrame.cpp

 
 #define LLDB_OPTIONS_frame_recognizer_add
 #include "CommandOptions.inc"
 
 class CommandObjectFrameRecognizerAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {

lldb/source/Commands/CommandObjectLog.cpp

public:
   }
 
   ~CommandObjectLogEnable() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Commands/CommandObjectMemory.cpp

 #define LLDB_OPTIONS_memory_write
 #include "CommandOptions.inc"
 
 // Write memory to the inferior process
 class CommandObjectMemoryWrite : public CommandObjectParsed {
 public:
   class OptionGroupWriteMemory : public OptionGroup {
   public:
-    OptionGroupWriteMemory() {}
+    OptionGroupWriteMemory() = default;
 
     ~OptionGroupWriteMemory() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_memory_write_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,

lldb/source/Commands/CommandObjectMemoryTag.cpp

 
 #define LLDB_OPTIONS_memory_tag_write
 #include "CommandOptions.inc"
 
 class CommandObjectMemoryTagWrite : public CommandObjectParsed {
 public:
   class OptionGroupTagWrite : public OptionGroup {
   public:
-    OptionGroupTagWrite() {}
+    OptionGroupTagWrite() = default;
 
     ~OptionGroupTagWrite() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_memory_tag_write_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,

lldb/source/Commands/CommandObjectPlatform.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       char short_option = (char)m_getopt_table[option_idx].val;
 
bool DoExecute(Args &args, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       char short_option = (char)m_getopt_table[option_idx].val;
 
bool DoExecute(Args &args, CommandReturnObject &result) override {
     } else {
       result.AppendError("no platform is selected\n");
     }
     return result.Succeeded();
   }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
       bool success = false;

 // "platform shell"
 #define LLDB_OPTIONS_platform_shell
 #include "CommandOptions.inc"
 
 class CommandObjectPlatformShell : public CommandObjectRaw {
 public:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_platform_shell_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,

lldb/source/Commands/CommandObjectProcess.cpp

CommandObjectProcessSaveCore(CommandInterpreter &interpreter)
                 eCommandProcessMustBeLaunched) {}
 
   ~CommandObjectProcessSaveCore() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_process_save_core_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
CommandObjectProcessStatus(CommandInterpreter &interpreter)
             eCommandRequiresProcess | eCommandTryTargetAPILock) {}
 
   ~CommandObjectProcessStatus() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {

lldb/source/Commands/CommandObjectReproducer.cpp

CommandObjectReproducerXCrash(CommandInterpreter &interpreter)
                             nullptr) {}
 
   ~CommandObjectReproducerXCrash() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandObjectReproducerDump(CommandInterpreter &interpreter)
                             nullptr) {}
 
   ~CommandObjectReproducerDump() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Commands/CommandObjectSettings.cpp

insert-before or insert-after.");
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
public:
   }
 
   ~CommandObjectSettingsWrite() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandObjectSettingsRead(CommandInterpreter &interpreter)
             nullptr) {}
 
   ~CommandObjectSettingsRead() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Commands/CommandObjectSource.cpp

 #pragma mark CommandObjectSourceInfo
 // CommandObjectSourceInfo - debug line entries dumping command
 #define LLDB_OPTIONS_source_info
 #include "CommandOptions.inc"
 
 class CommandObjectSourceInfo : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {

 #pragma mark CommandObjectSourceList
 // CommandObjectSourceList
 #define LLDB_OPTIONS_source_list
 #include "CommandOptions.inc"
 
 class CommandObjectSourceList : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {

 protected:
   struct SourceInfo {
     ConstString function;
     LineEntry line_entry;
 
     SourceInfo(ConstString name, const LineEntry &line_entry)
         : function(name), line_entry(line_entry) {}
 
-    SourceInfo() {}
+    SourceInfo() = default;
 
     bool IsValid() const { return (bool)function && line_entry.IsValid(); }
 
     bool operator==(const SourceInfo &rhs) const {
       return function == rhs.function &&
              line_entry.original_file == rhs.line_entry.original_file &&
              line_entry.line == rhs.line_entry.line;
     }

lldb/source/Commands/CommandObjectTarget.cpp

CommandObjectTargetModulesDumpSymtab(CommandInterpreter &interpreter)
             eCommandRequiresTarget) {}
 
   ~CommandObjectTargetModulesDumpSymtab() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

 // List images with associated information
 #define LLDB_OPTIONS_target_modules_list
 #include "CommandOptions.inc"
 
 class CommandObjectTargetModulesList : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
 
       const int short_option = m_getopt_table[option_idx].val;
enum {
     eLookupTypeSymbol,
     eLookupTypeFunction,
     eLookupTypeFunctionOrSymbol,
     kNumLookupTypes
   };
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
 
       const int short_option = m_getopt_table[option_idx].val;

lldb/source/Commands/CommandObjectType.cpp

 #define LLDB_OPTIONS_type_synth_add
 #include "CommandOptions.inc"
 
 class CommandObjectTypeSynthAdd : public CommandObjectParsed,
                                   public IOHandlerDelegateMultiline {
 private:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
       bool success;

 
 #define LLDB_OPTIONS_type_format_add
 #include "CommandOptions.inc"
 
 class CommandObjectTypeFormatAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_type_format_add_options);
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {

 
 #define LLDB_OPTIONS_type_formatter_delete
 #include "CommandOptions.inc"
 
 class CommandObjectTypeFormatterDelete : public CommandObjectParsed {
 protected:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

 
 #define LLDB_OPTIONS_type_formatter_clear
 #include "CommandOptions.inc"
 
 class CommandObjectTypeFormatterClear : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

 
 // CommandObjectTypeCategoryEnable
 #define LLDB_OPTIONS_type_category_enable
 #include "CommandOptions.inc"
 
 class CommandObjectTypeCategoryEnable : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

 
 // CommandObjectTypeCategoryDisable
 #define LLDB_OPTIONS_type_category_disable
 #include "CommandOptions.inc"
 
 class CommandObjectTypeCategoryDisable : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

 #include "CommandOptions.inc"
 
 class CommandObjectTypeFilterAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
     typedef std::vector<std::string> option_vector;
 
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
       bool success;
lldb::LanguageType GuessLanguage(StackFrame *frame) {
     if (s)
       lang_type = s->GetMangled().GuessLanguage();
 
     return lang_type;
   }
 
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_type_lookup_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,

lldb/source/Commands/CommandObjectWatchpoint.cpp

public:
   }
 
   ~CommandObjectWatchpointList() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

if (commands.GetSize() > 0) {
         result.GetImmediateErrorStream()->Flush();
       }
     }
     return ret_value;
   }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() {}
+    CommandOptions() = default;
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 

lldb/source/Core/IOHandlerCursesGUI.cpp

 
 protected:
   std::string m_label;
   std::function<void(Window &)> m_action;
 };
 
 class FormDelegate {
 public:
-  FormDelegate() {}
+  FormDelegate() = default;
 
   virtual ~FormDelegate() = default;
 
   virtual std::string GetName() = 0;
 
   virtual void UpdateFieldsVisibility() {}
 
   FieldDelegate *GetField(uint32_t field_index) {

 };
 
 ////////////
 // Searchers
 ////////////
 
 class SearcherDelegate {
 public:
-  SearcherDelegate() {}
+  SearcherDelegate() = default;
 
   virtual ~SearcherDelegate() = default;
 
   virtual int GetNumberOfMatches() = 0;
 
   // Get the string that will be displayed for the match at the input index.
   virtual const std::string &GetMatchTextAtIndex(int index) = 0;
 

lldb/source/Host/macosx/cfcpp/CFCData.cpp

 //===-- CFCData.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CFCData.h"
 
 // CFCData constructor
 CFCData::CFCData(CFDataRef data) : CFCReleaser<CFDataRef>(data) {}
 
 // CFCData copy constructor
-CFCData::CFCData(const CFCData &rhs) : CFCReleaser<CFDataRef>(rhs) {}
+CFCData::CFCData(const CFCData &rhs) = default;
 
 // CFCData copy constructor
 CFCData &CFCData::operator=(const CFCData &rhs)
 
 {
   if (this != &rhs)
     *this = rhs;
   return *this;

lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp

 //===-- CFCMutableArray.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CFCMutableArray.h"
 #include "CFCString.h"
 
 // CFCString constructor
 CFCMutableArray::CFCMutableArray(CFMutableArrayRef s)
     : CFCReleaser<CFMutableArrayRef>(s) {}
 
 // CFCMutableArray copy constructor
-CFCMutableArray::CFCMutableArray(const CFCMutableArray &rhs)
-    : CFCReleaser<CFMutableArrayRef>(rhs) // NOTE: this won't make a copy of the
-                                          // array, just add a new reference to
-                                          // it
-{}
+CFCMutableArray::CFCMutableArray(const CFCMutableArray &rhs) =
+    default; // NOTE: this won't make a copy of the
 
 // CFCMutableArray copy constructor
 CFCMutableArray &CFCMutableArray::operator=(const CFCMutableArray &rhs) {
   if (this != &rhs)
     *this = rhs; // NOTE: this operator won't make a copy of the array, just add
                  // a new reference to it
   return *this;
 }

lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.cpp

 //===-- CFCMutableDictionary.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CFCMutableDictionary.h"
 #include "CFCString.h"
 // CFCString constructor
 CFCMutableDictionary::CFCMutableDictionary(CFMutableDictionaryRef s)
     : CFCReleaser<CFMutableDictionaryRef>(s) {}
 
 // CFCMutableDictionary copy constructor
-CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary &rhs)
-    : CFCReleaser<CFMutableDictionaryRef>(rhs) {}
+CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary &rhs) =
+    default;
 
 // CFCMutableDictionary copy constructor
 const CFCMutableDictionary &CFCMutableDictionary::
 operator=(const CFCMutableDictionary &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }

lldb/source/Host/macosx/cfcpp/CFCMutableSet.cpp

 //===-- CFCMutableSet.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CFCMutableSet.h"
 
 
 // CFCString constructor
 CFCMutableSet::CFCMutableSet(CFMutableSetRef s)
     : CFCReleaser<CFMutableSetRef>(s) {}
 
 // CFCMutableSet copy constructor
-CFCMutableSet::CFCMutableSet(const CFCMutableSet &rhs)
-    : CFCReleaser<CFMutableSetRef>(rhs) {}
+CFCMutableSet::CFCMutableSet(const CFCMutableSet &rhs) = default;
 
 // CFCMutableSet copy constructor
 const CFCMutableSet &CFCMutableSet::operator=(const CFCMutableSet &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 

lldb/source/Host/macosx/cfcpp/CFCString.cpp

 //===-- CFCString.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CFCString.h"
 #include <glob.h>
 #include <string>
 
 // CFCString constructor
 CFCString::CFCString(CFStringRef s) : CFCReleaser<CFStringRef>(s) {}
 
 // CFCString copy constructor
-CFCString::CFCString(const CFCString &rhs) : CFCReleaser<CFStringRef>(rhs) {}
+CFCString::CFCString(const CFCString &rhs) = default;
 
 // CFCString copy constructor
 CFCString &CFCString::operator=(const CFCString &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 

lldb/source/Plugins/ExpressionParser/Clang/ClangASTImporter.cpp

void ClangASTImporter::ForgetSource(clang::ASTContext *dst_ast,
 
   if (!md)
     return;
 
   md->m_delegates.erase(src_ast);
   md->removeOriginsWithContext(src_ast);
 }
 
-ClangASTImporter::MapCompleter::~MapCompleter() {}
+ClangASTImporter::MapCompleter::~MapCompleter() = default;
 
 llvm::Expected<Decl *>
 ClangASTImporter::ASTImporterDelegate::ImportImpl(Decl *From) {
   if (m_std_handler) {
     llvm::Optional<Decl *> D = m_std_handler->Import(From);
     if (D) {
       // Make sure we don't use this decl later to map it back to it's original
       // decl. The decl the CxxModuleHandler created has nothing to do with

lldb/source/Plugins/REPL/Clang/ClangREPL.cpp

 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ClangREPL)
 
 ClangREPL::ClangREPL(lldb::LanguageType language, Target &target)
     : REPL(eKindClang, target), m_language(language),
       m_implicit_expr_result_regex("\\$[0-9]+") {}
 
-ClangREPL::~ClangREPL() {}
+ClangREPL::~ClangREPL() = default;
 
 void ClangREPL::Initialize() {
   LanguageSet languages;
   // FIXME: There isn't a way to ask CPlusPlusLanguage and ObjCLanguage for
   // a list of languages they support.
   languages.Insert(lldb::LanguageType::eLanguageTypeC);
   languages.Insert(lldb::LanguageType::eLanguageTypeC89);
   languages.Insert(lldb::LanguageType::eLanguageTypeC99);

lldb/source/Target/ExecutionContext.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb_private;
 
 ExecutionContext::ExecutionContext()
     : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {}
 
-ExecutionContext::ExecutionContext(const ExecutionContext &rhs)
-    : m_target_sp(rhs.m_target_sp), m_process_sp(rhs.m_process_sp),
-      m_thread_sp(rhs.m_thread_sp), m_frame_sp(rhs.m_frame_sp) {}
+ExecutionContext::ExecutionContext(const ExecutionContext &rhs) = default;
 
 ExecutionContext::ExecutionContext(const lldb::TargetSP &target_sp,
                                    bool get_process)
     : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
   if (target_sp)
     SetContext(target_sp, get_process);
 }
 

 }
 
 ExecutionContextRef::ExecutionContextRef(Target *target, bool adopt_selected)
     : m_target_wp(), m_process_wp(), m_thread_wp(), m_stack_id() {
   SetTargetPtr(target, adopt_selected);
 }
 
 ExecutionContextRef::ExecutionContextRef(const ExecutionContextRef &rhs)
-    : m_target_wp(rhs.m_target_wp), m_process_wp(rhs.m_process_wp),
-      m_thread_wp(rhs.m_thread_wp), m_tid(rhs.m_tid),
-      m_stack_id(rhs.m_stack_id) {}
+
+    = default;
 
 ExecutionContextRef &ExecutionContextRef::
 operator=(const ExecutionContextRef &rhs) {
   if (this != &rhs) {
     m_target_wp = rhs.m_target_wp;
     m_process_wp = rhs.m_process_wp;
     m_thread_wp = rhs.m_thread_wp;
     m_tid = rhs.m_tid;

lldb/source/Utility/XcodeSDK.cpp

if (!m_name.empty()) {
     if (!info.version.empty())
       m_name += info.version.getAsString();
     if (info.internal)
       m_name += ".Internal";
     m_name += ".sdk";
   }
 }
 
-XcodeSDK &XcodeSDK::operator=(const XcodeSDK &other) {
-  m_name = other.m_name;
-  return *this;
-}
+XcodeSDK &XcodeSDK::operator=(const XcodeSDK &other) = default;
 
 bool XcodeSDK::operator==(const XcodeSDK &other) {
   return m_name == other.m_name;
 }
 
 static XcodeSDK::Type ParseSDKName(llvm::StringRef &name) {
   if (name.consume_front("MacOSX"))
     return XcodeSDK::MacOSX;

lldb/tools/debugserver/source/DNBBreakpoint.cpp

 #pragma mark-- DNBBreakpoint
 DNBBreakpoint::DNBBreakpoint(nub_addr_t addr, nub_size_t byte_size,
                              bool hardware)
     : m_retain_count(1), m_byte_size(static_cast<uint32_t>(byte_size)),
       m_opcode(), m_addr(addr), m_enabled(0), m_hw_preferred(hardware),
       m_is_watchpoint(0), m_watch_read(0), m_watch_write(0),
       m_hw_index(INVALID_NUB_HW_INDEX) {}
 
-DNBBreakpoint::~DNBBreakpoint() {}
+DNBBreakpoint::~DNBBreakpoint() = default;
 
 void DNBBreakpoint::Dump() const {
   if (IsBreakpoint()) {
     DNBLog("DNBBreakpoint addr = 0x%llx  state = %s  type = %s breakpoint  "
            "hw_index = %i",
            (uint64_t)m_addr, m_enabled ? "enabled " : "disabled",
            IsHardware() ? "hardware" : "software", GetHardwareIndex());
   } else {
     DNBLog("DNBBreakpoint addr = 0x%llx  size = %llu  state = %s  type = %s "
            "watchpoint (%s%s)  hw_index = %i",
            (uint64_t)m_addr, (uint64_t)m_byte_size,
            m_enabled ? "enabled " : "disabled",
            IsHardware() ? "hardware" : "software", m_watch_read ? "r" : "",
            m_watch_write ? "w" : "", GetHardwareIndex());
   }
 }
 
 #pragma mark-- DNBBreakpointList
 
-DNBBreakpointList::DNBBreakpointList() {}
+DNBBreakpointList::DNBBreakpointList() = default;
 
-DNBBreakpointList::~DNBBreakpointList() {}
+DNBBreakpointList::~DNBBreakpointList() = default;
 
 DNBBreakpoint *DNBBreakpointList::Add(nub_addr_t addr, nub_size_t length,
                                       bool hardware) {
   m_breakpoints.insert(
       std::make_pair(addr, DNBBreakpoint(addr, length, hardware)));
   iterator pos = m_breakpoints.find(addr);
   return &pos->second;
 }

lldb/tools/debugserver/source/DNBDataRef.cpp

 
 DNBDataRef::DNBDataRef(const uint8_t *start, size_t size, bool swap)
     : m_start(start), m_end(start + size), m_swap(swap), m_ptrSize(0),
       m_addrPCRelative(INVALID_NUB_ADDRESS), m_addrTEXT(INVALID_NUB_ADDRESS),
       m_addrDATA(INVALID_NUB_ADDRESS) {}
 
 // Destructor
 
-DNBDataRef::~DNBDataRef() {}
+DNBDataRef::~DNBDataRef() = default;
 
 // Get8
 uint8_t DNBDataRef::Get8(offset_t *offset_ptr) const {
   uint8_t val = 0;
   if (ValidOffsetForDataOfSize(*offset_ptr, sizeof(val))) {
     val = *(m_start + *offset_ptr);
     *offset_ptr += sizeof(val);
   }

lldb/tools/debugserver/source/MacOSX/CFBundle.cpp

 // CFBundle constructor
 CFBundle::CFBundle(const char *path)
     : CFReleaser<CFBundleRef>(), m_bundle_url() {
   if (path && path[0])
     SetPath(path);
 }
 
 // CFBundle copy constructor
-CFBundle::CFBundle(const CFBundle &rhs)
-    : CFReleaser<CFBundleRef>(rhs), m_bundle_url(rhs.m_bundle_url) {}
+CFBundle::CFBundle(const CFBundle &rhs) = default;
 
 // CFBundle copy constructor
 CFBundle &CFBundle::operator=(const CFBundle &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 
 // Destructor
-CFBundle::~CFBundle() {}
+CFBundle::~CFBundle() = default;
 
 // Set the path for a bundle by supplying a
 bool CFBundle::SetPath(const char *path) {
   CFAllocatorRef alloc = kCFAllocatorDefault;
   // Release our old bundle and ULR
   reset(); // This class is a CFReleaser<CFBundleRef>
   m_bundle_url.reset();
   // Make a CFStringRef from the supplied path

lldb/tools/debugserver/source/MacOSX/CFString.cpp

 #include "CFString.h"
 #include <glob.h>
 #include <string>
 
 // CFString constructor
 CFString::CFString(CFStringRef s) : CFReleaser<CFStringRef>(s) {}
 
 // CFString copy constructor
-CFString::CFString(const CFString &rhs) : CFReleaser<CFStringRef>(rhs) {}
+CFString::CFString(const CFString &rhs) = default;
 
 // CFString copy constructor
 CFString &CFString::operator=(const CFString &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 
 CFString::CFString(const char *cstr, CFStringEncoding cstr_encoding)
     : CFReleaser<CFStringRef>() {
   if (cstr && cstr[0]) {
     reset(
         ::CFStringCreateWithCString(kCFAllocatorDefault, cstr, cstr_encoding));
   }
 }
 
 // Destructor
-CFString::~CFString() {}
+CFString::~CFString() = default;
 
 const char *CFString::GetFileSystemRepresentation(std::string &s) {
   return CFString::FileSystemRepresentation(get(), s);
 }
 
 CFStringRef CFString::SetFileSystemRepresentation(const char *path) {
   CFStringRef new_value = NULL;
   if (path && path[0])

lldb/tools/debugserver/source/MacOSX/MachThreadList.cpp

 #include <sys/sysctl.h>
 
 #include <memory>
 
 MachThreadList::MachThreadList()
     : m_threads(), m_threads_mutex(PTHREAD_MUTEX_RECURSIVE),
       m_is_64_bit(false) {}
 
-MachThreadList::~MachThreadList() {}
+MachThreadList::~MachThreadList() = default;
 
 nub_state_t MachThreadList::GetState(nub_thread_t tid) {
   MachThreadSP thread_sp(GetThreadByID(tid));
   if (thread_sp)
     return thread_sp->GetState();
   return eStateInvalid;
 }
 

lldb/tools/debugserver/source/MacOSX/MachVMMemory.cpp

 #import <System/sys/kern_memorystatus.h>
 }
 #endif
 
 static const vm_size_t kInvalidPageSize = ~0;
 
 MachVMMemory::MachVMMemory() : m_page_size(kInvalidPageSize), m_err(0) {}
 
-MachVMMemory::~MachVMMemory() {}
+MachVMMemory::~MachVMMemory() = default;
 
 nub_size_t MachVMMemory::PageSize(task_t task) {
   if (m_page_size == kInvalidPageSize) {
 #if defined(TASK_VM_INFO) && TASK_VM_INFO >= 22
     if (task != TASK_NULL) {
       kern_return_t kr;
       mach_msg_type_number_t info_count = TASK_VM_INFO_COUNT;
       task_vm_info_data_t vm_info;

lldb/tools/debugserver/source/StdStringExtractor.cpp

 
 StdStringExtractor::StdStringExtractor(const char *packet_cstr)
     : m_packet(), m_index(0) {
   if (packet_cstr)
     m_packet.assign(packet_cstr);
 }
 
 // Destructor
-StdStringExtractor::~StdStringExtractor() {}
+StdStringExtractor::~StdStringExtractor() = default;
 
 char StdStringExtractor::GetChar(char fail_value) {
   if (m_index < m_packet.size()) {
     char ch = m_packet[m_index];
     ++m_index;
     return ch;
   }
   m_index = UINT64_MAX;

lldb/tools/debugserver/source/TTYState.cpp

 #include "TTYState.h"
 #include <fcntl.h>
 #include <sys/signal.h>
 #include <unistd.h>
 
 TTYState::TTYState()
     : m_fd(-1), m_tflags(-1), m_ttystateErr(-1), m_processGroup(-1) {}
 
-TTYState::~TTYState() {}
+TTYState::~TTYState() = default;
 
 bool TTYState::GetTTYState(int fd, bool saveProcessGroup) {
   if (fd >= 0 && ::isatty(fd)) {
     m_fd = fd;
     m_tflags = fcntl(fd, F_GETFL, 0);
     m_ttystateErr = tcgetattr(fd, &m_ttystate);
     if (saveProcessGroup)
       m_processGroup = tcgetpgrp(0);
if (IsValid()) {
     }
     return true;
   }
   return false;
 }
 
 TTYStateSwitcher::TTYStateSwitcher() : m_currentState(~0) {}
 
-TTYStateSwitcher::~TTYStateSwitcher() {}
+TTYStateSwitcher::~TTYStateSwitcher() = default;
 
 bool TTYStateSwitcher::GetState(uint32_t idx, int fd, bool saveProcessGroup) {
   if (ValidStateIndex(idx))
     return m_ttystates[idx].GetTTYState(fd, saveProcessGroup);
   return false;
 }
 
 bool TTYStateSwitcher::SetState(uint32_t idx) const {

lldb/tools/lldb-vscode/IOStream.cpp

 #endif
 
 #include <fstream>
 #include <string>
 #include <vector>
 
 using namespace lldb_vscode;
 
-StreamDescriptor::StreamDescriptor() {}
+StreamDescriptor::StreamDescriptor() = default;
 
 StreamDescriptor::StreamDescriptor(StreamDescriptor &&other) {
   *this = std::move(other);
 }
 
 StreamDescriptor::~StreamDescriptor() {
   if (!m_close)
     return;

lldb/tools/lldb-vscode/VSCode.cpp

#if defined(_WIN32)
   result = _setmode(fileno(stdin), _O_BINARY);
   (void)result;
   assert(result);
 #endif
   if (log_file_path)
     log.reset(new std::ofstream(log_file_path));
 }
 
-VSCode::~VSCode() {}
+VSCode::~VSCode() = default;
 
 int64_t VSCode::GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const {
   auto pos = source_map.find(sourceReference);
   if (pos != source_map.end())
     return pos->second.GetLineForPC(pc);
   return 0;
 }