From 8051db16aa9513333062ab3145f038429f66780f Mon Sep 17 00:00:00 2001 From: Peter Collingbourne Date: Wed, 6 Nov 2013 20:12:45 +0000 Subject: [PATCH] Introduce ClangTool::buildASTs, and buildASTFromCode. These allow clients to retrieve persistent AST objects (ASTUnits) which can be used in an ad-hoc manner after parsing. To accommodate this change, the code for processing a CompilerInvocation using a FrontendAction has been factored out to FrontendActionFactory, and a new base class, ToolAction, has been introduced, allowing the tool to do arbitrary things with each CompilerInvocation. This change was necessary because ASTUnit does not use the FrontendAction interface directly. This change also causes the FileManager in ClangTool to use shared ownership. This will become necessary because ASTUnit takes shared ownership of FileManager (ClangTool's FileManager is currently unused by ASTUnit; this is a FIXME). As shown in the tests, any client of ToolInvocation will need to be modified to use shared ownership for FileManager. Differential Revision: http://llvm-reviews.chandlerc.com/D2097 git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@194164 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Tooling/Tooling.h | 74 +++++++++++--- lib/Tooling/Tooling.cpp | 154 +++++++++++++++++++++++------- unittests/Tooling/ToolingTest.cpp | 54 ++++++++++- 3 files changed, 232 insertions(+), 50 deletions(-) diff --git a/include/clang/Tooling/Tooling.h b/include/clang/Tooling/Tooling.h index 7e2be8a8ed..3a97645ab9 100644 --- a/include/clang/Tooling/Tooling.h +++ b/include/clang/Tooling/Tooling.h @@ -53,14 +53,33 @@ class FrontendAction; namespace tooling { +/// \brief Interface to process a clang::CompilerInvocation. +/// +/// If your tool is based on FrontendAction, you should be deriving from +/// FrontendActionFactory instead. +class ToolAction { +public: + virtual ~ToolAction(); + + /// \brief Perform an action for an invocation. + virtual bool runInvocation(clang::CompilerInvocation *Invocation, + FileManager *Files) = 0; +}; + /// \brief Interface to generate clang::FrontendActions. /// /// Having a factory interface allows, for example, a new FrontendAction to be -/// created for each translation unit processed by ClangTool. -class FrontendActionFactory { +/// created for each translation unit processed by ClangTool. This class is +/// also a ToolAction which uses the FrontendActions created by create() to +/// process each translation unit. +class FrontendActionFactory : public ToolAction { public: virtual ~FrontendActionFactory(); + /// \brief Invokes the compiler with a FrontendAction created by create(). + bool runInvocation(clang::CompilerInvocation *Invocation, + FileManager *Files); + /// \brief Returns a new clang::FrontendAction. /// /// The caller takes ownership of the returned action. @@ -133,6 +152,26 @@ bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code, const std::vector &Args, const Twine &FileName = "input.cc"); +/// \brief Builds an AST for 'Code'. +/// +/// \param Code C++ code. +/// \param FileName The file name which 'Code' will be mapped as. +/// +/// \return The resulting AST or null if an error occurred. +ASTUnit *buildASTFromCode(const Twine &Code, + const Twine &FileName = "input.cc"); + +/// \brief Builds an AST for 'Code' with additional flags. +/// +/// \param Code C++ code. +/// \param Args Additional flags to pass on. +/// \param FileName The file name which 'Code' will be mapped as. +/// +/// \return The resulting AST or null if an error occurred. +ASTUnit *buildASTFromCodeWithArgs(const Twine &Code, + const std::vector &Args, + const Twine &FileName = "input.cc"); + /// \brief Utility to run a FrontendAction in a single clang invocation. class ToolInvocation { public: @@ -145,9 +184,19 @@ class ToolInvocation { /// \param ToolAction The action to be executed. Class takes ownership. /// \param Files The FileManager used for the execution. Class does not take /// ownership. - ToolInvocation(ArrayRef CommandLine, FrontendAction *ToolAction, + ToolInvocation(ArrayRef CommandLine, FrontendAction *FAction, FileManager *Files); + /// \brief Create a tool invocation. + /// + /// \param CommandLine The command line arguments to clang. + /// \param Action The action to be executed. + /// \param Files The FileManager used for the execution. + ToolInvocation(ArrayRef CommandLine, ToolAction *Action, + FileManager *Files); + + ~ToolInvocation(); + /// \brief Map a virtual file to be used while running the tool. /// /// \param FilePath The path at which the content will be mapped. @@ -167,7 +216,8 @@ class ToolInvocation { clang::CompilerInvocation *Invocation); std::vector CommandLine; - OwningPtr ToolAction; + ToolAction *Action; + bool OwnsAction; FileManager *Files; // Maps -> . llvm::StringMap MappedFileContents; @@ -216,23 +266,25 @@ class ClangTool { /// \brief Clear the command line arguments adjuster chain. void clearArgumentsAdjusters(); - /// Runs a frontend action over all files specified in the command line. + /// Runs an action over all files specified in the command line. /// - /// \param ActionFactory Factory generating the frontend actions. The function - /// takes ownership of this parameter. A new action is generated for every - /// processed translation unit. - virtual int run(FrontendActionFactory *ActionFactory); + /// \param Action Tool action. + int run(ToolAction *Action); + + /// \brief Create an AST for each file specified in the command line and + /// append them to ASTs. + int buildASTs(std::vector &ASTs); /// \brief Returns the file manager used in the tool. /// /// The file manager is shared between all translation units. - FileManager &getFiles() { return Files; } + FileManager &getFiles() { return *Files; } private: // We store compile commands as pair (file name, compile command). std::vector< std::pair > CompileCommands; - FileManager Files; + llvm::IntrusiveRefCntPtr Files; // Contains a list of pairs (, ). std::vector< std::pair > MappedFileContents; diff --git a/lib/Tooling/Tooling.cpp b/lib/Tooling/Tooling.cpp index f9876daa6a..576989b454 100644 --- a/lib/Tooling/Tooling.cpp +++ b/lib/Tooling/Tooling.cpp @@ -13,9 +13,11 @@ //===----------------------------------------------------------------------===// #include "clang/Tooling/Tooling.h" +#include "clang/AST/ASTConsumer.h" #include "clang/Driver/Compilation.h" #include "clang/Driver/Driver.h" #include "clang/Driver/Tool.h" +#include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/TextDiagnosticPrinter.h" @@ -38,6 +40,8 @@ namespace clang { namespace tooling { +ToolAction::~ToolAction() {} + FrontendActionFactory::~FrontendActionFactory() {} // FIXME: This file contains structural duplication with other parts of the @@ -104,18 +108,26 @@ bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code, ToolAction, Code, std::vector(), FileName); } +static std::vector +getSyntaxOnlyToolArgs(const std::vector &ExtraArgs, + StringRef FileName) { + std::vector Args; + Args.push_back("clang-tool"); + Args.push_back("-fsyntax-only"); + Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end()); + Args.push_back(FileName.str()); + return Args; +} + bool runToolOnCodeWithArgs(clang::FrontendAction *ToolAction, const Twine &Code, const std::vector &Args, const Twine &FileName) { SmallString<16> FileNameStorage; StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage); - std::vector Commands; - Commands.push_back("clang-tool"); - Commands.push_back("-fsyntax-only"); - Commands.insert(Commands.end(), Args.begin(), Args.end()); - Commands.push_back(FileNameRef.data()); - FileManager Files((FileSystemOptions())); - ToolInvocation Invocation(Commands, ToolAction, &Files); + llvm::IntrusiveRefCntPtr Files( + new FileManager(FileSystemOptions())); + ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), ToolAction, + Files.getPtr()); SmallString<1024> CodeStorage; Invocation.mapVirtualFile(FileNameRef, @@ -138,10 +150,33 @@ std::string getAbsolutePath(StringRef File) { return AbsolutePath.str(); } -ToolInvocation::ToolInvocation( - ArrayRef CommandLine, FrontendAction *ToolAction, - FileManager *Files) - : CommandLine(CommandLine.vec()), ToolAction(ToolAction), Files(Files) { +namespace { + +class SingleFrontendActionFactory : public FrontendActionFactory { + FrontendAction *Action; + +public: + SingleFrontendActionFactory(FrontendAction *Action) : Action(Action) {} + + FrontendAction *create() { return Action; } +}; + +} + +ToolInvocation::ToolInvocation(ArrayRef CommandLine, + ToolAction *Action, FileManager *Files) + : CommandLine(CommandLine.vec()), Action(Action), OwnsAction(false), + Files(Files) {} + +ToolInvocation::ToolInvocation(ArrayRef CommandLine, + FrontendAction *FAction, FileManager *Files) + : CommandLine(CommandLine.vec()), + Action(new SingleFrontendActionFactory(FAction)), OwnsAction(true), + Files(Files) {} + +ToolInvocation::~ToolInvocation() { + if (OwnsAction) + delete Action; } void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) { @@ -175,6 +210,14 @@ bool ToolInvocation::run() { } OwningPtr Invocation( newInvocation(&Diagnostics, *CC1Args)); + for (llvm::StringMap::const_iterator + It = MappedFileContents.begin(), End = MappedFileContents.end(); + It != End; ++It) { + // Inject the code as the given file name into the preprocessor options. + const llvm::MemoryBuffer *Input = + llvm::MemoryBuffer::getMemBuffer(It->getValue()); + Invocation->getPreprocessorOpts().addRemappedFile(It->getKey(), Input); + } return runInvocation(BinaryName, Compilation.get(), Invocation.take()); } @@ -189,16 +232,20 @@ bool ToolInvocation::runInvocation( llvm::errs() << "\n"; } + return Action->runInvocation(Invocation, Files); +} + +bool FrontendActionFactory::runInvocation(CompilerInvocation *Invocation, + FileManager *Files) { // Create a compiler instance to handle the actual work. clang::CompilerInstance Compiler; Compiler.setInvocation(Invocation); Compiler.setFileManager(Files); - // FIXME: What about LangOpts? - // ToolAction can have lifetime requirements for Compiler or its members, and - // we need to ensure it's deleted earlier than Compiler. So we pass it to an - // OwningPtr declared after the Compiler variable. - OwningPtr ScopedToolAction(ToolAction.take()); + // The FrontendAction can have lifetime requirements for Compiler or its + // members, and we need to ensure it's deleted earlier than Compiler. So we + // pass it to an OwningPtr declared after the Compiler variable. + OwningPtr ScopedToolAction(create()); // Create the compilers actual diagnostics engine. Compiler.createDiagnostics(); @@ -206,32 +253,16 @@ bool ToolInvocation::runInvocation( return false; Compiler.createSourceManager(*Files); - addFileMappingsTo(Compiler.getSourceManager()); const bool Success = Compiler.ExecuteAction(*ScopedToolAction); - Compiler.resetAndLeakFileManager(); Files->clearStatCaches(); return Success; } -void ToolInvocation::addFileMappingsTo(SourceManager &Sources) { - for (llvm::StringMap::const_iterator - It = MappedFileContents.begin(), End = MappedFileContents.end(); - It != End; ++It) { - // Inject the code as the given file name into the preprocessor options. - const llvm::MemoryBuffer *Input = - llvm::MemoryBuffer::getMemBuffer(It->getValue()); - // FIXME: figure out what '0' stands for. - const FileEntry *FromFile = Files->getVirtualFile( - It->getKey(), Input->getBufferSize(), 0); - Sources.overrideFileContents(FromFile, Input); - } -} - ClangTool::ClangTool(const CompilationDatabase &Compilations, ArrayRef SourcePaths) - : Files((FileSystemOptions())) { + : Files(new FileManager(FileSystemOptions())) { ArgsAdjusters.push_back(new ClangStripOutputAdjuster()); ArgsAdjusters.push_back(new ClangSyntaxOnlyAdjuster()); for (unsigned I = 0, E = SourcePaths.size(); I != E; ++I) { @@ -274,7 +305,7 @@ void ClangTool::clearArgumentsAdjusters() { ArgsAdjusters.clear(); } -int ClangTool::run(FrontendActionFactory *ActionFactory) { +int ClangTool::run(ToolAction *Action) { // Exists solely for the purpose of lookup of the resource path. // This just needs to be some symbol in the binary. static int StaticSymbol; @@ -309,7 +340,7 @@ int ClangTool::run(FrontendActionFactory *ActionFactory) { DEBUG({ llvm::dbgs() << "Processing: " << File << ".\n"; }); - ToolInvocation Invocation(CommandLine, ActionFactory->create(), &Files); + ToolInvocation Invocation(CommandLine, Action, Files.getPtr()); for (int I = 0, E = MappedFileContents.size(); I != E; ++I) { Invocation.mapVirtualFile(MappedFileContents[I].first, MappedFileContents[I].second); @@ -323,5 +354,58 @@ int ClangTool::run(FrontendActionFactory *ActionFactory) { return ProcessingFailed ? 1 : 0; } +namespace { + +class ASTBuilderAction : public ToolAction { + std::vector &ASTs; + +public: + ASTBuilderAction(std::vector &ASTs) : ASTs(ASTs) {} + + bool runInvocation(CompilerInvocation *Invocation, + FileManager *Files) { + // FIXME: This should use the provided FileManager. + ASTUnit *AST = ASTUnit::LoadFromCompilerInvocation( + Invocation, + CompilerInstance::createDiagnostics(&Invocation->getDiagnosticOpts())); + if (!AST) + return false; + + ASTs.push_back(AST); + return true; + } +}; + +} + +int ClangTool::buildASTs(std::vector &ASTs) { + ASTBuilderAction Action(ASTs); + return run(&Action); +} + +ASTUnit *buildASTFromCode(const Twine &Code, const Twine &FileName) { + return buildASTFromCodeWithArgs(Code, std::vector(), FileName); +} + +ASTUnit *buildASTFromCodeWithArgs(const Twine &Code, + const std::vector &Args, + const Twine &FileName) { + SmallString<16> FileNameStorage; + StringRef FileNameRef = FileName.toNullTerminatedStringRef(FileNameStorage); + + std::vector ASTs; + ASTBuilderAction Action(ASTs); + ToolInvocation Invocation(getSyntaxOnlyToolArgs(Args, FileNameRef), &Action, 0); + + SmallString<1024> CodeStorage; + Invocation.mapVirtualFile(FileNameRef, + Code.toNullTerminatedStringRef(CodeStorage)); + if (!Invocation.run()) + return 0; + + assert(ASTs.size() == 1); + return ASTs[0]; +} + } // end namespace tooling } // end namespace clang diff --git a/unittests/Tooling/ToolingTest.cpp b/unittests/Tooling/ToolingTest.cpp index 412af7adda..096f688455 100644 --- a/unittests/Tooling/ToolingTest.cpp +++ b/unittests/Tooling/ToolingTest.cpp @@ -10,12 +10,14 @@ #include "clang/AST/ASTConsumer.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclGroup.h" +#include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendActions.h" #include "clang/Tooling/CompilationDatabase.h" #include "clang/Tooling/Tooling.h" #include "gtest/gtest.h" +#include "llvm/ADT/STLExtras.h" #include namespace clang { @@ -83,6 +85,18 @@ class FindClassDeclXConsumer : public clang::ASTConsumer { private: bool *FoundClassDeclX; }; +bool FindClassDeclX(ASTUnit *AST) { + for (std::vector::iterator i = AST->top_level_begin(), + e = AST->top_level_end(); + i != e; ++i) { + if (CXXRecordDecl* Record = dyn_cast(*i)) { + if (Record->getName() == "X") { + return true; + } + } + } + return false; +} } // end namespace TEST(runToolOnCode, FindsClassDecl) { @@ -97,6 +111,16 @@ TEST(runToolOnCode, FindsClassDecl) { EXPECT_FALSE(FoundClassDeclX); } +TEST(buildASTFromCode, FindsClassDecl) { + OwningPtr AST(buildASTFromCode("class X;")); + ASSERT_TRUE(AST.get()); + EXPECT_TRUE(FindClassDeclX(AST.get())); + + AST.reset(buildASTFromCode("class Y;")); + ASSERT_TRUE(AST.get()); + EXPECT_FALSE(FindClassDeclX(AST.get())); +} + TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromType) { OwningPtr Factory( newFrontendActionFactory()); @@ -119,13 +143,15 @@ TEST(newFrontendActionFactory, CreatesFrontendActionFactoryFromFactoryType) { } TEST(ToolInvocation, TestMapVirtualFile) { - clang::FileManager Files((clang::FileSystemOptions())); + IntrusiveRefCntPtr Files( + new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); - clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, &Files); + clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, + Files.getPtr()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); EXPECT_TRUE(Invocation.run()); @@ -136,13 +162,15 @@ TEST(ToolInvocation, TestVirtualModulesCompilation) { // mapped module.map is found on the include path. In the future, expand this // test to run a full modules enabled compilation, so we make sure we can // rerun modules compilations with a virtual file system. - clang::FileManager Files((clang::FileSystemOptions())); + IntrusiveRefCntPtr Files( + new clang::FileManager(clang::FileSystemOptions())); std::vector Args; Args.push_back("tool-executable"); Args.push_back("-Idef"); Args.push_back("-fsyntax-only"); Args.push_back("test.cpp"); - clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, &Files); + clang::tooling::ToolInvocation Invocation(Args, new SyntaxOnlyAction, + Files.getPtr()); Invocation.mapVirtualFile("test.cpp", "#include \n"); Invocation.mapVirtualFile("def/abc", "\n"); // Add a module.map file in the include directory of our header, so we trigger @@ -254,5 +282,23 @@ TEST(ClangToolTest, ArgumentAdjusters) { EXPECT_FALSE(Found); } +TEST(ClangToolTest, BuildASTs) { + FixedCompilationDatabase Compilations("/", std::vector()); + + std::vector Sources; + Sources.push_back("/a.cc"); + Sources.push_back("/b.cc"); + ClangTool Tool(Compilations, Sources); + + Tool.mapVirtualFile("/a.cc", "void a() {}"); + Tool.mapVirtualFile("/b.cc", "void b() {}"); + + std::vector ASTs; + EXPECT_EQ(0, Tool.buildASTs(ASTs)); + EXPECT_EQ(2u, ASTs.size()); + + llvm::DeleteContainerPointers(ASTs); +} + } // end namespace tooling } // end namespace clang -- 2.40.0