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