[LLDB] Fix Clang-tidy modernize-use-override warnings in source/Plugins/Language; other minor fixes.

[Eugene.Zelenko]

Summary

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

lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

-//===-- CPlusPlusLanguage.h ----------------------------------------*- C++ -*-===//
+//===-- CPlusPlusLanguage.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
protected:
         llvm::StringRef m_context;      // Decl context: "lldb::SBTarget"
         llvm::StringRef m_arguments;    // Arguments:    "(unsigned int)"
         llvm::StringRef m_qualifiers;   // Qualifiers:   "const"
         Type m_type;
         bool m_parsed;
         bool m_parse_error;
     };
 
-    virtual ~CPlusPlusLanguage() = default;
-    
-    CPlusPlusLanguage () = default;
-    
+    CPlusPlusLanguage() = default;
+    ~CPlusPlusLanguage() override = default;
+
     lldb::LanguageType
     GetLanguageType () const override
     {
         return lldb::eLanguageTypeC_plus_plus;
     }
     
     lldb::TypeCategoryImplSP
     GetFormatters () override;
public:
     // in some cases, compilers will output different names for one same type. when that happens, it might be impossible
     // to construct SBType objects for a valid type, because the name that is available is not the same as the name that
     // can be used as a search key in FindTypes(). the equivalents map here is meant to return possible alternative names
     // for a type through which a search can be conducted. Currently, this is only enabled for C++ but can be extended
     // to ObjC or other languages if necessary
     static uint32_t
     FindEquivalentNames(ConstString type_name, std::vector<ConstString>& equivalents);
 
-    
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual ConstString
+    ConstString
     GetPluginName() override;
     
-    virtual uint32_t
+    uint32_t
     GetPluginVersion() override;
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_CPlusPlusLanguage_h_
+#endif // liblldb_CPlusPlusLanguage_h_

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

-//===-- LibCxxInitializerList.cpp ----------------------------------*- C++ -*-===//
+//===-- LibCxxInitializerList.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "LibCxx.h"
 
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace lldb_private {
     namespace formatters {
         class LibcxxInitializerListSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibcxxInitializerListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~LibcxxInitializerListSyntheticFrontEnd() override;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
-            virtual
-            ~LibcxxInitializerListSyntheticFrontEnd ();
         private:
             ValueObject* m_start;
             CompilerType m_element_type;
             uint32_t m_element_size;
             size_t m_num_elements;
             std::map<size_t,lldb::ValueObjectSP> m_children;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::LibcxxInitializerListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd(*valobj_sp.get()),
 m_start(NULL),
 m_element_type(),
 m_element_size(0),
 m_num_elements(0),
 m_children()
 {
     if (valobj_sp)
         Update();
 }
 
+lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::~LibcxxInitializerListSyntheticFrontEnd()
+{
+    // this needs to stay around because it's a child object who will follow its parent's life cycle
+    // delete m_start;
+}
+
 size_t
 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::CalculateNumChildren ()
 {
     static ConstString g___size_("__size_");
     m_num_elements = 0;
     ValueObjectSP size_sp(m_backend.GetChildMemberWithName(g___size_, true));
     if (size_sp)
         m_num_elements = size_sp->GetValueAsUnsigned(0);

 size_t
 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     if (!m_start)
         return UINT32_MAX;
     return ExtractIndexFromString(name.GetCString());
 }
 
-lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::~LibcxxInitializerListSyntheticFrontEnd ()
-{
-    // this needs to stay around because it's a child object who will follow its parent's life cycle
-    // delete m_start;
-}
-
 lldb_private::SyntheticChildrenFrontEnd*
 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 {
     if (!valobj_sp)
         return NULL;
     return (new LibcxxInitializerListSyntheticFrontEnd(valobj_sp));
 }
-

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

-//===-- LibCxxList.cpp -------------------------------------------*- C++ -*-===//
+//===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "LibCxx.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace lldb_private {
     namespace formatters {
         class LibcxxStdListSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~LibcxxStdListSyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
+            
+            bool
+            MightHaveChildren() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
-            virtual
-            ~LibcxxStdListSyntheticFrontEnd ();
         private:
             bool
             HasLoop(size_t);
             
             size_t m_list_capping_size;
             static const bool g_use_loop_detect = true;
             size_t m_loop_detected;
             lldb::addr_t m_node_address;
             ValueObject* m_head;
             ValueObject* m_tail;
             CompilerType m_element_type;
             size_t m_count;
             std::map<size_t,lldb::ValueObjectSP> m_children;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 class ListEntry
 {
 public:
-    ListEntry () {}
+    ListEntry() = default;
     ListEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
     ListEntry (const ListEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
     ListEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
     
     ListEntry
     next ()
     {
         if (!m_entry_sp)

     
 private:
     ValueObjectSP m_entry_sp;
 };
 
 class ListIterator
 {
 public:
-    ListIterator () {}
+    ListIterator() = default;
     ListIterator (ListEntry entry) : m_entry(entry) {}
     ListIterator (ValueObjectSP entry) : m_entry(entry) {}
     ListIterator (const ListIterator& rhs) : m_entry(rhs.m_entry) {}
     ListIterator (ValueObject* entry) : m_entry(entry) {}
 
     ValueObjectSP
     value ()
     {
next ()
         m_entry = m_entry.next();
     }
     
     void
     prev ()
     {
         m_entry = m_entry.prev();
     }
+
 private:
     ListEntry m_entry;
 };
 
 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd(*valobj_sp.get()),
 m_list_capping_size(0),
 m_loop_detected(0),

 }
 
 size_t
 lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     return ExtractIndexFromString(name.GetCString());
 }
 
-lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::~LibcxxStdListSyntheticFrontEnd ()
-{}
-
 SyntheticChildrenFrontEnd*
 lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 {
     if (!valobj_sp)
         return NULL;
     return (new LibcxxStdListSyntheticFrontEnd(valobj_sp));
 }
-

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

-//===-- LibCxxList.cpp -------------------------------------------*- C++ -*-===//
+//===-- LibCxxList.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "LibCxx.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace lldb_private {
     namespace formatters {
         class LibcxxStdMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~LibcxxStdMapSyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
-            virtual
-            ~LibcxxStdMapSyntheticFrontEnd ();
         private:
             bool
             GetDataType();
             
             void
             GetValueOffset (const lldb::ValueObjectSP& node);
             
             ValueObject* m_tree;
             ValueObject* m_root_node;
             CompilerType m_element_type;
             uint32_t m_skip_size;
             size_t m_count;
             std::map<size_t,lldb::ValueObjectSP> m_children;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 class MapEntry
 {
 public:
-    MapEntry () {}
+    MapEntry() = default;
     explicit MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
     MapEntry (const MapEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
     explicit MapEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
     
     ValueObjectSP
     left () const
     {
         static ConstString g_left("__left_");

     
 private:
     ValueObjectSP m_entry_sp;
 };
 
 class MapIterator
 {
 public:
-    MapIterator () {}
+    MapIterator() = default;
     MapIterator (MapEntry entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
     MapIterator (ValueObjectSP entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
     MapIterator (const MapIterator& rhs) : m_entry(rhs.m_entry),m_max_depth(rhs.m_max_depth), m_error(false) {}
     MapIterator (ValueObject* entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
     
     ValueObjectSP
     value ()
     {
advance (size_t count)
             count--, steps++;
             if (m_error ||
                 m_entry.null() ||
                 (steps > m_max_depth))
                 return fail;
         }
         return m_entry.GetEntry();
     }
+
 protected:
     void
     next ()
     {
         if (m_entry.null())
             return;
         MapEntry right(m_entry.right());
         if (right.null() == false)

 }
 
 size_t
 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     return ExtractIndexFromString(name.GetCString());
 }
 
-lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::~LibcxxStdMapSyntheticFrontEnd ()
-{}
-
 SyntheticChildrenFrontEnd*
 lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 {
     if (!valobj_sp)
         return NULL;
     return (new LibcxxStdMapSyntheticFrontEnd(valobj_sp));
 }

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

-//===-- LibCxxUnorderedMap.cpp -----------------------------------*- C++ -*-===//
+//===-- LibCxxUnorderedMap.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "LibCxx.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace lldb_private {
     namespace formatters {
         class LibcxxStdUnorderedMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibcxxStdUnorderedMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~LibcxxStdUnorderedMapSyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
             
-            virtual
-            ~LibcxxStdUnorderedMapSyntheticFrontEnd ();
-        private:
-            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
+        private:
             ValueObject* m_tree;
             size_t m_num_elements;
             ValueObject* m_next_element;
             std::map<size_t,lldb::ValueObjectSP> m_children;
             std::vector<std::pair<ValueObject*, uint64_t> > m_elements_cache;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::LibcxxStdUnorderedMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd(*valobj_sp.get()),
 m_tree(NULL),
 m_num_elements(0),
 m_next_element(nullptr),
 m_children(),
 m_elements_cache()

 }
 
 size_t
 lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     return ExtractIndexFromString(name.GetCString());
 }
 
-lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::~LibcxxStdUnorderedMapSyntheticFrontEnd ()
-{}
-
 SyntheticChildrenFrontEnd*
 lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 {
     if (!valobj_sp)
         return NULL;
     return (new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp));
 }

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

-//===-- LibCxxVector.cpp -----------------------------------------*- C++ -*-===//
+//===-- LibCxxVector.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "LibCxx.h"
 
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace lldb_private {
     namespace formatters {
         class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~LibcxxStdVectorSyntheticFrontEnd() override;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
+            
+            bool
+            MightHaveChildren() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~LibcxxStdVectorSyntheticFrontEnd ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
         private:
             ValueObject* m_start;
             ValueObject* m_finish;
             CompilerType m_element_type;
             uint32_t m_element_size;
             std::map<size_t,lldb::ValueObjectSP> m_children;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd(*valobj_sp.get()),
 m_start(NULL),
 m_finish(NULL),
 m_element_type(),
 m_element_size(0),
 m_children()
 {
     if (valobj_sp)
         Update();
 }
 
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::~LibcxxStdVectorSyntheticFrontEnd()
+{
+    // these need to stay around because they are child objects who will follow their parent's life cycle
+    // delete m_start;
+    // delete m_finish;
+}
+
 size_t
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::CalculateNumChildren ()
 {
     if (!m_start || !m_finish)
         return 0;
     uint64_t start_val = m_start->GetValueAsUnsigned(0);
     uint64_t finish_val = m_finish->GetValueAsUnsigned(0);
     

 size_t
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     if (!m_start || !m_finish)
         return UINT32_MAX;
     return ExtractIndexFromString(name.GetCString());
 }
 
-lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::~LibcxxStdVectorSyntheticFrontEnd ()
-{
-    // these need to stay around because they are child objects who will follow their parent's life cycle
-    // delete m_start;
-    // delete m_finish;
-}
-
 lldb_private::SyntheticChildrenFrontEnd*
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 {
     if (!valobj_sp)
         return NULL;
     return (new LibcxxStdVectorSyntheticFrontEnd(valobj_sp));
 }
-

lldb/trunk/source/Plugins/Language/ObjC/Cocoa.cpp

-//===-- Cocoa.cpp -------------------------------------------------*- C++ -*-===//
+//===-- Cocoa.cpp -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "Cocoa.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
if (Language* language = Language::FindPlugin(lang))
         }
     }
     
     stream.Printf("%s%hhd%s",
                   prefix.c_str(),
                   value,
                   suffix.c_str());
 }
+
 static void
 NSNumber_FormatShort (ValueObject& valobj,
                       Stream& stream,
                       short value,
                       lldb::LanguageType lang)
 {
     static ConstString g_TypeHint("NSNumber:short");
     
     std::string prefix,suffix;
     if (Language* language = Language::FindPlugin(lang))
     {
         if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix))
         {
             prefix.clear();
             suffix.clear();
         }
     }
     
     stream.Printf("%s%hd%s",
                   prefix.c_str(),
                   value,
                   suffix.c_str());
 }
+
 static void
 NSNumber_FormatInt (ValueObject& valobj,
                     Stream& stream,
                     int value,
                     lldb::LanguageType lang)
 {
     static ConstString g_TypeHint("NSNumber:int");
     
     std::string prefix,suffix;
     if (Language* language = Language::FindPlugin(lang))
     {
         if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix))
         {
             prefix.clear();
             suffix.clear();
         }
     }
     
     stream.Printf("%s%d%s",
                   prefix.c_str(),
                   value,
                   suffix.c_str());
 }
+
 static void
 NSNumber_FormatLong (ValueObject& valobj,
                      Stream& stream,
                      uint64_t value,
                      lldb::LanguageType lang)
 {
     static ConstString g_TypeHint("NSNumber:long");
     
     std::string prefix,suffix;
     if (Language* language = Language::FindPlugin(lang))
     {
         if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix))
         {
             prefix.clear();
             suffix.clear();
         }
     }
     
     stream.Printf("%s%" PRId64 "%s",
                   prefix.c_str(),
                   value,
                   suffix.c_str());
 }
+
 static void
 NSNumber_FormatFloat (ValueObject& valobj,
                       Stream& stream,
                       float value,
                       lldb::LanguageType lang)
 {
     static ConstString g_TypeHint("NSNumber:float");
     
     std::string prefix,suffix;
     if (Language* language = Language::FindPlugin(lang))
     {
         if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix, suffix))
         {
             prefix.clear();
             suffix.clear();
         }
     }
     
     stream.Printf("%s%f%s",
                   prefix.c_str(),
                   value,
                   suffix.c_str());
 }
+
 static void
 NSNumber_FormatDouble (ValueObject& valobj,
                        Stream& stream,
                        double value,
                        lldb::LanguageType lang)
 {
     static ConstString g_TypeHint("NSNumber:double");
     

 class ObjCClassSyntheticChildrenFrontEnd : public SyntheticChildrenFrontEnd
 {
 public:
     ObjCClassSyntheticChildrenFrontEnd (lldb::ValueObjectSP valobj_sp) :
     SyntheticChildrenFrontEnd(*valobj_sp.get())
     {
     }
     
-    virtual size_t
-    CalculateNumChildren ()
+    ~ObjCClassSyntheticChildrenFrontEnd() override = default;
+
+    size_t
+    CalculateNumChildren() override
     {
         return 0;
     }
     
-    virtual lldb::ValueObjectSP
-    GetChildAtIndex (size_t idx)
+    lldb::ValueObjectSP
+    GetChildAtIndex(size_t idx) override
     {
         return lldb::ValueObjectSP();
     }
     
-    virtual bool
-    Update()
+    bool
+    Update() override
     {
         return false;
     }
     
-    virtual bool
-    MightHaveChildren ()
+    bool
+    MightHaveChildren() override
     {
         return false;
     }
     
-    virtual size_t
-    GetIndexOfChildWithName (const ConstString &name)
+    size_t
+    GetIndexOfChildWithName(const ConstString &name) override
     {
         return UINT32_MAX;
     }
-    
-    virtual
-    ~ObjCClassSyntheticChildrenFrontEnd ()
-    {
-    }
 };
 
 SyntheticChildrenFrontEnd*
 lldb_private::formatters::ObjCClassSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 {
     return new ObjCClassSyntheticChildrenFrontEnd(valobj_sp);
 }
 

 bool
 lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     stream.Printf("%s",valobj.GetObjectDescription());
     return true;
 }
 
 template bool
-lldb_private::formatters::NSDataSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
+lldb_private::formatters::NSDataSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&);
 
 template bool
-lldb_private::formatters::NSDataSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
+lldb_private::formatters::NSDataSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&);
 
 template bool
-lldb_private::formatters::ObjCSELSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
+lldb_private::formatters::ObjCSELSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&);
 
 template bool
-lldb_private::formatters::ObjCSELSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
+lldb_private::formatters::ObjCSELSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&);

lldb/trunk/source/Plugins/Language/ObjC/NSArray.cpp

 //===-- NSArray.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+#include "clang/AST/ASTContext.h"
+
+// Project includes
 #include "Cocoa.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 #include "lldb/Target/Target.h"
 
-#include "clang/AST/ASTContext.h"
-
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace  lldb_private {
     namespace formatters {
         class NSArrayMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~NSArrayMSyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update() = 0;
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override = 0;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
             
-            virtual
-            ~NSArrayMSyntheticFrontEnd () {}
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
             
         protected:
             virtual lldb::addr_t
             GetDataAddress () = 0;
             
             virtual uint64_t
             GetUsedCount () = 0;
             
             virtual uint64_t
             GetOffset () = 0;
             
             virtual uint64_t
             GetSize () = 0;
             
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             CompilerType m_id_type;
             std::vector<lldb::ValueObjectSP> m_children;
         };
         
         class NSArrayMSyntheticFrontEnd_109 : public NSArrayMSyntheticFrontEnd
         {
+        public:
+            NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp);
+
+            ~NSArrayMSyntheticFrontEnd_109() override;
+
+            bool
+            Update() override;
+            
+        protected:
+            lldb::addr_t
+            GetDataAddress() override;
+            
+            uint64_t
+            GetUsedCount() override;
+            
+            uint64_t
+            GetOffset() override;
+            
+            uint64_t
+            GetSize() override;
+            
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used;
                 uint32_t _priv1 : 2 ;
                 uint32_t _size : 30;
                 uint32_t _priv2 : 2;
                 uint32_t _offset : 30;
                 uint32_t _priv3;
                 uint32_t _data;
             };
+
             struct DataDescriptor_64
             {
                 uint64_t _used;
                 uint64_t _priv1 : 2 ;
                 uint64_t _size : 62;
                 uint64_t _priv2 : 2;
                 uint64_t _offset : 62;
                 uint32_t _priv3;
                 uint64_t _data;
             };
+
+            DataDescriptor_32 *m_data_32;
+            DataDescriptor_64 *m_data_64;
+        };
+        
+        class NSArrayMSyntheticFrontEnd_1010 : public NSArrayMSyntheticFrontEnd
+        {
         public:
-            NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp);
-            
-            virtual bool
-            Update();
-            
-            virtual
-            ~NSArrayMSyntheticFrontEnd_109 ();
+            NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp);
+            ~NSArrayMSyntheticFrontEnd_1010() override;
+            bool
+            Update() override;
             
         protected:
-            virtual lldb::addr_t
-            GetDataAddress ();
-            
-            virtual uint64_t
-            GetUsedCount ();
+            lldb::addr_t
+            GetDataAddress() override;
             
-            virtual uint64_t
-            GetOffset ();
+            uint64_t
+            GetUsedCount() override;
             
-            virtual uint64_t
-            GetSize ();
+            uint64_t
+            GetOffset() override;
             
-        private:
-            DataDescriptor_32 *m_data_32;
-            DataDescriptor_64 *m_data_64;
-        };
+            uint64_t
+            GetSize() override;
             
-        class NSArrayMSyntheticFrontEnd_1010 : public NSArrayMSyntheticFrontEnd
-        {
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used;
                 uint32_t _offset;
                 uint32_t _size : 28;
                 uint64_t _priv1 : 4;
                 uint32_t _priv2;
                 uint32_t _data;
             };
+
             struct DataDescriptor_64
             {
                 uint64_t _used;
                 uint64_t _offset;
                 uint64_t _size : 60;
                 uint64_t _priv1 : 4;
                 uint32_t _priv2;
                 uint64_t _data;
             };
-        public:
-            NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp);
-            
-            virtual bool
-            Update();
-            
-            virtual
-            ~NSArrayMSyntheticFrontEnd_1010 ();
-            
-        protected:
-            virtual lldb::addr_t
-            GetDataAddress ();
-            
-            virtual uint64_t
-            GetUsedCount ();
-            
-            virtual uint64_t
-            GetOffset ();
-            
-            virtual uint64_t
-            GetSize ();
-            
-        private:
             DataDescriptor_32 *m_data_32;
             DataDescriptor_64 *m_data_64;
         };
         
         class NSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~NSArrayISyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
+            
+            bool
+            Update() override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            MightHaveChildren() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~NSArrayISyntheticFrontEnd ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
         private:
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             uint64_t m_items;
             lldb::addr_t m_data_ptr;
             CompilerType m_id_type;
             std::vector<lldb::ValueObjectSP> m_children;
         };
         
         class NSArray0SyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSArray0SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~NSArray0SyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
             
-            virtual
-            ~NSArray0SyntheticFrontEnd ();
-        private:
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
         };
         
         class NSArrayCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~NSArrayCodeRunningSyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
             
-            virtual
-            ~NSArrayCodeRunningSyntheticFrontEnd ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 bool
 lldb_private::formatters::NSArraySummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     static ConstString g_TypeHint("NSArray");
     
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)

 {
     const char* item_name = name.GetCString();
     uint32_t idx = ExtractIndexFromString(item_name);
     if (idx < UINT32_MAX && idx >= CalculateNumChildren())
         return UINT32_MAX;
     return idx;
 }
 
+lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::~NSArrayMSyntheticFrontEnd_109()
+{
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+}
+
 lldb::addr_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetDataAddress ()
 {
     if (!m_data_32 && !m_data_64)
         return LLDB_INVALID_ADDRESS;
     return m_data_32 ? m_data_32->_data :
     m_data_64->_data;
 }

 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetSize ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_size :
     m_data_64->_size;
 }
 
-lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::~NSArrayMSyntheticFrontEnd_109 ()
+lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::~NSArrayMSyntheticFrontEnd_1010()
 {
     delete m_data_32;
     m_data_32 = NULL;
     delete m_data_64;
     m_data_64 = NULL;
 }
 
 lldb::addr_t

 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetSize ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_size :
     m_data_64->_size;
 }
 
-lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::~NSArrayMSyntheticFrontEnd_1010 ()
-{
-    delete m_data_32;
-    m_data_32 = NULL;
-    delete m_data_64;
-    m_data_64 = NULL;
-}
-
 lldb_private::formatters::NSArrayISyntheticFrontEnd::NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd (*valobj_sp.get()),
 m_exe_ctx_ref (),
 m_ptr_size (8),
 m_items (0),
 m_data_ptr (0)
 {
     if (valobj_sp)
     {
         CompilerType type = valobj_sp->GetCompilerType();
         if (type)
         {
             ClangASTContext *ast = valobj_sp->GetExecutionContextRef().GetTargetSP()->GetScratchClangASTContext();
             if (ast)
                 m_id_type = CompilerType(ast->getASTContext(), ast->getASTContext()->ObjCBuiltinIdTy);
         }
     }
 }
 
-lldb_private::formatters::NSArrayISyntheticFrontEnd::~NSArrayISyntheticFrontEnd ()
-{
-}
-
 size_t
 lldb_private::formatters::NSArrayISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     const char* item_name = name.GetCString();
     uint32_t idx = ExtractIndexFromString(item_name);
     if (idx < UINT32_MAX && idx >= CalculateNumChildren())
         return UINT32_MAX;
     return idx;
lldb_private::formatters::NSArrayISyntheticFrontEnd::GetChildAtIndex (size_t idx)
     return retval_sp;
 }
 
 lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd (*valobj_sp.get())
 {
 }
 
-lldb_private::formatters::NSArray0SyntheticFrontEnd::~NSArray0SyntheticFrontEnd ()
-{
-}
-
 size_t
 lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     return UINT32_MAX;
 }
 
 size_t
 lldb_private::formatters::NSArray0SyntheticFrontEnd::CalculateNumChildren ()
lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::MightHaveChildren ()
     return true;
 }
 
 size_t
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     return 0;
 }
-
-lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::~NSArrayCodeRunningSyntheticFrontEnd ()
-{}

lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.cpp

-//===-- NSDictionary.cpp ------------------------------------------*- C++ -*-===//
+//===-- NSDictionary.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+#include <mutex>
+
+// Other libraries and framework includes
+#include "clang/AST/DeclCXX.h"
+
+// Project includes
 #include "NSDictionary.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 
-#include "clang/AST/DeclCXX.h"
-
-#include <mutex>
-
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 std::map<ConstString, CXXFunctionSummaryFormat::Callback>&
 NSDictionary_Additionals::GetAdditionalSummaries ()
 {
     static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
GetLLDBNSPairType (TargetSP target_sp)
     }
     return compiler_type;
 }
 
 namespace lldb_private {
     namespace  formatters {
         class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
+        public:
+            NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
+
+            ~NSDictionaryISyntheticFrontEnd() override;
+
+            size_t
+            CalculateNumChildren() override;
+            
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
+            
+            bool
+            Update() override;
+            
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
+
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used : 26;
                 uint32_t _szidx : 6;
             };
+
             struct DataDescriptor_64
             {
                 uint64_t _used : 58;
                 uint32_t _szidx : 6;
             };
-            
             struct DictionaryItemDescriptor
             {
                 lldb::addr_t key_ptr;
                 lldb::addr_t val_ptr;
                 lldb::ValueObjectSP valobj_sp;
             };
-            
-        public:
-            NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
-            
-            virtual bool
-            Update();
-            
-            virtual bool
-            MightHaveChildren ();
-            
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~NSDictionaryISyntheticFrontEnd ();
-        private:
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             lldb::ByteOrder m_order;
             DataDescriptor_32 *m_data_32;
             DataDescriptor_64 *m_data_64;
             lldb::addr_t m_data_ptr;
             CompilerType m_pair_type;
             std::vector<DictionaryItemDescriptor> m_children;
         };
         
         class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
+        public:
+            NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
+
+            ~NSDictionaryMSyntheticFrontEnd() override;
+
+            size_t
+            CalculateNumChildren() override;
+            
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
+            
+            bool
+            Update() override;
+            
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
+
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used : 26;
                 uint32_t _kvo : 1;
                 uint32_t _size;
                 uint32_t _mutations;
                 uint32_t _objs_addr;
                 uint32_t _keys_addr;
             };
+
             struct DataDescriptor_64
             {
                 uint64_t _used : 58;
                 uint32_t _kvo : 1;
                 uint64_t _size;
                 uint64_t _mutations;
                 uint64_t _objs_addr;
                 uint64_t _keys_addr;
             };
+
             struct DictionaryItemDescriptor
             {
                 lldb::addr_t key_ptr;
                 lldb::addr_t val_ptr;
                 lldb::ValueObjectSP valobj_sp;
             };
-        public:
-            NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
-            
-            virtual bool
-            Update();
-            
-            virtual bool
-            MightHaveChildren ();
-            
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~NSDictionaryMSyntheticFrontEnd ();
-        private:
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             lldb::ByteOrder m_order;
             DataDescriptor_32 *m_data_32;
             DataDescriptor_64 *m_data_64;
             CompilerType m_pair_type;
             std::vector<DictionaryItemDescriptor> m_children;
         };
         
         class NSDictionaryCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~NSDictionaryCodeRunningSyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
             
-            virtual
-            ~NSDictionaryCodeRunningSyntheticFrontEnd ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 template<bool name_entries>
 bool
 lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     static ConstString g_TypeHint("NSDictionary");
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)

 }
 
 size_t
 lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     return 0;
 }
 
-lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::~NSDictionaryCodeRunningSyntheticFrontEnd ()
-{}
-
 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd(*valobj_sp.get()),
 m_exe_ctx_ref(),
 m_ptr_size(8),
 m_order(lldb::eByteOrderInvalid),
 m_data_32(NULL),
 m_data_64(NULL),
 m_pair_type()
if (!dict_item.valobj_sp)
                                                         data,
                                                         m_exe_ctx_ref,
                                                         m_pair_type);
     }
     return dict_item.valobj_sp;
 }
 
 template bool
-lldb_private::formatters::NSDictionarySummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
+lldb_private::formatters::NSDictionarySummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&);
 
 template bool
-lldb_private::formatters::NSDictionarySummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
+lldb_private::formatters::NSDictionarySummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&);

lldb/trunk/source/Plugins/Language/ObjC/NSIndexPath.cpp

-//===-- NSIndexPath.cpp ------------------------------------------*- C++ -*-===//
+//===-- NSIndexPath.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "Cocoa.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Symbol/ClangASTContext.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 class NSIndexPathSyntheticFrontEnd : public SyntheticChildrenFrontEnd
 {
 public:
     NSIndexPathSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
     SyntheticChildrenFrontEnd (*valobj_sp.get()),
     m_ptr_size(0),
     m_uint_star_type()
     {
         m_ptr_size = m_backend.GetTargetSP()->GetArchitecture().GetAddressByteSize();
     }
-    
-    virtual size_t
-    CalculateNumChildren ()
+    ~NSIndexPathSyntheticFrontEnd() override = default;
+
+    size_t
+    CalculateNumChildren() override
     {
         return m_impl.GetNumIndexes();
     }
     
-    virtual lldb::ValueObjectSP
-    GetChildAtIndex (size_t idx)
+    lldb::ValueObjectSP
+    GetChildAtIndex(size_t idx) override
     {
         return m_impl.GetIndexAtIndex(idx, m_uint_star_type);
     }
     
-    virtual bool
-    Update()
+    bool
+    Update() override
     {
         m_impl.Clear();
         
         TypeSystem* type_system = m_backend.GetCompilerType().GetTypeSystem();
         if (!type_system)
             return false;
 
         ClangASTContext *ast = m_backend.GetExecutionContextRef().GetTargetSP()->GetScratchClangASTContext();
Update() override
                     if (m_impl.m_outsourced.m_indexes)
                         m_impl.m_mode = Mode::Outsourced;
                 }
             }
         }
         return false;
     }
     
-    virtual bool
-    MightHaveChildren ()
+    bool
+    MightHaveChildren() override
     {
         if (m_impl.m_mode == Mode::Invalid)
             return false;
         return true;
     }
     
-    virtual size_t
-    GetIndexOfChildWithName (const ConstString &name)
+    size_t
+    GetIndexOfChildWithName(const ConstString &name) override
     {
         const char* item_name = name.GetCString();
         uint32_t idx = ExtractIndexFromString(item_name);
         if (idx < UINT32_MAX && idx >= CalculateNumChildren())
             return UINT32_MAX;
         return idx;
     }
     
-    virtual lldb::ValueObjectSP
-    GetSyntheticValue () { return nullptr; }
-    
-    virtual
-    ~NSIndexPathSyntheticFrontEnd () {}
-    
+    lldb::ValueObjectSP
+    GetSyntheticValue() override
+    {
+        return nullptr;
+    }
 protected:
     ObjCLanguageRuntime::ClassDescriptorSP m_descriptor_sp;
     
     enum class Mode {
         Inlined,
         Outsourced,
         Invalid
     };
struct Impl {
             Clear ()
             {
                 m_indexes = 0;
                 m_count = 0;
                 m_ptr_size = 0;
                 m_process = nullptr;
             }
                     
-          private:
           uint64_t m_indexes;
           size_t m_count;
           uint32_t m_ptr_size;
           Process *m_process;
                     
           // cfr. Foundation for the details of this code
           size_t _lengthForInlinePayload(uint32_t ptr_size) {
               m_ptr_size = ptr_size;
namespace lldb_private {
     namespace formatters {
         
         SyntheticChildrenFrontEnd* NSIndexPathSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
         {
             if (valobj_sp)
                 return new NSIndexPathSyntheticFrontEnd(valobj_sp);
             return nullptr;
         }
-    }
-}
+
+    } // namespace formatters
+} // namespace lldb_private

lldb/trunk/source/Plugins/Language/ObjC/NSSet.cpp

-//===-- NSSet.cpp ------------------------------------------------*- C++ -*-===//
+//===-- NSSet.cpp -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
 #include "NSSet.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
NSSet_Additionals::GetAdditionalSynthetics ()
     static std::map<ConstString, CXXSyntheticChildren::CreateFrontEndCallback> g_map;
     return g_map;
 }
 
 namespace lldb_private {
     namespace formatters {
         class NSSetISyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
+        public:
+            NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
+
+            ~NSSetISyntheticFrontEnd() override;
+
+            size_t
+            CalculateNumChildren() override;
+            
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
+            
+            bool
+            Update() override;
+            
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
+
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used : 26;
                 uint32_t _szidx : 6;
             };
+
             struct DataDescriptor_64
             {
                 uint64_t _used : 58;
                 uint32_t _szidx : 6;
             };
-            
             struct SetItemDescriptor
             {
                 lldb::addr_t item_ptr;
                 lldb::ValueObjectSP valobj_sp;
             };
-            
-        public:
-            NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
-            
-            virtual bool
-            Update();
-            
-            virtual bool
-            MightHaveChildren ();
-            
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~NSSetISyntheticFrontEnd ();
-        private:
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             DataDescriptor_32 *m_data_32;
             DataDescriptor_64 *m_data_64;
             lldb::addr_t m_data_ptr;
             std::vector<SetItemDescriptor> m_children;
         };
         
         class NSOrderedSetSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
-        private:
-            
         public:
             NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~NSOrderedSetSyntheticFrontEnd() override = default;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~NSOrderedSetSyntheticFrontEnd ();
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
         private:
             uint32_t m_count;
             std::map<uint32_t,lldb::ValueObjectSP> m_children;
         };
         
         class NSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
+        public:
+            NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
+
+            ~NSSetMSyntheticFrontEnd() override;
+
+            size_t
+            CalculateNumChildren() override;
+            
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
+            
+            bool
+            Update() override;
+            
+            bool
+            MightHaveChildren() override;
+            
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
+
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used : 26;
                 uint32_t _size;
                 uint32_t _mutations;
                 uint32_t _objs_addr;
             };
+
             struct DataDescriptor_64
             {
                 uint64_t _used : 58;
                 uint64_t _size;
                 uint64_t _mutations;
                 uint64_t _objs_addr;
             };
+
             struct SetItemDescriptor
             {
                 lldb::addr_t item_ptr;
                 lldb::ValueObjectSP valobj_sp;
             };
-        public:
-            NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
-            
-            virtual bool
-            Update();
-            
-            virtual bool
-            MightHaveChildren ();
-            
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
-            
-            virtual
-            ~NSSetMSyntheticFrontEnd ();
-        private:
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             DataDescriptor_32 *m_data_32;
             DataDescriptor_64 *m_data_64;
             std::vector<SetItemDescriptor> m_children;
         };
         
         class NSSetCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSSetCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
-            
-            virtual size_t
-            CalculateNumChildren ();
-            
-            virtual lldb::ValueObjectSP
-            GetChildAtIndex (size_t idx);
+            ~NSSetCodeRunningSyntheticFrontEnd() override;
+            size_t
+            CalculateNumChildren() override;
             
-            virtual bool
-            Update();
+            lldb::ValueObjectSP
+            GetChildAtIndex(size_t idx) override;
             
-            virtual bool
-            MightHaveChildren ();
+            bool
+            Update() override;
             
-            virtual size_t
-            GetIndexOfChildWithName (const ConstString &name);
+            bool
+            MightHaveChildren() override;
             
-            virtual
-            ~NSSetCodeRunningSyntheticFrontEnd ();
+            size_t
+            GetIndexOfChildWithName(const ConstString &name) override;
         };
-    }
-}
+    } // namespace formatters
+} // namespace lldb_private
 
 template<bool cf_style>
 bool
 lldb_private::formatters::NSSetSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     static ConstString g_TypeHint("NSSet");
     
     ProcessSP process_sp = valobj.GetProcessSP();

 {
     const char* item_name = name.GetCString();
     uint32_t idx = ExtractIndexFromString(item_name);
     if (idx < UINT32_MAX && idx >= CalculateNumChildren())
         return UINT32_MAX;
     return idx;
 }
 
-lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::~NSOrderedSetSyntheticFrontEnd ()
-{
-}
-
 template bool
 lldb_private::formatters::NSSetSummaryProvider<true> (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options);
 
 template bool
 lldb_private::formatters::NSSetSummaryProvider<false> (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options);
-

lldb/trunk/source/Plugins/Language/ObjC/ObjCLanguage.h

-//===-- ObjCLanguage.h ----------------------------------------*- C++ -*-===//
+//===-- ObjCLanguage.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
public:
         //  names[1] => "+[NSString myStringWithCString:]"
         // If name is specified without the leading '+' or '-' like "[NSString(my_additions) myStringWithCString:]"
         //  names[0] => "+[NSString(my_additions) myStringWithCString:]"
         //  names[1] => "-[NSString(my_additions) myStringWithCString:]"
         //  names[2] => "+[NSString myStringWithCString:]"
         //  names[3] => "-[NSString myStringWithCString:]"
         size_t
         GetFullNames (std::vector<ConstString> &names, bool append);
+
     protected:
         ConstString m_full;     // Full name:   "+[NSString(my_additions) myStringWithCString:]"
         ConstString m_class;    // Class name:  "NSString"
         ConstString m_class_category; // Class with category: "NSString(my_additions)"
         ConstString m_category; // Category:    "my_additions"
         ConstString m_selector; // Selector:    "myStringWithCString:"
         Type m_type;
         bool m_category_is_valid;
-
     };
 
-    virtual ~ObjCLanguage() = default;
-    
-    ObjCLanguage () = default;
-    
+    ObjCLanguage() = default;
+    ~ObjCLanguage() override = default;
+
     lldb::LanguageType
     GetLanguageType () const override
     {
         return lldb::eLanguageTypeObjC;
     }
     
     lldb::TypeCategoryImplSP
     GetFormatters () override;
IsPossibleObjCSelector (const char *name)
             return true;
         else
             return false;
     }
     
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual ConstString
+    ConstString
     GetPluginName() override;
     
-    virtual uint32_t
+    uint32_t
     GetPluginVersion() override;
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_ObjCLanguage_h_
+#endif // liblldb_ObjCLanguage_h_

lldb/trunk/source/Plugins/Language/ObjC/ObjCLanguage.cpp

-//===-- ObjCLanguage.cpp --------------------------------------*- C++ -*-===//
+//===-- ObjCLanguage.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ObjCLanguage.h"
-
+// C Includes
+// C++ Includes
 #include <mutex>
 
+// Other libraries and framework includes
+// Project includes
+#include "ObjCLanguage.h"
+
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"

 
 lldb_private::ConstString
 ObjCLanguage::GetPluginNameStatic()
 {
     static ConstString g_name("objc");
     return g_name;
 }
 
-
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 lldb_private::ConstString
 ObjCLanguage::GetPluginName()
 {
     return GetPluginNameStatic();
 }
#endif // LLDB_DISABLE_PYTHON
     .SetSkipReferences(false)
     .SetDontShowChildren(true)
     .SetDontShowValue(false)
     .SetShowMembersOneLiner(false)
     .SetHideItemNames(false);
     
     appkit_flags.SetDontShowChildren(false);
     
-    
 #ifndef LLDB_DISABLE_PYTHON
     AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSArray"), appkit_flags);
     AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags);
     AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags);
     AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArray0"), appkit_flags);
     AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayM"), appkit_flags);
     AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSCFArray"), appkit_flags);
     AddCXXSummary(objc_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFArrayRef"), appkit_flags);
LoadCoreMediaFormatters(TypeCategoryImplSP objc_category_sp)
     .SetSkipPointers(false)
     .SetSkipReferences(false);
     
 #ifndef LLDB_DISABLE_PYTHON
     AddCXXSummary(objc_category_sp, lldb_private::formatters::CMTimeSummaryProvider, "CMTime summary provider", ConstString("CMTime"), cm_flags);
 #endif // LLDB_DISABLE_PYTHON
 }
 
-
 lldb::TypeCategoryImplSP
 ObjCLanguage::GetFormatters ()
 {
     static std::once_flag g_initialize;
     static TypeCategoryImplSP g_category;
     
     std::call_once(g_initialize, [this] () -> void {
         DataVisualization::Categories::GetCategory(GetPluginName(), g_category);
private:
                 {
                     m_compiler_type.DumpTypeDescription(&stream);
                     stream.EOL();
                     return true;
                 }
                 return false;
             }
 
-            virtual ~ObjCScavengerResult() = default;
+            ~ObjCScavengerResult() override = default;
+
         private:
             CompilerType m_compiler_type;
         };
         
     protected:
         ObjCTypeScavenger() = default;
         
-        virtual ~ObjCTypeScavenger() = default;
+        ~ObjCTypeScavenger() override = default;
         
         bool
         Find_Impl (ExecutionContextScope *exe_scope,
                    const char *key,
                    ResultSet &results) override
         {
             bool result = false;
             

lldb/trunk/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h

-//===-- ObjCPlusPlusLanguage.h ----------------------------------------*- C++ -*-===//
+//===-- ObjCPlusPlusLanguage.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_ObjCPlusPlusLanguage_h_
 #define liblldb_ObjCPlusPlusLanguage_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/Language.h"
 
 namespace lldb_private {
     
 class ObjCPlusPlusLanguage :
     public Language
 {
 public:
-    virtual ~ObjCPlusPlusLanguage() = default;
-    
-    ObjCPlusPlusLanguage () = default;
-    
+    ObjCPlusPlusLanguage() = default;
+    ~ObjCPlusPlusLanguage() override = default;
+
     lldb::LanguageType
-    GetLanguageType () const
+    GetLanguageType() const override
     {
         return lldb::eLanguageTypeObjC_plus_plus;
     }
     
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
     Initialize();
     
     static void
     Terminate();
     
     static lldb_private::Language *
     CreateInstance (lldb::LanguageType language);
     
     static lldb_private::ConstString
     GetPluginNameStatic();
     
     //------------------------------------------------------------------
     // PluginInterface protocol
     //------------------------------------------------------------------
-    virtual ConstString
-    GetPluginName();
+    ConstString
+    GetPluginName() override;
     
-    virtual uint32_t
-    GetPluginVersion();
+    uint32_t
+    GetPluginVersion() override;
 };
     
 } // namespace lldb_private
 
-#endif  // liblldb_CPlusPlusLanguage_h_
+#endif // liblldb_CPlusPlusLanguage_h_