[AST][NFC] Remove temporary ASTTU file from Introspection generation.

[njames93]

Summary

We can use the Preprocessor to remap this file, cleaning up the cmake code.

[njames93]

Add new line at the end of remapped file.

[njames93]

Use InMemoryFileSystem instead of Remapped files, turns out they don't work if the file doesn't exist on disk.

clang/lib/Tooling/CMakeLists.txt

else()
   # internal hidden setting to override.
   # When the processing is disabled, a trivial/empty JSON
   # file is generated by clang-ast-dump and generate_cxx_src_locs.py
   # generates the same API, but with a trivial implementation.
   option(CLANG_TOOLING_BUILD_AST_INTROSPECTION "Enable AST introspection" TRUE)
 
   set(skip_expensive_processing $<OR:$<CONFIG:Debug>,$<NOT:$<BOOL:${CLANG_TOOLING_BUILD_AST_INTROSPECTION}>>>)
 
-  file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ASTTU.cpp
-    CONTENT "
-#include <clang/AST/AST.h>
-")
-
   set(implicitDirs)
   foreach(implicitDir ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES})
     list(APPEND implicitDirs -I ${implicitDir})
   endforeach()
 
   add_custom_command(
       COMMENT Generate ASTNodeAPI.json
       OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ASTNodeAPI.json
-      DEPENDS clang-ast-dump clang-resource-headers ${CMAKE_CURRENT_BINARY_DIR}/ASTTU.cpp
+      DEPENDS clang-ast-dump clang-resource-headers
       COMMAND
       $<TARGET_FILE:clang-ast-dump>
         # Skip this in debug mode because parsing AST.h is too slow
         --skip-processing=${skip_expensive_processing}
-        --astheader=${CMAKE_CURRENT_BINARY_DIR}/ASTTU.cpp
         -I ${CMAKE_BINARY_DIR}/lib/clang/${CLANG_VERSION}/include
         -I ${CMAKE_SOURCE_DIR}/../clang/include
         -I ${CMAKE_BINARY_DIR}/tools/clang/include
         -I ${CMAKE_BINARY_DIR}/include
         -I ${CMAKE_SOURCE_DIR}/include
         ${implicitDirs}
         --json-output-path ${CMAKE_CURRENT_BINARY_DIR}/ASTNodeAPI.json
   )

clang/lib/Tooling/DumpTool/ClangSrcLocDump.cpp

 //===- ClangSrcLocDump.cpp ------------------------------------*- C++ -*---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Job.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/JSON.h"
 
 #include "ASTSrcLocProcessor.h"
 
 using namespace clang::tooling;
 using namespace clang;
 using namespace llvm;
 
 static cl::list<std::string> IncludeDirectories(
     "I", cl::desc("Include directories to use while compiling"),
     cl::value_desc("directory"), cl::Required, cl::OneOrMore, cl::Prefix);
 
-static cl::opt<std::string>
-    AstHeaderFile("astheader", cl::desc("AST header to parse API from"),
-                  cl::Required, cl::value_desc("AST header file"));
-
 static cl::opt<bool>
     SkipProcessing("skip-processing",
                    cl::desc("Avoid processing the AST header file"),
                    cl::Required, cl::value_desc("bool"));
 
 static cl::opt<std::string> JsonOutputPath("json-output-path",
                                            cl::desc("json output path"),
                                            cl::Required,
CreateASTConsumer(clang::CompilerInstance &Compiler,
                     llvm::StringRef File) override {
     return Processor.createASTConsumer(Compiler, File);
   }
 
 private:
   ASTSrcLocProcessor Processor;
 };
 
+static const char Filename[] = "ASTTU.cpp";
+
 int main(int argc, const char **argv) {
 
   cl::ParseCommandLineOptions(argc, argv);
 
   if (SkipProcessing) {
     std::error_code EC;
     llvm::raw_fd_ostream JsonOut(JsonOutputPath, EC, llvm::sys::fs::F_Text);
     if (EC)
       return 1;
     JsonOut << formatv("{0:2}", llvm::json::Value(llvm::json::Object()));
     return 0;
   }
 
   std::vector<std::string> Args;
   Args.push_back("-cc1");
 
   llvm::transform(IncludeDirectories, std::back_inserter(Args),
                   [](const std::string &IncDir) { return "-I" + IncDir; });
 
   Args.push_back("-fsyntax-only");
-  Args.push_back(AstHeaderFile);
+  Args.push_back(Filename);
 
   std::vector<const char *> Argv(Args.size(), nullptr);
   llvm::transform(Args, Argv.begin(),
                   [](const std::string &Arg) { return Arg.c_str(); });
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   unsigned MissingArgIndex, MissingArgCount;
   auto Opts = driver::getDriverOptTable();
   auto ParsedArgs = Opts.ParseArgs(llvm::makeArrayRef(Argv).slice(1),
                                    MissingArgIndex, MissingArgCount);
   ParseDiagnosticArgs(*DiagOpts, ParsedArgs);
 
   // Don't output diagnostics, because common scenarios such as
   // cross-compiling fail with diagnostics.  This is not fatal, but
   // just causes attempts to use the introspection API to return no data.
-  std::string Str;
-  llvm::raw_string_ostream OS(Str);
-  TextDiagnosticPrinter DiagnosticPrinter(OS, &*DiagOpts);
+  TextDiagnosticPrinter DiagnosticPrinter(llvm::nulls(), &*DiagOpts);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
       &DiagnosticPrinter, false);
 
-  FileManager Files(FileSystemOptions(), vfs::getRealFileSystem());
+  auto *OFS = new llvm::vfs::OverlayFileSystem(vfs::getRealFileSystem());
+
+  auto *MemFS = new llvm::vfs::InMemoryFileSystem();
+  OFS->pushOverlay(MemFS);
+  MemFS->addFile(Filename, 0,
+                 MemoryBuffer::getMemBuffer("#include \"clang/AST/AST.h\"\n"));
+
+  auto Files = llvm::makeIntrusiveRefCnt<FileManager>(FileSystemOptions(), OFS);
 
   auto Driver = std::make_unique<driver::Driver>(
       "clang", llvm::sys::getDefaultTargetTriple(), Diagnostics,
-      "ast-api-dump-tool", &Files.getVirtualFileSystem());
+      "ast-api-dump-tool", OFS);
 
   std::unique_ptr<clang::driver::Compilation> Comp(
       Driver->BuildCompilation(llvm::makeArrayRef(Argv)));
   if (!Comp)
     return 1;
 
   const auto &Jobs = Comp->getJobs();
   if (Jobs.size() != 1 || !isa<driver::Command>(*Jobs.begin())) {
int main(int argc, const char **argv) {
   Compiler.setInvocation(std::move(Invocation));
 
   Compiler.createDiagnostics(&DiagnosticPrinter, false);
   if (!Compiler.hasDiagnostics())
     return 1;
 
   // Suppress "2 errors generated" or similar messages
   Compiler.getDiagnosticOpts().ShowCarets = false;
-  Compiler.createSourceManager(Files);
+  Compiler.createSourceManager(*Files);
+  Compiler.setFileManager(Files.get());
 
   ASTSrcLocGenerationAction ScopedToolAction;
   Compiler.ExecuteAction(ScopedToolAction);
 
-  Files.clearStatCache();
+  Files->clearStatCache();
 
   return 0;
 }