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 bool MultiplexExternalSemaSource::
98 FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) {
99   bool AnyDeclsFound = false;
100   for (size_t i = 0; i < Sources.size(); ++i)
101     AnyDeclsFound |= Sources[i]->FindExternalVisibleDeclsByName(DC, Name);
102   return AnyDeclsFound;
103 }
104 
105 void MultiplexExternalSemaSource::completeVisibleDeclsMap(const DeclContext *DC){
106   for(size_t i = 0; i < Sources.size(); ++i)
107     Sources[i]->completeVisibleDeclsMap(DC);
108 }
109 
110 void MultiplexExternalSemaSource::FindExternalLexicalDecls(
111     const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
112     SmallVectorImpl<Decl *> &Result) {
113   for(size_t i = 0; i < Sources.size(); ++i)
114     Sources[i]->FindExternalLexicalDecls(DC, IsKindWeWant, Result);
115 }
116 
117 void MultiplexExternalSemaSource::FindFileRegionDecls(FileID File,
118                                                       unsigned Offset,
119                                                       unsigned Length,
120                                                 SmallVectorImpl<Decl *> &Decls){
121   for(size_t i = 0; i < Sources.size(); ++i)
122     Sources[i]->FindFileRegionDecls(File, Offset, Length, Decls);
123 }
124 
125 void MultiplexExternalSemaSource::CompleteType(TagDecl *Tag) {
126   for(size_t i = 0; i < Sources.size(); ++i)
127     Sources[i]->CompleteType(Tag);
128 }
129 
130 void MultiplexExternalSemaSource::CompleteType(ObjCInterfaceDecl *Class) {
131   for(size_t i = 0; i < Sources.size(); ++i)
132     Sources[i]->CompleteType(Class);
133 }
134 
135 void MultiplexExternalSemaSource::ReadComments() {
136   for(size_t i = 0; i < Sources.size(); ++i)
137     Sources[i]->ReadComments();
138 }
139 
140 void MultiplexExternalSemaSource::StartedDeserializing() {
141   for(size_t i = 0; i < Sources.size(); ++i)
142     Sources[i]->StartedDeserializing();
143 }
144 
145 void MultiplexExternalSemaSource::FinishedDeserializing() {
146   for(size_t i = 0; i < Sources.size(); ++i)
147     Sources[i]->FinishedDeserializing();
148 }
149 
150 void MultiplexExternalSemaSource::StartTranslationUnit(ASTConsumer *Consumer) {
151   for(size_t i = 0; i < Sources.size(); ++i)
152     Sources[i]->StartTranslationUnit(Consumer);
153 }
154 
155 void MultiplexExternalSemaSource::PrintStats() {
156   for(size_t i = 0; i < Sources.size(); ++i)
157     Sources[i]->PrintStats();
158 }
159 
160 bool MultiplexExternalSemaSource::layoutRecordType(const RecordDecl *Record,
161                                                    uint64_t &Size,
162                                                    uint64_t &Alignment,
163                       llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
164                   llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
165           llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets){
166   for(size_t i = 0; i < Sources.size(); ++i)
167     if (Sources[i]->layoutRecordType(Record, Size, Alignment, FieldOffsets,
168                                      BaseOffsets, VirtualBaseOffsets))
169       return true;
170   return false;
171 }
172 
173 void MultiplexExternalSemaSource::
174 getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
175   for(size_t i = 0; i < Sources.size(); ++i)
176     Sources[i]->getMemoryBufferSizes(sizes);
177 
178 }
179 
180 //===----------------------------------------------------------------------===//
181 // ExternalSemaSource.
182 //===----------------------------------------------------------------------===//
183 
184 
185 void MultiplexExternalSemaSource::InitializeSema(Sema &S) {
186   for(size_t i = 0; i < Sources.size(); ++i)
187     Sources[i]->InitializeSema(S);
188 }
189 
190 void MultiplexExternalSemaSource::ForgetSema() {
191   for(size_t i = 0; i < Sources.size(); ++i)
192     Sources[i]->ForgetSema();
193 }
194 
195 void MultiplexExternalSemaSource::ReadMethodPool(Selector Sel) {
196   for(size_t i = 0; i < Sources.size(); ++i)
197     Sources[i]->ReadMethodPool(Sel);
198 }
199 
200 void MultiplexExternalSemaSource::updateOutOfDateSelector(Selector Sel) {
201   for(size_t i = 0; i < Sources.size(); ++i)
202     Sources[i]->updateOutOfDateSelector(Sel);
203 }
204 
205 void MultiplexExternalSemaSource::ReadKnownNamespaces(
206                                    SmallVectorImpl<NamespaceDecl*> &Namespaces){
207   for(size_t i = 0; i < Sources.size(); ++i)
208     Sources[i]->ReadKnownNamespaces(Namespaces);
209 }
210 
211 void MultiplexExternalSemaSource::ReadUndefinedButUsed(
212     llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
213   for(size_t i = 0; i < Sources.size(); ++i)
214     Sources[i]->ReadUndefinedButUsed(Undefined);
215 }
216 
217 void MultiplexExternalSemaSource::ReadMismatchingDeleteExpressions(
218     llvm::MapVector<FieldDecl *,
219                     llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
220         Exprs) {
221   for (auto &Source : Sources)
222     Source->ReadMismatchingDeleteExpressions(Exprs);
223 }
224 
225 bool MultiplexExternalSemaSource::LookupUnqualified(LookupResult &R, Scope *S){
226   for(size_t i = 0; i < Sources.size(); ++i)
227     Sources[i]->LookupUnqualified(R, S);
228 
229   return !R.empty();
230 }
231 
232 void MultiplexExternalSemaSource::ReadTentativeDefinitions(
233                                      SmallVectorImpl<VarDecl*> &TentativeDefs) {
234   for(size_t i = 0; i < Sources.size(); ++i)
235     Sources[i]->ReadTentativeDefinitions(TentativeDefs);
236 }
237 
238 void MultiplexExternalSemaSource::ReadUnusedFileScopedDecls(
239                                 SmallVectorImpl<const DeclaratorDecl*> &Decls) {
240   for(size_t i = 0; i < Sources.size(); ++i)
241     Sources[i]->ReadUnusedFileScopedDecls(Decls);
242 }
243 
244 void MultiplexExternalSemaSource::ReadDelegatingConstructors(
245                                   SmallVectorImpl<CXXConstructorDecl*> &Decls) {
246   for(size_t i = 0; i < Sources.size(); ++i)
247     Sources[i]->ReadDelegatingConstructors(Decls);
248 }
249 
250 void MultiplexExternalSemaSource::ReadExtVectorDecls(
251                                      SmallVectorImpl<TypedefNameDecl*> &Decls) {
252   for(size_t i = 0; i < Sources.size(); ++i)
253     Sources[i]->ReadExtVectorDecls(Decls);
254 }
255 
256 void MultiplexExternalSemaSource::ReadUnusedLocalTypedefNameCandidates(
257     llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
258   for(size_t i = 0; i < Sources.size(); ++i)
259     Sources[i]->ReadUnusedLocalTypedefNameCandidates(Decls);
260 }
261 
262 void MultiplexExternalSemaSource::ReadReferencedSelectors(
263                   SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
264   for(size_t i = 0; i < Sources.size(); ++i)
265     Sources[i]->ReadReferencedSelectors(Sels);
266 }
267 
268 void MultiplexExternalSemaSource::ReadWeakUndeclaredIdentifiers(
269                    SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) {
270   for(size_t i = 0; i < Sources.size(); ++i)
271     Sources[i]->ReadWeakUndeclaredIdentifiers(WI);
272 }
273 
274 void MultiplexExternalSemaSource::ReadUsedVTables(
275                                   SmallVectorImpl<ExternalVTableUse> &VTables) {
276   for(size_t i = 0; i < Sources.size(); ++i)
277     Sources[i]->ReadUsedVTables(VTables);
278 }
279 
280 void MultiplexExternalSemaSource::ReadPendingInstantiations(
281                                            SmallVectorImpl<std::pair<ValueDecl*,
282                                                    SourceLocation> > &Pending) {
283   for(size_t i = 0; i < Sources.size(); ++i)
284     Sources[i]->ReadPendingInstantiations(Pending);
285 }
286 
287 void MultiplexExternalSemaSource::ReadLateParsedTemplates(
288     llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
289         &LPTMap) {
290   for (size_t i = 0; i < Sources.size(); ++i)
291     Sources[i]->ReadLateParsedTemplates(LPTMap);
292 }
293 
294 TypoCorrection MultiplexExternalSemaSource::CorrectTypo(
295                                      const DeclarationNameInfo &Typo,
296                                      int LookupKind, Scope *S, CXXScopeSpec *SS,
297                                      CorrectionCandidateCallback &CCC,
298                                      DeclContext *MemberContext,
299                                      bool EnteringContext,
300                                      const ObjCObjectPointerType *OPT) {
301   for (size_t I = 0, E = Sources.size(); I < E; ++I) {
302     if (TypoCorrection C = Sources[I]->CorrectTypo(Typo, LookupKind, S, SS, CCC,
303                                                    MemberContext,
304                                                    EnteringContext, OPT))
305       return C;
306   }
307   return TypoCorrection();
308 }
309 
310 bool MultiplexExternalSemaSource::MaybeDiagnoseMissingCompleteType(
311     SourceLocation Loc, QualType T) {
312   for (size_t I = 0, E = Sources.size(); I < E; ++I) {
313     if (Sources[I]->MaybeDiagnoseMissingCompleteType(Loc, T))
314       return true;
315   }
316   return false;
317 }
318