Add support for owning module information to TypeSystemClang.

[aprantl]

Summary

This was split out from https://reviews.llvm.org/D75488.

[labath]

Thanks for splitting this up. This seems fine to me. I'll leave the approval to the type system folks.

I don't know how much we care about the size of the Type class. If we did, there are ways this could be optimized. But I guess the fact that we stored m_is_complete_objc_class as a lone bool flag (and so changing that to a uint32_t doesn't cost anything) means that we don't really care that much about it.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

1445–1446

bad formatting

7621

here too

[teemperor]

I'm not a big fan of storing data in the ClangExternalASTSourceCallbacks. The main reason is that this external source only exists when the ASTContext in the TypeSystemClang is created by the TypeSystemClang. When the TypeSystem adopts an ASTContext there can be any (or none) ExternalASTSource so GetOrCreateClangModule would crash/assert. ClangExternalASTSourceCallbacks always knows its respective TypeSystemClang, so storing the data in TypeSystemClang and then getting it from there when getSourceDescriptor/getModule is called will always work (and saves you from RTTI-casting/checking the ExternalASTSource).

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

1211

All the m_* variables that correspond to a part of ASTContext are only initialized when the TypeSystemClang has created its own ASTContext, so this code would crash if that's not the case. Calling getASTContext().getX() is the way that always works.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

323

Could we change this (and all similar parameters) from an unsigned to at one of those:

• A typedef such as typedef unsigned ModuleID. It seems to be optional, so llvm::Optional<ModuleID> would be even better so I could pass llvm::None instead of 0.
• (preferred) A new ModuleID type that doesn't implicitly construct from unsigned. Many of these functions already take some kind of integer and I would prefer if we don't add more.

That would also make the GetOrCreateClangModule self-documenting.

513

Could this be declared next to GetOrCreateClangModule? This is currently declared in the middle of the CompilerDeclContext backend (which no longer makes so much sense with the new version of the patch).

1038

The correct way to get the SourceManager and LangOpts is to do getASTContext().getSourceManager(). m_language_options_up, m_source_manager_upetc. are only set if the TypeSystemClang created its own ASTContext but are null if the TypeSystemClang adopted an ASTContext (e.g., in an expression).

This can also return a reference instead of a pointer. I removed the option to have an empty TypeSystemClang.

[shafik]

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

89

Why not use uint32_t like we did above? If we are going to assume 32 bits we should just use the fixed width type.

[shafik]

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

996 ↗

(On Diff #248234)

We are passing around 0 everywhere and it is not obvious what it means at all.

Can we name this somehow or make it a type?

[aprantl]

Addressed review feedback and made the whole thing more type-safe.

[labath]

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

146

I am kinda lost at this point, so I'm not sure which patch introduces this, but... this name does not seem very ideal, as it sounds like it is related to lldb_private::Module, while it does not really have that much in common with it.

And then there's ClangModulesDeclVendor::ModuleID -- I have no idea what's the relationship of this to that..

[aprantl]

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

996 ↗

(On Diff #248234)

This is just an intermediate step and gets replaced in https://reviews.llvm.org/D75488

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

146

I agree. I'm going to clean this up some more and I will also merge this review into https://reviews.llvm.org/D75488 because it doesn't actually make reviewing easier to see these API changes without their use.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

89

That is consistent with the type Clang uses for module IDs.

[aprantl]

I'm merging this back into https://reviews.llvm.org/D75488 for easier reviewing.

[aprantl]

And then there's ClangModulesDeclVendor::ModuleID -- I have no idea what's the relationship of this to that..

ClangModulesDeclVendor::ModuleID is a typedef to clang::Module * so it is a bit of a misnomer, since clang calls the unsigned module numbers module ids.

lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.h

 //===-- ClangExternalASTSourceCallbacks.h -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXTERNALASTSOURCECALLBACKS_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXTERNALASTSOURCECALLBACKS_H
 
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "clang/Basic/Module.h"
 
 namespace lldb_private {
 
-class TypeSystemClang;
-
 class ClangExternalASTSourceCallbacks : public clang::ExternalASTSource {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   bool isA(const void *ClassID) const override { return ClassID == &ID; }
   static bool classof(const clang::ExternalASTSource *s) { return s->isA(&ID); }
public:
 
   TypeSystemClang &GetTypeSystem() const { return m_ast; }
 
   /// Module-related methods.
   /// \{
   llvm::Optional<clang::ASTSourceDescriptor>
   getSourceDescriptor(unsigned ID) override;
   clang::Module *getModule(unsigned ID) override;
-  unsigned RegisterModule(clang::Module *module);
-  unsigned GetIDForModule(clang::Module *module);
+  ModuleID RegisterModule(clang::Module *module);
+  ModuleID GetIDForModule(clang::Module *module);
   /// \}
 private:
   TypeSystemClang &m_ast;
   std::vector<clang::Module *> m_modules;
   llvm::DenseMap<clang::Module *, unsigned> m_ids;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXTERNALASTSOURCECALLBACKS_H

lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.cpp

void ClangExternalASTSourceCallbacks::FindExternalLexicalDecls(
   if (decl_ctx) {
     clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(
         const_cast<clang::DeclContext *>(decl_ctx));
     if (tag_decl)
       CompleteType(tag_decl);
   }
 }
 
-unsigned ClangExternalASTSourceCallbacks::RegisterModule(clang::Module *module) {
+ModuleID ClangExternalASTSourceCallbacks::RegisterModule(clang::Module *module) {
   m_modules.push_back(module);
   unsigned id = m_modules.size();
   m_ids.insert({module, id});
-  return id;
+  return ModuleID(id);
 }
 
 llvm::Optional<clang::ASTSourceDescriptor>
 ClangExternalASTSourceCallbacks::getSourceDescriptor(unsigned id) {
   if (clang::Module *module = getModule(id))
     return {*module};
   return {};
 }
 
 clang::Module *ClangExternalASTSourceCallbacks::getModule(unsigned id) {
   if (id && id <= m_modules.size())
     return m_modules[id - 1];
   return nullptr;
 }
 
-unsigned ClangExternalASTSourceCallbacks::GetIDForModule(clang::Module *module) {
-  return m_ids[module];
+ModuleID ClangExternalASTSourceCallbacks::GetIDForModule(clang::Module *module) {
+  return ModuleID(m_ids[module]);
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

protected:
   class DelayedAddObjCClassProperty;
   typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
 
   typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
       DIEToDeclContextMap;
   typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
       DeclContextToDIEMap;
+  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::ModuleID>
+      DIEToModuleMap;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
       DIEToDeclMap;
   typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
   lldb_private::TypeSystemClang &m_ast;
   DIEToDeclMap m_die_to_decl;
   DeclToDIEMap m_decl_to_die;
   DIEToDeclContextMap m_die_to_decl_ctx;
   DeclContextToDIEMap m_decl_ctx_to_die;
+  DIEToModuleMap m_die_to_module;
   std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
   /// @}
 
   clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
 
   clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);
 
   clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die);
protected:
   lldb_private::Type *GetTypeForDIE(const DWARFDIE &die);
 
   clang::Decl *GetClangDeclForDIE(const DWARFDIE &die);
 
   clang::DeclContext *GetClangDeclContextForDIE(const DWARFDIE &die);
 
   clang::DeclContext *GetClangDeclContextContainingDIE(const DWARFDIE &die,
                                                        DWARFDIE *decl_ctx_die);
+  lldb_private::ModuleID GetOwningModuleID(const DWARFDIE &die);
 
   bool CopyUniqueClassMethodTypes(const DWARFDIE &src_class_die,
                                   const DWARFDIE &dst_class_die,
                                   lldb_private::Type *class_type,
                                   std::vector<DWARFDIE> &failures);
 
   clang::DeclContext *GetCachedClangDeclContextForDIE(const DWARFDIE &die);
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
   if (pcm_type.IsDefined())
     GetClangASTImporter().RequireCompleteType(ClangUtil::GetQualType(type));
 
   SymbolFileDWARF *dwarf = die.GetDWARF();
   TypeSP type_sp(new Type(
       die.GetID(), dwarf, pcm_type_sp->GetName(), pcm_type_sp->GetByteSize(),
       nullptr, LLDB_INVALID_UID, Type::eEncodingInvalid,
       &pcm_type_sp->GetDeclaration(), type, Type::ResolveState::Forward));
+  TypePayloadClang(type_sp->GetPayload())
+      .SetOwningModuleID(GetOwningModuleID(die));
 
   dwarf->GetTypeList().Insert(type_sp);
   dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
   clang::TagDecl *tag_decl = TypeSystemClang::GetAsTagDecl(type);
-  if (tag_decl)
+  ModuleID owning_module = GetOwningModuleID(die);
+  if (tag_decl) {
+    TypeSystemClang::SetOwningModule(tag_decl, owning_module);
+    if (auto *rd = llvm::dyn_cast<clang::RecordDecl>(tag_decl))
+      for (clang::FieldDecl *fd : rd->fields())
+        TypeSystemClang::SetOwningModule(fd, owning_module);
+    if (auto *ed = llvm::dyn_cast<clang::EnumDecl>(tag_decl))
+      for (clang::EnumConstantDecl *ecd : ed->enumerators())
+        TypeSystemClang::SetOwningModule(ecd, owning_module);
     LinkDeclContextToDIE(tag_decl, die);
-  else {
+  } else {
+    if (auto *oid = TypeSystemClang::GetAsObjCInterfaceDecl(type)) {
+      TypeSystemClang::SetOwningModule(oid, owning_module);
+      for (clang::ObjCMethodDecl *omd : oid->methods())
+        TypeSystemClang::SetOwningModule(omd, owning_module);
+      for (clang::ObjCPropertyDecl *opd : oid->properties())
+        TypeSystemClang::SetOwningModule(opd, owning_module);
+    }
     clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
     if (defn_decl_ctx)
       LinkDeclContextToDIE(defn_decl_ctx, die);
   }
 
   return type_sp;
 }
 
if (cu_language == eLanguageTypeObjC ||
       }
     }
   }
 
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
       dwarf->GetUID(attrs.type.Reference()), encoding_data_type, &attrs.decl,
       clang_type, resolve_state);
+  TypePayloadClang(type_sp->GetPayload()).SetOwningModuleID(GetOwningModuleID(die));
 
   dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
   return type_sp;
 }
 
 TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
                                       const DWARFDIE &die,
                                       ParsedDWARFTypeAttributes &attrs) {
if (!enumerator_clang_type) {
             "", DW_ATE_signed, *attrs.byte_size * 8);
       } else {
         enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt);
       }
     }
 
     clang_type = m_ast.CreateEnumerationType(
         attrs.name.GetCString(), GetClangDeclContextContainingDIE(die, nullptr),
-        ModuleID(), attrs.decl, enumerator_clang_type, attrs.is_scoped_enum);
+        GetOwningModuleID(die), attrs.decl, enumerator_clang_type,
+        attrs.is_scoped_enum);
   } else {
     enumerator_clang_type = m_ast.GetEnumerationIntegerType(clang_type);
   }
 
   LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type), die);
 
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
       dwarf->GetUID(attrs.type.Reference()), Type::eEncodingIsUID, &attrs.decl,
       clang_type, Type::ResolveState::Forward);
+  TypePayloadClang(type_sp->GetPayload()).SetOwningModuleID(GetOwningModuleID(die));
 
   if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     if (die.HasChildren()) {
       bool is_signed = false;
       enumerator_clang_type.IsIntegerType(is_signed);
       ParseChildEnumerators(clang_type, is_signed,
                             type_sp->GetByteSize().getValueOr(0), die);
     }
if (!type_handled) {
         }
       }
 
       if (!function_decl) {
         // We just have a function that isn't part of a class
         function_decl = m_ast.CreateFunctionDeclaration(
             ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                       : containing_decl_ctx,
-            ModuleID(), attrs.name.GetCString(), clang_type, attrs.storage,
+            GetOwningModuleID(die),
+            attrs.name.GetCString(), clang_type, attrs.storage,
             attrs.is_inline);
 
         if (has_template_params) {
           TypeSystemClang::TemplateParameterInfos template_param_infos;
           ParseTemplateParameterInfos(die, template_param_infos);
           template_function_decl = m_ast.CreateFunctionDeclaration(
               ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                         : containing_decl_ctx,
-              ModuleID(), attrs.name.GetCString(), clang_type, attrs.storage,
-              attrs.is_inline);
+              GetOwningModuleID(die), attrs.name.GetCString(), clang_type,
+              attrs.storage, attrs.is_inline);
           clang::FunctionTemplateDecl *func_template_decl =
               m_ast.CreateFunctionTemplateDecl(
-                  containing_decl_ctx, ModuleID(), template_function_decl,
-                  attrs.name.GetCString(), template_param_infos);
+                  containing_decl_ctx, GetOwningModuleID(die),
+                  template_function_decl, attrs.name.GetCString(),
+                  template_param_infos);
           m_ast.CreateFunctionTemplateSpecializationInfo(
               function_decl, func_template_decl, template_param_infos);
         }
 
         lldbassert(function_decl);
 
         if (function_decl) {
           LinkDeclContextToDIE(function_decl, die);
if (!clang_type) {
     metadata.SetUserID(die.GetID());
     metadata.SetIsDynamicCXXType(dwarf->ClassOrStructIsVirtual(die));
 
     if (attrs.name.GetStringRef().contains('<')) {
       TypeSystemClang::TemplateParameterInfos template_param_infos;
       if (ParseTemplateParameterInfos(die, template_param_infos)) {
         clang::ClassTemplateDecl *class_template_decl =
             m_ast.ParseClassTemplateDecl(
-                decl_ctx, ModuleID(), attrs.accessibility,
+                decl_ctx, GetOwningModuleID(die), attrs.accessibility,
                 attrs.name.GetCString(), tag_decl_kind, template_param_infos);
         if (!class_template_decl) {
           if (log) {
             dwarf->GetObjectFile()->GetModule()->LogMessage(
                 log,
                 "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" "
                 "clang::ClassTemplateDecl failed to return a decl.",
                 static_cast<void *>(this), die.GetOffset(),
                 DW_TAG_value_to_name(tag), attrs.name.GetCString());
           }
           return TypeSP();
         }
 
         clang::ClassTemplateSpecializationDecl *class_specialization_decl =
             m_ast.CreateClassTemplateSpecializationDecl(
-                decl_ctx, ModuleID(), class_template_decl, tag_decl_kind,
-                template_param_infos);
+                decl_ctx, GetOwningModuleID(die), class_template_decl,
+                tag_decl_kind, template_param_infos);
         clang_type = m_ast.CreateClassTemplateSpecializationType(
             class_specialization_decl);
         clang_type_was_created = true;
 
         m_ast.SetMetadata(class_template_decl, metadata);
         m_ast.SetMetadata(class_specialization_decl, metadata);
       }
     }
 
     if (!clang_type_was_created) {
       clang_type_was_created = true;
       clang_type = m_ast.CreateRecordType(
-          decl_ctx, ModuleID(), attrs.accessibility, attrs.name.GetCString(),
-          tag_decl_kind, attrs.class_language, &metadata,
-          attrs.exports_symbols);
+          decl_ctx, GetOwningModuleID(die), attrs.accessibility,
+          attrs.name.GetCString(), tag_decl_kind, attrs.class_language,
+          &metadata, attrs.exports_symbols);
     }
   }
 
   // Store a forward declaration to this class type in case any
   // parameters in any class methods need it for the clang types for
   // function prototypes.
   LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
   type_sp = std::make_shared<Type>(
case DW_TAG_formal_parameter: {
 
         if (!skip) {
           Type *type = die.ResolveTypeUID(param_type_die_form.Reference());
           if (type) {
             function_param_types.push_back(type->GetForwardCompilerType());
 
             clang::ParmVarDecl *param_var_decl =
                 m_ast.CreateParameterDeclaration(
-                    containing_decl_ctx, ModuleID(), name,
+                    containing_decl_ctx, GetOwningModuleID(die), name,
                     type->GetForwardCompilerType(), storage);
             assert(param_var_decl);
             function_param_decls.push_back(param_var_decl);
 
             m_ast.SetMetadataAsUserID(param_var_decl, die.GetID());
           }
         }
       }
case DW_TAG_formal_parameter: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     Type *type = GetTypeForDIE(die);
     if (dwarf && type) {
       const char *name = die.GetName();
       clang::DeclContext *decl_context =
           TypeSystemClang::DeclContextGetAsDeclContext(
               dwarf->GetDeclContextContainingUID(die.GetID()));
       decl = m_ast.CreateVariableDeclaration(
-          decl_context, ModuleID(), name,
+          decl_context, GetOwningModuleID(die), name,
           ClangUtil::GetQualType(type->GetForwardCompilerType()));
     }
     break;
   }
   case DW_TAG_imported_declaration: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
     if (imported_uid) {
if (die) {
     if (decl_ctx) {
       LinkDeclContextToDIE(decl_ctx, die);
       return decl_ctx;
     }
   }
   return nullptr;
 }
 
+ModuleID DWARFASTParserClang::GetOwningModuleID(const DWARFDIE &die) {
+  if (!die.IsValid())
+    return {};
+
+  for (DWARFDIE parent = die.GetParent(); parent.IsValid();
+       parent = parent.GetParent()) {
+    const dw_tag_t tag = parent.Tag();
+    if (tag == DW_TAG_module) {
+      DWARFDIE module_die = parent;
+      auto it = m_die_to_module.find(module_die.GetDIE());
+      if (it != m_die_to_module.end())
+        return it->second;
+      const char *name = module_die.GetAttributeValueAsString(DW_AT_name, 0);
+      if (!name)
+        return {};
+
+      ModuleID id =
+          m_ast.GetOrCreateClangModule(name, GetOwningModuleID(module_die));
+      m_die_to_module.insert({module_die.GetDIE(), id});
+      return id;
+    }
+  }
+  return {};
+}
+
 static bool IsSubroutine(const DWARFDIE &die) {
   switch (die.Tag()) {
   case DW_TAG_subprogram:
   case DW_TAG_inlined_subroutine:
     return true;
   default:
     return false;
   }
clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_lexical_block) {
     clang::BlockDecl *decl =
         llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
 
     if (!decl) {
       DWARFDIE decl_context_die;
       clang::DeclContext *decl_context =
           GetClangDeclContextContainingDIE(die, &decl_context_die);
-      decl = m_ast.CreateBlockDeclaration(decl_context, ModuleID());
+      decl = m_ast.CreateBlockDeclaration(decl_context, GetOwningModuleID(die));
 
       if (decl)
         LinkDeclContextToDIE((clang::DeclContext *)decl, die);
     }
 
     return decl;
   }
   return nullptr;

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

public:
 
   static constexpr unsigned ObjCClassBit = 1 << 31;
   bool IsCompleteObjCClass() { return Flags(m_payload).Test(ObjCClassBit); }
   void SetIsCompleteObjCClass(bool is_complete_objc_class) {
     m_payload = is_complete_objc_class ? Flags(m_payload).Set(ObjCClassBit)
                                        : Flags(m_payload).Clear(ObjCClassBit);
   }
   ModuleID GetOwningModuleID() {
     return ModuleID(Flags(m_payload).Clear(ObjCClassBit));
   }
   void SetOwningModuleID(ModuleID id);
   /// \}
 };
   
 /// A TypeSystem implementation based on Clang.
 ///
 /// This class uses a single clang::ASTContext as the backend for storing
public:
   ConvertAccessTypeToAccessSpecifier(lldb::AccessType access);
 
   static clang::AccessSpecifier
   UnifyAccessSpecifiers(clang::AccessSpecifier lhs, clang::AccessSpecifier rhs);
 
   static uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl,
                                     bool omit_empty_base_classes);
 
-  /// Synthesize a clang::Module and return its ID or 0.
-  unsigned GetOrCreateClangModule(llvm::StringRef name, unsigned parent,
+  /// Synthesize a clang::Module and return its ID or a default-constructed ID.
+  ModuleID GetOrCreateClangModule(llvm::StringRef name, ModuleID parent,
                                   bool is_framework = false,
                                   bool is_explicit = false);
 
   CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
                                 ModuleID owning_module,
                                 lldb::AccessType access_type,
                                 llvm::StringRef name, int kind,
                                 lldb::LanguageType language,
                                 ClangASTMetadata *metadata = nullptr,
                                 bool exports_symbols = false);
 
   class TemplateParameterInfos {
   public:
public:
 
   /// Creates a CompilerDeclContext from the given DeclContext
   /// with the current TypeSystemClang instance as its typesystem.
   /// The DeclContext has to come from the ASTContext of this
   /// TypeSystemClang.
   CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx);
 
   /// Set the owning module for \p decl.
   static void SetOwningModule(clang::Decl *decl, ModuleID owning_module);
 
   std::vector<CompilerDecl>
   DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
                             const bool ignore_using_decls) override;
 
   ConstString DeclContextGetName(void *opaque_decl_ctx) override;
 
   ConstString DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override;
#endif
 
   clang::DeclarationName
   GetDeclarationName(const char *name, const CompilerType &function_clang_type);
 
   clang::LangOptions *GetLangOpts() const {
     return m_language_options_up.get();
   }
   clang::SourceManager *GetSourceMgr() const {
     return m_source_manager_up.get();
   }
 
 private:
   const clang::ClassTemplateSpecializationDecl *
   GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type);
 
   // Classes that inherit from TypeSystemClang can see and modify these
   std::string m_target_triple;

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

if (clang::ObjCInterfaceDecl *interface_decl =
     return GetTypeForDecl(interface_decl);
   if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
     return GetTypeForDecl(tag_decl);
   return CompilerType();
 }
 
 CompilerType TypeSystemClang::GetTypeForDecl(TagDecl *decl) {
   return GetType(getASTContext().getTagDeclType(decl));
 }
 
 CompilerType TypeSystemClang::GetTypeForDecl(ObjCInterfaceDecl *decl) {
   return GetType(getASTContext().getObjCInterfaceType(decl));
 }
 
 #pragma mark Structure, Unions, Classes
 
 void TypeSystemClang::SetOwningModule(clang::Decl *decl, ModuleID owning_module) {
   if (!decl || !owning_module.HasValue())
     return;
 
   decl->setFromASTFile();
   decl->setOwningModuleID(*owning_module.get());
   decl->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible);
 }
 
-unsigned TypeSystemClang::GetOrCreateClangModule(llvm::StringRef name,
-                                                 unsigned parent,
+ModuleID TypeSystemClang::GetOrCreateClangModule(llvm::StringRef name,
+                                                 ModuleID parent,
                                                  bool is_framework,
                                                  bool is_explicit) {
   // Get the external AST source which holds the modules.
   auto *ast_source = llvm::dyn_cast_or_null<ClangExternalASTSourceCallbacks>(
       getASTContext().getExternalSource());
   assert(ast_source && "external ast source was lost");
   if (!ast_source)
-    return 0;
+    return {};
 
   // Lazily initialize the module map.
   if (!m_header_search_up) {
     auto HSOpts = std::make_shared<clang::HeaderSearchOptions>();
     m_header_search_up = std::make_unique<clang::HeaderSearch>(
         HSOpts, *m_source_manager_up, *m_diagnostics_engine_up,
         *m_language_options_up, m_target_info_up.get());
     m_module_map_up = std::make_unique<clang::ModuleMap>(
         *m_source_manager_up, *m_diagnostics_engine_up, *m_language_options_up,
         m_target_info_up.get(), *m_header_search_up);
   }
 
   // Get or create the module context.
   bool created;
   clang::Module *module;
-  auto parent_desc = ast_source->getSourceDescriptor(parent);
+  auto parent_desc = ast_source->getSourceDescriptor(parent.id);
   std::tie(module, created) = m_module_map_up->findOrCreateModule(
       name, parent_desc ? parent_desc->getModuleOrNull() : nullptr,
       is_framework, is_explicit);
   if (!created)
     return ast_source->GetIDForModule(module);
 
   module->Name = name.str();
   return ast_source->RegisterModule(module);

 }
 
 void TypeSystemClang::CreateFunctionTemplateSpecializationInfo(
     FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl,
     const TemplateParameterInfos &infos) {
   TemplateArgumentList *template_args_ptr =
       TemplateArgumentList::CreateCopy(func_decl->getASTContext(), infos.args);
 
   func_decl->setFunctionTemplateSpecialization(func_tmpl_decl,
                                                template_args_ptr, nullptr);
 }
 
 ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl(
     DeclContext *decl_ctx, ModuleID owning_module, lldb::AccessType access_type,
     const char *class_name, int kind,
     const TemplateParameterInfos &template_param_infos) {
   ASTContext &ast = getASTContext();
 
if (!getter_sel.isNull() && !getter) {
     const bool isImplicitlyDeclared = true;
     const bool isDefined = false;
     const clang::ObjCMethodDecl::ImplementationControl impControl =
         clang::ObjCMethodDecl::None;
     const bool HasRelatedResultType = false;
 
     getter = clang::ObjCMethodDecl::CreateDeserialized(clang_ast, 0);
     getter->setDeclName(getter_sel);
     getter->setReturnType(ClangUtil::GetQualType(property_clang_type_to_access));
     getter->setDeclContext(class_interface_decl);
     getter->setInstanceMethod(isInstance);
     getter->setVariadic(isVariadic);
     getter->setPropertyAccessor(isPropertyAccessor);
     getter->setSynthesizedAccessorStub(isSynthesizedAccessorStub);
     getter->setImplicit(isImplicitlyDeclared);
     getter->setDefined(isDefined);
     getter->setDeclImplementation(impControl);

lldb/test/Shell/SymbolFile/DWARF/Inputs/ModuleOwnership/A.h

+#include "B.h"                                                 // -*- ObjC -*-
+
+typedef int Typedef;
+
+struct TopLevelStruct {
+  int a;
+};
+
+typedef struct Struct_s {
+  int a;
+} Struct;
+
+struct Nested {
+  StructB fromb;
+};
+
+typedef enum Enum_e {
+  a = 0
+} Enum;
+
+@interface SomeClass {}
+@end
+
+template<typename T> struct Template { T field; };
+extern template struct Template<int>;
+
+namespace Namespace {
+template<typename T> struct InNamespace { T field; };
+extern template struct InNamespace<int>;
+}

lldb/test/Shell/SymbolFile/DWARF/Inputs/ModuleOwnership/B.h

+typedef struct {
+  int b;
+} StructB;
+
+namespace Namespace {
+template<typename T> struct AlsoInNamespace { T field; };
+ extern template struct AlsoInNamespace<int>;
+}

lldb/test/Shell/SymbolFile/DWARF/Inputs/ModuleOwnership/module.modulemap

+module A {
+  header "A.h"
+  module B {
+    header "B.h"
+  }
+}

lldb/test/Shell/SymbolFile/DWARF/lit.local.cfg

-config.suffixes = ['.cpp', '.m', '.s', '.test', '.ll']
+config.suffixes = ['.cpp', '.m', '.mm', '.s', '.test', '.ll']

lldb/test/Shell/SymbolFile/DWARF/module-ownership.mm

+// RUN: %clang --target=x86_64-apple-macosx -g -gmodules \
+// RUN:    -fmodules -fmodules-cache-path=%t.cache \
+// RUN:    -c -o %t.o %s -I%S/Inputs
+// RUN: lldb-test symbols -dump-clang-ast %t.o | FileCheck %s
+// Verify that the owning module information from DWARF is preserved in the AST. 
+
+@import A;
+
+Typedef t1;
+// CHECK-DAG: TypedefDecl {{.*}} imported in A Typedef
+
+TopLevelStruct s1;
+// CHECK-DAG: CXXRecordDecl {{.*}} imported in A struct TopLevelStruct
+// CHECK-DAG: -FieldDecl {{.*}} in A a 'int'
+
+Struct s2;
+// CHECK-DAG: CXXRecordDecl {{.*}} imported in A struct
+
+StructB s3;
+// CHECK-DAG: CXXRecordDecl {{.*}} imported in A.B struct
+// CHECK-DAG: -FieldDecl {{.*}} in A.B b 'int'
+
+Nested s4;
+// CHECK-DAG: CXXRecordDecl {{.*}} imported in A struct Nested
+// CHECK-DAG: -FieldDecl {{.*}} in A fromb 'StructB'
+
+Enum e1;
+// CHECK-DAG: EnumDecl {{.*}} imported in A Enum_e
+// CHECK-DAG: -EnumConstantDecl {{.*}} imported in A a
+
+SomeClass *obj1;
+// CHECK-DAG: ObjCInterfaceDecl {{.*}} imported in A SomeClass
+
+Template<int> t2;
+// CHECK-DAG: ClassTemplateSpecializationDecl {{.*}} imported in A struct Template
+
+Namespace::InNamespace<int> t3;
+// CHECK-DAG: ClassTemplateSpecializationDecl {{.*}} imported in A struct InNamespace
+
+Namespace::AlsoInNamespace<int> t4;
+// CHECK-DAG: ClassTemplateSpecializationDecl {{.*}} imported in A.B struct AlsoInNamespace