clang/lib/Sema/MultiplexExternalSemaSource.cpp

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