[C++20] [Modules] Replace is ModuleMapModule with isHeaderLikeModules

[ChuanqiXu]

Summary

I find that many places we should use isHeaderLikeModules instead of isModuleMapModules since the semantics of clang module map modules are similar to header units.

But the downside of the patch is that it misses test cases. Another alternative will be add the test case one by one, which will be more painful and slower but more stable.

clang/lib/CodeGen/CodeGenModule.cpp

bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
   }
   if (const auto *VD = dyn_cast<VarDecl>(Global)) {
     if (Context.getInlineVariableDefinitionKind(VD) ==
         ASTContext::InlineVariableDefinitionKind::WeakUnknown)
       // A definition of an inline constexpr static data member may change
       // linkage later if it's redeclared outside the class.
       return false;
     if (CXX20ModuleInits && VD->getOwningModule() &&
-        !VD->getOwningModule()->isModuleMapModule()) {
+        !VD->getOwningModule()->isHeaderLikeModule()) {
       // For CXX20, module-owned initializers need to be deferred, since it is
       // not known at this point if they will be run for the current module or
       // as part of the initializer for an imported one.
       return false;
     }
   }
   // If OpenMP is enabled and threadprivates must be generated like TLS, delay
   // codegen for global variables, because they may be marked as threadprivate.
if (!Import->getImportedOwningModule()) {
       if (CGDebugInfo *DI = getModuleDebugInfo())
         DI->EmitImportDecl(*Import);
     }
 
     // For C++ standard modules we are done - we will call the module
     // initializer for imported modules, and that will likewise call those for
     // any imports it has.
     if (CXX20ModuleInits && Import->getImportedOwningModule() &&
-        !Import->getImportedOwningModule()->isModuleMapModule())
+        !Import->getImportedOwningModule()->isHeaderLikeModule())
       break;
 
     // For clang C++ module map modules the initializers for sub-modules are
     // emitted here.
 
     // Find all of the submodules and emit the module initializers.
     llvm::SmallPtrSet<clang::Module *, 16> Visited;
     SmallVector<clang::Module *, 16> Stack;

clang/lib/Sema/SemaDecl.cpp

if (getLangOpts().CPlusPlus) {
     // The rules for implicit inlines changed in C++20 for methods and friends
     // with an in-class definition (when such a definition is not attached to
     // the global module).  User-specified 'inline' overrides this (set when
     // the function decl is created above).
     // FIXME: We need a better way to separate C++ standard and clang modules.
     bool ImplicitInlineCXX20 = !getLangOpts().CPlusPlusModules ||
                                !NewFD->getOwningModule() ||
                                NewFD->getOwningModule()->isGlobalModule() ||
-                               NewFD->getOwningModule()->isModuleMapModule();
+                               NewFD->getOwningModule()->isHeaderLikeModule();
     bool isInline = D.getDeclSpec().isInlineSpecified();
     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
     bool hasExplicit = D.getDeclSpec().hasExplicitSpecifier();
     isFriend = D.getDeclSpec().isFriendSpecified();
     if (isFriend && !isInline && D.isFunctionDefinition()) {
       // Pre-C++20 [class.friend]p5
       //   A function can be defined in a friend declaration of a
       //   class . . . . Such a function is implicitly inline.

clang/lib/Sema/SemaLookup.cpp

 // FIXME: Return false directly if we don't have an interface dependency on the
 // translation unit containing D.
 bool LookupResult::isReachableSlow(Sema &SemaRef, NamedDecl *D) {
   assert(!isVisible(SemaRef, D) && "Shouldn't call the slow case.\n");
 
   Module *DeclModule = SemaRef.getOwningModule(D);
   assert(DeclModule && "hidden decl has no owning module");
 
-  // Entities in module map modules are reachable only if they're visible.
-  if (DeclModule->isModuleMapModule())
+  // Entities in header like modules are reachable only if they're visible.
+  if (DeclModule->isHeaderLikeModule())
     return false;
 
   // If D comes from a module and SemaRef doesn't own a module, it implies D
   // comes from another TU. In case SemaRef owns a module, we could judge if D
   // comes from another TU by comparing the module unit.
   if (SemaRef.isModuleUnitOfCurrentTU(DeclModule))
     return true;
 

clang/lib/Sema/SemaOverload.cpp

void Sema::AddOverloadCandidate(
   if (!AllowExplicit && ExplicitSpecifier::getFromDecl(Function).isExplicit()) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_explicit;
     return;
   }
 
   // Functions with internal linkage are only viable in the same module unit.
   if (auto *MF = Function->getOwningModule()) {
-    if (getLangOpts().CPlusPlusModules && !MF->isModuleMapModule() &&
+    if (getLangOpts().CPlusPlusModules && !MF->isHeaderLikeModule() &&
         !isModuleUnitOfCurrentTU(MF)) {
       /// FIXME: Currently, the semantics of linkage in clang is slightly
       /// different from the semantics in C++ spec. In C++ spec, only names
       /// have linkage. So that all entities of the same should share one
       /// linkage. But in clang, different entities of the same could have
       /// different linkage.
       NamedDecl *ND = Function;
       if (auto *SpecInfo = Function->getTemplateSpecializationInfo())