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