[LLDB] Fix Clang-tidy misc-use-override warnings in remaining files in include/lldb/Interpreter, unify closing inclusion guards, formatting

[Eugene.Zelenko]

Summary

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.

[brucem]

Same issue here with whitespace and needing to be rebased forward.

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,

                          bool &word_complete,
                          lldb_private::StringList &matches);
 
-    
     static int
     ArchitectureNames (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,
+           SymbolContext &context,
+           Address *addr,
+           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);
     };

                              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,
+           SymbolContext &context,
+           Address *addr,
+           bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
         bool m_include_support_files;

                          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,
+           SymbolContext &context,
+           Address *addr,
+           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);
-
     };
 
     //----------------------------------------------------------------------

                          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,
+           SymbolContext &context,
+           Address *addr,
+           bool complete) override;
 
         size_t
-        DoCompletion (SearchFilter *filter);
+        DoCompletion(SearchFilter *filter) override;
 
     private:
 //        struct NameCmp {

         typedef std::set<ConstString> collection;
         collection m_match_set;
         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:
 
-
     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,

                              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

     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

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

     // to the specified command argument entry.
     static void
     AddIDsArgumentData(CommandArgumentEntry &arg, lldb::CommandArgumentType ID, lldb::CommandArgumentType IDRange);
-    
 };
 
 class CommandObjectParsed : public CommandObject

                          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

                          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,
+        const char *search_word,
+        StringList &commands_found,
+        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,
+         int &cursor_index,
+         int &cursor_char_position,
+         int match_start_point,
+         int max_return_elements,
+         bool &word_complete,
+         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)

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

                         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,
+        const char *search_word,
+        StringList &commands_found,
+        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,
+         int &cursor_index,
+         int &cursor_char_position,
+         int match_start_point,
+         int max_return_elements,
+         bool &word_complete,
+         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,
+           int &cursor_index,
+           int &cursor_char_position,
+           OptionElementVector &opt_element_vector,
+           int match_start_point,
+           int max_return_elements,
+           bool &word_complete,
+           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

                                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

 
 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 ();
+        ~OptionGroupBoolean() 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,
+           uint32_t option_idx,
+           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

                      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,
+       uint32_t option_idx,
+       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,
+       uint32_t option_idx,
+       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
     {

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

include/lldb/Interpreter/OptionGroupOutputFile.h

     
     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

     {
     }
 
-    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,
+       uint32_t option_idx,
+       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

                            const char *usage_text,
                            const char *default_value);
         
-        virtual
-        ~OptionGroupString ();
+        ~OptionGroupString() 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,
+           uint32_t option_idx,
+           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

                            const char *usage_text,
                            uint64_t default_value);
         
-        virtual
-        ~OptionGroupUInt64 ();
+        ~OptionGroupUInt64() 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,
+           uint32_t option_idx,
+           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

     
     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

     
     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
     {

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

include/lldb/Interpreter/OptionGroupVariable.h

         
         OptionGroupVariable (bool show_frame_options);
 
-        virtual
-        ~OptionGroupVariable ();
+        ~OptionGroupVariable() override;
         
-        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_arg);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+           uint32_t option_idx,
+           const char *option_arg) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         bool include_frame_options:1,
              show_args:1,       // Frame option only (include_frame_options == true)

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

include/lldb/Interpreter/OptionGroupWatchpoint.h

 
         OptionGroupWatchpoint ();
 
-        virtual
-        ~OptionGroupWatchpoint ();
+        ~OptionGroupWatchpoint() override;
         
-        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_arg);
+        Error
+        SetOptionValue(CommandInterpreter &interpreter,
+           uint32_t option_idx,
+           const char *option_arg) override;
         
-        virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter);
+        void
+        OptionParsingStarting(CommandInterpreter &interpreter) override;
         
         // Note:
         // eWatchRead == LLDB_WATCH_TYPE_READ; and

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

include/lldb/Interpreter/Options.h

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

         {
         }
         
-        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];

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

include/lldb/Interpreter/ScriptInterpreter.h

 
 #include "lldb/Utility/PseudoTerminal.h"
 
-
 namespace lldb_private {
     
 class ScriptInterpreterLocker

     virtual ~ScriptInterpreterLocker ()
     {
     }
+
 private:
     DISALLOW_COPY_AND_ASSIGN (ScriptInterpreterLocker);
 };

     
     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.

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