1 | //===-- ASTUtils.h ----------------------------------------------*- C++ -*-===// |
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 | #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTUTILS_H |
10 | #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTUTILS_H |
11 | |
12 | #include "clang/Basic/ASTSourceDescriptor.h" |
13 | #include "clang/Sema/Lookup.h" |
14 | #include "clang/Sema/MultiplexExternalSemaSource.h" |
15 | #include "clang/Sema/Sema.h" |
16 | #include "clang/Sema/SemaConsumer.h" |
17 | #include "llvm/ADT/IntrusiveRefCntPtr.h" |
18 | #include "llvm/Support/Casting.h" |
19 | #include <optional> |
20 | |
21 | namespace clang { |
22 | |
23 | class Module; |
24 | |
25 | } // namespace clang |
26 | |
27 | namespace lldb_private { |
28 | |
29 | /// Wraps an ExternalASTSource into an ExternalSemaSource. |
30 | /// |
31 | /// Assumes shared ownership of the underlying source. |
32 | class ExternalASTSourceWrapper : public clang::ExternalSemaSource { |
33 | llvm::IntrusiveRefCntPtr<ExternalASTSource> m_Source; |
34 | |
35 | public: |
36 | explicit ExternalASTSourceWrapper(ExternalASTSource *Source) |
37 | : m_Source(Source) { |
38 | assert(m_Source && "Can't wrap nullptr ExternalASTSource" ); |
39 | } |
40 | |
41 | ~ExternalASTSourceWrapper() override; |
42 | |
43 | clang::Decl *GetExternalDecl(clang::GlobalDeclID ID) override { |
44 | return m_Source->GetExternalDecl(ID); |
45 | } |
46 | |
47 | clang::Selector GetExternalSelector(uint32_t ID) override { |
48 | return m_Source->GetExternalSelector(ID); |
49 | } |
50 | |
51 | uint32_t GetNumExternalSelectors() override { |
52 | return m_Source->GetNumExternalSelectors(); |
53 | } |
54 | |
55 | clang::Stmt *GetExternalDeclStmt(uint64_t Offset) override { |
56 | return m_Source->GetExternalDeclStmt(Offset); |
57 | } |
58 | |
59 | clang::CXXCtorInitializer ** |
60 | GetExternalCXXCtorInitializers(uint64_t Offset) override { |
61 | return m_Source->GetExternalCXXCtorInitializers(Offset); |
62 | } |
63 | |
64 | clang::CXXBaseSpecifier * |
65 | GetExternalCXXBaseSpecifiers(uint64_t Offset) override { |
66 | return m_Source->GetExternalCXXBaseSpecifiers(Offset); |
67 | } |
68 | |
69 | void updateOutOfDateIdentifier(const clang::IdentifierInfo &II) override { |
70 | m_Source->updateOutOfDateIdentifier(II); |
71 | } |
72 | |
73 | bool FindExternalVisibleDeclsByName( |
74 | const clang::DeclContext *DC, clang::DeclarationName Name, |
75 | const clang::DeclContext *OriginalDC) override { |
76 | return m_Source->FindExternalVisibleDeclsByName(DC, Name, OriginalDC); |
77 | } |
78 | |
79 | bool LoadExternalSpecializations(const clang::Decl *D, |
80 | bool OnlyPartial) override { |
81 | return m_Source->LoadExternalSpecializations(D, OnlyPartial); |
82 | } |
83 | |
84 | bool LoadExternalSpecializations( |
85 | const clang::Decl *D, |
86 | llvm::ArrayRef<clang::TemplateArgument> TemplateArgs) override { |
87 | return m_Source->LoadExternalSpecializations(D, TemplateArgs); |
88 | } |
89 | |
90 | void completeVisibleDeclsMap(const clang::DeclContext *DC) override { |
91 | m_Source->completeVisibleDeclsMap(DC); |
92 | } |
93 | |
94 | clang::Module *getModule(unsigned ID) override { |
95 | return m_Source->getModule(ID); |
96 | } |
97 | |
98 | std::optional<clang::ASTSourceDescriptor> |
99 | getSourceDescriptor(unsigned ID) override { |
100 | return m_Source->getSourceDescriptor(ID); |
101 | } |
102 | |
103 | ExtKind hasExternalDefinitions(const clang::Decl *D) override { |
104 | return m_Source->hasExternalDefinitions(D); |
105 | } |
106 | |
107 | void FindExternalLexicalDecls( |
108 | const clang::DeclContext *DC, |
109 | llvm::function_ref<bool(clang::Decl::Kind)> IsKindWeWant, |
110 | llvm::SmallVectorImpl<clang::Decl *> &Result) override { |
111 | m_Source->FindExternalLexicalDecls(DC, IsKindWeWant, Result); |
112 | } |
113 | |
114 | void |
115 | FindFileRegionDecls(clang::FileID File, unsigned Offset, unsigned Length, |
116 | llvm::SmallVectorImpl<clang::Decl *> &Decls) override { |
117 | m_Source->FindFileRegionDecls(File, Offset, Length, Decls); |
118 | } |
119 | |
120 | void CompleteRedeclChain(const clang::Decl *D) override { |
121 | m_Source->CompleteRedeclChain(D); |
122 | } |
123 | |
124 | void CompleteType(clang::TagDecl *Tag) override { |
125 | m_Source->CompleteType(Tag); |
126 | } |
127 | |
128 | void CompleteType(clang::ObjCInterfaceDecl *Class) override { |
129 | m_Source->CompleteType(Class); |
130 | } |
131 | |
132 | void () override { m_Source->ReadComments(); } |
133 | |
134 | void StartedDeserializing() override { m_Source->StartedDeserializing(); } |
135 | |
136 | void FinishedDeserializing() override { m_Source->FinishedDeserializing(); } |
137 | |
138 | void StartTranslationUnit(clang::ASTConsumer *Consumer) override { |
139 | m_Source->StartTranslationUnit(Consumer); |
140 | } |
141 | |
142 | void PrintStats() override; |
143 | |
144 | bool layoutRecordType( |
145 | const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment, |
146 | llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets, |
147 | llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> |
148 | &BaseOffsets, |
149 | llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> |
150 | &VirtualBaseOffsets) override { |
151 | return m_Source->layoutRecordType(Record, Size, Alignment, FieldOffsets, |
152 | BaseOffsets, VirtualBaseOffsets); |
153 | } |
154 | |
155 | /// This gets called when Sema is reconciling undefined but used decls. |
156 | /// For LLDB's use-case, we never provide Clang with function definitions, |
157 | /// instead we rely on linkage names and symbol resolution to call the |
158 | /// correct funcitons during JITting. So this implementation clears |
159 | /// any "undefined" FunctionDecls that Clang found while parsing. |
160 | /// |
161 | /// \param[in,out] Undefined A set of used decls for which Clang has not |
162 | /// been provided a definition with. |
163 | /// |
164 | void ReadUndefinedButUsed( |
165 | llvm::MapVector<clang::NamedDecl *, clang::SourceLocation> &Undefined) |
166 | override { |
167 | Undefined.remove_if(Pred: [](auto const &decl_loc_pair) { |
168 | const clang::NamedDecl *ND = decl_loc_pair.first; |
169 | return llvm::isa_and_present<clang::FunctionDecl>(Val: ND); |
170 | }); |
171 | } |
172 | }; |
173 | |
174 | /// Wraps an ASTConsumer into an SemaConsumer. Doesn't take ownership of the |
175 | /// provided consumer. If the provided ASTConsumer is also a SemaConsumer, |
176 | /// the wrapper will also forward SemaConsumer functions. |
177 | class ASTConsumerForwarder : public clang::SemaConsumer { |
178 | clang::ASTConsumer *m_c; |
179 | clang::SemaConsumer *m_sc; |
180 | |
181 | public: |
182 | ASTConsumerForwarder(clang::ASTConsumer *c) : m_c(c) { |
183 | m_sc = llvm::dyn_cast<clang::SemaConsumer>(Val: m_c); |
184 | } |
185 | |
186 | ~ASTConsumerForwarder() override; |
187 | |
188 | void Initialize(clang::ASTContext &Context) override { |
189 | m_c->Initialize(Context); |
190 | } |
191 | |
192 | bool HandleTopLevelDecl(clang::DeclGroupRef D) override { |
193 | return m_c->HandleTopLevelDecl(D); |
194 | } |
195 | |
196 | void HandleInlineFunctionDefinition(clang::FunctionDecl *D) override { |
197 | m_c->HandleInlineFunctionDefinition(D); |
198 | } |
199 | |
200 | void HandleInterestingDecl(clang::DeclGroupRef D) override { |
201 | m_c->HandleInterestingDecl(D); |
202 | } |
203 | |
204 | void HandleTranslationUnit(clang::ASTContext &Ctx) override { |
205 | m_c->HandleTranslationUnit(Ctx); |
206 | } |
207 | |
208 | void HandleTagDeclDefinition(clang::TagDecl *D) override { |
209 | m_c->HandleTagDeclDefinition(D); |
210 | } |
211 | |
212 | void HandleTagDeclRequiredDefinition(const clang::TagDecl *D) override { |
213 | m_c->HandleTagDeclRequiredDefinition(D); |
214 | } |
215 | |
216 | void HandleCXXImplicitFunctionInstantiation(clang::FunctionDecl *D) override { |
217 | m_c->HandleCXXImplicitFunctionInstantiation(D); |
218 | } |
219 | |
220 | void HandleTopLevelDeclInObjCContainer(clang::DeclGroupRef D) override { |
221 | m_c->HandleTopLevelDeclInObjCContainer(D); |
222 | } |
223 | |
224 | void HandleImplicitImportDecl(clang::ImportDecl *D) override { |
225 | m_c->HandleImplicitImportDecl(D); |
226 | } |
227 | |
228 | void CompleteTentativeDefinition(clang::VarDecl *D) override { |
229 | m_c->CompleteTentativeDefinition(D); |
230 | } |
231 | |
232 | void AssignInheritanceModel(clang::CXXRecordDecl *RD) override { |
233 | m_c->AssignInheritanceModel(RD); |
234 | } |
235 | |
236 | void HandleCXXStaticMemberVarInstantiation(clang::VarDecl *D) override { |
237 | m_c->HandleCXXStaticMemberVarInstantiation(D); |
238 | } |
239 | |
240 | void HandleVTable(clang::CXXRecordDecl *RD) override { |
241 | m_c->HandleVTable(RD); |
242 | } |
243 | |
244 | clang::ASTMutationListener *GetASTMutationListener() override { |
245 | return m_c->GetASTMutationListener(); |
246 | } |
247 | |
248 | clang::ASTDeserializationListener *GetASTDeserializationListener() override { |
249 | return m_c->GetASTDeserializationListener(); |
250 | } |
251 | |
252 | void PrintStats() override; |
253 | |
254 | void InitializeSema(clang::Sema &S) override { |
255 | if (m_sc) |
256 | m_sc->InitializeSema(S); |
257 | } |
258 | |
259 | /// Inform the semantic consumer that Sema is no longer available. |
260 | void ForgetSema() override { |
261 | if (m_sc) |
262 | m_sc->ForgetSema(); |
263 | } |
264 | |
265 | bool shouldSkipFunctionBody(clang::Decl *D) override { |
266 | return m_c->shouldSkipFunctionBody(D); |
267 | } |
268 | }; |
269 | |
270 | /// A ExternalSemaSource multiplexer that prioritizes its sources. |
271 | /// |
272 | /// This ExternalSemaSource will forward all requests to its attached sources. |
273 | /// However, unlike a normal multiplexer it will not forward a request to all |
274 | /// sources, but instead give priority to certain sources. If a source with a |
275 | /// higher priority can fulfill a request, all sources with a lower priority |
276 | /// will not receive the request. |
277 | /// |
278 | /// This class is mostly use to multiplex between sources of different |
279 | /// 'quality', e.g. a C++ modules and debug information. The C++ module will |
280 | /// provide more accurate replies to the requests, but might not be able to |
281 | /// answer all requests. The debug information will be used as a fallback then |
282 | /// to provide information that is not in the C++ module. |
283 | class SemaSourceWithPriorities : public clang::ExternalSemaSource { |
284 | |
285 | private: |
286 | /// The sources ordered in decreasing priority. |
287 | llvm::SmallVector<clang::ExternalSemaSource *, 2> Sources; |
288 | |
289 | public: |
290 | /// Construct a SemaSourceWithPriorities with a 'high quality' source that |
291 | /// has the higher priority and a 'low quality' source that will be used |
292 | /// as a fallback. |
293 | /// |
294 | /// This class assumes shared ownership of the sources provided to it. |
295 | SemaSourceWithPriorities(clang::ExternalSemaSource *high_quality_source, |
296 | clang::ExternalSemaSource *low_quality_source) { |
297 | assert(high_quality_source); |
298 | assert(low_quality_source); |
299 | |
300 | high_quality_source->Retain(); |
301 | low_quality_source->Retain(); |
302 | |
303 | Sources.push_back(Elt: high_quality_source); |
304 | Sources.push_back(Elt: low_quality_source); |
305 | } |
306 | |
307 | ~SemaSourceWithPriorities() override; |
308 | |
309 | //===--------------------------------------------------------------------===// |
310 | // ExternalASTSource. |
311 | //===--------------------------------------------------------------------===// |
312 | |
313 | clang::Decl *GetExternalDecl(clang::GlobalDeclID ID) override { |
314 | for (size_t i = 0; i < Sources.size(); ++i) |
315 | if (clang::Decl *Result = Sources[i]->GetExternalDecl(ID)) |
316 | return Result; |
317 | return nullptr; |
318 | } |
319 | |
320 | bool LoadExternalSpecializations(const clang::Decl *D, |
321 | bool OnlyPartial) override { |
322 | bool newDeclFound = false; |
323 | for (size_t i = 0; i < Sources.size(); ++i) |
324 | newDeclFound |= Sources[i]->LoadExternalSpecializations(D, OnlyPartial); |
325 | return newDeclFound; |
326 | } |
327 | |
328 | bool LoadExternalSpecializations( |
329 | const clang::Decl *D, |
330 | llvm::ArrayRef<clang::TemplateArgument> TemplateArgs) override { |
331 | bool newDeclFound = false; |
332 | for (size_t i = 0; i < Sources.size(); ++i) |
333 | newDeclFound |= Sources[i]->LoadExternalSpecializations(D, TemplateArgs); |
334 | return newDeclFound; |
335 | } |
336 | |
337 | void CompleteRedeclChain(const clang::Decl *D) override { |
338 | for (size_t i = 0; i < Sources.size(); ++i) |
339 | Sources[i]->CompleteRedeclChain(D); |
340 | } |
341 | |
342 | clang::Selector GetExternalSelector(uint32_t ID) override { |
343 | clang::Selector Sel; |
344 | for (size_t i = 0; i < Sources.size(); ++i) { |
345 | Sel = Sources[i]->GetExternalSelector(ID); |
346 | if (!Sel.isNull()) |
347 | return Sel; |
348 | } |
349 | return Sel; |
350 | } |
351 | |
352 | uint32_t GetNumExternalSelectors() override { |
353 | for (size_t i = 0; i < Sources.size(); ++i) |
354 | if (uint32_t total = Sources[i]->GetNumExternalSelectors()) |
355 | return total; |
356 | return 0; |
357 | } |
358 | |
359 | clang::Stmt *GetExternalDeclStmt(uint64_t Offset) override { |
360 | for (size_t i = 0; i < Sources.size(); ++i) |
361 | if (clang::Stmt *Result = Sources[i]->GetExternalDeclStmt(Offset)) |
362 | return Result; |
363 | return nullptr; |
364 | } |
365 | |
366 | clang::CXXBaseSpecifier * |
367 | GetExternalCXXBaseSpecifiers(uint64_t Offset) override { |
368 | for (size_t i = 0; i < Sources.size(); ++i) |
369 | if (clang::CXXBaseSpecifier *R = |
370 | Sources[i]->GetExternalCXXBaseSpecifiers(Offset)) |
371 | return R; |
372 | return nullptr; |
373 | } |
374 | |
375 | clang::CXXCtorInitializer ** |
376 | GetExternalCXXCtorInitializers(uint64_t Offset) override { |
377 | for (auto *S : Sources) |
378 | if (auto *R = S->GetExternalCXXCtorInitializers(Offset)) |
379 | return R; |
380 | return nullptr; |
381 | } |
382 | |
383 | ExtKind hasExternalDefinitions(const clang::Decl *D) override { |
384 | for (const auto &S : Sources) |
385 | if (auto EK = S->hasExternalDefinitions(D)) |
386 | if (EK != EK_ReplyHazy) |
387 | return EK; |
388 | return EK_ReplyHazy; |
389 | } |
390 | |
391 | bool FindExternalVisibleDeclsByName( |
392 | const clang::DeclContext *DC, clang::DeclarationName Name, |
393 | const clang::DeclContext *OriginalDC) override { |
394 | for (size_t i = 0; i < Sources.size(); ++i) |
395 | if (Sources[i]->FindExternalVisibleDeclsByName(DC, Name, OriginalDC)) |
396 | return true; |
397 | return false; |
398 | } |
399 | |
400 | void completeVisibleDeclsMap(const clang::DeclContext *DC) override { |
401 | // FIXME: Only one source should be able to complete the decls map. |
402 | for (size_t i = 0; i < Sources.size(); ++i) |
403 | Sources[i]->completeVisibleDeclsMap(DC); |
404 | } |
405 | |
406 | void FindExternalLexicalDecls( |
407 | const clang::DeclContext *DC, |
408 | llvm::function_ref<bool(clang::Decl::Kind)> IsKindWeWant, |
409 | llvm::SmallVectorImpl<clang::Decl *> &Result) override { |
410 | for (size_t i = 0; i < Sources.size(); ++i) { |
411 | Sources[i]->FindExternalLexicalDecls(DC, IsKindWeWant, Result); |
412 | if (!Result.empty()) |
413 | return; |
414 | } |
415 | } |
416 | |
417 | void |
418 | FindFileRegionDecls(clang::FileID File, unsigned Offset, unsigned Length, |
419 | llvm::SmallVectorImpl<clang::Decl *> &Decls) override { |
420 | for (size_t i = 0; i < Sources.size(); ++i) |
421 | Sources[i]->FindFileRegionDecls(File, Offset, Length, Decls); |
422 | } |
423 | |
424 | void CompleteType(clang::TagDecl *Tag) override { |
425 | for (clang::ExternalSemaSource *S : Sources) { |
426 | S->CompleteType(Tag); |
427 | // Stop after the first source completed the type. |
428 | if (Tag->isCompleteDefinition()) |
429 | break; |
430 | } |
431 | } |
432 | |
433 | void CompleteType(clang::ObjCInterfaceDecl *Class) override { |
434 | for (size_t i = 0; i < Sources.size(); ++i) |
435 | Sources[i]->CompleteType(Class); |
436 | } |
437 | |
438 | void () override { |
439 | for (size_t i = 0; i < Sources.size(); ++i) |
440 | Sources[i]->ReadComments(); |
441 | } |
442 | |
443 | void StartedDeserializing() override { |
444 | for (size_t i = 0; i < Sources.size(); ++i) |
445 | Sources[i]->StartedDeserializing(); |
446 | } |
447 | |
448 | void FinishedDeserializing() override { |
449 | for (size_t i = 0; i < Sources.size(); ++i) |
450 | Sources[i]->FinishedDeserializing(); |
451 | } |
452 | |
453 | void StartTranslationUnit(clang::ASTConsumer *Consumer) override { |
454 | for (size_t i = 0; i < Sources.size(); ++i) |
455 | Sources[i]->StartTranslationUnit(Consumer); |
456 | } |
457 | |
458 | void PrintStats() override; |
459 | |
460 | clang::Module *getModule(unsigned ID) override { |
461 | for (size_t i = 0; i < Sources.size(); ++i) |
462 | if (auto M = Sources[i]->getModule(ID)) |
463 | return M; |
464 | return nullptr; |
465 | } |
466 | |
467 | bool layoutRecordType( |
468 | const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment, |
469 | llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets, |
470 | llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> |
471 | &BaseOffsets, |
472 | llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> |
473 | &VirtualBaseOffsets) override { |
474 | for (size_t i = 0; i < Sources.size(); ++i) |
475 | if (Sources[i]->layoutRecordType(Record, Size, Alignment, FieldOffsets, |
476 | BaseOffsets, VirtualBaseOffsets)) |
477 | return true; |
478 | return false; |
479 | } |
480 | |
481 | void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override { |
482 | for (auto &Source : Sources) |
483 | Source->getMemoryBufferSizes(sizes); |
484 | } |
485 | |
486 | //===--------------------------------------------------------------------===// |
487 | // ExternalSemaSource. |
488 | //===--------------------------------------------------------------------===// |
489 | |
490 | void InitializeSema(clang::Sema &S) override { |
491 | for (auto &Source : Sources) |
492 | Source->InitializeSema(S); |
493 | } |
494 | |
495 | void ForgetSema() override { |
496 | for (auto &Source : Sources) |
497 | Source->ForgetSema(); |
498 | } |
499 | |
500 | void ReadMethodPool(clang::Selector Sel) override { |
501 | for (auto &Source : Sources) |
502 | Source->ReadMethodPool(Sel); |
503 | } |
504 | |
505 | void updateOutOfDateSelector(clang::Selector Sel) override { |
506 | for (auto &Source : Sources) |
507 | Source->updateOutOfDateSelector(Sel); |
508 | } |
509 | |
510 | void ReadKnownNamespaces( |
511 | llvm::SmallVectorImpl<clang::NamespaceDecl *> &Namespaces) override { |
512 | for (auto &Source : Sources) |
513 | Source->ReadKnownNamespaces(Namespaces); |
514 | } |
515 | |
516 | void ReadUndefinedButUsed( |
517 | llvm::MapVector<clang::NamedDecl *, clang::SourceLocation> &Undefined) |
518 | override { |
519 | for (auto &Source : Sources) |
520 | Source->ReadUndefinedButUsed(Undefined); |
521 | } |
522 | |
523 | void ReadMismatchingDeleteExpressions( |
524 | llvm::MapVector<clang::FieldDecl *, |
525 | llvm::SmallVector<std::pair<clang::SourceLocation, bool>, |
526 | 4>> &Exprs) override { |
527 | for (auto &Source : Sources) |
528 | Source->ReadMismatchingDeleteExpressions(Exprs); |
529 | } |
530 | |
531 | bool LookupUnqualified(clang::LookupResult &R, clang::Scope *S) override { |
532 | for (auto &Source : Sources) { |
533 | Source->LookupUnqualified(R, S); |
534 | if (!R.empty()) |
535 | break; |
536 | } |
537 | |
538 | return !R.empty(); |
539 | } |
540 | |
541 | void ReadTentativeDefinitions( |
542 | llvm::SmallVectorImpl<clang::VarDecl *> &Defs) override { |
543 | for (auto &Source : Sources) |
544 | Source->ReadTentativeDefinitions(TentativeDefs&: Defs); |
545 | } |
546 | |
547 | void ReadUnusedFileScopedDecls( |
548 | llvm::SmallVectorImpl<const clang::DeclaratorDecl *> &Decls) override { |
549 | for (auto &Source : Sources) |
550 | Source->ReadUnusedFileScopedDecls(Decls); |
551 | } |
552 | |
553 | void ReadDelegatingConstructors( |
554 | llvm::SmallVectorImpl<clang::CXXConstructorDecl *> &Decls) override { |
555 | for (auto &Source : Sources) |
556 | Source->ReadDelegatingConstructors(Decls); |
557 | } |
558 | |
559 | void ReadExtVectorDecls( |
560 | llvm::SmallVectorImpl<clang::TypedefNameDecl *> &Decls) override { |
561 | for (auto &Source : Sources) |
562 | Source->ReadExtVectorDecls(Decls); |
563 | } |
564 | |
565 | void ReadUnusedLocalTypedefNameCandidates( |
566 | llvm::SmallSetVector<const clang::TypedefNameDecl *, 4> &Decls) override { |
567 | for (auto &Source : Sources) |
568 | Source->ReadUnusedLocalTypedefNameCandidates(Decls); |
569 | } |
570 | |
571 | void ReadReferencedSelectors( |
572 | llvm::SmallVectorImpl<std::pair<clang::Selector, clang::SourceLocation>> |
573 | &Sels) override { |
574 | for (auto &Source : Sources) |
575 | Source->ReadReferencedSelectors(Sels); |
576 | } |
577 | |
578 | void ReadWeakUndeclaredIdentifiers( |
579 | llvm::SmallVectorImpl<std::pair<clang::IdentifierInfo *, clang::WeakInfo>> |
580 | &WI) override { |
581 | for (auto &Source : Sources) |
582 | Source->ReadWeakUndeclaredIdentifiers(WI); |
583 | } |
584 | |
585 | void ReadUsedVTables( |
586 | llvm::SmallVectorImpl<clang::ExternalVTableUse> &VTables) override { |
587 | for (auto &Source : Sources) |
588 | Source->ReadUsedVTables(VTables); |
589 | } |
590 | |
591 | void ReadPendingInstantiations( |
592 | llvm::SmallVectorImpl< |
593 | std::pair<clang::ValueDecl *, clang::SourceLocation>> &Pending) |
594 | override { |
595 | for (auto &Source : Sources) |
596 | Source->ReadPendingInstantiations(Pending); |
597 | } |
598 | |
599 | void ReadLateParsedTemplates( |
600 | llvm::MapVector<const clang::FunctionDecl *, |
601 | std::unique_ptr<clang::LateParsedTemplate>> &LPTMap) |
602 | override { |
603 | for (auto &Source : Sources) |
604 | Source->ReadLateParsedTemplates(LPTMap); |
605 | } |
606 | |
607 | clang::TypoCorrection |
608 | CorrectTypo(const clang::DeclarationNameInfo &Typo, int LookupKind, |
609 | clang::Scope *S, clang::CXXScopeSpec *SS, |
610 | clang::CorrectionCandidateCallback &CCC, |
611 | clang::DeclContext *MemberContext, bool EnteringContext, |
612 | const clang::ObjCObjectPointerType *OPT) override { |
613 | for (auto &Source : Sources) { |
614 | if (clang::TypoCorrection C = |
615 | Source->CorrectTypo(Typo, LookupKind, S, SS, CCC, |
616 | MemberContext, EnteringContext, OPT)) |
617 | return C; |
618 | } |
619 | return clang::TypoCorrection(); |
620 | } |
621 | |
622 | bool MaybeDiagnoseMissingCompleteType(clang::SourceLocation Loc, |
623 | clang::QualType T) override { |
624 | for (auto &Source : Sources) { |
625 | if (Source->MaybeDiagnoseMissingCompleteType(Loc, T)) |
626 | return true; |
627 | } |
628 | return false; |
629 | } |
630 | }; |
631 | |
632 | } // namespace lldb_private |
633 | #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTUTILS_H |
634 | |