Remove const qualifier from Modules returned by ExternalASTSource. (NFC)

[aprantl]

Summary

This API is used by LLDB to attach owning module information to Declarations deserialized from DWARF.

[aprantl]

Rebase.

[teemperor]

Can you link what code is actually requiring this change? I just went over the patch series and it's not obvious to me what exactly this is used for.

[aprantl]

I added a comment to D75488. It's in getOrCreateModule().

[aprantl]

Pinging @teemperor

[teemperor]

I am fine with this if we *really* need it for D75488. So far the only direct place where we do need the module to be non-const was some redundant assignment for Name (I added a comment in D75488), but if that is removed I believe the rest of the code should work with a const Module.

[teemperor]

I seems quite a lot of APIs in Clang are already requiring non-const Modules so I think this is fine to make D75488 possible. Let's ship it

clang/include/clang/AST/ExternalASTSource.h

   /// Abstracts clang modules and precompiled header files and holds
   /// everything needed to generate debug info for an imported module
   /// or PCH.
   class ASTSourceDescriptor {
     StringRef PCHModuleName;
     StringRef Path;
     StringRef ASTFile;
     ASTFileSignature Signature;
-    const Module *ClangModule = nullptr;
+    Module *ClangModule = nullptr;
 
   public:
     ASTSourceDescriptor() = default;
     ASTSourceDescriptor(StringRef Name, StringRef Path, StringRef ASTFile,
                         ASTFileSignature Signature)
         : PCHModuleName(std::move(Name)), Path(std::move(Path)),
           ASTFile(std::move(ASTFile)), Signature(Signature) {}
-    ASTSourceDescriptor(const Module &M);
+    ASTSourceDescriptor(Module &M);
 
     std::string getModuleName() const;
     StringRef getPath() const { return Path; }
     StringRef getASTFile() const { return ASTFile; }
     ASTFileSignature getSignature() const { return Signature; }
-    const Module *getModuleOrNull() const { return ClangModule; }
+    Module *getModuleOrNull() const { return ClangModule; }
   };
 
   /// Return a descriptor for the corresponding module, if one exists.
   virtual llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID);
 
   enum ExtKind { EK_Always, EK_Never, EK_ReplyHazy };
 
   virtual ExtKind hasExternalDefinitions(const Decl *D);

clang/lib/AST/ExternalASTSource.cpp

ExternalASTSource::getSourceDescriptor(unsigned ID) {
   return None;
 }
 
 ExternalASTSource::ExtKind
 ExternalASTSource::hasExternalDefinitions(const Decl *D) {
   return EK_ReplyHazy;
 }
 
-ExternalASTSource::ASTSourceDescriptor::ASTSourceDescriptor(const Module &M)
+ExternalASTSource::ASTSourceDescriptor::ASTSourceDescriptor(Module &M)
   : Signature(M.Signature), ClangModule(&M) {
   if (M.Directory)
     Path = M.Directory->getName();
   if (auto *File = M.getASTFile())
     ASTFile = File->getName();
 }
 
 std::string ExternalASTSource::ASTSourceDescriptor::getModuleName() const {

clang/lib/Serialization/ASTReader.cpp

   auto PCHModules = getModuleManager().pch_modules();
   auto I = llvm::find(PCHModules, F);
   assert(I != PCHModules.end() && "emitting reference to unknown file");
   return (I - PCHModules.end()) << 1;
 }
 
 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
 ASTReader::getSourceDescriptor(unsigned ID) {
-  if (const Module *M = getSubmodule(ID))
+  if (Module *M = getSubmodule(ID))
     return ExternalASTSource::ASTSourceDescriptor(*M);
 
   // If there is only a single PCH, return it instead.
   // Chained PCH are not supported.
   const auto &PCHChain = ModuleMgr.pch_modules();
   if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
     ModuleFile &MF = ModuleMgr.getPrimaryModule();
     StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);