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

[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.

[labath]

Looks good, committed as r243738.

lldb/trunk/include/lldb/Core/AddressResolver.h

typedef enum
         Exact,
         Regexp,
         Glob
     } MatchType;
 
 
     AddressResolver ();
 
-    virtual
-    ~AddressResolver ();
+    ~AddressResolver () override;
 
     virtual void
     ResolveAddress (SearchFilter &filter);
 
     virtual void
     ResolveAddressInModules (SearchFilter &filter,
                              ModuleList &modules);
 
-    virtual void
-    GetDescription (Stream *s) = 0;
+    void
+    GetDescription (Stream *s) override = 0;
 
     std::vector<AddressRange> &
     GetAddressRanges ();
 
     size_t
     GetNumberOfAddresses ();
 
     AddressRange &
     GetAddressRangeAtIndex (size_t idx);
 
 protected:
 
     std::vector<AddressRange> m_address_ranges;
 
 private:
     DISALLOW_COPY_AND_ASSIGN(AddressResolver);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_AddressResolver_h_
+#endif // liblldb_AddressResolver_h_

lldb/trunk/include/lldb/Core/AddressResolverFileLine.h

class AddressResolverFileLine :
     public AddressResolver
 {
 public:
 
     AddressResolverFileLine (const FileSpec &resolver,
                              uint32_t line_no,
                              bool check_inlines);
 
-    virtual
-    ~AddressResolverFileLine ();
+    ~AddressResolverFileLine () override;
 
-    virtual Searcher::CallbackReturn
+    Searcher::CallbackReturn
     SearchCallback (SearchFilter &filter,
                     SymbolContext &context,
                     Address *addr,
-                    bool containing);
+                    bool containing) override;
 
-    virtual Searcher::Depth
-    GetDepth ();
+    Searcher::Depth
+    GetDepth () override;
 
-    virtual void
-    GetDescription (Stream *s);
+    void
+    GetDescription (Stream *s) override;
 
 protected:
     FileSpec m_file_spec; // This is the file spec we are looking for.
     uint32_t m_line_number; // This is the line number that we are looking for.
     bool m_inlines; // This determines whether the resolver looks for inlined functions or not.
 
 private:
     DISALLOW_COPY_AND_ASSIGN(AddressResolverFileLine);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_AddressResolverFileLine_h_
+#endif // liblldb_AddressResolverFileLine_h_

lldb/trunk/include/lldb/Core/AddressResolverName.h

public:
 
     // Creates a function breakpoint by regular expression.  Takes over control of the lifespan of func_regex.
     AddressResolverName (RegularExpression &func_regex);
 
     AddressResolverName (const char *class_name,
                          const char *method,
                          AddressResolver::MatchType type);
 
-    virtual
-    ~AddressResolverName ();
+    ~AddressResolverName () override;
 
-    virtual Searcher::CallbackReturn
+    Searcher::CallbackReturn
     SearchCallback (SearchFilter &filter,
                     SymbolContext &context,
                     Address *addr,
-                    bool containing);
+                    bool containing) override;
 
-    virtual Searcher::Depth
-    GetDepth ();
+    Searcher::Depth
+    GetDepth () override;
 
-    virtual void
-    GetDescription (Stream *s);
+    void
+    GetDescription (Stream *s) override;
 
 protected:
     ConstString m_func_name;
     ConstString m_class_name;  // FIXME: Not used yet.  The idea would be to stop on methods of this class.
     RegularExpression m_regex;
     AddressResolver::MatchType m_match_type;
 
 private:
     DISALLOW_COPY_AND_ASSIGN(AddressResolverName);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_AddressResolverName_h_
+#endif // liblldb_AddressResolverName_h_

lldb/trunk/include/lldb/Core/Event.h

 
 private:
     virtual void
     DoOnRemoval (Event *event_ptr)
     {
     }
 
     DISALLOW_COPY_AND_ASSIGN (EventData);
-
 };
 
 //----------------------------------------------------------------------
 // lldb::EventDataBytes
 //----------------------------------------------------------------------
 class EventDataBytes : public EventData
 {
 public:
     //------------------------------------------------------------------
     // Constructors
     //------------------------------------------------------------------
     EventDataBytes ();
 
     EventDataBytes (const char *cstr);
 
     EventDataBytes (const void *src, size_t src_len);
 
-    virtual
-    ~EventDataBytes();
+    ~EventDataBytes() override;
 
     //------------------------------------------------------------------
     // Member functions
     //------------------------------------------------------------------
-    virtual const ConstString &
-    GetFlavor () const;
+    const ConstString &
+    GetFlavor () const override;
 
-    virtual void
-    Dump (Stream *s) const;
+    void
+    Dump (Stream *s) const override;
 
     const void *
     GetBytes() const;
 
     size_t
     GetByteSize() const;
 
     void
public:
 
     static const ConstString &
     GetFlavorString ();
 
 private:
     std::string m_bytes;
 
     DISALLOW_COPY_AND_ASSIGN (EventDataBytes);
-
 };
 
 //----------------------------------------------------------------------
 // lldb::Event
 //----------------------------------------------------------------------
 class Event
 {
     friend class Broadcaster;
public:
     }
 
     void
     Clear()
     {
         m_data_ap.reset();
     }
 
-
 private:
     // This is only called by Listener when it pops an event off the queue for
     // the listener.  It calls the Event Data's DoOnRemoval() method, which is
     // virtual and can be overridden by the specific data classes.
 
     void
     DoOnRemoval ();
 
private:
 
 
     DISALLOW_COPY_AND_ASSIGN (Event);
     Event();    // Disallow default constructor
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_Event_h_
+#endif // liblldb_Event_h_

lldb/trunk/include/lldb/Core/FileLineResolver.h

FileLineResolver () :
         m_inlines (true)
     {
     }
         
     FileLineResolver (const FileSpec &resolver,
                       uint32_t line_no,
                       bool check_inlines);
 
-    virtual
-    ~FileLineResolver ();
+    ~FileLineResolver () override;
 
-    virtual Searcher::CallbackReturn
+    Searcher::CallbackReturn
     SearchCallback (SearchFilter &filter,
                     SymbolContext &context,
                     Address *addr,
-                    bool containing);
+                    bool containing) override;
 
-    virtual Searcher::Depth
-    GetDepth ();
+    Searcher::Depth
+    GetDepth () override;
 
-    virtual void
-    GetDescription (Stream *s);
+    void
+    GetDescription (Stream *s) override;
 
     const SymbolContextList &
     GetFileLineMatches()
     {
         return m_sc_list;
     }
 
     void
protected:
     bool m_inlines; // This determines whether the resolver looks for inlined functions or not.
 
 private:
     DISALLOW_COPY_AND_ASSIGN(FileLineResolver);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_FileLineResolver_h_
+#endif // liblldb_FileLineResolver_h_

lldb/trunk/include/lldb/Core/History.h

 
 private:
     typedef std::stack<HistoryEvent> collection;
 
     Mutex m_mutex;
     collection m_events;
     
     DISALLOW_COPY_AND_ASSIGN (HistorySource);
-
 };
     
 //----------------------------------------------------------------------
 /// @class HistorySourceUInt History.h "lldb/Core/History.h"
 /// @brief A class that defines history events that are represented by
 /// unsigned integers.
 ///
 /// Any history event that is defined by a unique monotonically 
 /// increasing unsigned integer
 //----------------------------------------------------------------------
 
 class HistorySourceUInt : public HistorySource
 {
     HistorySourceUInt (const char *id_name, uintptr_t start_value = 0u) :
         HistorySource(),
         m_name (id_name),
         m_curr_id (start_value)
     {
     }
     
-    virtual 
-    ~HistorySourceUInt()
+    ~HistorySourceUInt() override
     {
     }
     
     // Create a new history event. Subclasses should use any data or members
     // in the subclass of this class to produce a history event and push it
     // onto the end of the history stack.
     
-    virtual HistoryEvent
-    CreateHistoryEvent ()
+    HistoryEvent
+    CreateHistoryEvent () override
     {
         ++m_curr_id;
         return (HistoryEvent)m_curr_id;
     }
     
-    virtual void
-    DeleteHistoryEvent (HistoryEvent event)
+    void
+    DeleteHistoryEvent (HistoryEvent event) override
     {
         // Nothing to delete, the event contains the integer
     }
     
-    virtual void
-    DumpHistoryEvent (Stream &strm, HistoryEvent event);
+    void
+    DumpHistoryEvent (Stream &strm, HistoryEvent event) override;
     
-    virtual size_t
-    GetHistoryEventCount()
+    size_t
+    GetHistoryEventCount() override
     {
         return m_curr_id;
     }
     
-    virtual HistoryEvent
-    GetHistoryEventAtIndex (uint32_t idx)
+    HistoryEvent
+    GetHistoryEventAtIndex (uint32_t idx) override
     {
         return (HistoryEvent)((uintptr_t)idx);
     }
     
-    virtual HistoryEvent
-    GetCurrentHistoryEvent ()
+    HistoryEvent
+    GetCurrentHistoryEvent () override
     {
         return (HistoryEvent)m_curr_id;
     }
     
     // Return 0 when lhs == rhs, 1 if lhs > rhs, or -1 if lhs < rhs.
-    virtual int
+    int
     CompareHistoryEvents (const HistoryEvent lhs, 
-                          const HistoryEvent rhs)
+                          const HistoryEvent rhs) override
     {
         uintptr_t lhs_uint = (uintptr_t)lhs;
         uintptr_t rhs_uint = (uintptr_t)rhs;
         if (lhs_uint < rhs_uint)
             return -1;
         if (lhs_uint > rhs_uint)
             return +1;
         return 0;
     }
     
-    virtual bool
-    IsCurrentHistoryEvent (const HistoryEvent event)
+    bool
+    IsCurrentHistoryEvent (const HistoryEvent event) override
     {
         return (uintptr_t)event == m_curr_id;
     }
 
 protected:
     std::string m_name; // The name of the history unsigned integer
     uintptr_t m_curr_id; // The current value of the history unsigned unteger
 };
 
-
 } // namespace lldb_private
 
-#endif  // lldb_History_h_
+#endif // lldb_History_h_

lldb/trunk/include/lldb/Core/StreamAsynchronousIO.h

 namespace lldb_private {
 
 class StreamAsynchronousIO : 
     public Stream
 {
 public:
     StreamAsynchronousIO (Debugger &debugger, bool for_stdout);
     
-    virtual ~StreamAsynchronousIO ();
+    ~StreamAsynchronousIO () override;
     
-    virtual void
-    Flush ();
-    
-    virtual size_t
-    Write (const void *src, size_t src_len);
+    void
+    Flush () override;
     
+    size_t
+    Write (const void *src, size_t src_len) override;
     
 private:
     Debugger &m_debugger;
     std::string m_data;
     bool m_for_stdout;
 };
 
 } // namespace lldb_private
-#endif // #ifndef liblldb_StreamAsynchronousIO_h
+
+#endif // liblldb_StreamAsynchronousIO_h

lldb/trunk/include/lldb/Core/StreamCallback.h

 namespace lldb_private {
 
 class StreamCallback : 
     public Stream
 {
 public:
     StreamCallback (lldb::LogOutputCallback callback, void *baton);
     
-    virtual ~StreamCallback ();
+    ~StreamCallback () override;
     
-    virtual void
-    Flush ();
-    
-    virtual size_t
-    Write (const void *src, size_t src_len);
+    void
+    Flush () override;
     
+    size_t
+    Write (const void *src, size_t src_len) override;
     
 private:
     typedef std::map<lldb::tid_t, StreamString> collection;
     lldb::LogOutputCallback m_callback;
     void *m_baton;
     collection m_accumulated_data;
     Mutex m_collection_mutex;
     
     StreamString &FindStreamForThread(lldb::tid_t cur_tid);
 };
 
 } // namespace lldb_private
-#endif // #ifndef liblldb_StreamCallback_h
+
+#endif // liblldb_StreamCallback_h

lldb/trunk/include/lldb/Core/StreamFile.h

public:
     StreamFile (const char *path);
 
     StreamFile (const char *path,
                 uint32_t options,
                 uint32_t permissions = lldb::eFilePermissionsFileDefault);
 
     StreamFile (FILE *fh, bool transfer_ownership);
 
-    virtual
-    ~StreamFile();
+    ~StreamFile() override;
 
     File &
     GetFile ()
     {
         return m_file;
     }
 
     const File &
     GetFile () const
     {
         return m_file;
     }
 
-    virtual void
-    Flush ();
+    void
+    Flush () override;
 
-    virtual size_t
-    Write (const void *s, size_t length);
+    size_t
+    Write (const void *s, size_t length) override;
 
 protected:
     //------------------------------------------------------------------
     // Classes that inherit from StreamFile can see and modify these
     //------------------------------------------------------------------
     File m_file;
     
 private:
     DISALLOW_COPY_AND_ASSIGN (StreamFile);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_StreamFile_h_
+#endif // liblldb_StreamFile_h_

lldb/trunk/include/lldb/Core/StreamString.h

 {
 public:
     StreamString ();
 
     StreamString (uint32_t flags,
                   uint32_t addr_size,
                   lldb::ByteOrder byte_order);
 
-    virtual
-    ~StreamString ();
+    ~StreamString () override;
 
-    virtual void
-    Flush ();
+    void
+    Flush () override;
 
-    virtual size_t
-    Write (const void *s, size_t length);
+    size_t
+    Write (const void *s, size_t length) override;
 
     void
     Clear();
 
     bool
     Empty() const;
 
     const char *
public:
     const std::string &
     GetString() const;
 
     void
     FillLastLineToColumn (uint32_t column, char fill_char);
 
 protected:
     std::string m_packet;
-
 };
 
 } // namespace lldb_private
-#endif  // #ifndef liblldb_StreamString_h_
+
+#endif // liblldb_StreamString_h_

lldb/trunk/include/lldb/Core/StreamTee.h

StreamTee (const StreamTee &rhs) :
         Stream (rhs),
         m_streams_mutex (Mutex::eMutexTypeRecursive),
         m_streams() // Don't copy until we lock down "rhs"
     {
         Mutex::Locker locker (rhs.m_streams_mutex);
         m_streams = rhs.m_streams;
     }
 
-    virtual
-    ~StreamTee ()
+    ~StreamTee () override
     {
     }
 
     StreamTee &
     operator = (const StreamTee &rhs)
     {
         if (this != &rhs) {
             Stream::operator=(rhs);
             Mutex::Locker lhs_locker (m_streams_mutex);
             Mutex::Locker rhs_locker (rhs.m_streams_mutex);
             m_streams = rhs.m_streams;            
         }
         return *this;
     }
 
-    virtual void
-    Flush ()
+    void
+    Flush () override
     {
         Mutex::Locker locker (m_streams_mutex);
         collection::iterator pos, end;
         for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos)
         {
             // Allow for our collection to contain NULL streams. This allows
             // the StreamTee to be used with hard coded indexes for clients
             // that might want N total streams with only a few that are set
             // to valid values.
             Stream *strm = pos->get();
             if (strm)
                 strm->Flush ();
         }
     }
 
-    virtual size_t
-    Write (const void *s, size_t length)
+    size_t
+    Write (const void *s, size_t length) override
     {
         Mutex::Locker locker (m_streams_mutex);
         if (m_streams.empty())
             return 0;
     
         size_t min_bytes_written = SIZE_MAX;
         collection::iterator pos, end;
         for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos)
SetStreamAtIndex (uint32_t idx, const lldb::StreamSP& stream_sp)
         // as needed. This also allows this class to be used with hard
         // coded indexes that can be used contain many streams, not all
         // of which are valid.
         if (idx >= m_streams.size())
             m_streams.resize(idx + 1);
         m_streams[idx] = stream_sp;
     }
     
-
 protected:
     typedef std::vector<lldb::StreamSP> collection;
     mutable Mutex m_streams_mutex;
     collection m_streams;
 };
 
 } // namespace lldb_private
-#endif  // #ifndef liblldb_StreamTee_h_
+
+#endif // liblldb_StreamTee_h_