clang/unittests/AST/ASTImporterFixtures.cpp

   1 //===- unittest/AST/ASTImporterFixtures.cpp - AST unit test support -------===//
   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 /// \file
  10 /// Implementation of fixture classes for testing the ASTImporter.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ASTImporterFixtures.h"
  15
  16 #include "clang/AST/ASTImporter.h"
  17 #include "clang/AST/ASTImporterSharedState.h"
  18 #include "clang/Frontend/ASTUnit.h"
  19 #include "clang/Tooling/Tooling.h"
  20
  21 namespace clang {
  22 namespace ast_matchers {
  23
  24 void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
  25                                std::unique_ptr<llvm::MemoryBuffer> &&Buffer) {
  26   assert(ToAST);
  27   ASTContext &ToCtx = ToAST->getASTContext();
  28   auto *OFS = static_cast<llvm::vfs::OverlayFileSystem *>(
  29       &ToCtx.getSourceManager().getFileManager().getVirtualFileSystem());
  30   auto *MFS = static_cast<llvm::vfs::InMemoryFileSystem *>(
  31       OFS->overlays_begin()->get());
  32   MFS->addFile(FileName, 0, std::move(Buffer));
  33 }
  34
  35 void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
  36                                StringRef Code) {
  37   return createVirtualFileIfNeeded(ToAST, FileName,
  38                                    llvm::MemoryBuffer::getMemBuffer(Code));
  39 }
  40
  41 ASTImporterTestBase::TU::TU(StringRef Code, StringRef FileName,
  42                             std::vector<std::string> Args,
  43                             ImporterConstructor C,
  44                             ASTImporter::ODRHandlingType ODRHandling)
  45     : Code(std::string(Code)), FileName(std::string(FileName)),
  46       Unit(tooling::buildASTFromCodeWithArgs(this->Code, Args, this->FileName)),
  47       TUDecl(Unit->getASTContext().getTranslationUnitDecl()), Creator(C),
  48       ODRHandling(ODRHandling) {
  49   Unit->enableSourceFileDiagnostics();
  50
  51   // If the test doesn't need a specific ASTImporter, we just create a
  52   // normal ASTImporter with it.
  53   if (!Creator)
  54     Creator = [](ASTContext &ToContext, FileManager &ToFileManager,
  55                  ASTContext &FromContext, FileManager &FromFileManager,
  56                  bool MinimalImport,
  57                  const std::shared_ptr<ASTImporterSharedState> &SharedState) {
  58       return new ASTImporter(ToContext, ToFileManager, FromContext,
  59                              FromFileManager, MinimalImport, SharedState);
  60     };
  61 }
  62
  63 ASTImporterTestBase::TU::~TU() {}
  64
  65 void ASTImporterTestBase::TU::lazyInitImporter(
  66     const std::shared_ptr<ASTImporterSharedState> &SharedState,
  67     ASTUnit *ToAST) {
  68   assert(ToAST);
  69   if (!Importer) {
  70     Importer.reset(Creator(ToAST->getASTContext(), ToAST->getFileManager(),
  71                            Unit->getASTContext(), Unit->getFileManager(), false,
  72                            SharedState));
  73     Importer->setODRHandling(ODRHandling);
  74   }
  75   assert(&ToAST->getASTContext() == &Importer->getToContext());
  76   createVirtualFileIfNeeded(ToAST, FileName, Code);
  77 }
  78
  79 Decl *ASTImporterTestBase::TU::import(
  80     const std::shared_ptr<ASTImporterSharedState> &SharedState, ASTUnit *ToAST,
  81     Decl *FromDecl) {
  82   lazyInitImporter(SharedState, ToAST);
  83   if (auto ImportedOrErr = Importer->Import(FromDecl))
  84     return *ImportedOrErr;
  85   else {
  86     llvm::consumeError(ImportedOrErr.takeError());
  87     return nullptr;
  88   }
  89 }
  90
  91 llvm::Expected<Decl *> ASTImporterTestBase::TU::importOrError(
  92     const std::shared_ptr<ASTImporterSharedState> &SharedState, ASTUnit *ToAST,
  93     Decl *FromDecl) {
  94   lazyInitImporter(SharedState, ToAST);
  95   return Importer->Import(FromDecl);
  96 }
  97
  98 QualType ASTImporterTestBase::TU::import(
  99     const std::shared_ptr<ASTImporterSharedState> &SharedState, ASTUnit *ToAST,
 100     QualType FromType) {
 101   lazyInitImporter(SharedState, ToAST);
 102   if (auto ImportedOrErr = Importer->Import(FromType))
 103     return *ImportedOrErr;
 104   else {
 105     llvm::consumeError(ImportedOrErr.takeError());
 106     return QualType{};
 107   }
 108 }
 109
 110 void ASTImporterTestBase::lazyInitSharedState(TranslationUnitDecl *ToTU) {
 111   assert(ToTU);
 112   if (!SharedStatePtr)
 113     SharedStatePtr = std::make_shared<ASTImporterSharedState>(*ToTU);
 114 }
 115
 116 void ASTImporterTestBase::lazyInitToAST(TestLanguage ToLang,
 117                                         StringRef ToSrcCode,
 118                                         StringRef FileName) {
 119   if (ToAST)
 120     return;
 121   std::vector<std::string> ToArgs = getCommandLineArgsForLanguage(ToLang);
 122   // Source code must be a valid live buffer through the tests lifetime.
 123   ToCode = std::string(ToSrcCode);
 124   // Build the AST from an empty file.
 125   ToAST = tooling::buildASTFromCodeWithArgs(ToCode, ToArgs, FileName);
 126   ToAST->enableSourceFileDiagnostics();
 127   lazyInitSharedState(ToAST->getASTContext().getTranslationUnitDecl());
 128 }
 129
 130 ASTImporterTestBase::TU *ASTImporterTestBase::findFromTU(Decl *From) {
 131   // Create a virtual file in the To Ctx which corresponds to the file from
 132   // which we want to import the `From` Decl. Without this source locations
 133   // will be invalid in the ToCtx.
 134   auto It = llvm::find_if(FromTUs, [From](const TU &E) {
 135     return E.TUDecl == From->getTranslationUnitDecl();
 136   });
 137   assert(It != FromTUs.end());
 138   return &*It;
 139 }
 140
 141 std::tuple<Decl *, Decl *> ASTImporterTestBase::getImportedDecl(
 142     StringRef FromSrcCode, TestLanguage FromLang, StringRef ToSrcCode,
 143     TestLanguage ToLang, StringRef Identifier) {
 144   std::vector<std::string> FromArgs = getCommandLineArgsForLanguage(FromLang);
 145   std::vector<std::string> ToArgs = getCommandLineArgsForLanguage(ToLang);
 146
 147   FromTUs.emplace_back(FromSrcCode, InputFileName, FromArgs, Creator,
 148                        ODRHandling);
 149   TU &FromTU = FromTUs.back();
 150
 151   assert(!ToAST);
 152   lazyInitToAST(ToLang, ToSrcCode, OutputFileName);
 153
 154   ASTContext &FromCtx = FromTU.Unit->getASTContext();
 155
 156   IdentifierInfo *ImportedII = &FromCtx.Idents.get(Identifier);
 157   assert(ImportedII && "Declaration with the given identifier "
 158                        "should be specified in test!");
 159   DeclarationName ImportDeclName(ImportedII);
 160   SmallVector<NamedDecl *, 1> FoundDecls;
 161   FromCtx.getTranslationUnitDecl()->localUncachedLookup(ImportDeclName,
 162                                                         FoundDecls);
 163
 164   assert(FoundDecls.size() == 1);
 165
 166   Decl *Imported =
 167       FromTU.import(SharedStatePtr, ToAST.get(), FoundDecls.front());
 168
 169   assert(Imported);
 170   return std::make_tuple(*FoundDecls.begin(), Imported);
 171 }
 172
 173 TranslationUnitDecl *ASTImporterTestBase::getTuDecl(StringRef SrcCode,
 174                                                     TestLanguage Lang,
 175                                                     StringRef FileName) {
 176   assert(llvm::find_if(FromTUs, [FileName](const TU &E) {
 177            return E.FileName == FileName;
 178          }) == FromTUs.end());
 179
 180   std::vector<std::string> Args = getCommandLineArgsForLanguage(Lang);
 181   FromTUs.emplace_back(SrcCode, FileName, Args, Creator, ODRHandling);
 182   TU &Tu = FromTUs.back();
 183
 184   return Tu.TUDecl;
 185 }
 186
 187 TranslationUnitDecl *ASTImporterTestBase::getToTuDecl(StringRef ToSrcCode,
 188                                                       TestLanguage ToLang) {
 189   std::vector<std::string> ToArgs = getCommandLineArgsForLanguage(ToLang);
 190   assert(!ToAST);
 191   lazyInitToAST(ToLang, ToSrcCode, OutputFileName);
 192   return ToAST->getASTContext().getTranslationUnitDecl();
 193 }
 194
 195 Decl *ASTImporterTestBase::Import(Decl *From, TestLanguage ToLang) {
 196   lazyInitToAST(ToLang, "", OutputFileName);
 197   TU *FromTU = findFromTU(From);
 198   assert(SharedStatePtr);
 199   Decl *To = FromTU->import(SharedStatePtr, ToAST.get(), From);
 200   return To;
 201 }
 202
 203 llvm::Expected<Decl *> ASTImporterTestBase::importOrError(Decl *From,
 204                                                           TestLanguage ToLang) {
 205   lazyInitToAST(ToLang, "", OutputFileName);
 206   TU *FromTU = findFromTU(From);
 207   assert(SharedStatePtr);
 208   llvm::Expected<Decl *> To =
 209       FromTU->importOrError(SharedStatePtr, ToAST.get(), From);
 210   return To;
 211 }
 212
 213 QualType ASTImporterTestBase::ImportType(QualType FromType, Decl *TUDecl,
 214                                          TestLanguage ToLang) {
 215   lazyInitToAST(ToLang, "", OutputFileName);
 216   TU *FromTU = findFromTU(TUDecl);
 217   assert(SharedStatePtr);
 218   return FromTU->import(SharedStatePtr, ToAST.get(), FromType);
 219 }
 220
 221 ASTImporterTestBase::~ASTImporterTestBase() {
 222   if (!::testing::Test::HasFailure())
 223     return;
 224
 225   for (auto &Tu : FromTUs) {
 226     assert(Tu.Unit);
 227     llvm::errs() << "FromAST:\n";
 228     Tu.Unit->getASTContext().getTranslationUnitDecl()->dump();
 229     llvm::errs() << "\n";
 230   }
 231   if (ToAST) {
 232     llvm::errs() << "ToAST:\n";
 233     ToAST->getASTContext().getTranslationUnitDecl()->dump();
 234   }
 235 }
 236
 237 } // end namespace ast_matchers
 238 } // end namespace clang