ASTContext: Provide a query for module initializer contents.

[iains]

Summary

When deciding if a global module fragement decl is unused, we have
to account for the case that it is emitted as part of the module
initializer. In order to make this more efficient, modify the container
used to cache the module intializer decls.

[ChuanqiXu]

LGTM with a nits.

clang/include/clang/AST/ASTContext.h

1083

Nit: It looks better with containsModuleInitializer.

[iains]

although this was approved, we did not need to use it to implement the dependent changes.

clang/include/clang/AST/ASTContext.h

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Allocator.h"
class ASTContext : public RefCountedBase<ASTContext> {
   /// definitions of that entity.
   llvm::DenseMap<NamedDecl*, llvm::TinyPtrVector<Module*>> MergedDefModules;
 
   /// Initializers for a module, in order. Each Decl will be either
   /// something that has a semantic effect on startup (such as a variable with
   /// a non-constant initializer), or an ImportDecl (which recursively triggers
   /// initialization of another module).
   struct PerModuleInitializers {
-    llvm::SmallVector<Decl*, 4> Initializers;
+    llvm::SmallSetVector<Decl *, 4> Initializers;
     llvm::SmallVector<uint32_t, 4> LazyInitializers;
 
     void resolve(ASTContext &Ctx);
   };
   llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers;
 
   /// For module code-gen cases, this is the top-level module we are building.
   Module *TopLevelModule = nullptr;
public:
   /// or an ImportDecl nominating another module that has initializers.
   void addModuleInitializer(Module *M, Decl *Init);
 
   void addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs);
 
   /// Get the initializations to perform when importing a module, if any.
   ArrayRef<Decl*> getModuleInitializers(Module *M);
 
+  /// Does the module initializer array contain this decl.
+  bool moduleInitializerContains(Module *M, const Decl *D);
+
   /// Set the (C++20) module we are building.
   void setModuleForCodeGen(Module *M) { TopLevelModule = M; }
 
   /// Get module under construction, nullptr if this is not a C++20 module.
   Module *getModuleForCodeGen() const { return TopLevelModule; }
 
   TranslationUnitDecl *getTranslationUnitDecl() const {
     return TUDecl->getMostRecentDecl();

clang/lib/AST/ASTContext.cpp

void ASTContext::PerModuleInitializers::resolve(ASTContext &Ctx) {
 
   auto *Source = Ctx.getExternalSource();
   assert(Source && "lazy initializers but no external source");
 
   auto LazyInits = std::move(LazyInitializers);
   LazyInitializers.clear();
 
   for (auto ID : LazyInits)
-    Initializers.push_back(Source->GetExternalDecl(ID));
+    Initializers.insert(Source->GetExternalDecl(ID));
 
   assert(LazyInitializers.empty() &&
          "GetExternalDecl for lazy module initializer added more inits");
 }
 
 void ASTContext::addModuleInitializer(Module *M, Decl *D) {
   // One special case: if we add a module initializer that imports another
   // module, and that module's only initializer is an ImportDecl, simplify.
if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
       if (isa<ImportDecl>(OnlyDecl))
         D = OnlyDecl;
     }
   }
 
   auto *&Inits = ModuleInitializers[M];
   if (!Inits)
     Inits = new (*this) PerModuleInitializers;
-  Inits->Initializers.push_back(D);
+  Inits->Initializers.insert(D);
 }
 
 void ASTContext::addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs) {
   auto *&Inits = ModuleInitializers[M];
   if (!Inits)
     Inits = new (*this) PerModuleInitializers;
   Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
                                  IDs.begin(), IDs.end());
 }
 
 ArrayRef<Decl *> ASTContext::getModuleInitializers(Module *M) {
   auto It = ModuleInitializers.find(M);
   if (It == ModuleInitializers.end())
     return None;
 
   auto *Inits = It->second;
   Inits->resolve(*this);
-  return Inits->Initializers;
+  return Inits->Initializers.getArrayRef();
+}
+
+bool ASTContext::moduleInitializerContains(Module *M, const Decl *D) {
+  auto It = ModuleInitializers.find(M);
+  if (It == ModuleInitializers.end())
+    return false;
+
+  auto *Inits = It->second;
+  Inits->resolve(*this);
+  return Inits->Initializers.contains(const_cast<Decl *>(D));
 }
 
 ExternCContextDecl *ASTContext::getExternCContextDecl() const {
   if (!ExternCContext)
     ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl());
 
   return ExternCContext;
 }