[LLDB] Fix Clang-tidy misc-use-override warnings in some files in include/lldb/Interpreter and Host; other minor fixes.

[Eugene.Zelenko]

Summary

This is second attempt based on current code.

I checked this patch on my own build on RHEL 6.

Please check it in if it's OK, because I don't have SVN write access.

[Eugene.Zelenko]

Ping. Please review this patch, since these files is largest source of modernize-use-override warnings warnings in LLDB code.

[labath]

looks reasonable

[clayborg]

Looks good. I would venture to say just checkin any clang tidy things that aren't changing code functionality without need for review.

include/lldb/Host/MonitoringProcessLauncher.h

   public:
     explicit MonitoringProcessLauncher(std::unique_ptr<ProcessLauncher> delegate_launcher);
 
-    virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error);
+    HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error) override;
 
   private:
     std::unique_ptr<ProcessLauncher> m_delegate_launcher;
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // lldb_Host_MonitoringProcessLauncher_h_

include/lldb/Host/posix/HostProcessPosix.h

   public:
     HostProcessPosix();
     HostProcessPosix(lldb::process_t process);
-    virtual ~HostProcessPosix();
+    ~HostProcessPosix() override;
 
     virtual Error Signal(int signo) const;
     static Error Signal(lldb::process_t process, int signo);

 
     HostThread StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals) override;
 };
-}
 
-#endif
+} // namespace lldb_private
+
+#endif // lldb_Host_HostProcesPosix_h_

include/lldb/Interpreter/CommandCompletions.h

         // so you can add custom enums starting from here in your Option class.
         // Also if you & in this bit the base code will not process the option.
         eCustomCompletion         = (1u << 9)
-
     } CommonCompletionTypes;
 
     struct CommonCompletionElement

                SearchFilter *searcher,
                bool &word_complete,
                StringList &matches);
+
     static int
     DiskDirectories (CommandInterpreter &interpreter,
                      const char *partial_file_name,

                    int max_return_elements,
                    StringList &matches);
 
-        virtual ~Completer ();
+        ~Completer() override;
 
-        virtual CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete) = 0;
+        CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override = 0;
 
-        virtual Depth
-        GetDepth () = 0;
+        Depth
+        GetDepth() override = 0;
 
         virtual size_t
         DoCompletion (SearchFilter *filter) = 0;

             int m_match_start_point;
             int m_max_return_elements;
             StringList &m_matches;
+
         private:
-            DISALLOW_COPY_AND_ASSIGN (Completer);
+            DISALLOW_COPY_AND_ASSIGN(Completer);
     };
 
     //----------------------------------------------------------------------

     class SourceFileCompleter : public Completer
     {
     public:
-
         SourceFileCompleter (CommandInterpreter &interpreter,
                              bool include_support_files,
                              const char *completion_str,

                              int max_return_elements,
                              StringList &matches);
         
-        virtual Searcher::Depth GetDepth ();
+        Searcher::Depth GetDepth() override;
 
-        virtual Searcher::CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete);
+        Searcher::CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
         bool m_include_support_files;
         FileSpecList m_matching_files;
         const char *m_file_name;
         const char *m_dir_name;
-        DISALLOW_COPY_AND_ASSIGN (SourceFileCompleter);
 
+        DISALLOW_COPY_AND_ASSIGN(SourceFileCompleter);
     };
 
     //----------------------------------------------------------------------

     class ModuleCompleter : public Completer
     {
     public:
-
         ModuleCompleter (CommandInterpreter &interpreter,
                          const char *completion_str,
                          int match_start_point,
                          int max_return_elements,
                          StringList &matches);
         
-        virtual Searcher::Depth GetDepth ();
+        Searcher::Depth GetDepth() override;
 
-        virtual Searcher::CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete);
+        Searcher::CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
         const char *m_file_name;
         const char *m_dir_name;
-        DISALLOW_COPY_AND_ASSIGN (ModuleCompleter);
 
+        DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
     };
 
     //----------------------------------------------------------------------

     class SymbolCompleter : public Completer
     {
     public:
-
         SymbolCompleter (CommandInterpreter &interpreter,
                          const char *completion_str,
                          int match_start_point,
                          int max_return_elements,
                          StringList &matches);
         
-        virtual Searcher::Depth GetDepth ();
+        Searcher::Depth GetDepth() override;
 
-        virtual Searcher::CallbackReturn
-        SearchCallback (SearchFilter &filter,
-                        SymbolContext &context,
-                        Address *addr,
-                        bool complete);
+        Searcher::CallbackReturn
+        SearchCallback(SearchFilter &filter,
+                       bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
 //        struct NameCmp {

         RegularExpression m_regex;
         typedef std::set<ConstString> collection;
         collection m_match_set;
-        DISALLOW_COPY_AND_ASSIGN (SymbolCompleter);
 
+        DISALLOW_COPY_AND_ASSIGN(SymbolCompleter);
     };
 
 private:
     static CommonCompletionElement g_common_completions[];
-
 };
 
 } // namespace lldb_private
-#endif  // lldb_CommandCompletions_h_
+
+#endif // lldb_CommandCompletions_h_

include/lldb/Interpreter/CommandInterpreter.h

     public IOHandlerDelegate
 {
 public:
-
-
     typedef std::map<std::string, OptionArgVectorSP> OptionArgMap;
 
     enum

         eCommandTypesAllThem = 0xFFFF   // all commands
     };
 
+    CommandInterpreter(Debugger &debugger,
+                       lldb::ScriptLanguage script_language,
+                       bool synchronous_execution);
+
+    ~CommandInterpreter() override;
+
     // These two functions fill out the Broadcaster interface:
     
     static ConstString &GetStaticBroadcasterClass ();
 
-    virtual ConstString &GetBroadcasterClass() const
+    ConstString &GetBroadcasterClass() const override
     {
         return GetStaticBroadcasterClass();
     }

     SourceInitFile (bool in_cwd, 
                     CommandReturnObject &result);
 
-    CommandInterpreter (Debugger &debugger,
-                        lldb::ScriptLanguage script_language,
-                        bool synchronous_execution);
-
-    virtual
-    ~CommandInterpreter ();
-
     bool
     AddCommand (const char *name, 
                 const lldb::CommandObjectSP &cmd_sp,

     OptionArgVectorSP
     GetAliasOptions (const char *alias_name);
 
-
     bool
     ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp, 
                              const char *options_args,

     // Otherwise, returns the number of matches.
     //
     // FIXME: Only max_return_elements == -1 is supported at present.
-
     int
     HandleCompletion (const char *current_line,
                       const char *cursor,

     // Help command can call it for the first argument.
     // word_complete tells whether the completions are considered a "complete" response (so the
     // completer should complete the quote & put a space after the word.
-
     int
     HandleCompletionMatches (Args &input,
                              int &cursor_index,

                              bool &word_complete,
                              StringList &matches);
 
-
     int
     GetCommandNamesMatchingPartialString (const char *cmd_cstr, 
                                           bool include_aliases, 

     void
     SetScriptLanguage (lldb::ScriptLanguage lang);
 
-
     bool
     HasCommands ();
 

     //------------------------------------------------------------------
     // IOHandlerDelegate functions
     //------------------------------------------------------------------
-    virtual void
-    IOHandlerInputComplete (IOHandler &io_handler,
-                            std::string &line);
+    void
+    IOHandlerInputComplete(IOHandler &io_handler,
+                           std::string &line) override;
 
-    virtual ConstString
-    IOHandlerGetControlSequence (char ch)
+    ConstString
+    IOHandlerGetControlSequence(char ch) override
     {
         if (ch == 'd')
             return ConstString("quit\n");
         return ConstString();
     }
     
-    virtual bool
-    IOHandlerInterrupt (IOHandler &io_handler);
+    bool
+    IOHandlerInterrupt(IOHandler &io_handler) override;
 
     size_t
     GetProcessOutput ();

 
     lldb::CommandObjectSP
     GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL);
-
     
 private:
-    
     Error
     PreprocessCommand (std::string &command);
 

     CommandObject *
     ResolveCommandImpl(std::string &command_line, CommandReturnObject &result);
 
-
     Debugger &m_debugger;                       // The debugger session that this interpreter is associated with
     ExecutionContextRef m_exe_ctx_ref;          // The current execution context to use when handling commands
     bool m_synchronous_execution;

     uint32_t m_num_errors;
     bool m_quit_requested;
     bool m_stopped_for_crash;
-    
 };
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_CommandInterpreter_h_
+#endif // liblldb_CommandInterpreter_h_

include/lldb/Interpreter/CommandObject.h

 #ifndef liblldb_CommandObject_h_
 #define liblldb_CommandObject_h_
 
+// C Includes
+// C++ Includes
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandCompletions.h"

 class CommandObject
 {
 public:
-
     typedef const char *(ArgumentHelpCallbackFunction) ();
     
     struct ArgumentHelpCallback

         {
             return (help_callback != NULL);
         }
-
     };
     
     struct ArgumentTableEntry  // Entries in the main argument information table

     virtual
     ~CommandObject ();
 
-    
     static const char * 
     GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
     

     /// @return
     ///     The number of completions.
     //------------------------------------------------------------------
-
     virtual int
     HandleArgumentCompletion (Args &input,
                               int &cursor_index,

     // to the specified command argument entry.
     static void
     AddIDsArgumentData(CommandArgumentEntry &arg, lldb::CommandArgumentType ID, lldb::CommandArgumentType IDRange);
-    
 };
 
 class CommandObjectParsed : public CommandObject
 {
 public:
-
     CommandObjectParsed (CommandInterpreter &interpreter,
                          const char *name,
                          const char *help = NULL,

                          uint32_t flags = 0) :
         CommandObject (interpreter, name, help, syntax, flags) {}
 
-    virtual
-    ~CommandObjectParsed () {}
+    ~CommandObjectParsed() override = default;
     
-    virtual bool
-    Execute (const char *args_string, CommandReturnObject &result);
+    bool
+    Execute(const char *args_string, CommandReturnObject &result) override;
     
 protected:
     virtual bool
     DoExecute (Args& command,
              CommandReturnObject &result) = 0;
     
-    virtual bool
-    WantsRawCommandString() { return false; }
+    bool
+    WantsRawCommandString() override
+    {
+        return false;
+    }
 };
 
 class CommandObjectRaw : public CommandObject
 {
 public:
-
     CommandObjectRaw (CommandInterpreter &interpreter,
                          const char *name,
                          const char *help = NULL,

                          uint32_t flags = 0) :
         CommandObject (interpreter, name, help, syntax, flags) {}
 
-    virtual
-    ~CommandObjectRaw () {}
+    ~CommandObjectRaw() override = default;
     
-    virtual bool
-    Execute (const char *args_string, CommandReturnObject &result);
+    bool
+    Execute(const char *args_string, CommandReturnObject &result) override;
 
 protected:    
     virtual bool
     DoExecute (const char *command, CommandReturnObject &result) = 0;
 
-    virtual bool
-    WantsRawCommandString() { return true; }
+    bool
+    WantsRawCommandString() override
+    {
+        return true;
+    }
 };
 
-
 } // namespace lldb_private
 
-
-#endif  // liblldb_CommandObject_h_
+#endif // liblldb_CommandObject_h_

include/lldb/Interpreter/CommandObjectMultiword.h

                             const char *syntax = NULL,
                             uint32_t flags = 0);
     
-    virtual
-    ~CommandObjectMultiword ();
+    ~CommandObjectMultiword() override;
 
-    virtual bool
-    IsMultiwordObject () { return true; }
+    bool
+    IsMultiwordObject() override
+    {
+        return true;
+    }
 
-    virtual bool
-    LoadSubCommand (const char *cmd_name, 
-                    const lldb::CommandObjectSP& command_obj);
+    bool
+    LoadSubCommand(const char *cmd_name,
+                   const lldb::CommandObjectSP& command_obj) override;
 
-    virtual void
-    GenerateHelpText (Stream &output_stream);
+    void
+    GenerateHelpText(Stream &output_stream) override;
 
-    virtual lldb::CommandObjectSP
-    GetSubcommandSP (const char *sub_cmd, StringList *matches = NULL);
+    lldb::CommandObjectSP
+    GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
 
-    virtual CommandObject *
-    GetSubcommandObject (const char *sub_cmd, StringList *matches = NULL);
+    CommandObject *
+    GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
 
-    virtual void
-    AproposAllSubCommands (const char *prefix,
-                           const char *search_word,
-                           StringList &commands_found,
-                           StringList &commands_help);
+    void
+    AproposAllSubCommands(const char *prefix,
+                          StringList &commands_help) override;
 
-    virtual bool
-    WantsRawCommandString() { return false; }
+    bool
+    WantsRawCommandString() override
+    {
+        return false;
+    }
 
-    virtual int
-    HandleCompletion (Args &input,
-                      int &cursor_index,
-                      int &cursor_char_position,
-                      int match_start_point,
-                      int max_return_elements,
-                      bool &word_complete,
-                      StringList &matches);
+    int
+    HandleCompletion(Args &input,
+                     StringList &matches) override;
 
-    virtual const char *GetRepeatCommand (Args &current_command_args, uint32_t index);
+    const char *
+    GetRepeatCommand (Args &current_command_args, uint32_t index) override;
 
-    virtual bool
-    Execute (const char *args_string,
-             CommandReturnObject &result);
+    bool
+    Execute(const char *args_string,
+            CommandReturnObject &result) override;
     
-    virtual bool
-    IsRemovable() const { return m_can_be_removed; }
+    bool
+    IsRemovable() const override
+    {
+        return m_can_be_removed;
+    }
     
     void
     SetRemovable (bool removable)

     CommandObject::CommandMap m_subcommand_dict;
     bool m_can_be_removed;
 };
-
     
 class CommandObjectProxy : public CommandObject
 {

                         const char *syntax = NULL,
                         uint32_t flags = 0);
     
-    virtual
-    ~CommandObjectProxy ();
+    ~CommandObjectProxy() override;
     
     // Subclasses must provide a command object that will be transparently
     // used for this object.
     virtual CommandObject *
     GetProxyCommandObject() = 0;
 
-    virtual const char *
-    GetHelpLong ();
+    const char *
+    GetHelpLong() override;
     
-    virtual bool
-    IsRemovable() const;
+    bool
+    IsRemovable() const override;
 
-    virtual bool
-    IsMultiwordObject ();
+    bool
+    IsMultiwordObject() override;
     
-    virtual lldb::CommandObjectSP
-    GetSubcommandSP (const char *sub_cmd, StringList *matches = NULL);
+    lldb::CommandObjectSP
+    GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
     
-    virtual CommandObject *
-    GetSubcommandObject (const char *sub_cmd, StringList *matches = NULL);
+    CommandObject *
+    GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
     
-    virtual void
-    AproposAllSubCommands (const char *prefix,
-                           const char *search_word,
-                           StringList &commands_found,
-                           StringList &commands_help);
+    void
+    AproposAllSubCommands(const char *prefix,
+                          StringList &commands_help) override;
 
-    virtual bool
-    LoadSubCommand (const char *cmd_name,
-                    const lldb::CommandObjectSP& command_obj);
+    bool
+    LoadSubCommand(const char *cmd_name,
+                   const lldb::CommandObjectSP& command_obj) override;
     
-    virtual bool
-    WantsRawCommandString();
+    bool
+    WantsRawCommandString() override;
     
-    virtual bool
-    WantsCompletion();
+    bool
+    WantsCompletion() override;
     
-    virtual Options *
-    GetOptions ();
-    
+    Options *
+    GetOptions() override;
 
-    virtual int
-    HandleCompletion (Args &input,
-                      int &cursor_index,
-                      int &cursor_char_position,
-                      int match_start_point,
-                      int max_return_elements,
-                      bool &word_complete,
-                      StringList &matches);
+    int
+    HandleCompletion(Args &input,
+                     StringList &matches) override;
 
-    virtual int
-    HandleArgumentCompletion (Args &input,
-                              int &cursor_index,
-                              int &cursor_char_position,
-                              OptionElementVector &opt_element_vector,
-                              int match_start_point,
-                              int max_return_elements,
-                              bool &word_complete,
-                              StringList &matches);
+    int
+    HandleArgumentCompletion(Args &input,
+                             StringList &matches) override;
 
-    virtual const char *
-    GetRepeatCommand (Args &current_command_args,
-                      uint32_t index);
+    const char *
+    GetRepeatCommand(Args &current_command_args,
+                     uint32_t index) override;
 
-    virtual bool
-    Execute (const char *args_string,
-             CommandReturnObject &result);
+    bool
+    Execute(const char *args_string,
+            CommandReturnObject &result) override;
 
 protected:
-    
     // These two want to iterate over the subcommand dictionary.
     friend class CommandInterpreter;
     friend class CommandObjectSyntax;
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectMultiword_h_
+#endif // liblldb_CommandObjectMultiword_h_

include/lldb/Interpreter/CommandObjectRegexCommand.h

 class CommandObjectRegexCommand : public CommandObjectRaw
 {
 public:
-
     CommandObjectRegexCommand (CommandInterpreter &interpreter,
                                const char *name, 
                                const char *help, 

                                uint32_t completion_type_mask,
                                bool is_removable);
     
-    virtual
-    ~CommandObjectRegexCommand ();
+    ~CommandObjectRegexCommand() override;
 
     bool
     IsRemovable () const override { return m_is_removable; }

 
 } // namespace lldb_private
 
-#endif  // liblldb_CommandObjectRegexCommand_h_
+#endif // liblldb_CommandObjectRegexCommand_h_

include/lldb/Interpreter/CommandOptionValidators.h

 #ifndef liblldb_CommandOptionValidators_h_
 #define liblldb_CommandOptionValidators_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private-types.h"
 
 namespace lldb_private {

 
 class PosixPlatformCommandOptionValidator : public OptionValidator
 {
-    virtual bool IsValid(Platform &platform, const ExecutionContext &target) const;
-    virtual const char* ShortConditionString() const;
-    virtual const char* LongConditionString() const;
+    bool IsValid(Platform &platform, const ExecutionContext &target) const override;
+    const char* ShortConditionString() const override;
+    const char* LongConditionString() const override;
 };
 
 } // namespace lldb_private
 
-
-#endif  // liblldb_CommandOptionValidators_h_
+#endif // liblldb_CommandOptionValidators_h_

include/lldb/Interpreter/OptionGroupArchitecture.h

     
     OptionGroupArchitecture ();
     
-    virtual
-    ~OptionGroupArchitecture ();
+    ~OptionGroupArchitecture() override;
 
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   uint32_t option_idx,
+                   const char *option_value) override;
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
-    
     bool
     GetArchitecture (Platform *platform, ArchSpec &arch);
 

     {
         return !m_arch_str.empty();
     }
+
     const char *
     GetArchitectureName ()
     {

 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupArchitecture_h_
+#endif // liblldb_OptionGroupArchitecture_h_

include/lldb/Interpreter/OptionGroupBoolean.h

                             bool default_value,
                             bool no_argument_toggle_default);
         
-        virtual
-        ~OptionGroupBoolean ();
-        
-        
-        virtual uint32_t
-        GetNumDefinitions ()
+        ~OptionGroupBoolean() override;
+
+        uint32_t
+        GetNumDefinitions() override
         {
             return 1;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions() override
         {
             return &m_option_definition;
         }
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       const char *option_value) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         OptionValueBoolean &
         GetOptionValue ()

     protected:
         OptionValueBoolean m_value;
         OptionDefinition m_option_definition;
-        
     };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupBoolean_h_
+#endif // liblldb_OptionGroupBoolean_h_

include/lldb/Interpreter/OptionGroupFile.h

 class OptionGroupFile : public OptionGroup
 {
 public:
-    
     OptionGroupFile (uint32_t usage_mask,
                      bool required,
                      const char *long_option, 

                      lldb::CommandArgumentType argument_type,
                      const char *usage_text);
     
-    virtual
-    ~OptionGroupFile ();
+    ~OptionGroupFile() override;
 
-    
-    virtual uint32_t
-    GetNumDefinitions ()
+    uint32_t
+    GetNumDefinitions() override
     {
         return 1;
     }
     
-    virtual const OptionDefinition*
-    GetDefinitions ()
+    const OptionDefinition*
+    GetDefinitions() override
     {
         return &m_option_definition;
     }
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     OptionValueFileSpec &
     GetOptionValue ()

 protected:
     OptionValueFileSpec m_file;
     OptionDefinition m_option_definition;
-    
 };
 
 //-------------------------------------------------------------------------

                          lldb::CommandArgumentType argument_type,
                          const char *usage_text);
     
-    virtual
-    ~OptionGroupFileList ();
+    ~OptionGroupFileList() override;
     
-    
-    virtual uint32_t
-    GetNumDefinitions ()
+    uint32_t
+    GetNumDefinitions() override
     {
         return 1;
     }
     
-    virtual const OptionDefinition*
-    GetDefinitions ()
+    const OptionDefinition*
+    GetDefinitions() override
     {
         return &m_option_definition;
     }
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
-    
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
 
     OptionValueFileSpecList &
     GetOptionValue ()

 protected:
     OptionValueFileSpecList m_file_list;
     OptionDefinition m_option_definition;
-    
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupFile_h_
+#endif // liblldb_OptionGroupFile_h_

include/lldb/Interpreter/OptionGroupFormat.h

                        uint64_t default_byte_size = UINT64_MAX,  // Pass UINT64_MAX to disable the "--size" option
                        uint64_t default_count = UINT64_MAX);     // Pass UINT64_MAX to disable the "--count" option
     
-    virtual
-    ~OptionGroupFormat ();
+    ~OptionGroupFormat() override;
 
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   uint32_t option_idx,
+                   const char *option_value) override;
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
-    
     lldb::Format
     GetFormat () const
     {

     }
 
 protected:
-
     bool
     ParserGDBFormatLetter (CommandInterpreter &interpreter,
                            char format_letter,

     OptionValueUInt64 m_count;
     char m_prev_gdb_format;
     char m_prev_gdb_size;
-    
     bool m_has_gdb_format;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupFormat_h_
+#endif // liblldb_OptionGroupFormat_h_

include/lldb/Interpreter/OptionGroupOutputFile.h

 class OptionGroupOutputFile : public OptionGroup
 {
 public:
-    
     OptionGroupOutputFile ();
     
-    virtual
-    ~OptionGroupOutputFile ();
+    ~OptionGroupOutputFile() override;
 
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   uint32_t option_idx,
+                   const char *option_value) override;
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
-    
     const OptionValueFileSpec &
     GetFile ()
     {

 protected:
     OptionValueFileSpec m_file;
     OptionValueBoolean m_append;
-    
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupOutputFile_h_
+#endif // liblldb_OptionGroupOutputFile_h_

include/lldb/Interpreter/OptionGroupPlatform.h

 class OptionGroupPlatform : public OptionGroup
 {
 public:
-    
     OptionGroupPlatform (bool include_platform_option) :
         OptionGroup(),
         m_platform_name (),

     {
     }
 
-    virtual
-    ~OptionGroupPlatform ()
-    {
-    }
+    ~OptionGroupPlatform() override = default;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   const char *option_value) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
     lldb::PlatformSP 
     CreatePlatformWithOptions (CommandInterpreter &interpreter,

 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupPlatform_h_
+#endif // liblldb_OptionGroupPlatform_h_

include/lldb/Interpreter/OptionGroupString.h

     class OptionGroupString : public OptionGroup
     {
     public:
-        
         OptionGroupString (uint32_t usage_mask,
                            bool required,
                            const char *long_option, 

                            const char *usage_text,
                            const char *default_value);
         
-        virtual
-        ~OptionGroupString ();
-        
-        
-        virtual uint32_t
-        GetNumDefinitions ()
+        ~OptionGroupString() override;
+
+        uint32_t
+        GetNumDefinitions() override
         {
             return 1;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions() override
         {
             return &m_option_definition;
         }
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       const char *option_value) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         OptionValueString &
         GetOptionValue ()

     protected:
         OptionValueString m_value;
         OptionDefinition m_option_definition;
-        
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupString_h_
+#endif // liblldb_OptionGroupString_h_

include/lldb/Interpreter/OptionGroupUInt64.h

 #include "lldb/Interpreter/OptionValueUInt64.h"
 
 namespace lldb_private {
+
     //-------------------------------------------------------------------------
     // OptionGroupUInt64
     //-------------------------------------------------------------------------

     class OptionGroupUInt64 : public OptionGroup
     {
     public:
-        
         OptionGroupUInt64 (uint32_t usage_mask,
                            bool required,
                            const char *long_option, 

                            const char *usage_text,
                            uint64_t default_value);
         
-        virtual
-        ~OptionGroupUInt64 ();
-        
-        
-        virtual uint32_t
-        GetNumDefinitions ()
+        ~OptionGroupUInt64() override;
+
+        uint32_t
+        GetNumDefinitions() override
         {
             return 1;
         }
         
-        virtual const OptionDefinition*
-        GetDefinitions ()
+        const OptionDefinition*
+        GetDefinitions() override
         {
             return &m_option_definition;
         }
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       const char *option_value) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         OptionValueUInt64 &
         GetOptionValue ()

     protected:
         OptionValueUInt64 m_value;
         OptionDefinition m_option_definition;
-        
     };
     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupUInt64_h_
+#endif // liblldb_OptionGroupUInt64_h_

include/lldb/Interpreter/OptionGroupUUID.h

 #include "lldb/Interpreter/OptionValueUUID.h"
 
 namespace lldb_private {
+
 //-------------------------------------------------------------------------
 // OptionGroupUUID
 //-------------------------------------------------------------------------

 class OptionGroupUUID : public OptionGroup
 {
 public:
-    
     OptionGroupUUID ();
     
-    virtual
-    ~OptionGroupUUID ();
+    ~OptionGroupUUID() override;
 
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   uint32_t option_idx,
+                   const char *option_value) override;
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
-    
     const OptionValueUUID &
     GetOptionValue () const
     {

 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupUUID_h_
+#endif // liblldb_OptionGroupUUID_h_

include/lldb/Interpreter/OptionGroupValueObjectDisplay.h

 class OptionGroupValueObjectDisplay : public OptionGroup
 {
 public:
-    
     OptionGroupValueObjectDisplay ();
     
-    virtual
-    ~OptionGroupValueObjectDisplay ();
+    ~OptionGroupValueObjectDisplay() override;
 
+    uint32_t
+    GetNumDefinitions() override;
     
-    virtual uint32_t
-    GetNumDefinitions ();
+    const OptionDefinition*
+    GetDefinitions() override;
     
-    virtual const OptionDefinition*
-    GetDefinitions ();
+    Error
+    SetOptionValue(CommandInterpreter &interpreter,
+                   uint32_t option_idx,
+                   const char *option_value) override;
     
-    virtual Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value);
+    void
+    OptionParsingStarting(CommandInterpreter &interpreter) override;
     
-    virtual void
-    OptionParsingStarting (CommandInterpreter &interpreter);
-    
     bool
     AnyOptionWasSet () const
     {
-        return show_types == true ||
-               no_summary_depth  != 0 ||
-               show_location == true ||
-               flat_output == true ||
-               use_objc == true ||
+        return show_types ||
+               no_summary_depth != 0 ||
+               show_location ||
+               flat_output ||
+               use_objc ||
                max_depth != UINT32_MAX ||
                ptr_depth != 0 ||
-               use_synth == false ||
-               be_raw == true ||
-               ignore_cap == true ||
-               run_validator == true;
+               !use_synth ||
+               be_raw ||
+               ignore_cap ||
+               run_validator;
     }
     
     DumpValueObjectOptions

 
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupValueObjectDisplay_h_
+#endif // liblldb_OptionGroupValueObjectDisplay_h_

include/lldb/Interpreter/OptionGroupVariable.h

     class OptionGroupVariable : public OptionGroup
     {
     public:
-        
         OptionGroupVariable (bool show_frame_options);
 
-        virtual
-        ~OptionGroupVariable ();
+        ~OptionGroupVariable() override;
+
+        uint32_t
+        GetNumDefinitions() override;
         
-        virtual uint32_t
-        GetNumDefinitions ();
+        const OptionDefinition*
+        GetDefinitions() override;
         
-        virtual const OptionDefinition*
-        GetDefinitions ();
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       uint32_t option_idx,
+                       const char *option_arg) override;
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx, 
-                        const char *option_arg);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
-        
         bool include_frame_options:1,
              show_args:1,       // Frame option only (include_frame_options == true)
              show_locals:1,     // Frame option only (include_frame_options == true)

     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupVariable_h_
+#endif // liblldb_OptionGroupVariable_h_

include/lldb/Interpreter/OptionGroupWatchpoint.h

     class OptionGroupWatchpoint : public OptionGroup
     {
     public:
-        
+        OptionGroupWatchpoint ();
+
+        ~OptionGroupWatchpoint() override;
+
         static bool
         IsWatchSizeSupported(uint32_t watch_size);
 
-        OptionGroupWatchpoint ();
-
-        virtual
-        ~OptionGroupWatchpoint ();
+        uint32_t
+        GetNumDefinitions() override;
         
-        virtual uint32_t
-        GetNumDefinitions ();
+        const OptionDefinition*
+        GetDefinitions() override;
         
-        virtual const OptionDefinition*
-        GetDefinitions ();
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+                       uint32_t option_idx,
+                       const char *option_arg) override;
         
-        virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx, 
-                        const char *option_arg);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
-        
         // Note:
         // eWatchRead == LLDB_WATCH_TYPE_READ; and
         // eWatchWrite == LLDB_WATCH_TYPE_WRITE

     
 } // namespace lldb_private
 
-#endif  // liblldb_OptionGroupWatchpoint_h_
+#endif // liblldb_OptionGroupWatchpoint_h_

include/lldb/Interpreter/Options.h

 #define liblldb_Options_h_
 
 // C Includes
-
 // C++ Includes
 #include <set>
 #include <vector>

       return isprint(ch);
   }
 
-
 //----------------------------------------------------------------------
 /// @class Options Options.h "lldb/Interpreter/Options.h"
 /// @brief A command line option parsing protocol class.

 class Options
 {
 public:
-
     Options (CommandInterpreter &interpreter);
 
     virtual

     // Verify that the options given are in the options table and can 
     // be used together, but there may be some required options that are
     // missing (used to verify options that get folded into command aliases).
-
     bool
     VerifyPartialOptions (CommandReturnObject &result);
 

     class OptionGroup
     {
     public:
-        OptionGroup () 
-        {
-        }
-        
+        OptionGroup() = default;
+
         virtual 
-        ~OptionGroup () 
-        {
-        }
-        
+        ~OptionGroup() = default;
+
         virtual uint32_t
         GetNumDefinitions () = 0;
 

     class OptionGroupOptions : public Options
     {
     public:
-        
         OptionGroupOptions (CommandInterpreter &interpreter) :
             Options (interpreter),
             m_option_defs (),

         {
         }
         
-        virtual
-        ~OptionGroupOptions ()
-        {
-        }
-        
-        
+        ~OptionGroupOptions() override = default;
+
         //----------------------------------------------------------------------
         /// Append options from a OptionGroup class.
         ///

             return m_did_finalize;
         }
         
-        virtual Error
-        SetOptionValue (uint32_t option_idx, 
-                        const char *option_arg);
+        Error
+        SetOptionValue(uint32_t option_idx, 
+                       const char *option_arg) override;
         
-        virtual void
-        OptionParsingStarting ();
+        void
+        OptionParsingStarting() override;
         
-        virtual Error
-        OptionParsingFinished ();
+        Error
+        OptionParsingFinished() override;
         
         const OptionDefinition*
-        GetDefinitions ()
+        GetDefinitions() override
         {
             assert (m_did_finalize);
             return &m_option_defs[0];

         OptionInfos m_option_infos;
         bool m_did_finalize;
     };
-    
 
 } // namespace lldb_private
 
-#endif  // liblldb_Options_h_
+#endif // liblldb_Options_h_

include/lldb/Interpreter/ScriptInterpreter.h

 #ifndef liblldb_ScriptInterpreter_h_
 #define liblldb_ScriptInterpreter_h_
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "lldb/lldb-private.h"
 
 #include "lldb/Core/Broadcaster.h"

 
 #include "lldb/Utility/PseudoTerminal.h"
 
-
 namespace lldb_private {
     
 class ScriptInterpreterLocker
 {
 public:
     
-    ScriptInterpreterLocker ()
-    {
-    }
+    ScriptInterpreterLocker() = default;
     
-    virtual ~ScriptInterpreterLocker ()
-    {
-    }
+    virtual ~ScriptInterpreterLocker() = default;
+
 private:
     DISALLOW_COPY_AND_ASSIGN (ScriptInterpreterLocker);
 };

 class ScriptInterpreter : public PluginInterface
 {
 public:
-
     typedef enum
     {
         eScriptReturnTypeCharPtr,

     
     ScriptInterpreter (CommandInterpreter &interpreter, lldb::ScriptLanguage script_lang);
 
-    virtual ~ScriptInterpreter ();
+    ~ScriptInterpreter() override;
 
     struct ExecuteScriptOptions
     {

     SetBreakpointCommandCallbackFunction (BreakpointOptions *bp_options,
                                   const char *function_name)
     {
-        return;
     }
     
     /// Set a one-liner as the callback for the watchpoint.

     SetWatchpointCommandCallback (WatchpointOptions *wp_options,
                                   const char *oneliner)
     {
-        return;
     }
 
     virtual bool

     virtual bool
     GetDocumentationForItem (const char* item, std::string& dest)
     {
-    dest.clear();
+        dest.clear();
         return false;
     }
     

     int
     GetMasterFileDescriptor ();
 
-  CommandInterpreter &
-  GetCommandInterpreter ();
+    CommandInterpreter &
+    GetCommandInterpreter();
 
     static std::string
     LanguageToString (lldb::ScriptLanguage language);

 
 } // namespace lldb_private
 
-#endif // #ifndef liblldb_ScriptInterpreter_h_
+#endif // liblldb_ScriptInterpreter_h_