[cxxmodules] Do not cache the file lookup failure.

In cases where we have the module cache path and prebuilt module path pointing
to the same location, the FileManager should not cache the module file lookup
failure because it may currently be building the module.

This patch is necessary because the global module index is built from the
module cache path and it is loaded from the prebuilt module path.

In a full explicit or implicit module build infrastructure this is not a problem.
However, in a mixed scenario (where modules for third-party dependencies are
built implicitly) such as ours this is problematic. One of the reasons is that
we cannot configure the prebuilt modules paths or module cache paths externally.
This is because the interpreter (at construction time) #includes RuntimeUniverse
which may trigger module build.

This patch allows us to refactor some of the code working around this issue.

interpreter/cling/lib/Interpreter/CIFactory.cpp

@@ -529,34 +529,12 @@ namespace {
     return Paths;
   }
 
-  /// \brief Prepares a file path for string comparison with another file path.
-  /// This easily be tricked by a malicious user with hardlinking directories
-  /// and so on, but for a comparison in good faith this should be enough.
-  static std::string normalizePath(StringRef path) {
-    SmallVector<char, 256> AbsolutePath, Result;
-    AbsolutePath.insert(AbsolutePath.begin(), path.begin(), path.end());
-    llvm::sys::fs::make_absolute(AbsolutePath);
-    llvm::sys::fs::real_path(AbsolutePath, Result, true);
-    return llvm::Twine(Result).str();
-  }
-
   /// \brief Adds all the paths to the prebuilt module paths of the given
   /// HeaderSearchOptions.
   static void addPrebuiltModulePaths(clang::HeaderSearchOptions& Opts,
                                      const SmallVectorImpl<StringRef>& Paths) {
-    for (StringRef ModulePath : Paths) {
-      // FIXME: If we have a prebuilt module path that is equal to our module
-      // cache we fail to compile the clang builtin modules for some reason.
-      // This makes clang to think it failed to build a dependency module, i.e.
-      // if we are building module C, clang goes off and builds B and A first.
-      // If the module cache points to the same location as the prebuilt module
-      // path, clang errors out on building module A, however, it builds it.
-      // Next time we run, it will build module B and issue diagnostics.
-      // If we run third time, it'd build successfully C and continue.
-      // For now it is fixed by just checking those two paths are not identical.
-      if (normalizePath(ModulePath) != normalizePath(Opts.ModuleCachePath))
-        Opts.AddPrebuiltModulePath(ModulePath);
-    }
+    for (StringRef ModulePath : Paths)
+      Opts.AddPrebuiltModulePath(ModulePath);
   }
 
   static std::string getIncludePathForHeader(const clang::HeaderSearch& HS,

interpreter/llvm/src/tools/clang/lib/Lex/HeaderSearch.cpp

@@ -138,6 +138,7 @@ std::string HeaderSearch::getModuleFileName(Module *Module) {
 std::string HeaderSearch::getModuleFileName(StringRef ModuleName,
                                             StringRef ModuleMapPath,
                                             bool UsePrebuiltPath) {
+  std::string ModuleCachePath = getModuleCachePath();
   if (UsePrebuiltPath) {
     if (HSOpts->PrebuiltModulePaths.empty())
       return std::string();
@@ -146,20 +147,25 @@ std::string HeaderSearch::getModuleFileName(StringRef ModuleName,
     for (const std::string &Dir : HSOpts->PrebuiltModulePaths) {
       SmallString<256> Result(Dir);
       llvm::sys::fs::make_absolute(Result);
-
+      bool CacheFailure = true;
+      // If we have the same ModuleCachePath and PrebuiltModulePath pointing
+      // to the same folder we should not cache the file lookup failure as it
+      // may be currently building an implicit module.
+      if (!ModuleCachePath.empty() && ModuleCachePath == Result)
+        CacheFailure = false;
       llvm::sys::path::append(Result, ModuleName + ".pcm");
-      if (getFileMgr().getFile(Result.str()))
+      if (getFileMgr().getFile(Result.str(), /*Open=*/false, CacheFailure))
         return Result.str().str();
     }
     return std::string();
   }
 
   // If we don't have a module cache path or aren't supposed to use one, we
   // can't do anything.
-  if (getModuleCachePath().empty())
+  if (ModuleCachePath.empty())
     return std::string();
 
-  SmallString<256> Result(getModuleCachePath());
+  SmallString<256> Result(ModuleCachePath);
   llvm::sys::fs::make_absolute(Result);
 
   if (HSOpts->DisableModuleHash) {