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 ///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 ///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 Module *MultiplexExternalSemaSource::getModule(unsigned ID) {
168   for (size_t i = 0; i < Sources.size(); ++i)
169     if (auto M = Sources[i]->getModule(ID))
170       return M;
171   return nullptr;
172 }
173 
174 bool MultiplexExternalSemaSource::DeclIsFromPCHWithObjectFile(const Decl *D) {
175   for (auto *S : Sources)
176     if (S->DeclIsFromPCHWithObjectFile(D))
177       return true;
178   return false;
179 }
180 
181 bool MultiplexExternalSemaSource::layoutRecordType(const RecordDecl *Record,
182                                                    uint64_t &Size,
183                                                    uint64_t &Alignment,
184                       llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
185                   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
186           llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets){
187   for(size_t i = 0; i < Sources.size(); ++i)
188     if (Sources[i]->layoutRecordType(Record, Size, Alignment, FieldOffsets,
189                                      BaseOffsets, VirtualBaseOffsets))
190       return true;
191   return false;
192 }
193 
194 void MultiplexExternalSemaSource::
195 getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
196   for(size_t i = 0; i < Sources.size(); ++i)
197     Sources[i]->getMemoryBufferSizes(sizes);
198 
199 }
200 
201 //===----------------------------------------------------------------------===//
202 // ExternalSemaSource.
203 //===----------------------------------------------------------------------===//
204 
205 
206 void MultiplexExternalSemaSource::InitializeSema(Sema &S) {
207   for(size_t i = 0; i < Sources.size(); ++i)
208     Sources[i]->InitializeSema(S);
209 }
210 
211 void MultiplexExternalSemaSource::ForgetSema() {
212   for(size_t i = 0; i < Sources.size(); ++i)
213     Sources[i]->ForgetSema();
214 }
215 
216 void MultiplexExternalSemaSource::ReadMethodPool(Selector Sel) {
217   for(size_t i = 0; i < Sources.size(); ++i)
218     Sources[i]->ReadMethodPool(Sel);
219 }
220 
221 void MultiplexExternalSemaSource::updateOutOfDateSelector(Selector Sel) {
222   for(size_t i = 0; i < Sources.size(); ++i)
223     Sources[i]->updateOutOfDateSelector(Sel);
224 }
225 
226 void MultiplexExternalSemaSource::ReadKnownNamespaces(
227                                    SmallVectorImpl<NamespaceDecl*> &Namespaces){
228   for(size_t i = 0; i < Sources.size(); ++i)
229     Sources[i]->ReadKnownNamespaces(Namespaces);
230 }
231 
232 void MultiplexExternalSemaSource::ReadUndefinedButUsed(
233     llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
234   for(size_t i = 0; i < Sources.size(); ++i)
235     Sources[i]->ReadUndefinedButUsed(Undefined);
236 }
237 
238 void MultiplexExternalSemaSource::ReadMismatchingDeleteExpressions(
239     llvm::MapVector<FieldDecl *,
240                     llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
241         Exprs) {
242   for (auto &Source : Sources)
243     Source->ReadMismatchingDeleteExpressions(Exprs);
244 }
245 
246 bool MultiplexExternalSemaSource::LookupUnqualified(LookupResult &R, Scope *S){
247   for(size_t i = 0; i < Sources.size(); ++i)
248     Sources[i]->LookupUnqualified(R, S);
249 
250   return !R.empty();
251 }
252 
253 void MultiplexExternalSemaSource::ReadTentativeDefinitions(
254                                      SmallVectorImpl<VarDecl*> &TentativeDefs) {
255   for(size_t i = 0; i < Sources.size(); ++i)
256     Sources[i]->ReadTentativeDefinitions(TentativeDefs);
257 }
258 
259 void MultiplexExternalSemaSource::ReadUnusedFileScopedDecls(
260                                 SmallVectorImpl<const DeclaratorDecl*> &Decls) {
261   for(size_t i = 0; i < Sources.size(); ++i)
262     Sources[i]->ReadUnusedFileScopedDecls(Decls);
263 }
264 
265 void MultiplexExternalSemaSource::ReadDelegatingConstructors(
266                                   SmallVectorImpl<CXXConstructorDecl*> &Decls) {
267   for(size_t i = 0; i < Sources.size(); ++i)
268     Sources[i]->ReadDelegatingConstructors(Decls);
269 }
270 
271 void MultiplexExternalSemaSource::ReadExtVectorDecls(
272                                      SmallVectorImpl<TypedefNameDecl*> &Decls) {
273   for(size_t i = 0; i < Sources.size(); ++i)
274     Sources[i]->ReadExtVectorDecls(Decls);
275 }
276 
277 void MultiplexExternalSemaSource::ReadUnusedLocalTypedefNameCandidates(
278     llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
279   for(size_t i = 0; i < Sources.size(); ++i)
280     Sources[i]->ReadUnusedLocalTypedefNameCandidates(Decls);
281 }
282 
283 void MultiplexExternalSemaSource::ReadReferencedSelectors(
284                   SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
285   for(size_t i = 0; i < Sources.size(); ++i)
286     Sources[i]->ReadReferencedSelectors(Sels);
287 }
288 
289 void MultiplexExternalSemaSource::ReadWeakUndeclaredIdentifiers(
290                    SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) {
291   for(size_t i = 0; i < Sources.size(); ++i)
292     Sources[i]->ReadWeakUndeclaredIdentifiers(WI);
293 }
294 
295 void MultiplexExternalSemaSource::ReadUsedVTables(
296                                   SmallVectorImpl<ExternalVTableUse> &VTables) {
297   for(size_t i = 0; i < Sources.size(); ++i)
298     Sources[i]->ReadUsedVTables(VTables);
299 }
300 
301 void MultiplexExternalSemaSource::ReadPendingInstantiations(
302                                            SmallVectorImpl<std::pair<ValueDecl*,
303                                                    SourceLocation> > &Pending) {
304   for(size_t i = 0; i < Sources.size(); ++i)
305     Sources[i]->ReadPendingInstantiations(Pending);
306 }
307 
308 void MultiplexExternalSemaSource::ReadLateParsedTemplates(
309     llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
310         &LPTMap) {
311   for (size_t i = 0; i < Sources.size(); ++i)
312     Sources[i]->ReadLateParsedTemplates(LPTMap);
313 }
314 
315 TypoCorrection MultiplexExternalSemaSource::CorrectTypo(
316                                      const DeclarationNameInfo &Typo,
317                                      int LookupKind, Scope *S, CXXScopeSpec *SS,
318                                      CorrectionCandidateCallback &CCC,
319                                      DeclContext *MemberContext,
320                                      bool EnteringContext,
321                                      const ObjCObjectPointerType *OPT) {
322   for (size_t I = 0, E = Sources.size(); I < E; ++I) {
323     if (TypoCorrection C = Sources[I]->CorrectTypo(Typo, LookupKind, S, SS, CCC,
324                                                    MemberContext,
325                                                    EnteringContext, OPT))
326       return C;
327   }
328   return TypoCorrection();
329 }
330 
331 bool MultiplexExternalSemaSource::MaybeDiagnoseMissingCompleteType(
332     SourceLocation Loc, QualType T) {
333   for (size_t I = 0, E = Sources.size(); I < E; ++I) {
334     if (Sources[I]->MaybeDiagnoseMissingCompleteType(Loc, T))
335       return true;
336   }
337   return false;
338 }
339