[LLDB] Fix Clang-tidy misc-use-override warnings in remaining files in include; other minor fixes.

[Eugene.Zelenko]

Summary

This is second attempt based on current code.

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

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

lldb/trunk/include/lldb/Core/ValueObjectSyntheticFilter.h

 //===-- ValueObjectSyntheticFilter.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_ValueObjectSyntheticFilter_h_
 #define liblldb_ValueObjectSyntheticFilter_h_
 
 // C Includes
 // C++ Includes
 #include <vector>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ThreadSafeSTLMap.h"
 #include "lldb/Core/ValueObject.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // A ValueObject that obtains its children from some source other than
 // real information
 // This is currently used to implement Python-based children and filters
 // but you can bind it to any source of synthetic information and have
 // it behave accordingly
 //----------------------------------------------------------------------
 class ValueObjectSynthetic : public ValueObject
 {
 public:
-    virtual
-    ~ValueObjectSynthetic();
+    ~ValueObjectSynthetic() override;
 
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
     
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
     
-    virtual ConstString
-    GetQualifiedTypeName();
+    ConstString
+    GetQualifiedTypeName() override;
     
-    virtual ConstString
-    GetDisplayTypeName();
+    ConstString
+    GetDisplayTypeName() override;
 
-    virtual bool
-    MightHaveChildren();
+    bool
+    MightHaveChildren() override;
 
-    virtual size_t
-    CalculateNumChildren();
+    size_t
+    CalculateNumChildren() override;
 
-    virtual lldb::ValueType
-    GetValueType() const;
+    lldb::ValueType
+    GetValueType() const override;
     
-    virtual lldb::ValueObjectSP
-    GetChildAtIndex (size_t idx, bool can_create);
+    lldb::ValueObjectSP
+    GetChildAtIndex(size_t idx, bool can_create) override;
     
-    virtual lldb::ValueObjectSP
-    GetChildMemberWithName (const ConstString &name, bool can_create);
+    lldb::ValueObjectSP
+    GetChildMemberWithName(const ConstString &name, bool can_create) override;
     
-    virtual size_t
-    GetIndexOfChildWithName (const ConstString &name);
+    size_t
+    GetIndexOfChildWithName(const ConstString &name) override;
 
-    virtual lldb::ValueObjectSP
-    GetDynamicValue (lldb::DynamicValueType valueType);
+    lldb::ValueObjectSP
+    GetDynamicValue(lldb::DynamicValueType valueType) override;
     
-    virtual bool
-    IsInScope ();
+    bool
+    IsInScope() override;
     
-    virtual bool
-    HasSyntheticValue()
+    bool
+    HasSyntheticValue() override
     {
         return false;
     }
     
-    virtual bool
-    IsSynthetic() { return true; }
+    bool
+    IsSynthetic() override
+    {
+        return true;
+    }
     
-    virtual void
-    CalculateSyntheticValue (bool use_synthetic)
+    void
+    CalculateSyntheticValue(bool use_synthetic) override
     {
     }
     
-    virtual bool
-    IsDynamic ()
+    bool
+    IsDynamic() override
     {
         if (m_parent)
             return m_parent->IsDynamic();
         else
             return false;
     }
     
-    virtual lldb::ValueObjectSP
-    GetStaticValue ()
+    lldb::ValueObjectSP
+    GetStaticValue() override
     {
         if (m_parent)
             return m_parent->GetStaticValue();
         else
             return GetSP();
     }
     
     virtual lldb::DynamicValueType
     GetDynamicValueType ()
     {
         if (m_parent)
             return m_parent->GetDynamicValueType();
         else
             return lldb::eNoDynamicValues;
     }
 
-    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;
     }
     
-    virtual lldb::ValueObjectSP
-    GetNonSyntheticValue ();
+    lldb::ValueObjectSP
+    GetNonSyntheticValue() override;
     
-    virtual bool
-    CanProvideValue ();
+    bool
+    CanProvideValue() override;
     
-    virtual bool
-    DoesProvideSyntheticValue ()
+    bool
+    DoesProvideSyntheticValue() override
     {
         return (UpdateValueIfNeeded(), m_provides_value == eLazyBoolYes);
     }
     
-    virtual bool
-    GetIsConstant () const
+    bool
+    GetIsConstant() const override
     {
         return false;
     }
 
-    virtual bool
-    SetValueFromCString (const char *value_str, Error& error);
+    bool
+    SetValueFromCString(const char *value_str, Error& error) override;
     
-    virtual void
-    SetFormat (lldb::Format format);
+    void
+    SetFormat(lldb::Format format) override;
     
-    virtual lldb::LanguageType
-    GetPreferredDisplayLanguage ();
+    lldb::LanguageType
+    GetPreferredDisplayLanguage() override;
     
     void
     SetPreferredDisplayLanguage (lldb::LanguageType);
     
-    virtual bool
-    GetDeclaration (Declaration &decl);
+    bool
+    GetDeclaration(Declaration &decl) override;
 
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual LazyBool
-    CanUpdateWithInvalidExecutionContext ()
+    LazyBool
+    CanUpdateWithInvalidExecutionContext() override
     {
         return eLazyBoolYes;
     }
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
     
     virtual void
     CreateSynthFilter ();
 
     // we need to hold on to the SyntheticChildren because someone might delete the type binding while we are alive
     lldb::SyntheticChildrenSP m_synth_sp;
     std::unique_ptr<SyntheticChildrenFrontEnd> m_synth_filter_ap;
     
private:
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectSynthetic);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectSyntheticFilter_h_
+#endif // liblldb_ValueObjectSyntheticFilter_h_

lldb/trunk/include/lldb/Core/ValueObjectVariable.h

 
 //----------------------------------------------------------------------
 // A ValueObject that contains a root variable that may or may not
 // have children.
 //----------------------------------------------------------------------
 class ValueObjectVariable : public ValueObject
 {
 public:
+    ~ValueObjectVariable() override;
+
     static lldb::ValueObjectSP
     Create (ExecutionContextScope *exe_scope, const lldb::VariableSP &var_sp);
 
-    virtual
-    ~ValueObjectVariable();
-
-    virtual uint64_t
-    GetByteSize();
+    uint64_t
+    GetByteSize() override;
 
-    virtual ConstString
-    GetTypeName();
+    ConstString
+    GetTypeName() override;
 
-    virtual ConstString
-    GetQualifiedTypeName();
+    ConstString
+    GetQualifiedTypeName() override;
     
-    virtual ConstString
-    GetDisplayTypeName();
+    ConstString
+    GetDisplayTypeName() 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 lldb::ModuleSP
-    GetModule();
+    lldb::ModuleSP
+    GetModule() override;
     
-    virtual SymbolContextScope *
-    GetSymbolContextScope();
+    SymbolContextScope *
+    GetSymbolContextScope() override;
 
-    virtual bool
-    GetDeclaration (Declaration &decl);
+    bool
+    GetDeclaration(Declaration &decl) override;
     
-    virtual const char *
-    GetLocationAsCString ();
+    const char *
+    GetLocationAsCString() override;
     
-    virtual bool
-    SetValueFromCString (const char *value_str, Error& error);
+    bool
+    SetValueFromCString(const char *value_str, Error& error) override;
 
-    virtual bool
-    SetData (DataExtractor &data, Error &error);
+    bool
+    SetData(DataExtractor &data, Error &error) override;
     
 protected:
-    virtual bool
-    UpdateValue ();
+    bool
+    UpdateValue() override;
     
-    virtual CompilerType
-    GetCompilerTypeImpl ();
+    CompilerType
+    GetCompilerTypeImpl() override;
 
     lldb::VariableSP  m_variable_sp;  ///< The variable that this value object is based upon
     Value m_resolved_value;           ///< The value that DWARFExpression resolves this variable to before we patch it up
 
 private:
     ValueObjectVariable (ExecutionContextScope *exe_scope, const lldb::VariableSP &var_sp);
     //------------------------------------------------------------------
     // For ValueObject only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (ValueObjectVariable);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ValueObjectVariable_h_
+#endif // liblldb_ValueObjectVariable_h_

lldb/trunk/include/lldb/Symbol/GoASTContext.h

 //===-- GoASTContext.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef __lldb__GoASTContext__
-#define __lldb__GoASTContext__
+#ifndef liblldb_GoASTContext_h_
+#define liblldb_GoASTContext_h_
 
+// C Includes
+// C++ Includes
 #include <map>
+
+// Other libraries and framework includes
+// Project includes
 #include "lldb/Core/ConstString.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/CompilerType.h"
 
 namespace lldb_private
 {
 
 class Declaration;
 class GoType;
 
 class GoASTContext : public TypeSystem
 {
   public:
     GoASTContext();
-    ~GoASTContext();
+    ~GoASTContext() override;
 
     //------------------------------------------------------------------
     // PluginInterface functions
     //------------------------------------------------------------------
     ConstString
     GetPluginName() override;
 
     uint32_t
public:
     EnumerateSupportedLanguages(std::set<lldb::LanguageType> &languages_for_types, std::set<lldb::LanguageType> &languages_for_expressions);
 
     static void
     Initialize ();
 
     static void
     Terminate ();
     
-
     DWARFASTParser *GetDWARFParser() override;
 
     void
     SetAddressByteSize(int byte_size)
     {
         m_pointer_byte_size = byte_size;
     }
 
     //------------------------------------------------------------------
     // llvm casting support
     //------------------------------------------------------------------
     static bool classof(const TypeSystem *ts)
     {
         return ts->getKind() == TypeSystem::eKindGo;
     }
 
     //----------------------------------------------------------------------
     // CompilerDecl functions
     //----------------------------------------------------------------------
-    virtual ConstString
+    ConstString
     DeclGetName (void *opaque_decl) override
     {
         return ConstString();
     }
 
-    virtual lldb::VariableSP
+    lldb::VariableSP
     DeclGetVariable (void *opaque_decl) override
     {
         return lldb::VariableSP();
     }
 
-    virtual void
+    void
     DeclLinkToObject (void *opaque_decl, std::shared_ptr<void> object) override
     {
     }
 
     //----------------------------------------------------------------------
     // CompilerDeclContext functions
     //----------------------------------------------------------------------
     
-    virtual std::vector<void *>
+    std::vector<void *>
     DeclContextFindDeclByName (void *opaque_decl_ctx, ConstString name) override
     {
         return std::vector<void *>();
     }
 
-    virtual bool
+    bool
     DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) override
     {
         return false;
     }
 
-    virtual ConstString
+    ConstString
     DeclContextGetName(void *opaque_decl_ctx) override
     {
         return ConstString();
     }
 
-    virtual bool
+    bool
     DeclContextIsClassMethod(void *opaque_decl_ctx, lldb::LanguageType *language_ptr, bool *is_instance_method_ptr,
                              ConstString *language_object_name_ptr) override
     {
         return false;
     }
 
     //----------------------------------------------------------------------
     // Creating Types
public:
     bool IsVoidType(lldb::opaque_compiler_type_t type) override;
 
     bool SupportsLanguage (lldb::LanguageType language) override;
 
     //----------------------------------------------------------------------
     // Type Completion
     //----------------------------------------------------------------------
 
-    virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
+    bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
 
     //----------------------------------------------------------------------
     // AST related queries
     //----------------------------------------------------------------------
 
-    virtual uint32_t GetPointerByteSize() override;
+    uint32_t GetPointerByteSize() override;
 
     //----------------------------------------------------------------------
     // Accessors
     //----------------------------------------------------------------------
 
-    virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type) override;
+    ConstString GetTypeName(lldb::opaque_compiler_type_t type) override;
 
-    virtual uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type = NULL) override;
+    uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_compiler_type = NULL) override;
 
-    virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;
+    lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;
 
-    virtual lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;
+    lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;
 
     //----------------------------------------------------------------------
     // Creating related types
     //----------------------------------------------------------------------
 
-    virtual CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride = nullptr) override;
+    CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride = nullptr) override;
 
-    virtual CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;
+    CompilerType GetCanonicalType(lldb::opaque_compiler_type_t type) override;
 
     // Returns -1 if this isn't a function of if the function doesn't have a prototype
     // Returns a value >= 0 if there is a prototype.
-    virtual int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;
+    int GetFunctionArgumentCount(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override;
+    CompilerType GetFunctionArgumentTypeAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override;
 
-    virtual CompilerType GetFunctionReturnType(lldb::opaque_compiler_type_t type) override;
+    CompilerType GetFunctionReturnType(lldb::opaque_compiler_type_t type) override;
 
-    virtual size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override;
+    size_t GetNumMemberFunctions(lldb::opaque_compiler_type_t type) override;
 
-    virtual TypeMemberFunctionImpl GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override;
+    TypeMemberFunctionImpl GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, size_t idx) override;
 
-    virtual CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override;
+    CompilerType GetPointeeType(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;
+    CompilerType GetPointerType(lldb::opaque_compiler_type_t type) override;
 
     //----------------------------------------------------------------------
     // Exploring the type
     //----------------------------------------------------------------------
 
-    virtual uint64_t GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override;
+    uint64_t GetBitSize(lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) override;
 
-    virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count) override;
+    lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type, uint64_t &count) override;
 
-    virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
+    lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
 
-    virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) override;
+    uint32_t GetNumChildren(lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) override;
 
-    virtual lldb::BasicType GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
+    lldb::BasicType GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetBuiltinTypeForEncodingAndBitSize (lldb::Encoding encoding,
-                                                              size_t bit_size) override;
+    CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
 
-    virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
+    uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr,
-                                         uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) override;
+    CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, std::string &name, uint64_t *bit_offset_ptr,
 
-    virtual uint32_t
+    uint32_t
     GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override
     {
         return 0;
     }
 
-    virtual uint32_t
+    uint32_t
     GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override
     {
         return 0;
     }
 
-    virtual CompilerType
+    CompilerType
     GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override
     {
         return CompilerType();
     }
 
-    virtual CompilerType
+    CompilerType
     GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) override
     {
         return CompilerType();
     }
 
-    virtual CompilerType GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
-                                                     bool transparent_pointers, bool omit_empty_base_classes,
-                                                     bool ignore_array_bounds, std::string &child_name,
-                                                     uint32_t &child_byte_size, int32_t &child_byte_offset,
-                                                     uint32_t &child_bitfield_bit_size,
-                                                     uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
-                                                     bool &child_is_deref_of_parent, ValueObject *valobj) override;
+    CompilerType GetChildCompilerTypeAtIndex(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
 
     // Lookup a child given a name. This function will match base class names
     // and member member names in "clang_type" only, not descendants.
-    virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) override;
+    uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) override;
 
     // Lookup a child member given a name. This function will match member names
     // only and will descend into "clang_type" children in search for the first
     // member in this class, or any base class that matches "name".
     // TODO: Return all matches for a given name by returning a vector<vector<uint32_t>>
     // so we catch all names that match a given child name, not just the first.
-    virtual size_t GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes,
-                                                 std::vector<uint32_t> &child_indexes) override;
+    size_t GetIndexOfChildMemberWithName(lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes,
 
-    virtual size_t
+    size_t
     GetNumTemplateArguments(lldb::opaque_compiler_type_t type) override
     {
         return 0;
     }
 
-    virtual CompilerType
+    CompilerType
     GetTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx, lldb::TemplateArgumentKind &kind) override
     {
         return CompilerType();
     }
 
     //----------------------------------------------------------------------
     // Dumping types
     //----------------------------------------------------------------------
-    virtual void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
-                           const DataExtractor &data, lldb::offset_t data_offset, size_t data_byte_size,
-                           uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, bool show_summary,
-                           bool verbose, uint32_t depth) override;
+    void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
 
-    virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data,
-                               lldb::offset_t data_offset, size_t data_byte_size, uint32_t bitfield_bit_size,
-                               uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope) override;
+    bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, const DataExtractor &data,
 
-    virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type) override; // Dump to stdout
+    void DumpTypeDescription(lldb::opaque_compiler_type_t type) override; // Dump to stdout
 
-    virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s) override;
+    void DumpTypeDescription(lldb::opaque_compiler_type_t type, Stream *s) override;
 
     //----------------------------------------------------------------------
     // TODO: These methods appear unused. Should they be removed?
     //----------------------------------------------------------------------
 
-    virtual bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override;
+    bool IsRuntimeGeneratedType(lldb::opaque_compiler_type_t type) override;
 
-    virtual void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data,
-                             lldb::offset_t data_offset, size_t data_byte_size) override;
+    void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, const DataExtractor &data,
 
     // Converts "s" to a floating point value and place resulting floating
     // point bytes in the "dst" buffer.
-    virtual size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) override;
+    size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) override;
 
     //----------------------------------------------------------------------
     // TODO: Determine if these methods should move to ClangASTContext.
     //----------------------------------------------------------------------
 
-    virtual bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = NULL) override;
+    bool IsPointerOrReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = NULL) override;
 
-    virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
+    unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length) override;
+    bool IsCStringType(lldb::opaque_compiler_type_t type, uint32_t &length) override;
 
-    virtual size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override;
+    size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
+    CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) override;
 
-    virtual bool IsBeingDefined(lldb::opaque_compiler_type_t type) override;
+    bool IsBeingDefined(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsConst(lldb::opaque_compiler_type_t type) override;
+    bool IsConst(lldb::opaque_compiler_type_t type) override;
 
-    virtual uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr) override;
+    uint32_t IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, CompilerType *base_type_ptr) override;
 
-    virtual bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override;
+    bool IsPolymorphicClass(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsTypedefType(lldb::opaque_compiler_type_t type) override;
+    bool IsTypedefType(lldb::opaque_compiler_type_t type) override;
 
     // If the current object represents a typedef type, get the underlying type
-    virtual CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
+    CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) override;
+    bool IsVectorType(lldb::opaque_compiler_type_t type, CompilerType *element_type, uint64_t *size) override;
 
-    virtual CompilerType GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override;
+    CompilerType GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) override;
 
-    virtual CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override;
+    CompilerType GetNonReferenceType(lldb::opaque_compiler_type_t type) override;
 
-    virtual bool IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = nullptr, bool *is_rvalue = nullptr) override;
+    bool IsReferenceType(lldb::opaque_compiler_type_t type, CompilerType *pointee_type = nullptr, bool *is_rvalue = nullptr) override;
 
   private:
     typedef std::map<ConstString, std::unique_ptr<GoType>> TypeMap;
     int m_pointer_byte_size;
     int m_int_byte_size;
     std::unique_ptr<TypeMap> m_types;
     std::unique_ptr<DWARFASTParser> m_dwarf_ast_parser_ap;
 
     GoASTContext(const GoASTContext &) = delete;
     const GoASTContext &operator=(const GoASTContext &) = delete;
 };
-}
 
-#endif /* defined(__lldb__GoASTContext__) */
+} // namespace lldb_private
+
+#endif // liblldb_GoASTContext_h_

lldb/trunk/include/lldb/Symbol/TypeSystem.h

 //===-- TypeSystem.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_TypeSystem_h_
 #define liblldb_TypeSystem_h_
 
+// C Includes
+// C++ Includes
 #include <functional>
 #include <map>
 #include <string>
 
+// Other libraries and framework includes
+#include "llvm/ADT/APSInt.h"
+#include "llvm/Support/Casting.h"
+
+// Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
-#include "llvm/ADT/APSInt.h"
-#include "llvm/Support/Casting.h"
 
 class DWARFDIE;
 class DWARFASTParser;
 
 namespace lldb_private {
     
 //----------------------------------------------------------------------
 // Interface for representing the Type Systems in different languages.
public:
     //----------------------------------------------------------------------
     enum LLVMCastKind {
         eKindClang,
         eKindSwift,
         eKindGo,
         kNumKinds
     };
 
+    //----------------------------------------------------------------------
+    // Constructors and Destructors
+    //----------------------------------------------------------------------
+    TypeSystem(LLVMCastKind kind);
+    
+    ~TypeSystem() override;
+
     LLVMCastKind getKind() const { return m_kind; }
 
     static lldb::TypeSystemSP
     CreateInstance (lldb::LanguageType language, Module *module);
 
     static lldb::TypeSystemSP
     CreateInstance (lldb::LanguageType language, Target *target);
 
-    //----------------------------------------------------------------------
-    // Constructors and Destructors
-    //----------------------------------------------------------------------
-    TypeSystem (LLVMCastKind kind);
-    
-    virtual ~TypeSystem ();
-
     virtual DWARFASTParser *
     GetDWARFParser ()
     {
         return nullptr;
     }
 
     virtual SymbolFile *
     GetSymbolFile () const
public:
     virtual CompilerType
     GetTemplateArgument (lldb::opaque_compiler_type_t type,
                          size_t idx,
                          lldb::TemplateArgumentKind &kind) = 0;
     
     //----------------------------------------------------------------------
     // Dumping types
     //----------------------------------------------------------------------
+
     virtual void
     DumpValue (lldb::opaque_compiler_type_t type,
                ExecutionContext *exe_ctx,
                Stream *s,
                lldb::Format format,
                const DataExtractor &data,
                lldb::offset_t data_offset,
                size_t data_byte_size,
public:
         GetTypeSystemForLanguage (lldb::LanguageType language, Target *target, bool can_create);
 
     protected:
         typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> collection;
         mutable Mutex m_mutex; ///< A mutex to keep this object happy in multi-threaded environments.
         collection m_map;
     };
 
-
 } // namespace lldb_private
 
-#endif // #ifndef liblldb_TypeSystem_h_
+#endif // liblldb_TypeSystem_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepOverRange.h

 #include "lldb/Target/ThreadPlanStepRange.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepOverRange : public ThreadPlanStepRange,
                                        ThreadPlanShouldStopHere
 {
 public:
-
     ThreadPlanStepOverRange (Thread &thread, 
                              const AddressRange &range, 
                              const SymbolContext &addr_context, 
                              lldb::RunMode stop_others,
                              LazyBool step_out_avoids_no_debug);
                              
-    virtual ~ThreadPlanStepOverRange ();
+    ~ThreadPlanStepOverRange() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ShouldStop (Event *event_ptr);
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ShouldStop(Event *event_ptr) override;
     
 protected:
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+    bool DoPlanExplainsStop(Event *event_ptr) override;
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
     
-    virtual void
-    SetFlagsToDefault ()
+    void
+    SetFlagsToDefault() override
     {
         GetFlags().Set(ThreadPlanStepOverRange::s_default_flag_values);
     }
-    
-    
-    
 private:
-
     static uint32_t s_default_flag_values;
     
     void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);
     bool IsEquivalentContext(const SymbolContext &context);
 
     bool m_first_resume;
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepOverRange);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepOverRange_h_
+#endif // liblldb_ThreadPlanStepOverRange_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepRange.h

public:
     ThreadPlanStepRange (ThreadPlanKind kind,
                          const char *name,
                          Thread &thread,
                          const AddressRange &range,
                          const SymbolContext &addr_context,
                          lldb::RunMode stop_others,
                          bool given_ranges_only = false);
 
-    virtual ~ThreadPlanStepRange ();
-
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level) = 0;
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr) = 0;
-    virtual Vote ShouldReportStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
-    virtual void DidPush ();
-    virtual bool IsPlanStale ();
+    ~ThreadPlanStepRange() override;
 
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override = 0;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override = 0;
+    Vote ShouldReportStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
+    void DidPush() override;
+    bool IsPlanStale() override;
 
     void AddRange(const AddressRange &new_range);
 
 protected:
-
     bool InRange();
     lldb::FrameComparison CompareCurrentFrameToStartFrame();
     bool InSymbol();
     void DumpRanges (Stream *s);
     
     Disassembler *
     GetDisassembler ();
 
bool                      m_no_more_plans;   // Need this one so we can tell if we stepped into a call,
                                                  // but can't continue, in which case we are done.
     bool                      m_first_run_event; // We want to broadcast only one running event, our first.
     lldb::BreakpointSP        m_next_branch_bp_sp;
     bool                      m_use_fast_step;
     bool                      m_given_ranges_only;
 
 private:
     std::vector<lldb::DisassemblerSP> m_instruction_ranges;
-    DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepRange);
 
+    DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepRange);
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepRange_h_
+#endif // liblldb_ThreadPlanStepRange_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepThrough.h

 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 
 namespace lldb_private {
 
 class ThreadPlanStepThrough : public ThreadPlan
 {
 public:
-    virtual ~ThreadPlanStepThrough ();
+    ~ThreadPlanStepThrough() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
-    virtual void DidPush();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
+    void DidPush() override;
 
 protected:
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
+    bool DoPlanExplainsStop(Event *event_ptr) override;
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
 
     ThreadPlanStepThrough (Thread &thread,
                            StackID &return_stack_id,
                            bool stop_others);
 
     void
     LookForPlanToStepThroughFromCurrentPC ();
     
     bool 
     HitOurBackstopBreakpoint();
 
 private:
     friend lldb::ThreadPlanSP
+
     Thread::QueueThreadPlanForStepThrough (StackID &return_stack_id,
                                            bool abort_other_plans,
                                            bool stop_others);
                                            
     void ClearBackstopBreakpoint();
 
     lldb::ThreadPlanSP m_sub_plan_sp;
     lldb::addr_t      m_start_address;
     lldb::break_id_t  m_backstop_bkpt_id;
     lldb::addr_t      m_backstop_addr;
     StackID           m_return_stack_id;
     bool              m_stop_others;
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepThrough);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepThrough_h_
+#endif // liblldb_ThreadPlanStepThrough_h_

lldb/trunk/include/lldb/Target/ThreadPlanStepUntil.h

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlan.h"
 
 namespace lldb_private {
 
-
 class ThreadPlanStepUntil : public ThreadPlan
 {
 public:
-    virtual ~ThreadPlanStepUntil ();
+    ~ThreadPlanStepUntil() override;
 
-    virtual void GetDescription (Stream *s, lldb::DescriptionLevel level);
-    virtual bool ValidatePlan (Stream *error);
-    virtual bool ShouldStop (Event *event_ptr);
-    virtual bool StopOthers ();
-    virtual lldb::StateType GetPlanRunState ();
-    virtual bool WillStop ();
-    virtual bool MischiefManaged ();
+    void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+    bool ValidatePlan(Stream *error) override;
+    bool ShouldStop(Event *event_ptr) override;
+    bool StopOthers() override;
+    lldb::StateType GetPlanRunState() override;
+    bool WillStop() override;
+    bool MischiefManaged() override;
 
 protected:
-    virtual bool DoWillResume (lldb::StateType resume_state, bool current_plan);
-    virtual bool DoPlanExplainsStop (Event *event_ptr);
+    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
+    bool DoPlanExplainsStop(Event *event_ptr) override;
 
     ThreadPlanStepUntil (Thread &thread,
                          lldb::addr_t *address_list,
                          size_t num_addresses,
                          bool stop_others,
                          uint32_t frame_idx = 0);
-    void AnalyzeStop(void);
 
-private:
+    void AnalyzeStop();
 
+private:
     StackID m_stack_id;
     lldb::addr_t m_step_from_insn;
     lldb::break_id_t m_return_bp_id;
     lldb::addr_t m_return_addr;
     bool m_stepped_out;
     bool m_should_stop;
     bool m_ran_analyze;
     bool m_explains_stop;
Thread::QueueThreadPlanForStepUntil (bool abort_other_plans,
                                          size_t num_addresses,
                                          bool stop_others,
                                          uint32_t frame_idx);
 
     // Need an appropriate marker for the current stack so we can tell step out
     // from step in.
 
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepUntil);
-
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanStepUntil_h_
+#endif // liblldb_ThreadPlanStepUntil_h_

lldb/trunk/include/lldb/Target/ThreadPlanTracer.h

 
 namespace lldb_private {
 
 class ThreadPlanTracer
 {
 friend class ThreadPlan;
 
 public:
-
     typedef enum ThreadPlanTracerStyle
     {
         eLocation = 0,
         eStateChange,
         eCheckFrames,
         ePython
     } ThreadPlanTracerStyle;
+
     ThreadPlanTracer (Thread &thread, lldb::StreamSP &stream_sp);    
     ThreadPlanTracer (Thread &thread);
         
-    virtual ~ThreadPlanTracer()
-    {
-    }
+    virtual ~ThreadPlanTracer() = default;
     
     virtual void TracingStarted ()
     {
-    
     }
     
     virtual void TracingEnded ()
     {
-    
     }
     
     bool
     EnableTracing(bool value)
     {
         bool old_value = m_enabled;
         m_enabled = value;
         if (old_value == false && value == true)
public:
     }
 
 protected:
     Thread &m_thread;
 
     Stream *
     GetLogStream ();
     
-    
-    
     virtual void Log();
     
 private:
     bool
     TracerExplainsStop ();
         
     bool m_single_step;
     bool m_enabled;
     lldb::StreamSP m_stream_sp;
 };
     
 class ThreadPlanAssemblyTracer : public ThreadPlanTracer
 {
 public:
     ThreadPlanAssemblyTracer (Thread &thread, lldb::StreamSP &stream_sp);    
     ThreadPlanAssemblyTracer (Thread &thread);    
-    virtual ~ThreadPlanAssemblyTracer ();
-    virtual void TracingStarted ();
-    virtual void TracingEnded ();
-    virtual void Log();
-private:
-    
+    ~ThreadPlanAssemblyTracer() override;
+
+    void TracingStarted() override;
+    void TracingEnded() override;
+    void Log() override;
+private:
     Disassembler *
     GetDisassembler ();
 
     TypeFromUser
     GetIntPointerType();
 
     lldb::DisassemblerSP    m_disassembler_sp;
     TypeFromUser            m_intptr_type;
     std::vector<RegisterValue> m_register_values;
     lldb::DataBufferSP      m_buffer_sp;
 };
 
 } // namespace lldb_private
 
-#endif  // liblldb_ThreadPlanTracer_h_
+#endif // liblldb_ThreadPlanTracer_h_