[C++20][Modules][6/8] Record direct module imports.

[iains]

Summary

This is a small cache to avoid having to check both Exports and
Imports.

[iains]

Rebased onto dependent patch after changes

[iains]

rebased onto import state machine.

[iains]

Rebased onto other modules work.

[iains]

patch 6 of 8 to implement basic C++20 module partition support.

[iains]

rebased onto changes in parent patches.

[ChuanqiXu]

hmmm, I don't find this is used in following patch. Oversight?

[ChuanqiXu]

Sorry, I took an oversight.

[iains]

rebased onto parent patch changes

[iains]

rebased

[iains]

rebased.

[iains]

rebased

clang/include/clang/Sema/Sema.h

struct ModuleScope {
     bool ModuleInterface = false;
     bool IsPartition = false;
     bool ImplicitGlobalModuleFragment = false;
     VisibleModuleSet OuterVisibleModules;
   };
   /// The modules we're currently parsing.
   llvm::SmallVector<ModuleScope, 16> ModuleScopes;
 
+  /// The modules we imported directly.
+  llvm::SmallPtrSet<clang::Module *, 8> DirectModuleImports;
+
   /// Namespace definitions that we will export when they finish.
   llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces;
 
   /// Get the module whose scope we are currently within.
   Module *getCurrentModule() const {
     return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
   }
 
private:
   VisibleModuleSet VisibleModules;
 
 public:
   /// Get the module owning an entity.
   Module *getOwningModule(const Decl *Entity) {
     return Entity->getOwningModule();
   }
 
+  bool isModuleDirectlyImported(const Module *M) {
+    return DirectModuleImports.contains(M);
+  }
+
   /// Make a merged definition of an existing hidden definition \p ND
   /// visible at the specified location.
   void makeMergedDefinitionVisible(NamedDecl *ND);
 
   bool isModuleVisible(const Module *M, bool ModulePrivate = false);
 
   // When loading a non-modular PCH files, this is used to restore module
   // visibility.

clang/lib/Sema/SemaModule.cpp

DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
   if (getLangOpts().CPlusPlusModules && !ModuleScopes.empty() &&
       ModuleScopes.back().Module->isModulePurview() &&
       ModuleScopes.back().Module == Mod) {
     Diag(ImportLoc, diag::err_module_self_import_cxx20)
          << Mod->getFullModuleName()
          << !ModuleScopes.back().ModuleInterface;
   }
 
+  // In some cases we need to know if an entity was present in a directly-
+  // imported module (as opposed to a transitive import).
+  DirectModuleImports.insert(Mod);
+
   // FIXME: we should support importing a submodule within a different submodule
   // of the same top-level module. Until we do, make it an error rather than
   // silently ignoring the import.
   // Import-from-implementation is valid in the Modules TS. FIXME: Should we
   // warn on a redundant import of the current module?
   // FIXME: Import of a module from an implementation partition of the same
   // module is permitted.
   if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&