This is the next step in building the standalone tools infrastructure:

This patch simplifies writing of standalone Clang tools. As an
example, we add clang-check, a tool that runs a syntax only frontend
action over a .cc file. When you integrate this into your favorite
editor, you get much faster feedback on your compilation errors, thus
reducing your feedback cycle especially when writing new code.

The tool depends on integration of an outstanding patch to CMake to
work which allows you to always have a current compile command
database in your cmake output directory when you set
CMAKE_EXPORT_COMPILE_COMMANDS.

llvm-svn: 130306

Author: r4nt

clang/examples/CMakeLists.txt

@@ -1,3 +1,3 @@
 add_subdirectory(clang-interpreter)
 add_subdirectory(PrintFunctionNames)
-
+add_subdirectory(Tooling)

clang/examples/Tooling/CMakeLists.txt

@@ -0,0 +1,6 @@
+set(LLVM_USED_LIBS clangTooling clangBasic)
+
+add_clang_executable(clang-check
+  ClangCheck.cpp
+  )
+

clang/examples/Tooling/ClangCheck.cpp

@@ -0,0 +1,108 @@
+//===- examples/Tooling/ClangCheck.cpp - Clang check tool -----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements a clang-check tool that runs the
+//  clang::SyntaxOnlyAction over a number of translation units.
+//
+//  Usage:
+//  clang-check <cmake-output-dir> <file1> <file2> ...
+//
+//  Where <cmake-output-dir> is a CMake build directory in which a file named
+//  compile_commands.json exists (enable -DCMAKE_EXPORT_COMPILE_COMMANDS in
+//  CMake to get this output).
+//
+//  <file1> ... specify the paths of files in the CMake source tree. This  path
+//  is looked up in the compile command database. If the path of a file is
+//  absolute, it needs to point into CMake's source tree. If the path is
+//  relative, the current working directory needs to be in the CMake source
+//  tree and the file must be in a subdirectory of the current working
+//  directory. "./" prefixes in the relative files will be automatically
+//  removed, but the rest of a relative path must be a suffix of a path in
+//  the compile command line database.
+//
+//  For example, to use clang-check on all files in a subtree of the source
+//  tree, use:
+//  /path/to/cmake/sources $ find . -name '*.cpp' \
+//      |xargs clang-check /path/to/cmake/build
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/system_error.h"
+
+/// \brief Returns the absolute path of 'File', by prepending it with
+/// 'BaseDirectory' if 'File' is not absolute. Otherwise returns 'File'.
+/// If 'File' starts with "./", the returned path will not contain the "./".
+/// Otherwise, the returned path will contain the literal path-concatenation of
+/// 'BaseDirectory' and 'File'.
+///
+/// \param File Either an absolute or relative path.
+/// \param BaseDirectory An absolute path.
+///
+/// FIXME: Put this somewhere where it is more generally available.
+static std::string GetAbsolutePath(
+    llvm::StringRef File, llvm::StringRef BaseDirectory) {
+  assert(llvm::sys::path::is_absolute(BaseDirectory));
+  if (llvm::sys::path::is_absolute(File)) {
+    return File;
+  }
+  llvm::StringRef RelativePath(File);
+  if (RelativePath.startswith("./")) {
+    RelativePath = RelativePath.substr(strlen("./"));
+  }
+  llvm::SmallString<1024> AbsolutePath(BaseDirectory);
+  llvm::sys::path::append(AbsolutePath, RelativePath);
+  return AbsolutePath.str();
+}
+
+int main(int argc, char **argv) {
+  if (argc < 3) {
+    llvm::outs() << "Usage: " << argv[0] << " <cmake-output-dir> "
+                 << "<file1> <file2> ...\n";
+    return 1;
+  }
+  // FIXME: We should pull how to find the database into the Tooling package.
+  llvm::OwningPtr<llvm::MemoryBuffer> JsonDatabase;
+  llvm::SmallString<1024> JsonDatabasePath(argv[1]);
+  llvm::sys::path::append(JsonDatabasePath, "compile_commands.json");
+  llvm::error_code Result =
+      llvm::MemoryBuffer::getFile(JsonDatabasePath, JsonDatabase);
+  if (Result != 0) {
+    llvm::outs() << "Error while opening JSON database: " << Result.message()
+                 << "\n";
+    return 1;
+  }
+  llvm::StringRef BaseDirectory(::getenv("PWD"));
+  for (int I = 2; I < argc; ++I) {
+    llvm::SmallString<1024> File(GetAbsolutePath(argv[I], BaseDirectory));
+    llvm::outs() << "Processing " << File << ".\n";
+    std::string ErrorMessage;
+    clang::tooling::CompileCommand LookupResult =
+        clang::tooling::FindCompileArgsInJsonDatabase(
+            File.str(), JsonDatabase->getBuffer(), ErrorMessage);
+    if (!LookupResult.CommandLine.empty()) {
+      if (!clang::tooling::RunToolWithFlags(
+               new clang::SyntaxOnlyAction,
+               LookupResult.CommandLine.size(),
+               clang::tooling::CommandLineToArgv(
+                   &LookupResult.CommandLine).data())) {
+        llvm::outs() << "Error while processing " << File << ".\n";
+      }
+    } else {
+      llvm::outs() << "Skipping " << File << ". Command line not found.\n";
+    }
+  }
+  return 0;
+}

clang/include/clang/Tooling/Tooling.h

@@ -16,6 +16,8 @@
 #define LLVM_CLANG_TOOLING_TOOLING_H
 
 #include "llvm/ADT/StringRef.h"
+#include <string>
+#include <vector>
 
 namespace clang {
 
@@ -26,12 +28,53 @@ namespace tooling {
 /// \brief Runs (and deletes) the tool on 'Code' with the -fsynatx-only flag.
 ///
 /// \param ToolAction The action to run over the code.
-//  \param Code C++ code.
+/// \param Code C++ code.
 ///
 /// \return - True if 'ToolAction' was successfully executed.
 bool RunSyntaxOnlyToolOnCode(
     clang::FrontendAction *ToolAction, llvm::StringRef Code);
 
+/// \brief Runs (and deletes) the tool with the given Clang flags.
+///
+/// \param ToolAction The action to run over the code.
+/// \param Argc The number of elements in Argv.
+/// \param Argv The command line arguments, including the path the binary
+/// was started with (Argv[0]).
+bool RunToolWithFlags(
+    clang::FrontendAction* ToolAction, int Argc, char *Argv[]);
+
+/// \brief Converts a vector<string> into a vector<char*> suitable to pass
+/// to main-style functions taking (int Argc, char *Argv[]).
+std::vector<char*> CommandLineToArgv(const std::vector<std::string>* Command);
+
+/// \brief Specifies the working directory and command of a compilation.
+struct CompileCommand {
+  /// \brief The working directory the command was executed from.
+  std::string Directory;
+
+  /// \brief The command line that was executed.
+  std::vector<std::string> CommandLine;
+};
+
+/// \brief Looks up the compile command for 'FileName' in 'JsonDatabase'.
+///
+/// \param FileName The path to an input file for which we want the compile
+/// command line. If the 'JsonDatabase' was created by CMake, this must be
+/// an absolute path inside the CMake source directory which does not have
+/// symlinks resolved.
+///
+/// \param JsonDatabase A JSON formatted list of compile commands. This lookup
+/// command supports only a subset of the JSON standard as written by CMake.
+///
+/// \param ErrorMessage If non-empty, an error occurred and 'ErrorMessage' will
+/// be set to contain the error message. In this case CompileCommand will
+/// contain an empty directory and command line.
+///
+/// \see JsonCompileCommandLineDatabase
+CompileCommand FindCompileArgsInJsonDatabase(
+    llvm::StringRef FileName, llvm::StringRef JsonDatabase,
+    std::string &ErrorMessage);
+
 } // end namespace tooling
 } // end namespace clang
 

clang/lib/Tooling/CMakeLists.txt

@@ -1,5 +1,6 @@
 SET(LLVM_USED_LIBS clangBasic clangFrontend clangAST)
 
 add_clang_library(clangTooling
+  JsonCompileCommandLineDatabase.cpp
   Tooling.cpp
   )