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
15using namespace clang;
16
17char MultiplexExternalSemaSource::ID;
18
19/// Constructs a new multiplexing external sema source and appends the
20/// given element to it.
21///
22MultiplexExternalSemaSource::MultiplexExternalSemaSource(
23 ExternalSemaSource *S1, ExternalSemaSource *S2) {
24 S1->Retain();
25 S2->Retain();
26 Sources.push_back(Elt: S1);
27 Sources.push_back(Elt: S2);
28}
29
30// pin the vtable here.
31MultiplexExternalSemaSource::~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///
40void MultiplexExternalSemaSource::AddSource(ExternalSemaSource *Source) {
41 Source->Retain();
42 Sources.push_back(Elt: Source);
43}
44
45//===----------------------------------------------------------------------===//
46// ExternalASTSource.
47//===----------------------------------------------------------------------===//
48
49Decl *MultiplexExternalSemaSource::GetExternalDecl(Decl::DeclID 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
56void MultiplexExternalSemaSource::CompleteRedeclChain(const Decl *D) {
57 for (size_t i = 0; i < Sources.size(); ++i)
58 Sources[i]->CompleteRedeclChain(D);
59}
60
61Selector 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
71uint32_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
78Stmt *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
85CXXBaseSpecifier *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
93CXXCtorInitializer **
94MultiplexExternalSemaSource::GetExternalCXXCtorInitializers(uint64_t Offset) {
95 for (auto *S : Sources)
96 if (auto *R = S->GetExternalCXXCtorInitializers(Offset))
97 return R;
98 return nullptr;
99}
100
101ExternalASTSource::ExtKind
102MultiplexExternalSemaSource::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
110bool MultiplexExternalSemaSource::
111FindExternalVisibleDeclsByName(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
118void MultiplexExternalSemaSource::completeVisibleDeclsMap(const DeclContext *DC){
119 for(size_t i = 0; i < Sources.size(); ++i)
120 Sources[i]->completeVisibleDeclsMap(DC);
121}
122
123void 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
130void 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
138void MultiplexExternalSemaSource::CompleteType(TagDecl *Tag) {
139 for(size_t i = 0; i < Sources.size(); ++i)
140 Sources[i]->CompleteType(Tag);
141}
142
143void MultiplexExternalSemaSource::CompleteType(ObjCInterfaceDecl *Class) {
144 for(size_t i = 0; i < Sources.size(); ++i)
145 Sources[i]->CompleteType(Class);
146}
147
148void MultiplexExternalSemaSource::ReadComments() {
149 for(size_t i = 0; i < Sources.size(); ++i)
150 Sources[i]->ReadComments();
151}
152
153void MultiplexExternalSemaSource::StartedDeserializing() {
154 for(size_t i = 0; i < Sources.size(); ++i)
155 Sources[i]->StartedDeserializing();
156}
157
158void MultiplexExternalSemaSource::FinishedDeserializing() {
159 for(size_t i = 0; i < Sources.size(); ++i)
160 Sources[i]->FinishedDeserializing();
161}
162
163void MultiplexExternalSemaSource::StartTranslationUnit(ASTConsumer *Consumer) {
164 for(size_t i = 0; i < Sources.size(); ++i)
165 Sources[i]->StartTranslationUnit(Consumer);
166}
167
168void MultiplexExternalSemaSource::PrintStats() {
169 for(size_t i = 0; i < Sources.size(); ++i)
170 Sources[i]->PrintStats();
171}
172
173Module *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
180bool 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
193void MultiplexExternalSemaSource::
194getMemoryBufferSizes(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
205void MultiplexExternalSemaSource::InitializeSema(Sema &S) {
206 for(size_t i = 0; i < Sources.size(); ++i)
207 Sources[i]->InitializeSema(S);
208}
209
210void MultiplexExternalSemaSource::ForgetSema() {
211 for(size_t i = 0; i < Sources.size(); ++i)
212 Sources[i]->ForgetSema();
213}
214
215void MultiplexExternalSemaSource::ReadMethodPool(Selector Sel) {
216 for(size_t i = 0; i < Sources.size(); ++i)
217 Sources[i]->ReadMethodPool(Sel);
218}
219
220void MultiplexExternalSemaSource::updateOutOfDateSelector(Selector Sel) {
221 for(size_t i = 0; i < Sources.size(); ++i)
222 Sources[i]->updateOutOfDateSelector(Sel);
223}
224
225void MultiplexExternalSemaSource::ReadKnownNamespaces(
226 SmallVectorImpl<NamespaceDecl*> &Namespaces){
227 for(size_t i = 0; i < Sources.size(); ++i)
228 Sources[i]->ReadKnownNamespaces(Namespaces);
229}
230
231void 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
237void 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
245bool 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
252void MultiplexExternalSemaSource::ReadTentativeDefinitions(
253 SmallVectorImpl<VarDecl*> &TentativeDefs) {
254 for(size_t i = 0; i < Sources.size(); ++i)
255 Sources[i]->ReadTentativeDefinitions(TentativeDefs);
256}
257
258void MultiplexExternalSemaSource::ReadUnusedFileScopedDecls(
259 SmallVectorImpl<const DeclaratorDecl*> &Decls) {
260 for(size_t i = 0; i < Sources.size(); ++i)
261 Sources[i]->ReadUnusedFileScopedDecls(Decls);
262}
263
264void MultiplexExternalSemaSource::ReadDelegatingConstructors(
265 SmallVectorImpl<CXXConstructorDecl*> &Decls) {
266 for(size_t i = 0; i < Sources.size(); ++i)
267 Sources[i]->ReadDelegatingConstructors(Decls);
268}
269
270void MultiplexExternalSemaSource::ReadExtVectorDecls(
271 SmallVectorImpl<TypedefNameDecl*> &Decls) {
272 for(size_t i = 0; i < Sources.size(); ++i)
273 Sources[i]->ReadExtVectorDecls(Decls);
274}
275
276void 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
282void 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
288void 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
294void 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
300void MultiplexExternalSemaSource::ReadUsedVTables(
301 SmallVectorImpl<ExternalVTableUse> &VTables) {
302 for(size_t i = 0; i < Sources.size(); ++i)
303 Sources[i]->ReadUsedVTables(VTables);
304}
305
306void 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
313void 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
320TypoCorrection 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
336bool 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
345void MultiplexExternalSemaSource::AssignedLambdaNumbering(
346 const CXXRecordDecl *Lambda) {
347 for (auto *Source : Sources)
348 Source->AssignedLambdaNumbering(Lambda);
349}
350

source code of clang/lib/Sema/MultiplexExternalSemaSource.cpp