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/Basic/Module.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; }
 };
 
 
 } // namespace clang
 
 #endif // LLVM_CLANG_BASIC_MODULE_H

clang/lib/Basic/Module.cpp

for (auto &C : V.M->Conflicts) {
           Path.push_back(I->M);
         Cb(Path, C.Other, C.Message);
       }
     }
   };
   VisitModule({M, nullptr});
 }
 
-ASTSourceDescriptor::ASTSourceDescriptor(const Module &M)
+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 ASTSourceDescriptor::getModuleName() const {
   if (ClangModule)
     return ClangModule->Name;
   else
     return std::string(PCHModuleName);
 }

clang/lib/Serialization/ASTReader.cpp

unsigned ASTReader::getModuleFileID(ModuleFile *F) {
   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<ASTSourceDescriptor>
 ASTReader::getSourceDescriptor(unsigned ID) {
-  if (const Module *M = getSubmodule(ID))
+  if (Module *M = getSubmodule(ID))
     return 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);