Use the VFS from the CompilerInvocation by default

[teemperor]

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.

[v.g.vassilev]

You should probably update the code creating the vfs before the call to createFileManager in lib/Frontend/FrontendAction.cpp.

[teemperor]

• Added test case.

[teemperor]

• Moved code from FrontendAction.cpp into createFileManager()

[v.g.vassilev]

This patch can rely on a post commit review if necessary.

[teemperor]

• Rebased diff before merging.

[teemperor]

• Rebased with the correct diff...

cfe/trunk/include/clang/Frontend/CompilerInstance.h

public:
   /// \return The new object on success, or null on failure.
   static IntrusiveRefCntPtr<DiagnosticsEngine>
   createDiagnostics(DiagnosticOptions *Opts,
                     DiagnosticConsumer *Client = nullptr,
                     bool ShouldOwnClient = true,
                     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);
 
   /// Create the preprocessor, using the invocation, file, and source managers,
   /// and replace any existing one with it.
   void createPreprocessor(TranslationUnitKind TUKind);
 

cfe/trunk/lib/Frontend/CompilerInstance.cpp

CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
   // Configure our handling of diagnostics.
   ProcessWarningOptions(*Diags, *Opts);
 
   return Diags;
 }
 
 // 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
 
 void CompilerInstance::createSourceManager(FileManager &FileMgr) {
   SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
 }
 

cfe/trunk/lib/Frontend/FrontendAction.cpp

if (Input.getKind().getFormat() == InputKind::Precompiled) {
     // Create the AST consumer.
     CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
     if (!CI.hasASTConsumer())
       goto failure;
 
     return true;
   }
 
-  if (!CI.hasVirtualFileSystem()) {
-    if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
-          createVFSFromCompilerInvocation(CI.getInvocation(),
-                                          CI.getDiagnostics()))
-      CI.setVirtualFileSystem(VFS);
-    else
+  // Set up the file and source managers, if needed.
+  if (!CI.hasFileManager()) {
+    if (!CI.createFileManager()) {
       goto failure;
     }
-
-  // Set up the file and source managers, if needed.
-  if (!CI.hasFileManager())
-    CI.createFileManager();
+  }
   if (!CI.hasSourceManager())
     CI.createSourceManager(CI.getFileManager());
 
   // Set up embedding for any specified files. Do this before we load any
   // source files, including the primary module map for the compilation.
   for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
     if (const auto *FE = CI.getFileManager().getFile(F, /*openFile*/true))
       CI.getSourceManager().setFileIsTransient(FE);

cfe/trunk/unittests/Frontend/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(FrontendTests
   ASTUnitTest.cpp
+  CompilerInstanceTest.cpp
   FrontendActionTest.cpp
   CodeGenActionTest.cpp
   PCHPreambleTest.cpp
   )
 target_link_libraries(FrontendTests
   clangAST
   clangBasic
   clangFrontend
   clangLex
   clangSema
   clangCodeGen
   )

cfe/trunk/unittests/Frontend/CompilerInstanceTest.cpp

+//===- 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