Correctly look up declarations in inline namespaces

[teemperor]

Summary

This patch marks the inline namespaces from DWARF as inline and also ensures that looking
up declarations now follows the lookup rules for inline namespaces.

[aprantl]

lldb/source/Symbol/ClangASTContext.cpp

10269 ↗

(On Diff #190031)

auto *

lldb/source/Symbol/CompilerDeclContext.cpp

68 ↗

(On Diff #190031)

would if (this == &other) also work?

[teemperor]

• Addressed Adrian's comments.

include/lldb/Symbol/ClangASTContext.h

public:
   // Returns a mask containing bits from the ClangASTContext::eTypeXXX
   // enumerations
 
   //------------------------------------------------------------------
   // Namespace Declarations
   //------------------------------------------------------------------
 
   clang::NamespaceDecl *
-  GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx);
+  GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx,
+                                bool is_inline = false);
 
   static clang::NamespaceDecl *
   GetUniqueNamespaceDeclaration(clang::ASTContext *ast, const char *name,
-                                clang::DeclContext *decl_ctx);
+                                clang::DeclContext *decl_ctx,
+                                bool is_inline = false);
 
   //------------------------------------------------------------------
   // Function Types
   //------------------------------------------------------------------
 
   clang::FunctionDecl *
   CreateFunctionDeclaration(clang::DeclContext *decl_ctx, const char *name,
                             const CompilerType &function_Type, int storage,
public:
 
   ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override;
 
   bool DeclContextIsClassMethod(void *opaque_decl_ctx,
                                 lldb::LanguageType *language_ptr,
                                 bool *is_instance_method_ptr,
                                 ConstString *language_object_name_ptr) override;
 
+  bool DeclContextIsContainedInLookup(void *opaque_decl_ctx,
+                                      void *other_opaque_decl_ctx) override;
+
   //----------------------------------------------------------------------
   // Clang specific clang::DeclContext functions
   //----------------------------------------------------------------------
 
   static clang::DeclContext *
   DeclContextGetAsDeclContext(const CompilerDeclContext &dc);
 
   static clang::ObjCMethodDecl *

include/lldb/Symbol/CompilerDeclContext.h

public:
   ///     Returns true if this is a decl context that represents a method
   ///     in a struct, union or class.
   //----------------------------------------------------------------------
   bool IsClassMethod(lldb::LanguageType *language_ptr,
                      bool *is_instance_method_ptr,
                      ConstString *language_object_name_ptr);
 
   //----------------------------------------------------------------------
+  /// Check if the given other decl context is contained in the lookup
+  /// of this decl context (for example because the other context is a nested
+  /// inline namespace).
+  ///
+  /// @param[in] other
+  ///     The other decl context for which we should check if it is contained
+  ///     in the lookoup of this context.
+  ///
+  /// @return
+  ///     Returns true iff the other decl context is contained in the lookup
+  ///     of this decl context.
+  //----------------------------------------------------------------------
+  bool IsContainedInLookup(CompilerDeclContext other) const;
+
+  //----------------------------------------------------------------------
   // Accessors
   //----------------------------------------------------------------------
 
   TypeSystem *GetTypeSystem() const { return m_type_system; }
 
   void *GetOpaqueDeclContext() const { return m_opaque_decl_ctx; }
 
   void SetDeclContext(TypeSystem *type_system, void *decl_ctx) {

include/lldb/Symbol/TypeSystem.h

public:
 
   virtual ConstString
   DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) = 0;
 
   virtual bool DeclContextIsClassMethod(
       void *opaque_decl_ctx, lldb::LanguageType *language_ptr,
       bool *is_instance_method_ptr, ConstString *language_object_name_ptr) = 0;
 
+  virtual bool DeclContextIsContainedInLookup(void *opaque_decl_ctx,
+                                              void *other_opaque_decl_ctx) = 0;
+
   //----------------------------------------------------------------------
   // Tests
   //----------------------------------------------------------------------
 
   virtual bool IsArrayType(lldb::opaque_compiler_type_t type,
                            CompilerType *element_type, uint64_t *size,
                            bool *is_incomplete) = 0;
 

packages/Python/lldbsuite/test/expression_command/inline-namespace/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/expression_command/inline-namespace/TestInlineNamespace.py

+"""
+Test that we correctly handle inline namespaces.
+"""
+
+import lldb
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestInlineNamespace(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self,
+            "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
+
+        # The 'A::B::f' function must be found via 'A::f' as 'B' is an inline
+        # namespace.
+        self.expect("expr A::f()", substrs=['$0 = 3'])
+        # But we should still find the function when we pretend the inline
+        # namespace is not inline.
+        self.expect("expr A::B::f()", substrs=['$1 = 3'])

packages/Python/lldbsuite/test/expression_command/inline-namespace/main.cpp

+namespace A {
+  inline namespace B {
+    int f() { return 3; }
+  };
+}
+
+int main(int argc, char **argv) {
+  // Set break point at this line.
+  return A::f();
+}

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (die && die.Tag() == DW_TAG_namespace) {
     clang::NamespaceDecl *namespace_decl =
         static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
     if (namespace_decl)
       return namespace_decl;
     else {
       const char *namespace_name = die.GetName();
       clang::DeclContext *containing_decl_ctx =
           GetClangDeclContextContainingDIE(die, nullptr);
-      namespace_decl = m_ast.GetUniqueNamespaceDeclaration(namespace_name,
-                                                           containing_decl_ctx);
+      bool is_inline =
+          die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0;
+
+      namespace_decl = m_ast.GetUniqueNamespaceDeclaration(
+          namespace_name, containing_decl_ctx, is_inline);
       Log *log =
           nullptr; // (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
       if (log) {
         SymbolFileDWARF *dwarf = die.GetDWARF();
         if (namespace_name) {
           dwarf->GetObjectFile()->GetModule()->LogMessage(
               log, "ASTContext => %p: 0x%8.8" PRIx64
                    ": DW_TAG_namespace with DW_AT_name(\"%s\") => "

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (decl_ctx == nullptr || !decl_ctx->IsValid())
     return true;
 
   if (die) {
     DWARFASTParser *dwarf_ast = die.GetDWARFParser();
     if (dwarf_ast) {
       CompilerDeclContext actual_decl_ctx =
           dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
       if (actual_decl_ctx)
-        return actual_decl_ctx == *decl_ctx;
+        return decl_ctx->IsContainedInLookup(actual_decl_ctx);
     }
   }
   return false;
 }
 
 uint32_t SymbolFileDWARF::FindFunctions(
     ConstString name, const CompilerDeclContext *parent_decl_ctx,
     FunctionNameType name_type_mask, bool include_inlines, bool append,

source/Symbol/ClangASTContext.cpp

if (cxx_record_decl) {
     } else
       num_bases = cxx_record_decl->getNumBases();
   }
   return num_bases;
 }
 
 #pragma mark Namespace Declarations
 
-NamespaceDecl *
-ClangASTContext::GetUniqueNamespaceDeclaration(const char *name,
-                                               DeclContext *decl_ctx) {
+NamespaceDecl *ClangASTContext::GetUniqueNamespaceDeclaration(
+    const char *name, DeclContext *decl_ctx, bool is_inline) {
   NamespaceDecl *namespace_decl = nullptr;
   ASTContext *ast = getASTContext();
   TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl();
   if (decl_ctx == nullptr)
     decl_ctx = translation_unit_decl;
 
   if (name) {
     IdentifierInfo &identifier_info = ast->Idents.get(name);
     DeclarationName decl_name(&identifier_info);
     clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
     for (NamedDecl *decl : result) {
       namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
       if (namespace_decl)
         return namespace_decl;
     }
 
     namespace_decl =
-        NamespaceDecl::Create(*ast, decl_ctx, false, SourceLocation(),
+        NamespaceDecl::Create(*ast, decl_ctx, is_inline, SourceLocation(),
                               SourceLocation(), &identifier_info, nullptr);
 
     decl_ctx->addDecl(namespace_decl);
   } else {
     if (decl_ctx == translation_unit_decl) {
       namespace_decl = translation_unit_decl->getAnonymousNamespace();
       if (namespace_decl)
         return namespace_decl;
NamespaceDecl *ClangASTContext::GetUniqueNamespaceDeclaration(
   }
 #ifdef LLDB_CONFIGURATION_DEBUG
   VerifyDecl(namespace_decl);
 #endif
   return namespace_decl;
 }
 
 NamespaceDecl *ClangASTContext::GetUniqueNamespaceDeclaration(
-    clang::ASTContext *ast, const char *name, clang::DeclContext *decl_ctx) {
+    clang::ASTContext *ast, const char *name, clang::DeclContext *decl_ctx,
+    bool is_inline) {
   ClangASTContext *ast_ctx = ClangASTContext::GetASTContext(ast);
   if (ast_ctx == nullptr)
     return nullptr;
 
-  return ast_ctx->GetUniqueNamespaceDeclaration(name, decl_ctx);
+  return ast_ctx->GetUniqueNamespaceDeclaration(name, decl_ctx, is_inline);
 }
 
 clang::BlockDecl *
 ClangASTContext::CreateBlockDeclaration(clang::DeclContext *ctx) {
   if (ctx != nullptr) {
     clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx,
                                                       clang::SourceLocation());
     ctx->addDecl(decl);
if (ObjCMethodDecl *objc_method =
           language_object_name_ptr->SetCString(metadata->GetObjectPtrName());
         return true;
       }
     }
   }
   return false;
 }
 
+bool ClangASTContext::DeclContextIsContainedInLookup(
+    void *opaque_decl_ctx, void *other_opaque_decl_ctx) {
+  auto *decl_ctx = (clang::DeclContext *)opaque_decl_ctx;
+  auto *other = (clang::DeclContext *)other_opaque_decl_ctx;
+
+  do {
+    // A decl context always includes its own contents in its lookup.
+    if (decl_ctx == other)
+      return true;
+
+    // If we have an inline namespace, then the lookup of the parent context
+    // also includes the inline namespace contents.
+  } while (other->isInlineNamespace() && (other = other->getParent()));
+
+  return false;
+}
+
 clang::DeclContext *
 ClangASTContext::DeclContextGetAsDeclContext(const CompilerDeclContext &dc) {
   if (dc.IsClang())
     return (clang::DeclContext *)dc.GetOpaqueDeclContext();
   return nullptr;
 }
 
 ObjCMethodDecl *

source/Symbol/CompilerDeclContext.cpp

bool CompilerDeclContext::IsClassMethod(lldb::LanguageType *language_ptr,
   if (IsValid())
     return m_type_system->DeclContextIsClassMethod(
         m_opaque_decl_ctx, language_ptr, is_instance_method_ptr,
         language_object_name_ptr);
   else
     return false;
 }
 
+bool CompilerDeclContext::IsContainedInLookup(CompilerDeclContext other) const {
+  if (!IsValid())
+    return false;
+
+  // If the other context is just the current context, we don't need to go
+  // over the type system to know that the lookup is identical.
+  if (this == &other)
+    return true;
+
+  return m_type_system->DeclContextIsContainedInLookup(m_opaque_decl_ctx,
+                                                       other.m_opaque_decl_ctx);
+}
+
 bool lldb_private::operator==(const lldb_private::CompilerDeclContext &lhs,
                               const lldb_private::CompilerDeclContext &rhs) {
   return lhs.GetTypeSystem() == rhs.GetTypeSystem() &&
          lhs.GetOpaqueDeclContext() == rhs.GetOpaqueDeclContext();
 }
 
 bool lldb_private::operator!=(const lldb_private::CompilerDeclContext &lhs,
                               const lldb_private::CompilerDeclContext &rhs) {
   return lhs.GetTypeSystem() != rhs.GetTypeSystem() ||
          lhs.GetOpaqueDeclContext() != rhs.GetOpaqueDeclContext();
 }