Use the VFS from the CompilerInvocation by default

Summary:
The CompilerInstance should create its default VFS from its CompilerInvocation. Right now the
user has to manually create the VFS before creating the FileManager even though
`-ivfsoverlay file.yaml` was passed via the CompilerInvocation (which is exactly how we worked
around this issue in `FrontendAction.cpp` so far).

This patch uses the invocation's VFS by default and also tests this behavior now from the
point of view of a program that uses the clang API.

Reviewers: benlangmuir, v.g.vassilev

Reviewed By: v.g.vassilev

Subscribers: mgorny, cfe-commits, v.g.vassilev

Differential Revision: https://reviews.llvm.org/D37416

llvm-svn: 313049

clang/include/clang/Frontend/CompilerInstance.h

@@ -640,7 +640,9 @@ public:
                     const CodeGenOptions *CodeGenOpts = nullptr);
 
   /// Create the file manager and replace any existing one with it.
-  void createFileManager();
+  ///
+  /// \return The new file manager on success, or null on failure.
+  FileManager *createFileManager();
 
   /// Create the source manager and replace any existing one with it.
   void createSourceManager(FileManager &FileMgr);

clang/lib/Frontend/CompilerInstance.cpp

@@ -300,12 +300,16 @@ CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
 
 // File Manager
 
-void CompilerInstance::createFileManager() {
+FileManager *CompilerInstance::createFileManager() {
   if (!hasVirtualFileSystem()) {
-    // TODO: choose the virtual file system based on the CompilerInvocation.
-    setVirtualFileSystem(vfs::getRealFileSystem());
+    if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
+            createVFSFromCompilerInvocation(getInvocation(), getDiagnostics()))
+      setVirtualFileSystem(VFS);
+    else
+      return nullptr;
   }
   FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
+  return FileMgr.get();
 }
 
 // Source Manager

clang/lib/Frontend/FrontendAction.cpp

@@ -633,18 +633,12 @@ bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
     return true;
   }
 
-  if (!CI.hasVirtualFileSystem()) {
-    if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
-          createVFSFromCompilerInvocation(CI.getInvocation(),
-                                          CI.getDiagnostics()))
-      CI.setVirtualFileSystem(VFS);
-    else
-      goto failure;
-  }
-
   // Set up the file and source managers, if needed.
-  if (!CI.hasFileManager())
-    CI.createFileManager();
+  if (!CI.hasFileManager()) {
+    if (!CI.createFileManager()) {
+      goto failure;
+    }
+  }
   if (!CI.hasSourceManager())
     CI.createSourceManager(CI.getFileManager());
 

clang/unittests/Frontend/CMakeLists.txt

@@ -4,6 +4,7 @@ set(LLVM_LINK_COMPONENTS
 
 add_clang_unittest(FrontendTests
   ASTUnitTest.cpp
+  CompilerInstanceTest.cpp
   FrontendActionTest.cpp
   CodeGenActionTest.cpp
   PCHPreambleTest.cpp

clang/unittests/Frontend/CompilerInstanceTest.cpp

@@ -0,0 +1,74 @@
+//===- unittests/Frontend/CompilerInstanceTest.cpp - CI tests -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/CompilerInvocation.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace clang;
+
+namespace {
+
+TEST(CompilerInstance, DefaultVFSOverlayFromInvocation) {
+  // Create a temporary VFS overlay yaml file.
+  int FD;
+  SmallString<256> FileName;
+  ASSERT_FALSE(sys::fs::createTemporaryFile("vfs", "yaml", FD, FileName));
+  tool_output_file File(FileName, FD);
+
+  SmallString<256> CurrentPath;
+  sys::fs::current_path(CurrentPath);
+  sys::fs::make_absolute(CurrentPath, FileName);
+
+  // Mount the VFS file itself on the path 'virtual.file'. Makes this test
+  // a bit shorter than creating a new dummy file just for this purpose.
+  const std::string CurrentPathStr = CurrentPath.str();
+  const std::string FileNameStr = FileName.str();
+  const char *VFSYaml = "{ 'version': 0, 'roots': [\n"
+                        "  { 'name': '%s',\n"
+                        "    'type': 'directory',\n"
+                        "    'contents': [\n"
+                        "      { 'name': 'vfs-virtual.file', 'type': 'file',\n"
+                        "        'external-contents': '%s'\n"
+                        "      }\n"
+                        "    ]\n"
+                        "  }\n"
+                        "]}\n";
+  File.os() << format(VFSYaml, CurrentPathStr.c_str(), FileName.c_str());
+  File.os().flush();
+
+  // Create a CompilerInvocation that uses this overlay file.
+  const std::string VFSArg = "-ivfsoverlay" + FileNameStr;
+  const char *Args[] = {"clang", VFSArg.c_str(), "-xc++", "-"};
+
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+      CompilerInstance::createDiagnostics(new DiagnosticOptions());
+
+  std::shared_ptr<CompilerInvocation> CInvok =
+      createInvocationFromCommandLine(Args, Diags);
+
+  if (!CInvok)
+    FAIL() << "could not create compiler invocation";
+  // Create a minimal CompilerInstance which should use the VFS we specified
+  // in the CompilerInvocation (as we don't explicitly set our own).
+  CompilerInstance Instance;
+  Instance.setDiagnostics(Diags.get());
+  Instance.setInvocation(CInvok);
+  Instance.createFileManager();
+
+  // Check if the virtual file exists which means that our VFS is used by the
+  // CompilerInstance.
+  ASSERT_TRUE(Instance.getFileManager().getFile("vfs-virtual.file"));
+}
+
+} // anonymous namespace