contrib/llvm/tools/clang/lib/Sema/MultiplexExternalSemaSource.cpp

   1 //===--- MultiplexExternalSemaSource.cpp  ---------------------------------===//
   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 event dispatching to the subscribed clients.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #include "clang/Sema/MultiplexExternalSemaSource.h"
  14 #include "clang/AST/DeclContextInternals.h"
  15 #include "clang/Sema/Lookup.h"
  16
  17 using namespace clang;
  18
  19 ///\brief Constructs a new multiplexing external sema source and appends the
  20 /// given element to it.
  21 ///
  22 MultiplexExternalSemaSource::MultiplexExternalSemaSource(ExternalSemaSource &s1,
  23                                                         ExternalSemaSource &s2){
  24   Sources.push_back(&s1);
  25   Sources.push_back(&s2);
  26 }
  27
  28 // pin the vtable here.
  29 MultiplexExternalSemaSource::~MultiplexExternalSemaSource() {}
  30
  31 ///\brief Appends new source to the source list.
  32 ///
  33 ///\param[in] source - An ExternalSemaSource.
  34 ///
  35 void MultiplexExternalSemaSource::addSource(ExternalSemaSource &source) {
  36   Sources.push_back(&source);
  37 }
  38
  39 //===----------------------------------------------------------------------===//
  40 // ExternalASTSource.
  41 //===----------------------------------------------------------------------===//
  42
  43 Decl *MultiplexExternalSemaSource::GetExternalDecl(uint32_t ID) {
  44   for(size_t i = 0; i < Sources.size(); ++i)
  45     if (Decl *Result = Sources[i]->GetExternalDecl(ID))
  46       return Result;
  47   return nullptr;
  48 }
  49
  50 void MultiplexExternalSemaSource::CompleteRedeclChain(const Decl *D) {
  51   for (size_t i = 0; i < Sources.size(); ++i)
  52     Sources[i]->CompleteRedeclChain(D);
  53 }
  54
  55 Selector MultiplexExternalSemaSource::GetExternalSelector(uint32_t ID) {
  56   Selector Sel;
  57   for(size_t i = 0; i < Sources.size(); ++i) {
  58     Sel = Sources[i]->GetExternalSelector(ID);
  59     if (!Sel.isNull())
  60       return Sel;
  61   }
  62   return Sel;
  63 }
  64
  65 uint32_t MultiplexExternalSemaSource::GetNumExternalSelectors() {
  66   uint32_t total = 0;
  67   for(size_t i = 0; i < Sources.size(); ++i)
  68     total += Sources[i]->GetNumExternalSelectors();
  69   return total;
  70 }
  71
  72 Stmt *MultiplexExternalSemaSource::GetExternalDeclStmt(uint64_t Offset) {
  73   for(size_t i = 0; i < Sources.size(); ++i)
  74     if (Stmt *Result = Sources[i]->GetExternalDeclStmt(Offset))
  75       return Result;
  76   return nullptr;
  77 }
  78
  79 CXXBaseSpecifier *MultiplexExternalSemaSource::GetExternalCXXBaseSpecifiers(
  80                                                                uint64_t Offset){
  81   for(size_t i = 0; i < Sources.size(); ++i)
  82     if (CXXBaseSpecifier *R = Sources[i]->GetExternalCXXBaseSpecifiers(Offset))
  83       return R;
  84   return nullptr;
  85 }
  86
  87 CXXCtorInitializer **
  88 MultiplexExternalSemaSource::GetExternalCXXCtorInitializers(uint64_t Offset) {
  89   for (auto *S : Sources)
  90     if (auto *R = S->GetExternalCXXCtorInitializers(Offset))
  91       return R;
  92   return nullptr;
  93 }
  94
  95 ExternalASTSource::ExtKind
  96 MultiplexExternalSemaSource::hasExternalDefinitions(const Decl *D) {
  97   for (const auto &S : Sources)
  98     if (auto EK = S->hasExternalDefinitions(D))
  99       if (EK != EK_ReplyHazy)
 100         return EK;
 101   return EK_ReplyHazy;
 102 }
 103
 104 bool MultiplexExternalSemaSource::
 105 FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) {
 106   bool AnyDeclsFound = false;
 107   for (size_t i = 0; i < Sources.size(); ++i)
 108     AnyDeclsFound |= Sources[i]->FindExternalVisibleDeclsByName(DC, Name);
 109   return AnyDeclsFound;
 110 }
 111
 112 void MultiplexExternalSemaSource::completeVisibleDeclsMap(const DeclContext *DC){
 113   for(size_t i = 0; i < Sources.size(); ++i)
 114     Sources[i]->completeVisibleDeclsMap(DC);
 115 }
 116
 117 void MultiplexExternalSemaSource::FindExternalLexicalDecls(
 118     const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
 119     SmallVectorImpl<Decl *> &Result) {
 120   for(size_t i = 0; i < Sources.size(); ++i)
 121     Sources[i]->FindExternalLexicalDecls(DC, IsKindWeWant, Result);
 122 }
 123
 124 void MultiplexExternalSemaSource::FindFileRegionDecls(FileID File,
 125                                                       unsigned Offset,
 126                                                       unsigned Length,
 127                                                 SmallVectorImpl<Decl *> &Decls){
 128   for(size_t i = 0; i < Sources.size(); ++i)
 129     Sources[i]->FindFileRegionDecls(File, Offset, Length, Decls);
 130 }
 131
 132 void MultiplexExternalSemaSource::CompleteType(TagDecl *Tag) {
 133   for(size_t i = 0; i < Sources.size(); ++i)
 134     Sources[i]->CompleteType(Tag);
 135 }
 136
 137 void MultiplexExternalSemaSource::CompleteType(ObjCInterfaceDecl *Class) {
 138   for(size_t i = 0; i < Sources.size(); ++i)
 139     Sources[i]->CompleteType(Class);
 140 }
 141
 142 void MultiplexExternalSemaSource::ReadComments() {
 143   for(size_t i = 0; i < Sources.size(); ++i)
 144     Sources[i]->ReadComments();
 145 }
 146
 147 void MultiplexExternalSemaSource::StartedDeserializing() {
 148   for(size_t i = 0; i < Sources.size(); ++i)
 149     Sources[i]->StartedDeserializing();
 150 }
 151
 152 void MultiplexExternalSemaSource::FinishedDeserializing() {
 153   for(size_t i = 0; i < Sources.size(); ++i)
 154     Sources[i]->FinishedDeserializing();
 155 }
 156
 157 void MultiplexExternalSemaSource::StartTranslationUnit(ASTConsumer *Consumer) {
 158   for(size_t i = 0; i < Sources.size(); ++i)
 159     Sources[i]->StartTranslationUnit(Consumer);
 160 }
 161
 162 void MultiplexExternalSemaSource::PrintStats() {
 163   for(size_t i = 0; i < Sources.size(); ++i)
 164     Sources[i]->PrintStats();
 165 }
 166
 167 bool MultiplexExternalSemaSource::layoutRecordType(const RecordDecl *Record,
 168                                                    uint64_t &Size,
 169                                                    uint64_t &Alignment,
 170                       llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
 171                   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
 172           llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets){
 173   for(size_t i = 0; i < Sources.size(); ++i)
 174     if (Sources[i]->layoutRecordType(Record, Size, Alignment, FieldOffsets,
 175                                      BaseOffsets, VirtualBaseOffsets))
 176       return true;
 177   return false;
 178 }
 179
 180 void MultiplexExternalSemaSource::
 181 getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
 182   for(size_t i = 0; i < Sources.size(); ++i)
 183     Sources[i]->getMemoryBufferSizes(sizes);
 184
 185 }
 186
 187 //===----------------------------------------------------------------------===//
 188 // ExternalSemaSource.
 189 //===----------------------------------------------------------------------===//
 190
 191
 192 void MultiplexExternalSemaSource::InitializeSema(Sema &S) {
 193   for(size_t i = 0; i < Sources.size(); ++i)
 194     Sources[i]->InitializeSema(S);
 195 }
 196
 197 void MultiplexExternalSemaSource::ForgetSema() {
 198   for(size_t i = 0; i < Sources.size(); ++i)
 199     Sources[i]->ForgetSema();
 200 }
 201
 202 void MultiplexExternalSemaSource::ReadMethodPool(Selector Sel) {
 203   for(size_t i = 0; i < Sources.size(); ++i)
 204     Sources[i]->ReadMethodPool(Sel);
 205 }
 206
 207 void MultiplexExternalSemaSource::updateOutOfDateSelector(Selector Sel) {
 208   for(size_t i = 0; i < Sources.size(); ++i)
 209     Sources[i]->updateOutOfDateSelector(Sel);
 210 }
 211
 212 void MultiplexExternalSemaSource::ReadKnownNamespaces(
 213                                    SmallVectorImpl<NamespaceDecl*> &Namespaces){
 214   for(size_t i = 0; i < Sources.size(); ++i)
 215     Sources[i]->ReadKnownNamespaces(Namespaces);
 216 }
 217
 218 void MultiplexExternalSemaSource::ReadUndefinedButUsed(
 219     llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
 220   for(size_t i = 0; i < Sources.size(); ++i)
 221     Sources[i]->ReadUndefinedButUsed(Undefined);
 222 }
 223
 224 void MultiplexExternalSemaSource::ReadMismatchingDeleteExpressions(
 225     llvm::MapVector<FieldDecl *,
 226                     llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
 227         Exprs) {
 228   for (auto &Source : Sources)
 229     Source->ReadMismatchingDeleteExpressions(Exprs);
 230 }
 231
 232 bool MultiplexExternalSemaSource::LookupUnqualified(LookupResult &R, Scope *S){
 233   for(size_t i = 0; i < Sources.size(); ++i)
 234     Sources[i]->LookupUnqualified(R, S);
 235
 236   return !R.empty();
 237 }
 238
 239 void MultiplexExternalSemaSource::ReadTentativeDefinitions(
 240                                      SmallVectorImpl<VarDecl*> &TentativeDefs) {
 241   for(size_t i = 0; i < Sources.size(); ++i)
 242     Sources[i]->ReadTentativeDefinitions(TentativeDefs);
 243 }
 244
 245 void MultiplexExternalSemaSource::ReadUnusedFileScopedDecls(
 246                                 SmallVectorImpl<const DeclaratorDecl*> &Decls) {
 247   for(size_t i = 0; i < Sources.size(); ++i)
 248     Sources[i]->ReadUnusedFileScopedDecls(Decls);
 249 }
 250
 251 void MultiplexExternalSemaSource::ReadDelegatingConstructors(
 252                                   SmallVectorImpl<CXXConstructorDecl*> &Decls) {
 253   for(size_t i = 0; i < Sources.size(); ++i)
 254     Sources[i]->ReadDelegatingConstructors(Decls);
 255 }
 256
 257 void MultiplexExternalSemaSource::ReadExtVectorDecls(
 258                                      SmallVectorImpl<TypedefNameDecl*> &Decls) {
 259   for(size_t i = 0; i < Sources.size(); ++i)
 260     Sources[i]->ReadExtVectorDecls(Decls);
 261 }
 262
 263 void MultiplexExternalSemaSource::ReadUnusedLocalTypedefNameCandidates(
 264     llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
 265   for(size_t i = 0; i < Sources.size(); ++i)
 266     Sources[i]->ReadUnusedLocalTypedefNameCandidates(Decls);
 267 }
 268
 269 void MultiplexExternalSemaSource::ReadReferencedSelectors(
 270                   SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
 271   for(size_t i = 0; i < Sources.size(); ++i)
 272     Sources[i]->ReadReferencedSelectors(Sels);
 273 }
 274
 275 void MultiplexExternalSemaSource::ReadWeakUndeclaredIdentifiers(
 276                    SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) {
 277   for(size_t i = 0; i < Sources.size(); ++i)
 278     Sources[i]->ReadWeakUndeclaredIdentifiers(WI);
 279 }
 280
 281 void MultiplexExternalSemaSource::ReadUsedVTables(
 282                                   SmallVectorImpl<ExternalVTableUse> &VTables) {
 283   for(size_t i = 0; i < Sources.size(); ++i)
 284     Sources[i]->ReadUsedVTables(VTables);
 285 }
 286
 287 void MultiplexExternalSemaSource::ReadPendingInstantiations(
 288                                            SmallVectorImpl<std::pair<ValueDecl*,
 289                                                    SourceLocation> > &Pending) {
 290   for(size_t i = 0; i < Sources.size(); ++i)
 291     Sources[i]->ReadPendingInstantiations(Pending);
 292 }
 293
 294 void MultiplexExternalSemaSource::ReadLateParsedTemplates(
 295     llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
 296         &LPTMap) {
 297   for (size_t i = 0; i < Sources.size(); ++i)
 298     Sources[i]->ReadLateParsedTemplates(LPTMap);
 299 }
 300
 301 TypoCorrection MultiplexExternalSemaSource::CorrectTypo(
 302                                      const DeclarationNameInfo &Typo,
 303                                      int LookupKind, Scope *S, CXXScopeSpec *SS,
 304                                      CorrectionCandidateCallback &CCC,
 305                                      DeclContext *MemberContext,
 306                                      bool EnteringContext,
 307                                      const ObjCObjectPointerType *OPT) {
 308   for (size_t I = 0, E = Sources.size(); I < E; ++I) {
 309     if (TypoCorrection C = Sources[I]->CorrectTypo(Typo, LookupKind, S, SS, CCC,
 310                                                    MemberContext,
 311                                                    EnteringContext, OPT))
 312       return C;
 313   }
 314   return TypoCorrection();
 315 }
 316
 317 bool MultiplexExternalSemaSource::MaybeDiagnoseMissingCompleteType(
 318     SourceLocation Loc, QualType T) {
 319   for (size_t I = 0, E = Sources.size(); I < E; ++I) {
 320     if (Sources[I]->MaybeDiagnoseMissingCompleteType(Loc, T))
 321       return true;
 322   }
 323   return false;
 324 }