contrib/llvm/tools/clang/lib/AST/ExternalASTMerger.cpp

   1 //===- ExternalASTMerger.cpp - Merging External AST Interface ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements the ExternalASTMerger, which vends a combination of
  11 //  ASTs from several different ASTContext/FileManager pairs
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/Decl.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/ExternalASTMerger.h"
  19
  20 using namespace clang;
  21
  22 namespace {
  23
  24 template <typename T> struct Source {
  25   T t;
  26   Source(T t) : t(t) {}
  27   operator T() { return t; }
  28   template <typename U = T> U &get() { return t; }
  29   template <typename U = T> const U &get() const { return t; }
  30   template <typename U> operator Source<U>() { return Source<U>(t); }
  31 };
  32
  33 typedef std::pair<Source<NamedDecl *>, ASTImporter *> Candidate;
  34
  35 class LazyASTImporter : public ASTImporter {
  36 public:
  37   LazyASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
  38                   ASTContext &FromContext, FileManager &FromFileManager)
  39       : ASTImporter(ToContext, ToFileManager, FromContext, FromFileManager,
  40                     /*MinimalImport=*/true) {}
  41   Decl *Imported(Decl *From, Decl *To) override {
  42     if (auto ToTag = dyn_cast<TagDecl>(To)) {
  43       ToTag->setHasExternalLexicalStorage();
  44       ToTag->setMustBuildLookupTable();
  45     } else if (auto ToNamespace = dyn_cast<NamespaceDecl>(To)) {
  46       ToNamespace->setHasExternalVisibleStorage();
  47     }
  48     return ASTImporter::Imported(From, To);
  49   }
  50 };
  51
  52 Source<const DeclContext *>
  53 LookupSameContext(Source<TranslationUnitDecl *> SourceTU, const DeclContext *DC,
  54                   ASTImporter &ReverseImporter) {
  55   if (DC->isTranslationUnit()) {
  56     return SourceTU;
  57   }
  58   Source<const DeclContext *> SourceParentDC =
  59       LookupSameContext(SourceTU, DC->getParent(), ReverseImporter);
  60   if (!SourceParentDC) {
  61     // If we couldn't find the parent DC in this TranslationUnit, give up.
  62     return nullptr;
  63   }
  64   auto ND = cast<NamedDecl>(DC);
  65   DeclarationName Name = ND->getDeclName();
  66   Source<DeclarationName> SourceName = ReverseImporter.Import(Name);
  67   DeclContext::lookup_result SearchResult =
  68       SourceParentDC.get()->lookup(SourceName.get());
  69   size_t SearchResultSize = SearchResult.size();
  70   // Handle multiple candidates once we have a test for it.
  71   // This may turn up when we import template specializations correctly.
  72   assert(SearchResultSize < 2);
  73   if (SearchResultSize == 0) {
  74     // couldn't find the name, so we have to give up
  75     return nullptr;
  76   } else {
  77     NamedDecl *SearchResultDecl = SearchResult[0];
  78     return dyn_cast<DeclContext>(SearchResultDecl);
  79   }
  80 }
  81
  82 bool IsForwardDeclaration(Decl *D) {
  83   assert(!isa<ObjCInterfaceDecl>(D)); // TODO handle this case
  84   if (auto TD = dyn_cast<TagDecl>(D)) {
  85     return !TD->isThisDeclarationADefinition();
  86   } else if (auto FD = dyn_cast<FunctionDecl>(D)) {
  87     return !FD->isThisDeclarationADefinition();
  88   } else {
  89     return false;
  90   }
  91 }
  92
  93 template <typename CallbackType>
  94 void ForEachMatchingDC(
  95     const DeclContext *DC,
  96     llvm::ArrayRef<ExternalASTMerger::ImporterPair> Importers,
  97     CallbackType Callback) {
  98   for (const ExternalASTMerger::ImporterPair &IP : Importers) {
  99     Source<TranslationUnitDecl *> SourceTU =
 100         IP.Forward->getFromContext().getTranslationUnitDecl();
 101     if (auto SourceDC = LookupSameContext(SourceTU, DC, *IP.Reverse))
 102       Callback(IP, SourceDC);
 103   }
 104 }
 105
 106 bool HasDeclOfSameType(llvm::ArrayRef<Candidate> Decls, const Candidate &C) {
 107   return llvm::any_of(Decls, [&](const Candidate &D) {
 108     return C.first.get()->getKind() == D.first.get()->getKind();
 109   });
 110 }
 111 } // end namespace
 112
 113 ExternalASTMerger::ExternalASTMerger(const ImporterEndpoint &Target,
 114                                      llvm::ArrayRef<ImporterEndpoint> Sources) {
 115   for (const ImporterEndpoint &S : Sources) {
 116     Importers.push_back(
 117         {llvm::make_unique<LazyASTImporter>(Target.AST, Target.FM, S.AST, S.FM),
 118          llvm::make_unique<ASTImporter>(S.AST, S.FM, Target.AST, Target.FM,
 119                                         /*MinimalImport=*/true)});
 120   }
 121 }
 122
 123 bool ExternalASTMerger::FindExternalVisibleDeclsByName(const DeclContext *DC,
 124                                                        DeclarationName Name) {
 125   llvm::SmallVector<NamedDecl *, 1> Decls;
 126   llvm::SmallVector<Candidate, 4> CompleteDecls;
 127   llvm::SmallVector<Candidate, 4> ForwardDecls;
 128
 129   auto FilterFoundDecl = [&CompleteDecls, &ForwardDecls](const Candidate &C) {
 130     if (IsForwardDeclaration(C.first.get())) {
 131       if (!HasDeclOfSameType(ForwardDecls, C)) {
 132         ForwardDecls.push_back(C);
 133       }
 134     } else {
 135       CompleteDecls.push_back(C);
 136     }
 137   };
 138
 139   ForEachMatchingDC(
 140       DC, Importers,
 141       [&](const ImporterPair &IP, Source<const DeclContext *> SourceDC) {
 142         DeclarationName FromName = IP.Reverse->Import(Name);
 143         DeclContextLookupResult Result = SourceDC.get()->lookup(FromName);
 144         for (NamedDecl *FromD : Result) {
 145           FilterFoundDecl(std::make_pair(FromD, IP.Forward.get()));
 146         }
 147       });
 148
 149   llvm::ArrayRef<Candidate> DeclsToReport =
 150       CompleteDecls.empty() ? ForwardDecls : CompleteDecls;
 151
 152   if (DeclsToReport.empty()) {
 153     return false;
 154   }
 155
 156   Decls.reserve(DeclsToReport.size());
 157   for (const Candidate &C : DeclsToReport) {
 158     NamedDecl *d = cast<NamedDecl>(C.second->Import(C.first.get()));
 159     assert(d);
 160     Decls.push_back(d);
 161   }
 162   SetExternalVisibleDeclsForName(DC, Name, Decls);
 163   return true;
 164 }
 165
 166 void ExternalASTMerger::FindExternalLexicalDecls(
 167     const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
 168     SmallVectorImpl<Decl *> &Result) {
 169   ForEachMatchingDC(
 170       DC, Importers,
 171       [&](const ImporterPair &IP, Source<const DeclContext *> SourceDC) {
 172         for (const Decl *SourceDecl : SourceDC.get()->decls()) {
 173           if (IsKindWeWant(SourceDecl->getKind())) {
 174             Decl *ImportedDecl =
 175                 IP.Forward->Import(const_cast<Decl *>(SourceDecl));
 176             assert(ImportedDecl->getDeclContext() == DC);
 177             (void)ImportedDecl;
 178           }
 179         }
 180       });
 181 }
 182