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

[Eugene.Zelenko]

Summary

Also fixed similar problem in source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h to fix Clang warnings appeared with LLVM_ENABLE_WARNINGS.

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]

Committed as r245275. Note that some changes did not apply cleanly anymore. I have committed only the subset which did.

lldb/trunk/include/lldb/Core/ConnectionSharedMemory.h

 
 class ConnectionSharedMemory :
     public Connection
 {
 public:
 
     ConnectionSharedMemory ();
 
-    virtual
-    ~ConnectionSharedMemory ();
+    ~ConnectionSharedMemory () override;
 
-    virtual bool
-    IsConnected () const;
+    bool
+    IsConnected () const override;
 
     virtual lldb::ConnectionStatus
     BytesAvailable (uint32_t timeout_usec, Error *error_ptr);
 
-    virtual lldb::ConnectionStatus
-    Connect (const char *s, Error *error_ptr);
+    lldb::ConnectionStatus
+    Connect (const char *s, Error *error_ptr) override;
 
-    virtual lldb::ConnectionStatus
-    Disconnect (Error *error_ptr);
+    lldb::ConnectionStatus
+    Disconnect (Error *error_ptr) override;
 
-    virtual size_t
+    size_t
     Read (void *dst, 
           size_t dst_len, 
           uint32_t timeout_usec,
           lldb::ConnectionStatus &status, 
-          Error *error_ptr);
+          Error *error_ptr) override;
 
-    virtual size_t
-    Write (const void *src, size_t src_len, lldb::ConnectionStatus &status, Error *error_ptr);
+    size_t
+    Write (const void *src, size_t src_len, lldb::ConnectionStatus &status, Error *error_ptr) override;
 
-    virtual std::string
-    GetURI();
+    std::string
+    GetURI() override;
 
     lldb::ConnectionStatus
     Open (bool create, const char *name, size_t size, Error *error_ptr);
 
 protected:
 
     std::string m_name;
     int m_fd;    // One buffer that contains all we need
     DataBufferMemoryMap m_mmap;
+
 private:
+
     DISALLOW_COPY_AND_ASSIGN (ConnectionSharedMemory);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ConnectionSharedMemory_h_
+#endif // liblldb_ConnectionSharedMemory_h_

lldb/trunk/include/lldb/Core/DataBufferHeap.h

 //===-- DataBufferHeap.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_DataBufferHeap_h_
 #define liblldb_DataBufferHeap_h_
-#if defined(__cplusplus)
 
 #include <vector>
 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/DataBuffer.h"
 
 namespace lldb_private {
 
public:
     DataBufferHeap (const void *src, lldb::offset_t src_len);
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// Virtual destructor since this class inherits from a pure virtual
     /// base class #DataBuffer.
     //------------------------------------------------------------------
-    virtual
-    ~DataBufferHeap();
+    ~DataBufferHeap() override;
 
     //------------------------------------------------------------------
     /// @copydoc DataBuffer::GetBytes()
     //------------------------------------------------------------------
-    virtual uint8_t *
-    GetBytes ();
+    uint8_t *
+    GetBytes () override;
 
     //------------------------------------------------------------------
     /// @copydoc DataBuffer::GetBytes() const
     //------------------------------------------------------------------
-    virtual const uint8_t *
-    GetBytes () const;
+    const uint8_t *
+    GetBytes () const override;
 
     //------------------------------------------------------------------
     /// @copydoc DataBuffer::GetByteSize() const
     //------------------------------------------------------------------
-    virtual lldb::offset_t
-    GetByteSize () const;
+    lldb::offset_t
+    GetByteSize () const override;
 
     //------------------------------------------------------------------
     /// Set the number of bytes in the data buffer.
     ///
     /// Sets the number of bytes that this object should be able to
     /// contain. This can be used prior to copying data into the buffer.
     ///
     /// @param[in] byte_size
private:
     // takes care of free the data when the object is deleted.
     //------------------------------------------------------------------
     typedef std::vector<uint8_t> buffer_t; ///< Buffer type
     buffer_t m_data; ///< The heap based buffer where data is stored
 };
 
 } // namespace lldb_private
 
-#endif  // #if defined(__cplusplus)
-#endif  // liblldb_DataBufferHeap_h_
+#endif // liblldb_DataBufferHeap_h_

lldb/trunk/include/lldb/Core/DataBufferMemoryMap.h

 //===-- DataBufferMemoryMap.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_DataBufferMemoryMap_h_
 #define liblldb_DataBufferMemoryMap_h_
-#if defined(__cplusplus)
-
 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/Error.h"
 #include <string>
 
 namespace lldb_private {
 
public:
     DataBufferMemoryMap ();
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// Virtual destructor since this class inherits from a pure virtual
     /// base class #DataBuffer.
     //------------------------------------------------------------------
-    virtual
-    ~DataBufferMemoryMap ();
+    ~DataBufferMemoryMap () override;
 
     //------------------------------------------------------------------
     /// Reverts this object to an empty state by unmapping any memory
     /// that is currently owned.
     //------------------------------------------------------------------
     void
     Clear ();
 
     //------------------------------------------------------------------
     /// @copydoc DataBuffer::GetBytes()
     //------------------------------------------------------------------
-    virtual uint8_t *
-    GetBytes ();
+    uint8_t *
+    GetBytes () override;
 
     //------------------------------------------------------------------
     /// @copydoc DataBuffer::GetBytes() const
     //------------------------------------------------------------------
-    virtual const uint8_t *
-    GetBytes () const;
+    const uint8_t *
+    GetBytes () const override;
 
     //------------------------------------------------------------------
     /// @copydoc DataBuffer::GetByteSize() const
     //------------------------------------------------------------------
-    virtual lldb::offset_t
-    GetByteSize () const;
+    lldb::offset_t
+    GetByteSize () const override;
 
     //------------------------------------------------------------------
     /// Error get accessor.
     ///
     /// @return
     ///     A const reference to Error object in case memory mapping
     ///     fails.
     //------------------------------------------------------------------
protected:
     lldb::offset_t m_size;  ///< The size of the data the user got when data was requested
 
 private:
     DISALLOW_COPY_AND_ASSIGN (DataBufferMemoryMap);
 };
 
 } // namespace lldb_private
 
-#endif  // #if defined(__cplusplus)
-#endif  // liblldb_DataBufferMemoryMap_h_
+#endif // liblldb_DataBufferMemoryMap_h_

lldb/trunk/include/lldb/Core/StructuredData.h

public:
     class Array : public Object
     {
     public:
         Array () :
             Object (Type::eTypeArray)
         {
         }
 
-        virtual
-        ~Array()
+        ~Array() override
         {
         }
 
         bool
         ForEach (std::function <bool(Object* object)> const &foreach_callback) const
         {
             for (const auto &object_sp : m_items)
             {
                 if (foreach_callback(object_sp.get()) == false)
                     return false;
             }
             return true;
         }
 
-
         size_t
         GetSize() const
         {
             return m_items.size();
         }
 
         ObjectSP
         operator[](size_t idx)
public:
 
         void Dump(Stream &s) const override;
 
     protected:
         typedef std::vector<ObjectSP> collection;
         collection m_items;
     };
 
-
-    class Integer  : public Object
+    class Integer : public Object
     {
     public:
         Integer (uint64_t i = 0) :
             Object (Type::eTypeInteger),
             m_value (i)
         {
         }
 
-        virtual ~Integer()
+        ~Integer() override
         {
         }
 
         void
         SetValue (uint64_t value)
         {
             m_value = value;
         }
 
         uint64_t
         GetValue ()
         {
             return m_value;
         }
 
         void Dump(Stream &s) const override;
 
     protected:
         uint64_t m_value;
     };
 
-    class Float  : public Object
+    class Float : public Object
     {
     public:
         Float (double d = 0.0) :
             Object (Type::eTypeFloat),
             m_value (d)
         {
         }
 
-        virtual ~Float()
+        ~Float() override
         {
         }
 
         void
         SetValue (double value)
         {
             m_value = value;
         }
 
         double
         GetValue ()
         {
             return m_value;
         }
 
         void Dump(Stream &s) const override;
 
     protected:
         double m_value;
     };
 
-    class Boolean  : public Object
+    class Boolean : public Object
     {
     public:
         Boolean (bool b = false) :
             Object (Type::eTypeBoolean),
             m_value (b)
         {
         }
 
-        virtual ~Boolean()
+        ~Boolean() override
         {
         }
 
         void
         SetValue (bool value)
         {
             m_value = value;
         }
 
         bool
         GetValue ()
         {
             return m_value;
         }
 
         void Dump(Stream &s) const override;
 
     protected:
         bool m_value;
     };
 
-
-
-    class String  : public Object
+    class String : public Object
     {
     public:
         String (const char *cstr = NULL) :
             Object (Type::eTypeString),
             m_value ()
         {
             if (cstr)
                 m_value = cstr;
public:
     public:
 
         Dictionary () :
             Object (Type::eTypeDictionary),
             m_dict ()
         {
         }
 
-        virtual ~Dictionary()
+        ~Dictionary() override
         {
         }
 
         size_t
         GetSize() const
         {
             return m_dict.size();
         }
public:
     class Null : public Object
     {
     public:
         Null () :
             Object (Type::eTypeNull)
         {
         }
 
-        virtual ~Null()
+        ~Null() override
         {
         }
 
         bool
         IsValid() const override
         {
             return false;
         }
class Generic : public Object
         void Dump(Stream &s) const override;
 
       private:
         void *m_object;
     };
 
     static ObjectSP
     ParseJSON (std::string json_text);
-
 };  // class StructuredData
 
-
 } // namespace lldb_private
 
-#endif  // liblldb_StructuredData_h_
+#endif // liblldb_StructuredData_h_

lldb/trunk/include/lldb/Core/ValueObjectCast.h

 class ValueObjectCast : public ValueObject
 {
 public:
     static lldb::ValueObjectSP
     Create (ValueObject &parent, 
             const ConstString &name, 
             const CompilerType &cast_type);
 
-    virtual
-    ~ValueObjectCast();
+    ~ValueObjectCast() override;
     
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
     
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
     
-    virtual lldb::ValueType
-    GetValueType() const;
+    lldb::ValueType
+    GetValueType() const override;
     
-    virtual bool
-    IsInScope ();
+    bool
+    IsInScope() override;
     
-    virtual ValueObject *
-    GetParent()
+    ValueObject *
+    GetParent() override
     {
         if (m_parent)
             return m_parent->GetParent();
         else
             return NULL;
     }
     
-    virtual const ValueObject *
-    GetParent() const
+    const ValueObject *
+    GetParent() const override
     {
         if (m_parent)
             return m_parent->GetParent();
         else
             return NULL;
     }
     
 protected:
private:
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectCast);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectCast_h_
+#endif // liblldb_ValueObjectCast_h_

lldb/trunk/include/lldb/Core/ValueObjectChild.h

ValueObjectChild (ValueObject &parent,
                       bool is_deref_of_parent,
                       AddressType child_ptr_or_ref_addr_type);
 
     DISALLOW_COPY_AND_ASSIGN (ValueObjectChild);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectChild_h_
+#endif // liblldb_ValueObjectChild_h_

lldb/trunk/include/lldb/Core/ValueObjectConstResult.h

private:
     ValueObjectConstResult (ExecutionContextScope *exe_scope,
                             const Error& error);
 
     DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResult);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectConstResult_h_
+#endif // liblldb_ValueObjectConstResult_h_

lldb/trunk/include/lldb/Core/ValueObjectConstResultCast.h

 {
 public:
     ValueObjectConstResultCast (
         ValueObject &parent,
         const ConstString &name,
         const CompilerType &cast_type,
         lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
 
-    virtual
-    ~ValueObjectConstResultCast ();
+    ~ValueObjectConstResultCast() override;
 
-    virtual lldb::ValueObjectSP
-    Dereference (Error &error);
+    lldb::ValueObjectSP
+    Dereference(Error &error) override;
 
-    virtual ValueObject *
-    CreateChildAtIndex (size_t idx,
-                        bool synthetic_array_member,
-                        int32_t synthetic_index);
+    ValueObject *
+    CreateChildAtIndex(size_t idx,
+           bool synthetic_array_member,
+           int32_t synthetic_index) override;
 
     virtual CompilerType
     GetClangType ()
     {
         return ValueObjectCast::GetClangType();
     }
 
     virtual lldb::ValueObjectSP

lldb/trunk/include/lldb/Core/ValueObjectConstResultChild.h

ValueObjectConstResultChild (ValueObject &parent,
                                  uint32_t byte_size,
                                  int32_t byte_offset,
                                  uint32_t bitfield_bit_size,
                                  uint32_t bitfield_bit_offset,
                                  bool is_base_class,
                                  bool is_deref_of_parent,
                                  lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
     
-    virtual ~ValueObjectConstResultChild();
+    ~ValueObjectConstResultChild() override;
     
-    virtual lldb::ValueObjectSP
-    Dereference (Error &error);
+    lldb::ValueObjectSP
+    Dereference(Error &error) override;
     
-    virtual ValueObject *
-    CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
+    ValueObject *
+    CreateChildAtIndex(size_t idx, bool synthetic_array_member, int32_t synthetic_index) override;
 
     virtual CompilerType
     GetClangType ()
     {
         return ValueObjectChild::GetClangType();
     }
     
     virtual lldb::ValueObjectSP
private:
     friend class ValueObjectConstResult;
     friend class ValueObjectConstResultImpl;
 
     DISALLOW_COPY_AND_ASSIGN (ValueObjectConstResultChild);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectConstResultChild_h_
+#endif // liblldb_ValueObjectConstResultChild_h_

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

public:
     typedef void*           (*SWIGPython_GetDynamicSetting)     (void* module,
                                                                  const char* setting,
                                                                  const lldb::TargetSP& target_sp);
 
     friend class ::IOHandlerPythonInterpreter;
 
     ScriptInterpreterPython (CommandInterpreter &interpreter);
 
-    ~ScriptInterpreterPython ();
+    ~ScriptInterpreterPython() override;
 
     bool
     Interrupt() override;
 
     bool
     ExecuteOneLine (const char *command,
                     CommandReturnObject *result,
                     const ExecuteScriptOptions &options = ExecuteScriptOptions()) override;
public:
         
         Locker (ScriptInterpreterPython *py_interpreter = NULL,
                 uint16_t on_entry = AcquireLock | InitSession,
                 uint16_t on_leave = FreeLock | TearDownSession,
                 FILE *in = NULL,
                 FILE *out = NULL,
                 FILE *err = NULL);
         
-      ~Locker ();
+        ~Locker () override;
 
   private:
         
         bool
         DoAcquireLock ();
         
         bool
         DoInitSession (uint16_t on_entry_flags, FILE *in, FILE *out, FILE *err);
protected:
     bool m_session_is_active;
     bool m_pty_slave_is_open;
     bool m_valid_session;
     uint32_t m_lock_count;
     PyThreadState *m_command_thread_state;
 };
 } // namespace lldb_private
 
-#endif // #ifdef LLDB_DISABLE_PYTHON
+#endif // LLDB_DISABLE_PYTHON
 
-#endif // #ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H
+#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTINTERPRETERPYTHON_H