[clang][modules] NFC: Factor out path-based submodule lookup

[jansvoboda11]

Summary

This is a prep patch for D113775 that factors out the path-based submodule lookup used in CompilerInstance::loadModule.

[dexonsmith]

LGTM

clang/include/clang/Frontend/CompilerInstance.h

private:
   /// ModuleMap.  First attempt to load it from the given path on disk.  If that
   /// fails, defer to compileModuleAndReadAST, which will first build and then
   /// load it.
   ModuleLoadResult findOrCompileModuleAndReadAST(StringRef ModuleName,
                                                  SourceLocation ImportLoc,
                                                  SourceLocation ModuleNameLoc,
                                                  bool IsInclusionDirective);
 
+  // Get the submodule corresponding to the module path.
+  Module *getSubmoduleCorrespondingToPath(
+    bool &MapPrivateSubModToTopLevel, Module *Module, SourceLocation ImportLoc,
+    ModuleIdPath Path, Module::NameVisibilityKind Visibility,
+    bool IsInclusionDirective);
+
 public:
   ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path,
                               Module::NameVisibilityKind Visibility,
                               bool IsInclusionDirective) override;
 
   void createModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName,
                               StringRef Source) override;
 

clang/lib/Frontend/CompilerInstance.cpp

if (getPreprocessorOpts().FailedModules)
       getPreprocessorOpts().FailedModules->addFailed(ModuleName);
     return nullptr;
   }
 
   // Okay, we've rebuilt and now loaded the module.
   return M;
 }
 
-ModuleLoadResult
-CompilerInstance::loadModule(SourceLocation ImportLoc,
-                             ModuleIdPath Path,
-                             Module::NameVisibilityKind Visibility,
-                             bool IsInclusionDirective) {
-  // Determine what file we're searching from.
-  StringRef ModuleName = Path[0].first->getName();
-  SourceLocation ModuleNameLoc = Path[0].second;
-
-  // If we've already handled this import, just return the cached result.
-  // This one-element cache is important to eliminate redundant diagnostics
-  // when both the preprocessor and parser see the same import declaration.
-  if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
-    // Make the named module visible.
-    if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
-      TheASTReader->makeModuleVisible(LastModuleImportResult, Visibility,
-                                      ImportLoc);
-    return LastModuleImportResult;
-  }
-
-  // If we don't already have information on this module, load the module now.
-  Module *Module = nullptr;
-  ModuleMap &MM = getPreprocessor().getHeaderSearchInfo().getModuleMap();
-  if (auto MaybeModule = MM.getCachedModuleLoad(*Path[0].first)) {
-    // Use the cached result, which may be nullptr.
-    Module = *MaybeModule;
-  } else if (ModuleName == getLangOpts().CurrentModule) {
-    // This is the module we're building.
-    Module = PP->getHeaderSearchInfo().lookupModule(
-        ModuleName, ImportLoc, /*AllowSearch*/ true,
-        /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
-    /// FIXME: perhaps we should (a) look for a module using the module name
-    //  to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
-    //if (Module == nullptr) {
-    //  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
-    //    << ModuleName;
-    //  DisableGeneratingGlobalModuleIndex = true;
-    //  return ModuleLoadResult();
-    //}
-    MM.cacheModuleLoad(*Path[0].first, Module);
-  } else {
-    ModuleLoadResult Result = findOrCompileModuleAndReadAST(
-        ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective);
-    if (!Result.isNormal())
-      return Result;
-    if (!Result)
-      DisableGeneratingGlobalModuleIndex = true;
-    Module = Result;
-    MM.cacheModuleLoad(*Path[0].first, Module);
-  }
-
-  // If we never found the module, fail.  Otherwise, verify the module and link
-  // it up.
-  if (!Module)
-    return ModuleLoadResult();
+Module *CompilerInstance::getSubmoduleCorrespondingToPath(
+    bool &MapPrivateSubModToTopLevel, Module *Module, SourceLocation ImportLoc,
+    ModuleIdPath Path, Module::NameVisibilityKind Visibility,
+  MapPrivateSubModToTopLevel = false;
 
-  // Verify that the rest of the module path actually corresponds to
-  // a submodule.
-  bool MapPrivateSubModToTopLevel = false;
   for (unsigned I = 1, N = Path.size(); I != N; ++I) {
     StringRef Name = Path[I].first->getName();
     clang::Module *Sub = Module->findSubmodule(Name);
 
     // If the user is requesting Foo.Private and it doesn't exist, try to
     // match Foo_Private and emit a warning asking for the user to write
     // @import Foo_Private instead. FIXME: remove this when existing clients
     // migrate off of Foo.Private syntax.
if (!Sub) {
           << Path[I].first << Module->getFullModuleName()
           << SourceRange(Path[0].second, Path[I - 1].second);
       break;
     }
 
     Module = Sub;
   }
 
+  return Module;
+}
+
+ModuleLoadResult
+CompilerInstance::loadModule(SourceLocation ImportLoc,
+                             ModuleIdPath Path,
+                             Module::NameVisibilityKind Visibility,
+                             bool IsInclusionDirective) {
+  // Determine what file we're searching from.
+  StringRef ModuleName = Path[0].first->getName();
+  SourceLocation ModuleNameLoc = Path[0].second;
+
+  // If we've already handled this import, just return the cached result.
+  // This one-element cache is important to eliminate redundant diagnostics
+  // when both the preprocessor and parser see the same import declaration.
+  if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
+    // Make the named module visible.
+    if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
+      TheASTReader->makeModuleVisible(LastModuleImportResult, Visibility,
+                                      ImportLoc);
+    return LastModuleImportResult;
+  }
+
+  // If we don't already have information on this module, load the module now.
+  Module *Module = nullptr;
+  ModuleMap &MM = getPreprocessor().getHeaderSearchInfo().getModuleMap();
+  if (auto MaybeModule = MM.getCachedModuleLoad(*Path[0].first)) {
+    // Use the cached result, which may be nullptr.
+    Module = *MaybeModule;
+  } else if (ModuleName == getLangOpts().CurrentModule) {
+    // This is the module we're building.
+    Module = PP->getHeaderSearchInfo().lookupModule(
+        ModuleName, ImportLoc, /*AllowSearch*/ true,
+        /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
+    /// FIXME: perhaps we should (a) look for a module using the module name
+    //  to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
+    //if (Module == nullptr) {
+    //  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
+    //    << ModuleName;
+    //  DisableGeneratingGlobalModuleIndex = true;
+    //  return ModuleLoadResult();
+    //}
+    MM.cacheModuleLoad(*Path[0].first, Module);
+  } else {
+    ModuleLoadResult Result = findOrCompileModuleAndReadAST(
+        ModuleName, ImportLoc, ModuleNameLoc, IsInclusionDirective);
+    if (!Result.isNormal())
+      return Result;
+    if (!Result)
+      DisableGeneratingGlobalModuleIndex = true;
+    Module = Result;
+    MM.cacheModuleLoad(*Path[0].first, Module);
+  }
+
+  // If we never found the module, fail.  Otherwise, verify the module and link
+  // it up.
+  if (!Module)
+    return ModuleLoadResult();
+
+  bool MapPrivateSubModToTopLevel = false;
+  Module = getSubmoduleCorrespondingToPath(MapPrivateSubModToTopLevel, Module,
+                                           ImportLoc, Path, Visibility,
+                                           IsInclusionDirective);
+
   // Make the named module visible, if it's not already part of the module
   // we are parsing.
   if (ModuleName != getLangOpts().CurrentModule) {
     if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
       // We have an umbrella header or directory that doesn't actually include
       // all of the headers within the directory it covers. Complain about
       // this missing submodule and recover by forgetting that we ever saw
       // this submodule.