[Tooling] Make clang-tool find libc++ dir on mac when running on a file without compilation database.

[hokein]

Summary

This is a regression of r348365.

When clang-tools run on a file without a complation database (clang-check /tmp/t.cc),
we will use fixed compilation database as a fallback. However the actual compiler
path in the fallback complation command is just clang-tool which is
insufficient to detect the libc++ dir.

[ilya-biryukov]

LGTM.

lib/Tooling/CompilationDatabase.cpp

 // They are not used for syntax checking, and could confuse targets
 // which don't support these options.
 struct FilterUnusedFlags {
   bool operator() (StringRef S) {
     return (S == "-no-integrated-as") || S.startswith("-Wa,");
   }
 };
 
+std::string GetClangToolCommand() {
+  static int Dummy;
+  std::string ClangExecutable =
+      llvm::sys::fs::getMainExecutable("clang", (void *)&Dummy);
+  SmallString<128> ClangToolPath;
+  ClangToolPath = llvm::sys::path::parent_path(ClangExecutable);
+  llvm::sys::path::append(ClangToolPath, "clang-tool");
+  return ClangToolPath.str();
+}
+
 } // namespace
 
 /// Strips any positional args and possible argv[0] from a command-line
 /// provided by the user to construct a FixedCompilationDatabase.
 ///
 /// FixedCompilationDatabase requires a command line to be in this format as it
 /// constructs the command line for each file by appending the name of the file
 /// to be compiled. FixedCompilationDatabase also adds its own argv[0] to the
static bool stripPositionalArgs(std::vector<const char *> Args,
 
   // The clang executable path isn't required since the jobs the driver builds
   // will not be executed.
   std::unique_ptr<driver::Driver> NewDriver(new driver::Driver(
       /* ClangExecutable= */ "", llvm::sys::getDefaultTargetTriple(),
       Diagnostics));
   NewDriver->setCheckInputsExist(false);
 
-  // This becomes the new argv[0]. The value is actually not important as it
-  // isn't used for invoking Tools.
-  Args.insert(Args.begin(), "clang-tool");
+  // This becomes the new argv[0]. The value is used to detect libc++ include
+  // dirs on Mac, it isn't used for other platforms.
+  Args.insert(Args.begin(), GetClangToolCommand().c_str());
 
   // By adding -c, we force the driver to treat compilation as the last phase.
   // It will then issue warnings via Diagnostics about un-used options that
   // would have been used for linking. If the user provided a compiler name as
   // the original argv[0], this will be treated as a linker input thanks to
   // insertng a new argv[0] above. All un-used options get collected by
   // UnusedInputdiagConsumer and get stripped out later.
   Args.push_back("-c");
FixedCompilationDatabase::loadFromFile(StringRef Path, std::string &ErrorMsg) {
   std::vector<std::string> Args{llvm::line_iterator(**File),
                                 llvm::line_iterator()};
   return llvm::make_unique<FixedCompilationDatabase>(
       llvm::sys::path::parent_path(Path), std::move(Args));
 }
 
 FixedCompilationDatabase::
 FixedCompilationDatabase(Twine Directory, ArrayRef<std::string> CommandLine) {
-  std::vector<std::string> ToolCommandLine(1, "clang-tool");
+  std::vector<std::string> ToolCommandLine(1, GetClangToolCommand());
   ToolCommandLine.insert(ToolCommandLine.end(),
                          CommandLine.begin(), CommandLine.end());
   CompileCommands.emplace_back(Directory, StringRef(),
                                std::move(ToolCommandLine),
                                StringRef());
 }
 
 std::vector<CompileCommand>

test/Tooling/clang-check-mac-libcxx-fixed-compilation-db.cpp

+// Clang on MacOS can find libc++ living beside the installed compiler.
+// This test makes sure our libTooling-based tools emulate this properly with
+// fixed compilation database.
+//
+// RUN: rm -rf %t
+// RUN: mkdir %t
+//
+// Install the mock libc++ (simulates the libc++ directory structure).
+// RUN: cp -r %S/Inputs/mock-libcxx %t/
+//
+// RUN: cp clang-check %t/mock-libcxx/bin/
+// RUN: cp "%s" "%t/test.cpp"
+// RUN: %t/mock-libcxx/bin/clang-check -p "%t" "%t/test.cpp" -- -stdlib=libc++
+
+#include <mock_vector>
+vector v;