clang/unittests/Tooling/Syntax/TreeTestBase.cpp

   1 //===- TreeTestBase.cpp ---------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file provides the test infrastructure for syntax trees.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "TreeTestBase.h"
  14 #include "clang/AST/ASTConsumer.h"
  15 #include "clang/Basic/LLVM.h"
  16 #include "clang/Frontend/CompilerInstance.h"
  17 #include "clang/Frontend/CompilerInvocation.h"
  18 #include "clang/Frontend/FrontendAction.h"
  19 #include "clang/Frontend/TextDiagnosticPrinter.h"
  20 #include "clang/Lex/PreprocessorOptions.h"
  21 #include "clang/Testing/CommandLineArgs.h"
  22 #include "clang/Testing/TestClangConfig.h"
  23 #include "clang/Tooling/Syntax/BuildTree.h"
  24 #include "clang/Tooling/Syntax/Nodes.h"
  25 #include "clang/Tooling/Syntax/Tokens.h"
  26 #include "clang/Tooling/Syntax/Tree.h"
  27 #include "llvm/ADT/ArrayRef.h"
  28 #include "llvm/ADT/StringRef.h"
  29 #include "llvm/Support/Casting.h"
  30 #include "llvm/Support/Error.h"
  31 #include "llvm/Testing/Annotations/Annotations.h"
  32 #include "gtest/gtest.h"
  33
  34 using namespace clang;
  35 using namespace clang::syntax;
  36
  37 namespace {
  38 ArrayRef<syntax::Token> tokens(syntax::Node *N,
  39                                const TokenBufferTokenManager &STM) {
  40   assert(N->isOriginal() && "tokens of modified nodes are not well-defined");
  41   if (auto *L = dyn_cast<syntax::Leaf>(N))
  42     return llvm::ArrayRef(STM.getToken(L->getTokenKey()), 1);
  43   auto *T = cast<syntax::Tree>(N);
  44   return llvm::ArrayRef(STM.getToken(T->findFirstLeaf()->getTokenKey()),
  45                         STM.getToken(T->findLastLeaf()->getTokenKey()) + 1);
  46 }
  47 } // namespace
  48
  49 std::vector<TestClangConfig> clang::syntax::allTestClangConfigs() {
  50   std::vector<TestClangConfig> all_configs;
  51   for (TestLanguage lang : {Lang_C89, Lang_C99, Lang_CXX03, Lang_CXX11,
  52                             Lang_CXX14, Lang_CXX17, Lang_CXX20}) {
  53     TestClangConfig config;
  54     config.Language = lang;
  55     config.Target = "x86_64-pc-linux-gnu";
  56     all_configs.push_back(config);
  57
  58     // Windows target is interesting to test because it enables
  59     // `-fdelayed-template-parsing`.
  60     config.Target = "x86_64-pc-win32-msvc";
  61     all_configs.push_back(config);
  62   }
  63   return all_configs;
  64 }
  65
  66 syntax::TranslationUnit *
  67 SyntaxTreeTest::buildTree(StringRef Code, const TestClangConfig &ClangConfig) {
  68   // FIXME: this code is almost the identical to the one in TokensTest. Share
  69   //        it.
  70   class BuildSyntaxTree : public ASTConsumer {
  71   public:
  72     BuildSyntaxTree(syntax::TranslationUnit *&Root,
  73                     std::unique_ptr<syntax::TokenBuffer> &TB,
  74                     std::unique_ptr<syntax::TokenBufferTokenManager> &TM,
  75                     std::unique_ptr<syntax::Arena> &Arena,
  76                     std::unique_ptr<syntax::TokenCollector> Tokens)
  77         : Root(Root), TB(TB), TM(TM), Arena(Arena), Tokens(std::move(Tokens)) {
  78       assert(this->Tokens);
  79     }
  80
  81     void HandleTranslationUnit(ASTContext &Ctx) override {
  82       TB = std::make_unique<syntax::TokenBuffer>(std::move(*Tokens).consume());
  83       Tokens = nullptr; // make sure we fail if this gets called twice.
  84       TM = std::make_unique<syntax::TokenBufferTokenManager>(
  85           *TB, Ctx.getLangOpts(), Ctx.getSourceManager());
  86       Arena = std::make_unique<syntax::Arena>();
  87       Root = syntax::buildSyntaxTree(*Arena, *TM, Ctx);
  88     }
  89
  90   private:
  91     syntax::TranslationUnit *&Root;
  92     std::unique_ptr<syntax::TokenBuffer> &TB;
  93     std::unique_ptr<syntax::TokenBufferTokenManager> &TM;
  94     std::unique_ptr<syntax::Arena> &Arena;
  95     std::unique_ptr<syntax::TokenCollector> Tokens;
  96   };
  97
  98   class BuildSyntaxTreeAction : public ASTFrontendAction {
  99   public:
 100     BuildSyntaxTreeAction(syntax::TranslationUnit *&Root,
 101                           std::unique_ptr<syntax::TokenBufferTokenManager> &TM,
 102                           std::unique_ptr<syntax::TokenBuffer> &TB,
 103                           std::unique_ptr<syntax::Arena> &Arena)
 104         : Root(Root), TM(TM), TB(TB), Arena(Arena) {}
 105
 106     std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 107                                                    StringRef InFile) override {
 108       // We start recording the tokens, ast consumer will take on the result.
 109       auto Tokens =
 110           std::make_unique<syntax::TokenCollector>(CI.getPreprocessor());
 111       return std::make_unique<BuildSyntaxTree>(Root, TB, TM, Arena,
 112                                                std::move(Tokens));
 113     }
 114
 115   private:
 116     syntax::TranslationUnit *&Root;
 117     std::unique_ptr<syntax::TokenBufferTokenManager> &TM;
 118     std::unique_ptr<syntax::TokenBuffer> &TB;
 119     std::unique_ptr<syntax::Arena> &Arena;
 120   };
 121
 122   constexpr const char *FileName = "./input.cpp";
 123   FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
 124
 125   if (!Diags->getClient())
 126     Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), DiagOpts.get()));
 127   Diags->setSeverityForGroup(diag::Flavor::WarningOrError, "unused-value",
 128                              diag::Severity::Ignored, SourceLocation());
 129
 130   // Prepare to run a compiler.
 131   std::vector<std::string> Args = {
 132       "syntax-test",
 133       "-fsyntax-only",
 134   };
 135   llvm::copy(ClangConfig.getCommandLineArgs(), std::back_inserter(Args));
 136   Args.push_back(FileName);
 137
 138   std::vector<const char *> ArgsCStr;
 139   for (const std::string &arg : Args) {
 140     ArgsCStr.push_back(arg.c_str());
 141   }
 142
 143   CreateInvocationOptions CIOpts;
 144   CIOpts.Diags = Diags;
 145   CIOpts.VFS = FS;
 146   Invocation = createInvocation(ArgsCStr, std::move(CIOpts));
 147   assert(Invocation);
 148   Invocation->getFrontendOpts().DisableFree = false;
 149   Invocation->getPreprocessorOpts().addRemappedFile(
 150       FileName, llvm::MemoryBuffer::getMemBufferCopy(Code).release());
 151   CompilerInstance Compiler;
 152   Compiler.setInvocation(Invocation);
 153   Compiler.setDiagnostics(Diags.get());
 154   Compiler.setFileManager(FileMgr.get());
 155   Compiler.setSourceManager(SourceMgr.get());
 156
 157   syntax::TranslationUnit *Root = nullptr;
 158   BuildSyntaxTreeAction Recorder(Root, this->TM, this->TB, this->Arena);
 159
 160   // Action could not be executed but the frontend didn't identify any errors
 161   // in the code ==> problem in setting up the action.
 162   if (!Compiler.ExecuteAction(Recorder) &&
 163       Diags->getClient()->getNumErrors() == 0) {
 164     ADD_FAILURE() << "failed to run the frontend";
 165     std::abort();
 166   }
 167   return Root;
 168 }
 169
 170 syntax::Node *SyntaxTreeTest::nodeByRange(llvm::Annotations::Range R,
 171                                           syntax::Node *Root) {
 172   ArrayRef<syntax::Token> Toks = tokens(Root, *TM);
 173
 174   if (Toks.front().location().isFileID() && Toks.back().location().isFileID() &&
 175       syntax::Token::range(*SourceMgr, Toks.front(), Toks.back()) ==
 176           syntax::FileRange(SourceMgr->getMainFileID(), R.Begin, R.End))
 177     return Root;
 178
 179   auto *T = dyn_cast<syntax::Tree>(Root);
 180   if (!T)
 181     return nullptr;
 182   for (auto *C = T->getFirstChild(); C != nullptr; C = C->getNextSibling()) {
 183     if (auto *Result = nodeByRange(R, C))
 184       return Result;
 185   }
 186   return nullptr;
 187 }