[Tooling] Avoid boilerplate in common cases

[sammccall]

Summary

The tooling APIs have a lot of extension points for customization:
e.g. Executor, FrontendActionFactory, FrontendAction, ASTConsumer.
This customization is often not needed, and makes the APIs unergonomic.

This change introduces some shortcuts to bypass them, while attempting
not to add more concepts/complexity to the APIs.

main() entrypoint

Today tools are expected to create an executor (which can fail), then
use it to execute their action (which can report errors).
Errors are reported with llvm::Error, which is not what main() needs
(exit codes) but must be handled.

This patch adds executeFromCommandLineArgs(), which wraps this in a
single function which returns an exit code.

(It also tweaks ToolExecutor's execute() API to avoid replicating several
overloads here).

Skipping over FrontendAction to ASTConsumer

Tools that override ASTConsumer must provide two factory indirections:

FrontendActionFactory -> FrontendAction -> ASTConsumer.

These are sometimes meaningful, but often not.
newFrontendActionFactory<ActionT>() already lets you skip the first.

Now newFrontendActionFactory<ConsumerT>() lets you skip the second, too.

Implementing simple actions as lambdas

A large fraction of tools simply want to consume the final AST and do
something with it. Even ASTConsumer is too heavyweight an abstraction.

This patch adds consumeASTs(), which is a FrontendActionFactory that
calls a function once for each parsed AST:

Exec->execute(consumeASTs([&](ASTContext &Ctx) {
  ... process AST ...
}));

Bonus: through lambda captures, state can be easily shared across TUs.
(This otherwise tends to require plumbing, or use of global variables)

[sammccall]

update description

[sammccall]

tweak comment, remove unused overload

[sammccall]

squash commits

[sammccall]

format

[sammccall]

Example of using conusmeASTs + executeFromCommandLine: https://github.com/sam-mccall/crubit/commit/37295cfeb67be7154e2ec87c8a2c27c860b59049

(It's not that many extra lines of code, but they're not really easy ones to write, and to work out whether they're minimal/correct)

clang/include/clang/Tooling/AllTUsExecution.h

public:
   AllTUsToolExecutor(CommonOptionsParser Options, unsigned ThreadCount,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps =
                          std::make_shared<PCHContainerOperations>());
 
   StringRef getExecutorName() const override { return ExecutorName; }
 
   using ToolExecutor::execute;
 
-  llvm::Error
-  execute(llvm::ArrayRef<
-          std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
-              Actions) override;
+  llvm::Error execute(llvm::ArrayRef<Action> Actions) override;
 
   ExecutionContext *getExecutionContext() override { return &Context; };
 
   ToolResults *getToolResults() override { return Results.get(); }
 
   void mapVirtualFile(StringRef FilePath, StringRef Content) override {
     OverlayFiles[FilePath] = std::string(Content);
   }

clang/include/clang/Tooling/Execution.h

 ///  executor according to the command-line arguments.
 class ToolExecutor {
 public:
   virtual ~ToolExecutor() {}
 
   /// Returns the name of a specific executor.
   virtual StringRef getExecutorName() const = 0;
 
+  /// A frontend action to be executed, with optional ArgumentsAdjuster.
+  struct Action {
+    Action(std::unique_ptr<FrontendActionFactory> Factory)
+        : Factory(std::move(Factory)) {}
+    Action(std::unique_ptr<FrontendActionFactory> Factory,
+           ArgumentsAdjuster Adjuster)
+        : Factory(std::move(Factory)), Adjuster(std::move(Adjuster)) {}
+
+    std::unique_ptr<FrontendActionFactory> Factory;
+    ArgumentsAdjuster Adjuster;
+  };
   /// Executes each action with a corresponding arguments adjuster.
-  virtual llvm::Error
-  execute(llvm::ArrayRef<
-          std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
-              Actions) = 0;
+  /// FIXME: the ability to execute multiple actions appears unused, remove it?
+  virtual llvm::Error execute(llvm::ArrayRef<Action> Actions) = 0;
 
   /// Convenient functions for the above `execute`.
-  llvm::Error execute(std::unique_ptr<FrontendActionFactory> Action);
-  /// Executes an action with an argument adjuster.
-  llvm::Error execute(std::unique_ptr<FrontendActionFactory> Action,
-                      ArgumentsAdjuster Adjuster);
+  llvm::Error execute(Action);
 
   /// Returns a reference to the execution context.
   ///
   /// This should be passed to tool callbacks, and tool callbacks should report
   /// results via the returned context.
   virtual ExecutionContext *getExecutionContext() = 0;
 
   /// Returns a reference to the result container.
createExecutorFromCommandLineArgs(int &argc, const char **argv,
                                   llvm::cl::OptionCategory &Category,
                                   const char *Overview = nullptr);
 
 namespace internal {
 llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgsImpl(int &argc, const char **argv,
                                       llvm::cl::OptionCategory &Category,
                                       const char *Overview = nullptr);
+
 } // end namespace internal
 
+/// Runs an action on inputs specified by the command-line arguments.
+///
+/// If errors occur, they are reported to llvm::errs() and nonzero is returned:
+///   1 indicates bad tooling flags (failed to initialize executor)
+///   2 indicates parsing errors on some files
+///
+/// Expected usage is from main():
+///   int main(int argc, const char **argv) {
+///     return executeFromCommandLineArgs(argc, argv,
+///       consumeASTs([](ASTContext &C){ C.getTranslationUnitDecl()->dump(); });
+///   }
+int executeFromCommandLineArgs(int &argc, const char **argv,
+                               ToolExecutor::Action,
+                               const char *Overview = nullptr);
+
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_EXECUTION_H

clang/include/clang/Tooling/StandaloneExecution.h

StandaloneToolExecutor(
       CommonOptionsParser Options,
       std::shared_ptr<PCHContainerOperations> PCHContainerOps =
           std::make_shared<PCHContainerOperations>());
 
   StringRef getExecutorName() const override { return ExecutorName; }
 
   using ToolExecutor::execute;
 
-  llvm::Error
-  execute(llvm::ArrayRef<
-          std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
-              Actions) override;
+  llvm::Error execute(llvm::ArrayRef<Action> Actions) override;
 
   /// Set a \c DiagnosticConsumer to use during parsing.
   void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer) {
     Tool.setDiagnosticConsumer(DiagConsumer);
   }
 
   ExecutionContext *getExecutionContext() override { return &Context; };
 

clang/include/clang/Tooling/Tooling.h

 
 #include "clang/AST/ASTConsumer.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/PCHContainerOperations.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace clang {
 
 class CompilerInstance;
 class CompilerInvocation;
 class DiagnosticConsumer;
bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
                      DiagnosticConsumer *DiagConsumer) override;
 
   /// Returns a new clang::FrontendAction.
   virtual std::unique_ptr<FrontendAction> create() = 0;
 };
 
 /// Returns a new FrontendActionFactory for a given type.
 ///
-/// T must derive from clang::FrontendAction.
+/// T must derive from clang::FrontendAction or clang::ASTConsumer.
 ///
 /// Example:
 /// std::unique_ptr<FrontendActionFactory> Factory =
 ///   newFrontendActionFactory<clang::SyntaxOnlyAction>();
-template <typename T>
+template <typename T,
+          typename = std::enable_if<std::is_base_of_v<FrontendAction, T> ||
+                                    std::is_base_of_v<ASTConsumer, T>>>
 std::unique_ptr<FrontendActionFactory> newFrontendActionFactory();
 
+/// Allows a function that accepts ASTs to be used as a FrontendActionFactory.
+///
+/// Example:
+///   Executor->execute(consumeASTs([&](ASTContext &Ctx) {
+///      Ctx.getTranslationUnitDecl()->dump();
+///   }));
+///
+/// This is suitable for actions that merely consume the AST that clang builds.
+/// It does not provide a way to customize the preprocessor etc.
+std::unique_ptr<FrontendActionFactory>
+    consumeASTs(llvm::unique_function<void(ASTContext &) const>);
+
 /// Callbacks called before and after each source file processed by a
 /// FrontendAction created by the FrontedActionFactory returned by \c
 /// newFrontendActionFactory.
 class SourceFileCallbacks {
 public:
   virtual ~SourceFileCallbacks() = default;
 
   /// Called before a source file is processed by a FrontEndAction.
private:
 
   ArgumentsAdjuster ArgsAdjuster;
 
   DiagnosticConsumer *DiagConsumer = nullptr;
 
   bool PrintErrorMessage = true;
 };
 
-template <typename T>
+template <typename T, typename EnableT>
 std::unique_ptr<FrontendActionFactory> newFrontendActionFactory() {
+  if constexpr (std::is_base_of_v<FrontendAction, T>) {
     class SimpleFrontendActionFactory : public FrontendActionFactory {
     public:
       std::unique_ptr<FrontendAction> create() override {
         return std::make_unique<T>();
       }
     };
 
     return std::unique_ptr<FrontendActionFactory>(
         new SimpleFrontendActionFactory);
+  } else {
+    class SimpleFrontendAction : public ASTFrontendAction {
+      std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
+                                                     StringRef) override {
+        return std::make_unique<T>();
+      }
+    };
+    return newFrontendActionFactory<SimpleFrontendAction>();
+  }
 }
 
 template <typename FactoryT>
 inline std::unique_ptr<FrontendActionFactory> newFrontendActionFactory(
     FactoryT *ConsumerFactory, SourceFileCallbacks *Callbacks) {
   class FrontendActionFactoryAdapter : public FrontendActionFactory {
   public:
     explicit FrontendActionFactoryAdapter(FactoryT *ConsumerFactory,

clang/lib/Tooling/AllTUsExecution.cpp

 AllTUsToolExecutor::AllTUsToolExecutor(
     CommonOptionsParser Options, unsigned ThreadCount,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : OptionsParser(std::move(Options)),
       Compilations(OptionsParser->getCompilations()),
       Results(new ThreadSafeToolResults), Context(Results.get()),
       ThreadCount(ThreadCount) {}
 
-llvm::Error AllTUsToolExecutor::execute(
-    llvm::ArrayRef<
-        std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
-        Actions) {
+llvm::Error AllTUsToolExecutor::execute(llvm::ArrayRef<Action> Actions) {
   if (Actions.empty())
     return make_string_error("No action to execute.");
 
   if (Actions.size() != 1)
     return make_string_error(
         "Only support executing exactly 1 action at this point.");
 
   std::string ErrorMsg;
for (std::string File : Files) {
             Log("[" + std::to_string(Count()) + "/" + TotalNumStr +
                 "] Processing file " + Path);
             // Each thread gets an independent copy of a VFS to allow different
             // concurrent working directories.
             IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS =
                 llvm::vfs::createPhysicalFileSystem();
             ClangTool Tool(Compilations, {Path},
                            std::make_shared<PCHContainerOperations>(), FS);
-            Tool.appendArgumentsAdjuster(Action.second);
+            Tool.appendArgumentsAdjuster(Action.Adjuster);
             Tool.appendArgumentsAdjuster(getDefaultArgumentsAdjusters());
             for (const auto &FileAndContent : OverlayFiles)
               Tool.mapVirtualFile(FileAndContent.first(),
                                   FileAndContent.second);
-            if (Tool.run(Action.first.get()))
+            if (Tool.run(Action.Factory.get()))
               AppendError(llvm::Twine("Failed to run action on ") + Path +
                           "\n");
           },
           File);
     }
     // Make sure all tasks have finished before resetting the working directory.
     Pool.wait();
   }

clang/lib/Tooling/Execution.cpp

 //===- lib/Tooling/Execution.cpp - Implements tool execution framework. ---===//
 //
 // 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/Tooling/Execution.h"
 #include "clang/Tooling/ToolExecutorPluginRegistry.h"
 #include "clang/Tooling/Tooling.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include <utility>
 
 LLVM_INSTANTIATE_REGISTRY(clang::tooling::ToolExecutorPluginRegistry)
 
 namespace clang {
 namespace tooling {
 
 llvm::cl::opt<std::string>
     ExecutorName("executor", llvm::cl::desc("The name of the executor to use."),
for (const auto &KV : KVResults) {
     Callback(KV.first, KV.second);
   }
 }
 
 void ExecutionContext::reportResult(StringRef Key, StringRef Value) {
   Results->addResult(Key, Value);
 }
 
-llvm::Error
-ToolExecutor::execute(std::unique_ptr<FrontendActionFactory> Action) {
-  return execute(std::move(Action), ArgumentsAdjuster());
-}
-
-llvm::Error ToolExecutor::execute(std::unique_ptr<FrontendActionFactory> Action,
-                                  ArgumentsAdjuster Adjuster) {
-  std::vector<
-      std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
-      Actions;
-  Actions.emplace_back(std::move(Action), std::move(Adjuster));
-  return execute(Actions);
-}
+llvm::Error ToolExecutor::execute(Action A) { return execute(ArrayRef(A)); }
 
 namespace internal {
 llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgsImpl(int &argc, const char **argv,
                                       llvm::cl::OptionCategory &Category,
                                       const char *Overview) {
   auto OptionsParser =
       CommonOptionsParser::create(argc, argv, Category, llvm::cl::ZeroOrMore,

 llvm::Expected<std::unique_ptr<ToolExecutor>>
 createExecutorFromCommandLineArgs(int &argc, const char **argv,
                                   llvm::cl::OptionCategory &Category,
                                   const char *Overview) {
   return internal::createExecutorFromCommandLineArgsImpl(argc, argv, Category,
                                                          Overview);
 }
 
+int executeFromCommandLineArgs(int &argc, const char **argv,
+                               ToolExecutor::Action Action,
+                               const char *Overview) {
+  static llvm::cl::OptionCategory Category("Execution options");
+  auto Exec = createExecutorFromCommandLineArgs(argc, argv, Category, Overview);
+  if (!Exec) {
+    llvm::errs() << toString(Exec.takeError());
+    return 1;
+  }
+  auto Err = (*Exec)->execute(std::move(Action));
+  if (Err) {
+    llvm::errs() << toString(std::move(Err));
+    return 2;
+  }
+  return 0;
+}
+
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the StandaloneToolExecutorPlugin etc.
 extern volatile int StandaloneToolExecutorAnchorSource;
 extern volatile int AllTUsToolExecutorAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED StandaloneToolExecutorAnchorDest =
     StandaloneToolExecutorAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED AllTUsToolExecutorAnchorDest =
     AllTUsToolExecutorAnchorSource;
 
 } // end namespace tooling
 } // end namespace clang

clang/lib/Tooling/StandaloneExecution.cpp

StandaloneToolExecutor::StandaloneToolExecutor(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : OptionsParser(std::move(Options)),
       Tool(OptionsParser->getCompilations(), OptionsParser->getSourcePathList(),
            std::move(PCHContainerOps)),
       Context(&Results), ArgsAdjuster(getDefaultArgumentsAdjusters()) {
   Tool.clearArgumentsAdjusters();
 }
 
-llvm::Error StandaloneToolExecutor::execute(
-    llvm::ArrayRef<
-        std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
-        Actions) {
+llvm::Error StandaloneToolExecutor::execute(llvm::ArrayRef<Action> Actions) {
   if (Actions.empty())
     return make_string_error("No action to execute.");
 
   if (Actions.size() != 1)
     return make_string_error(
         "Only support executing exactly 1 action at this point.");
 
   auto &Action = Actions.front();
-  Tool.appendArgumentsAdjuster(Action.second);
+  Tool.appendArgumentsAdjuster(Action.Adjuster);
   Tool.appendArgumentsAdjuster(ArgsAdjuster);
-  if (Tool.run(Action.first.get()))
+  if (Tool.run(Action.Factory.get()))
     return make_string_error("Failed to run action.");
 
   return llvm::Error::success();
 }
 
 class StandaloneToolExecutorPlugin : public ToolExecutorPlugin {
 public:
   llvm::Expected<std::unique_ptr<ToolExecutor>>

clang/lib/Tooling/Tooling.cpp

 //===- Tooling.cpp - Running clang standalone tools -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements functions to run clang tools standalone instead
 //  of running them as a plugin.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Tooling.h"
+#include "clang/AST/ASTConsumer.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
 #include "clang/Basic/LLVM.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/Driver/ToolChain.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
+#include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/FrontendOptions.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
 
   if (!Invocation.run())
     return nullptr;
 
   assert(ASTs.size() == 1);
   return std::move(ASTs[0]);
 }
 
+std::unique_ptr<FrontendActionFactory>
+consumeASTs(llvm::unique_function<void(ASTContext &) const> Func) {
+  using Delegate = llvm::unique_function<void(ASTContext &) const>;
+  struct Consumer : public ASTConsumer {
+    const Delegate &Func;
+    Consumer(const Delegate &Func) : Func(Func) {}
+    void HandleTranslationUnit(ASTContext &Ctx) override { Func(Ctx); }
+  };
+  struct Action : public ASTFrontendAction {
+    const Delegate &Func;
+    Action(const Delegate &Func) : Func(Func) {}
+    std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
+                                                   StringRef) override {
+      return std::make_unique<Consumer>(Func);
+    }
+  };
+  struct Factory : public FrontendActionFactory {
+    Delegate Func;
+    Factory(Delegate Func) : Func(std::move(Func)) {}
+    std::unique_ptr<FrontendAction> create() override {
+      return std::make_unique<Action>(Func);
+    }
+  };
+  return std::make_unique<Factory>(std::move(Func));
+}
+
 } // namespace tooling
 } // namespace clang

clang/unittests/Tooling/ExecutionTest.cpp

 //===- unittest/Tooling/ExecutionTest.cpp - Tool execution tests. --------===//
 //
 // 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/Tooling/Execution.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclarationName.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Tooling/AllTUsExecution.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/StandaloneExecution.h"
 #include "clang/Tooling/ToolExecutorPluginRegistry.h"
 #include "clang/Tooling/Tooling.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <algorithm>
 #include <string>
+#include <vector>
 
 namespace clang {
 namespace tooling {
 
 namespace {
 
 // This traverses the AST and outputs function name as key and "1" as value for
 // each function declaration.

 public:
   static const char *ExecutorName;
 
   TestToolExecutor(CommonOptionsParser Options)
       : OptionsParser(std::move(Options)) {}
 
   StringRef getExecutorName() const override { return ExecutorName; }
 
-  llvm::Error
-  execute(llvm::ArrayRef<std::pair<std::unique_ptr<FrontendActionFactory>,
-                                   ArgumentsAdjuster>>) override {
+  llvm::Error execute(llvm::ArrayRef<Action>) override {
     return llvm::Error::success();
   }
 
   ExecutionContext *getExecutionContext() override { return nullptr; };
 
   ToolResults *getToolResults() override { return nullptr; }
 
   llvm::ArrayRef<std::string> getSourcePaths() const {
std::vector<const char *> argv = {"prog", "test.cpp",
                                     "--executor=test-executor"};
   int argc = argv.size();
   auto Executor = internal::createExecutorFromCommandLineArgsImpl(
       argc, &argv[0], TestCategory);
   ASSERT_TRUE((bool)Executor);
   EXPECT_EQ(Executor->get()->getExecutorName(), TestToolExecutor::ExecutorName);
 }
 
+TEST(CreateToolExecutorTest, ExecuteFromCommandLine) {
+  llvm::unittest::TempFile Source1("test1", ".cpp", "int x = 0;", true);
+  llvm::unittest::TempFile Source2("test2", ".cpp", "int y = 0;", true);
+  std::string Path1 = Source1.path().str();
+  std::string Path2 = Source2.path().str();
+  std::vector<const char *> argv = {"prog", Path1.c_str(), Path2.c_str()};
+
+  int argc = argv.size();
+  int YCount = 0;
+  int Result = executeFromCommandLineArgs(
+      argc, &argv[0], consumeASTs([&](ASTContext &Ctx) {
+        DeclarationName Y(&Ctx.Idents.get("y"));
+        YCount += Ctx.getTranslationUnitDecl()->lookup(Y).isSingleResult();
+      }));
+  EXPECT_EQ(Result, 0);
+  EXPECT_EQ(YCount, 1);
+}
+
 TEST(StandaloneToolTest, SynctaxOnlyActionOnSimpleCode) {
   FixedCompilationDatabase Compilations(".", std::vector<std::string>());
   StandaloneToolExecutor Executor(Compilations,
                                   std::vector<std::string>(1, "a.cc"));
   Executor.mapVirtualFile("a.cc", "int x = 0;");
 
-  auto Err = Executor.execute(newFrontendActionFactory<SyntaxOnlyAction>(),
-                              getClangSyntaxOnlyAdjuster());
+  auto Err = Executor.execute({newFrontendActionFactory<SyntaxOnlyAction>(),
+                               getClangSyntaxOnlyAdjuster()});
   ASSERT_TRUE(!Err);
 }
 
 TEST(StandaloneToolTest, SimpleAction) {
   FixedCompilationDatabase Compilations(".", std::vector<std::string>());
   StandaloneToolExecutor Executor(Compilations,
                                   std::vector<std::string>(1, "a.cc"));
   Executor.mapVirtualFile("a.cc", "int x = 0;");

clang/unittests/Tooling/ToolingTest.cpp

 //===- unittest/Tooling/ToolingTest.cpp - Tooling unit tests --------------===//
 //
 // 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/Tooling/Tooling.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclGroup.h"
+#include "clang/AST/DeclarationName.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Testing/CommandLineArgs.h"
TEST(buildASTFromCode, ReportsErrors) {
   std::unique_ptr<ASTUnit> AST = buildASTFromCodeWithArgs(
       "int x = \"A\";", {}, "input.cc", "clang-tool",
       std::make_shared<PCHContainerOperations>(),
       getClangStripDependencyFileAdjuster(), FileContentMappings(), &Consumer);
   EXPECT_TRUE(AST.get());
   EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
 }
 
-TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) {
+TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromActionType) {
   std::unique_ptr<FrontendActionFactory> Factory(
       newFrontendActionFactory<SyntaxOnlyAction>());
   std::unique_ptr<FrontendAction> Action(Factory->create());
   EXPECT_TRUE(Action.get() != nullptr);
 }
 
+TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromConsumerType) {
+  class MyASTConsumer : public ASTConsumer {};
+  std::unique_ptr<FrontendActionFactory> Factory(
+      newFrontendActionFactory<MyASTConsumer>());
+  std::unique_ptr<FrontendAction> Action(Factory->create());
+  EXPECT_TRUE(Action.get() != nullptr);
+}
+
 struct IndependentFrontendActionCreator {
   std::unique_ptr<ASTConsumer> newASTConsumer() {
     return std::make_unique<FindTopLevelDeclConsumer>(nullptr);
   }
 };
 
 TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) {
   IndependentFrontendActionCreator Creator;
TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) {
   Tool.run(Action.get());
 
   EXPECT_TRUE(EndCallback.Matched);
   EXPECT_EQ(2u, EndCallback.BeginCalled);
   EXPECT_EQ(2u, EndCallback.EndCalled);
 }
 #endif
 
+TEST(newFrontendActionFactory, ConsumeASTs) {
+  FixedCompilationDatabase Compilations(".", std::vector<std::string>());
+  ClangTool Tool(Compilations, {"a.cc"});
+  Tool.mapVirtualFile("a.cc", "int x = 1;");
+  bool FoundX = false;
+  Tool.run(consumeASTs([&](ASTContext &Ctx) {
+             DeclarationName X(&Ctx.Idents.get("x"));
+             FoundX = Ctx.getTranslationUnitDecl()->lookup(X).isSingleResult();
+           }).get());
+  EXPECT_TRUE(FoundX);
+}
+
 struct SkipBodyConsumer : public clang::ASTConsumer {
   /// Skip the 'skipMe' function.
   bool shouldSkipFunctionBody(Decl *D) override {
     NamedDecl *F = dyn_cast<NamedDecl>(D);
     return F && F->getNameAsString() == "skipMe";
   }
 };