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 }
327