clang 10.0.0git

ODRHash.cpp
Go to the documentation of this file.
1 //===-- ODRHash.cpp - Hashing to diagnose ODR failures ----------*- 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 /// \file
10 /// This file implements the ODRHash class, which calculates a hash based
11 /// on AST nodes, which is stable across different runs.
12 ///
13 //===----------------------------------------------------------------------===//
14
15 #include "clang/AST/ODRHash.h"
16
17 #include "clang/AST/DeclVisitor.h"
18 #include "clang/AST/NestedNameSpecifier.h"
19 #include "clang/AST/StmtVisitor.h"
20 #include "clang/AST/TypeVisitor.h"
21
22 using namespace clang;
23
24 void ODRHash::AddStmt(const Stmt *S) {
25 assert(S && "Expecting non-null pointer.");
26 S->ProcessODRHash(ID, *this);
27 }
28
29 void ODRHash::AddIdentifierInfo(const IdentifierInfo *II) {
30 assert(II && "Expecting non-null pointer.");
31 ID.AddString(II->getName());
32 }
33
34 void ODRHash::AddDeclarationName(DeclarationName Name, bool TreatAsDecl) {
35 if (TreatAsDecl)
36 // Matches the NamedDecl check in AddDecl
37 AddBoolean(true);
38
39 AddDeclarationNameImpl(Name);
40
41 if (TreatAsDecl)
42 // Matches the ClassTemplateSpecializationDecl check in AddDecl
43 AddBoolean(false);
44 }
45
46 void ODRHash::AddDeclarationNameImpl(DeclarationName Name) {
47 // Index all DeclarationName and use index numbers to refer to them.
48 auto Result = DeclNameMap.insert(std::make_pair(Name, DeclNameMap.size()));
49 ID.AddInteger(Result.first->second);
50 if (!Result.second) {
51 // If found in map, the DeclarationName has previously been processed.
52 return;
53 }
54
55 // First time processing each DeclarationName, also process its details.
56 AddBoolean(Name.isEmpty());
57 if (Name.isEmpty())
58 return;
59
60 auto Kind = Name.getNameKind();
61 ID.AddInteger(Kind);
62 switch (Kind) {
63 case DeclarationName::Identifier:
64 AddIdentifierInfo(Name.getAsIdentifierInfo());
65 break;
66 case DeclarationName::ObjCZeroArgSelector:
67 case DeclarationName::ObjCOneArgSelector:
68 case DeclarationName::ObjCMultiArgSelector: {
69 Selector S = Name.getObjCSelector();
70 AddBoolean(S.isNull());
71 AddBoolean(S.isKeywordSelector());
72 AddBoolean(S.isUnarySelector());
73 unsigned NumArgs = S.getNumArgs();
74 ID.AddInteger(NumArgs);
75 for (unsigned i = 0; i < NumArgs; ++i) {
76 const IdentifierInfo *II = S.getIdentifierInfoForSlot(i);
77 AddBoolean(II);
78 if (II) {
79 AddIdentifierInfo(II);
80 }
81 }
82 break;
83 }
84 case DeclarationName::CXXConstructorName:
85 case DeclarationName::CXXDestructorName:
86 AddQualType(Name.getCXXNameType());
87 break;
88 case DeclarationName::CXXOperatorName:
89 ID.AddInteger(Name.getCXXOverloadedOperator());
90 break;
91 case DeclarationName::CXXLiteralOperatorName:
92 AddIdentifierInfo(Name.getCXXLiteralIdentifier());
93 break;
94 case DeclarationName::CXXConversionFunctionName:
95 AddQualType(Name.getCXXNameType());
96 break;
97 case DeclarationName::CXXUsingDirective:
98 break;
99 case DeclarationName::CXXDeductionGuideName: {
100 auto *Template = Name.getCXXDeductionGuideTemplate();
101 AddBoolean(Template);
102 if (Template) {
103 AddDecl(Template);
104 }
105 }
106 }
107 }
108
109 void ODRHash::AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
110 assert(NNS && "Expecting non-null pointer.");
111 const auto *Prefix = NNS->getPrefix();
112 AddBoolean(Prefix);
113 if (Prefix) {
114 AddNestedNameSpecifier(Prefix);
115 }
116 auto Kind = NNS->getKind();
117 ID.AddInteger(Kind);
118 switch (Kind) {
119 case NestedNameSpecifier::Identifier:
120 AddIdentifierInfo(NNS->getAsIdentifier());
121 break;
122 case NestedNameSpecifier::Namespace:
123 AddDecl(NNS->getAsNamespace());
124 break;
125 case NestedNameSpecifier::NamespaceAlias:
126 AddDecl(NNS->getAsNamespaceAlias());
127 break;
128 case NestedNameSpecifier::TypeSpec:
129 case NestedNameSpecifier::TypeSpecWithTemplate:
130 AddType(NNS->getAsType());
131 break;
132 case NestedNameSpecifier::Global:
133 case NestedNameSpecifier::Super:
134 break;
135 }
136 }
137
138 void ODRHash::AddTemplateName(TemplateName Name) {
139 auto Kind = Name.getKind();
140 ID.AddInteger(Kind);
141
142 switch (Kind) {
143 case TemplateName::Template:
144 AddDecl(Name.getAsTemplateDecl());
145 break;
146 // TODO: Support these cases.
147 case TemplateName::OverloadedTemplate:
148 case TemplateName::AssumedTemplate:
149 case TemplateName::QualifiedTemplate:
150 case TemplateName::DependentTemplate:
151 case TemplateName::SubstTemplateTemplateParm:
152 case TemplateName::SubstTemplateTemplateParmPack:
153 break;
154 }
155 }
156
157 void ODRHash::AddTemplateArgument(TemplateArgument TA) {
158 const auto Kind = TA.getKind();
159 ID.AddInteger(Kind);
160
161 switch (Kind) {
162 case TemplateArgument::Null:
163 llvm_unreachable("Expected valid TemplateArgument");
164 case TemplateArgument::Type:
165 AddQualType(TA.getAsType());
166 break;
167 case TemplateArgument::Declaration:
168 AddDecl(TA.getAsDecl());
169 break;
170 case TemplateArgument::NullPtr:
171 case TemplateArgument::Integral:
172 break;
173 case TemplateArgument::Template:
174 case TemplateArgument::TemplateExpansion:
175 AddTemplateName(TA.getAsTemplateOrTemplatePattern());
176 break;
177 case TemplateArgument::Expression:
178 AddStmt(TA.getAsExpr());
179 break;
180 case TemplateArgument::Pack:
181 ID.AddInteger(TA.pack_size());
182 for (auto SubTA : TA.pack_elements()) {
183 AddTemplateArgument(SubTA);
184 }
185 break;
186 }
187 }
188
189 void ODRHash::AddTemplateParameterList(const TemplateParameterList *TPL) {
190 assert(TPL && "Expecting non-null pointer.");
191
192 ID.AddInteger(TPL->size());
193 for (auto *ND : TPL->asArray()) {
194 AddSubDecl(ND);
195 }
196 }
197
198 void ODRHash::clear() {
199 DeclNameMap.clear();
200 Bools.clear();
201 ID.clear();
202 }
203
204 unsigned ODRHash::CalculateHash() {
205 // Append the bools to the end of the data segment backwards. This allows
206 // for the bools data to be compressed 32 times smaller compared to using
207 // ID.AddBoolean
208 const unsigned unsigned_bits = sizeof(unsigned) * CHAR_BIT;
209 const unsigned size = Bools.size();
210 const unsigned remainder = size % unsigned_bits;
211 const unsigned loops = size / unsigned_bits;
212 auto I = Bools.rbegin();
213 unsigned value = 0;
214 for (unsigned i = 0; i < remainder; ++i) {
215 value <<= 1;
216 value |= *I;
217 ++I;
218 }
219 ID.AddInteger(value);
220
221 for (unsigned i = 0; i < loops; ++i) {
222 value = 0;
223 for (unsigned j = 0; j < unsigned_bits; ++j) {
224 value <<= 1;
225 value |= *I;
226 ++I;
227 }
228 ID.AddInteger(value);
229 }
230
231 assert(I == Bools.rend());
232 Bools.clear();
233 return ID.ComputeHash();
234 }
235
236 namespace {
237 // Process a Decl pointer. Add* methods call back into ODRHash while Visit*
238 // methods process the relevant parts of the Decl.
239 class ODRDeclVisitor : public ConstDeclVisitor<ODRDeclVisitor> {
240 typedef ConstDeclVisitor<ODRDeclVisitor> Inherited;
241 llvm::FoldingSetNodeID &ID;
242 ODRHash &Hash;
243
244 public:
245 ODRDeclVisitor(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
246 : ID(ID), Hash(Hash) {}
247
248 void AddStmt(const Stmt *S) {
249 Hash.AddBoolean(S);
250 if (S) {
251 Hash.AddStmt(S);
252 }
253 }
254
255 void AddIdentifierInfo(const IdentifierInfo *II) {
256 Hash.AddBoolean(II);
257 if (II) {
258 Hash.AddIdentifierInfo(II);
259 }
260 }
261
262 void AddQualType(QualType T) {
263 Hash.AddQualType(T);
264 }
265
266 void AddDecl(const Decl *D) {
267 Hash.AddBoolean(D);
268 if (D) {
269 Hash.AddDecl(D);
270 }
271 }
272
273 void AddTemplateArgument(TemplateArgument TA) {
274 Hash.AddTemplateArgument(TA);
275 }
276
277 void Visit(const Decl *D) {
278 ID.AddInteger(D->getKind());
279 Inherited::Visit(D);
280 }
281
282 void VisitNamedDecl(const NamedDecl *D) {
283 Hash.AddDeclarationName(D->getDeclName());
284 Inherited::VisitNamedDecl(D);
285 }
286
287 void VisitValueDecl(const ValueDecl *D) {
288 if (!isa<FunctionDecl>(D)) {
289 AddQualType(D->getType());
290 }
291 Inherited::VisitValueDecl(D);
292 }
293
294 void VisitVarDecl(const VarDecl *D) {
295 Hash.AddBoolean(D->isStaticLocal());
296 Hash.AddBoolean(D->isConstexpr());
297 const bool HasInit = D->hasInit();
298 Hash.AddBoolean(HasInit);
299 if (HasInit) {
300 AddStmt(D->getInit());
301 }
302 Inherited::VisitVarDecl(D);
303 }
304
305 void VisitParmVarDecl(const ParmVarDecl *D) {
306 // TODO: Handle default arguments.
307 Inherited::VisitParmVarDecl(D);
308 }
309
310 void VisitAccessSpecDecl(const AccessSpecDecl *D) {
311 ID.AddInteger(D->getAccess());
312 Inherited::VisitAccessSpecDecl(D);
313 }
314
315 void VisitStaticAssertDecl(const StaticAssertDecl *D) {
316 AddStmt(D->getAssertExpr());
317 AddStmt(D->getMessage());
318
319 Inherited::VisitStaticAssertDecl(D);
320 }
321
322 void VisitFieldDecl(const FieldDecl *D) {
323 const bool IsBitfield = D->isBitField();
324 Hash.AddBoolean(IsBitfield);
325
326 if (IsBitfield) {
327 AddStmt(D->getBitWidth());
328 }
329
330 Hash.AddBoolean(D->isMutable());
331 AddStmt(D->getInClassInitializer());
332
333 Inherited::VisitFieldDecl(D);
334 }
335
336 void VisitFunctionDecl(const FunctionDecl *D) {
337 // Handled by the ODRHash for FunctionDecl
338 ID.AddInteger(D->getODRHash());
339
340 Inherited::VisitFunctionDecl(D);
341 }
342
343 void VisitCXXMethodDecl(const CXXMethodDecl *D) {
344 // Handled by the ODRHash for FunctionDecl
345
346 Inherited::VisitCXXMethodDecl(D);
347 }
348
349 void VisitTypedefNameDecl(const TypedefNameDecl *D) {
350 AddQualType(D->getUnderlyingType());
351
352 Inherited::VisitTypedefNameDecl(D);
353 }
354
355 void VisitTypedefDecl(const TypedefDecl *D) {
356 Inherited::VisitTypedefDecl(D);
357 }
358
359 void VisitTypeAliasDecl(const TypeAliasDecl *D) {
360 Inherited::VisitTypeAliasDecl(D);
361 }
362
363 void VisitFriendDecl(const FriendDecl *D) {
364 TypeSourceInfo *TSI = D->getFriendType();
365 Hash.AddBoolean(TSI);
366 if (TSI) {
367 AddQualType(TSI->getType());
368 } else {
369 AddDecl(D->getFriendDecl());
370 }
371 }
372
373 void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
374 // Only care about default arguments as part of the definition.
375 const bool hasDefaultArgument =
376 D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
377 Hash.AddBoolean(hasDefaultArgument);
378 if (hasDefaultArgument) {
379 AddTemplateArgument(D->getDefaultArgument());
380 }
381 Hash.AddBoolean(D->isParameterPack());
382
383 const TypeConstraint *TC = D->getTypeConstraint();
384 Hash.AddBoolean(TC != nullptr);
385 if (TC)
386 AddStmt(TC->getImmediatelyDeclaredConstraint());
387
388 Inherited::VisitTemplateTypeParmDecl(D);
389 }
390
391 void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
392 // Only care about default arguments as part of the definition.
393 const bool hasDefaultArgument =
394 D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
395 Hash.AddBoolean(hasDefaultArgument);
396 if (hasDefaultArgument) {
397 AddStmt(D->getDefaultArgument());
398 }
399 Hash.AddBoolean(D->isParameterPack());
400
401 Inherited::VisitNonTypeTemplateParmDecl(D);
402 }
403
404 void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
405 // Only care about default arguments as part of the definition.
406 const bool hasDefaultArgument =
407 D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
408 Hash.AddBoolean(hasDefaultArgument);
409 if (hasDefaultArgument) {
410 AddTemplateArgument(D->getDefaultArgument().getArgument());
411 }
412 Hash.AddBoolean(D->isParameterPack());
413
414 Inherited::VisitTemplateTemplateParmDecl(D);
415 }
416
417 void VisitTemplateDecl(const TemplateDecl *D) {
418 Hash.AddTemplateParameterList(D->getTemplateParameters());
419
420 Inherited::VisitTemplateDecl(D);
421 }
422
423 void VisitRedeclarableTemplateDecl(const RedeclarableTemplateDecl *D) {
424 Hash.AddBoolean(D->isMemberSpecialization());
425 Inherited::VisitRedeclarableTemplateDecl(D);
426 }
427
428 void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
429 AddDecl(D->getTemplatedDecl());
430 ID.AddInteger(D->getTemplatedDecl()->getODRHash());
431 Inherited::VisitFunctionTemplateDecl(D);
432 }
433
434 void VisitEnumConstantDecl(const EnumConstantDecl *D) {
435 AddStmt(D->getInitExpr());
436 Inherited::VisitEnumConstantDecl(D);
437 }
438 };
439 } // namespace
440
441 // Only allow a small portion of Decl's to be processed. Remove this once
442 // all Decl's can be handled.
443 bool ODRHash::isWhitelistedDecl(const Decl *D, const DeclContext *Parent) {
444 if (D->isImplicit()) return false;
445 if (D->getDeclContext() != Parent) return false;
446
447 switch (D->getKind()) {
448 default:
449 return false;
450 case Decl::AccessSpec:
451 case Decl::CXXConstructor:
452 case Decl::CXXDestructor:
453 case Decl::CXXMethod:
454 case Decl::EnumConstant: // Only found in EnumDecl's.
455 case Decl::Field:
456 case Decl::Friend:
457 case Decl::FunctionTemplate:
458 case Decl::StaticAssert:
459 case Decl::TypeAlias:
460 case Decl::Typedef:
461 case Decl::Var:
462 return true;
463 }
464 }
465
466 void ODRHash::AddSubDecl(const Decl *D) {
467 assert(D && "Expecting non-null pointer.");
468
469 ODRDeclVisitor(ID, *this).Visit(D);
470 }
471
472 void ODRHash::AddCXXRecordDecl(const CXXRecordDecl *Record) {
473 assert(Record && Record->hasDefinition() &&
474 "Expected non-null record to be a definition.");
475
476 const DeclContext *DC = Record;
477 while (DC) {
478 if (isa<ClassTemplateSpecializationDecl>(DC)) {
479 return;
480 }
481 DC = DC->getParent();
482 }
483
484 AddDecl(Record);
485
486 // Filter out sub-Decls which will not be processed in order to get an
487 // accurate count of Decl's.
488 llvm::SmallVector<const Decl *, 16> Decls;
489 for (Decl *SubDecl : Record->decls()) {
490 if (isWhitelistedDecl(SubDecl, Record)) {
491 Decls.push_back(SubDecl);
492 if (auto *Function = dyn_cast<FunctionDecl>(SubDecl)) {
493 // Compute/Preload ODRHash into FunctionDecl.
494 Function->getODRHash();
495 }
496 }
497 }
498
499 ID.AddInteger(Decls.size());
500 for (auto SubDecl : Decls) {
501 AddSubDecl(SubDecl);
502 }
503
504 const ClassTemplateDecl *TD = Record->getDescribedClassTemplate();
505 AddBoolean(TD);
506 if (TD) {
507 AddTemplateParameterList(TD->getTemplateParameters());
508 }
509
510 ID.AddInteger(Record->getNumBases());
511 auto Bases = Record->bases();
512 for (auto Base : Bases) {
513 AddQualType(Base.getType());
514 ID.AddInteger(Base.isVirtual());
515 ID.AddInteger(Base.getAccessSpecifierAsWritten());
516 }
517 }
518
519 void ODRHash::AddFunctionDecl(const FunctionDecl *Function,
520 bool SkipBody) {
521 assert(Function && "Expecting non-null pointer.");
522
523 // Skip functions that are specializations or in specialization context.
524 const DeclContext *DC = Function;
525 while (DC) {
526 if (isa<ClassTemplateSpecializationDecl>(DC)) return;
527 if (auto *F = dyn_cast<FunctionDecl>(DC)) {
528 if (F->isFunctionTemplateSpecialization()) {
529 if (!isa<CXXMethodDecl>(DC)) return;
530 if (DC->getLexicalParent()->isFileContext()) return;
531 // Inline method specializations are the only supported
532 // specialization for now.
533 }
534 }
535 DC = DC->getParent();
536 }
537
538 ID.AddInteger(Function->getDeclKind());
539
540 const auto *SpecializationArgs = Function->getTemplateSpecializationArgs();
541 AddBoolean(SpecializationArgs);
542 if (SpecializationArgs) {
543 ID.AddInteger(SpecializationArgs->size());
544 for (const TemplateArgument &TA : SpecializationArgs->asArray()) {
545 AddTemplateArgument(TA);
546 }
547 }
548
549 if (const auto *Method = dyn_cast<CXXMethodDecl>(Function)) {
550 AddBoolean(Method->isConst());
551 AddBoolean(Method->isVolatile());
552 }
553
554 ID.AddInteger(Function->getStorageClass());
555 AddBoolean(Function->isInlineSpecified());
556 AddBoolean(Function->isVirtualAsWritten());
557 AddBoolean(Function->isPure());
558 AddBoolean(Function->isDeletedAsWritten());
559 AddBoolean(Function->isExplicitlyDefaulted());
560
561 AddDecl(Function);
562
563 AddQualType(Function->getReturnType());
564
565 ID.AddInteger(Function->param_size());
566 for (auto Param : Function->parameters())
567 AddSubDecl(Param);
568
569 if (SkipBody) {
570 AddBoolean(false);
571 return;
572 }
573
574 const bool HasBody = Function->isThisDeclarationADefinition() &&
575 !Function->isDefaulted() && !Function->isDeleted() &&
576 !Function->isLateTemplateParsed();
577 AddBoolean(HasBody);
578 if (!HasBody) {
579 return;
580 }
581
582 auto *Body = Function->getBody();
583 AddBoolean(Body);
584 if (Body)
585 AddStmt(Body);
586
587 // Filter out sub-Decls which will not be processed in order to get an
588 // accurate count of Decl's.
589 llvm::SmallVector<const Decl *, 16> Decls;
590 for (Decl *SubDecl : Function->decls()) {
591 if (isWhitelistedDecl(SubDecl, Function)) {
592 Decls.push_back(SubDecl);
593 }
594 }
595
596 ID.AddInteger(Decls.size());
597 for (auto SubDecl : Decls) {
598 AddSubDecl(SubDecl);
599 }
600 }
601
602 void ODRHash::AddEnumDecl(const EnumDecl *Enum) {
603 assert(Enum);
604 AddDeclarationName(Enum->getDeclName());
605
606 AddBoolean(Enum->isScoped());
607 if (Enum->isScoped())
608 AddBoolean(Enum->isScopedUsingClassTag());
609
610 if (Enum->getIntegerTypeSourceInfo())
611 AddQualType(Enum->getIntegerType());
612
613 // Filter out sub-Decls which will not be processed in order to get an
614 // accurate count of Decl's.
615 llvm::SmallVector<const Decl *, 16> Decls;
616 for (Decl *SubDecl : Enum->decls()) {
617 if (isWhitelistedDecl(SubDecl, Enum)) {
618 assert(isa<EnumConstantDecl>(SubDecl) && "Unexpected Decl");
619 Decls.push_back(SubDecl);
620 }
621 }
622
623 ID.AddInteger(Decls.size());
624 for (auto SubDecl : Decls) {
625 AddSubDecl(SubDecl);
626 }
627
628 }
629
630 void ODRHash::AddDecl(const Decl *D) {
631 assert(D && "Expecting non-null pointer.");
632 D = D->getCanonicalDecl();
633
634 const NamedDecl *ND = dyn_cast<NamedDecl>(D);
635 AddBoolean(ND);
636 if (!ND) {
637 ID.AddInteger(D->getKind());
638 return;
639 }
640
641 AddDeclarationName(ND->getDeclName());
642
643 const auto *Specialization =
644 dyn_cast<ClassTemplateSpecializationDecl>(D);
645 AddBoolean(Specialization);
646 if (Specialization) {
647 const TemplateArgumentList &List = Specialization->getTemplateArgs();
648 ID.AddInteger(List.size());
649 for (const TemplateArgument &TA : List.asArray())
650 AddTemplateArgument(TA);
651 }
652 }
653
654 namespace {
655 // Process a Type pointer. Add* methods call back into ODRHash while Visit*
656 // methods process the relevant parts of the Type.
657 class ODRTypeVisitor : public TypeVisitor<ODRTypeVisitor> {
658 typedef TypeVisitor<ODRTypeVisitor> Inherited;
659 llvm::FoldingSetNodeID &ID;
660 ODRHash &Hash;
661
662 public:
663 ODRTypeVisitor(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
664 : ID(ID), Hash(Hash) {}
665
666 void AddStmt(Stmt *S) {
667 Hash.AddBoolean(S);
668 if (S) {
669 Hash.AddStmt(S);
670 }
671 }
672
673 void AddDecl(Decl *D) {
674 Hash.AddBoolean(D);
675 if (D) {
676 Hash.AddDecl(D);
677 }
678 }
679
680 void AddQualType(QualType T) {
681 Hash.AddQualType(T);
682 }
683
684 void AddType(const Type *T) {
685 Hash.AddBoolean(T);
686 if (T) {
687 Hash.AddType(T);
688 }
689 }
690
691 void AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
692 Hash.AddBoolean(NNS);
693 if (NNS) {
694 Hash.AddNestedNameSpecifier(NNS);
695 }
696 }
697
698 void AddIdentifierInfo(const IdentifierInfo *II) {
699 Hash.AddBoolean(II);
700 if (II) {
701 Hash.AddIdentifierInfo(II);
702 }
703 }
704
705 void VisitQualifiers(Qualifiers Quals) {
706 ID.AddInteger(Quals.getAsOpaqueValue());
707 }
708
709 // Return the RecordType if the typedef only strips away a keyword.
710 // Otherwise, return the original type.
711 static const Type *RemoveTypedef(const Type *T) {
712 const auto *TypedefT = dyn_cast<TypedefType>(T);
713 if (!TypedefT) {
714 return T;
715 }
716
717 const TypedefNameDecl *D = TypedefT->getDecl();
718 QualType UnderlyingType = D->getUnderlyingType();
719
720 if (UnderlyingType.hasLocalQualifiers()) {
721 return T;
722 }
723
724 const auto *ElaboratedT = dyn_cast<ElaboratedType>(UnderlyingType);
725 if (!ElaboratedT) {
726 return T;
727 }
728
729 if (ElaboratedT->getQualifier() != nullptr) {
730 return T;
731 }
732
733 QualType NamedType = ElaboratedT->getNamedType();
734 if (NamedType.hasLocalQualifiers()) {
735 return T;
736 }
737
738 const auto *RecordT = dyn_cast<RecordType>(NamedType);
739 if (!RecordT) {
740 return T;
741 }
742
743 const IdentifierInfo *TypedefII = TypedefT->getDecl()->getIdentifier();
744 const IdentifierInfo *RecordII = RecordT->getDecl()->getIdentifier();
745 if (!TypedefII || !RecordII ||
746 TypedefII->getName() != RecordII->getName()) {
747 return T;
748 }
749
750 return RecordT;
751 }
752
753 void Visit(const Type *T) {
754 T = RemoveTypedef(T);
755 ID.AddInteger(T->getTypeClass());
756 Inherited::Visit(T);
757 }
758
759 void VisitType(const Type *T) {}
760
761 void VisitAdjustedType(const AdjustedType *T) {
762 QualType Original = T->getOriginalType();
763 QualType Adjusted = T->getAdjustedType();
764
765 // The original type and pointee type can be the same, as in the case of
766 // function pointers decaying to themselves. Set a bool and only process
767 // the type once, to prevent doubling the work.
768 SplitQualType split = Adjusted.split();
769 if (auto Pointer = dyn_cast<PointerType>(split.Ty)) {
770 if (Pointer->getPointeeType() == Original) {
771 Hash.AddBoolean(true);
772 ID.AddInteger(split.Quals.getAsOpaqueValue());
773 AddQualType(Original);
774 VisitType(T);
775 return;
776 }
777 }
778
779 // The original type and pointee type are different, such as in the case
780 // of a array decaying to an element pointer. Set a bool to false and
781 // process both types.
782 Hash.AddBoolean(false);
783 AddQualType(Original);
784 AddQualType(Adjusted);
785
786 VisitType(T);
787 }
788
789 void VisitDecayedType(const DecayedType *T) {
790 // getDecayedType and getPointeeType are derived from getAdjustedType
791 // and don't need to be separately processed.
792 VisitAdjustedType(T);
793 }
794
795 void VisitArrayType(const ArrayType *T) {
796 AddQualType(T->getElementType());
797 ID.AddInteger(T->getSizeModifier());
798 VisitQualifiers(T->getIndexTypeQualifiers());
799 VisitType(T);
800 }
801 void VisitConstantArrayType(const ConstantArrayType *T) {
802 T->getSize().Profile(ID);
803 VisitArrayType(T);
804 }
805
806 void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
807 AddStmt(T->getSizeExpr());
808 VisitArrayType(T);
809 }
810
811 void VisitIncompleteArrayType(const IncompleteArrayType *T) {
812 VisitArrayType(T);
813 }
814
815 void VisitVariableArrayType(const VariableArrayType *T) {
816 AddStmt(T->getSizeExpr());
817 VisitArrayType(T);
818 }
819
820 void VisitAttributedType(const AttributedType *T) {
821 ID.AddInteger(T->getAttrKind());
822 AddQualType(T->getModifiedType());
823 AddQualType(T->getEquivalentType());
824
825 VisitType(T);
826 }
827
828 void VisitBlockPointerType(const BlockPointerType *T) {
829 AddQualType(T->getPointeeType());
830 VisitType(T);
831 }
832
833 void VisitBuiltinType(const BuiltinType *T) {
834 ID.AddInteger(T->getKind());
835 VisitType(T);
836 }
837
838 void VisitComplexType(const ComplexType *T) {
839 AddQualType(T->getElementType());
840 VisitType(T);
841 }
842
843 void VisitDecltypeType(const DecltypeType *T) {
844 AddStmt(T->getUnderlyingExpr());
845 AddQualType(T->getUnderlyingType());
846 VisitType(T);
847 }
848
849 void VisitDependentDecltypeType(const DependentDecltypeType *T) {
850 VisitDecltypeType(T);
851 }
852
853 void VisitDeducedType(const DeducedType *T) {
854 AddQualType(T->getDeducedType());
855 VisitType(T);
856 }
857
858 void VisitAutoType(const AutoType *T) {
859 ID.AddInteger((unsigned)T->getKeyword());
860 ID.AddInteger(T->isConstrained());
861 if (T->isConstrained()) {
862 AddDecl(T->getTypeConstraintConcept());
863 ID.AddInteger(T->getNumArgs());
864 for (const auto &TA : T->getTypeConstraintArguments())
865 Hash.AddTemplateArgument(TA);
866 }
867 VisitDeducedType(T);
868 }
869
870 void VisitDeducedTemplateSpecializationType(
871 const DeducedTemplateSpecializationType *T) {
872 Hash.AddTemplateName(T->getTemplateName());
873 VisitDeducedType(T);
874 }
875
876 void VisitDependentAddressSpaceType(const DependentAddressSpaceType *T) {
877 AddQualType(T->getPointeeType());
878 AddStmt(T->getAddrSpaceExpr());
879 VisitType(T);
880 }
881
882 void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) {
883 AddQualType(T->getElementType());
884 AddStmt(T->getSizeExpr());
885 VisitType(T);
886 }
887
888 void VisitFunctionType(const FunctionType *T) {
889 AddQualType(T->getReturnType());
890 T->getExtInfo().Profile(ID);
891 Hash.AddBoolean(T->isConst());
892 Hash.AddBoolean(T->isVolatile());
893 Hash.AddBoolean(T->isRestrict());
894 VisitType(T);
895 }
896
897 void VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
898 VisitFunctionType(T);
899 }
900
901 void VisitFunctionProtoType(const FunctionProtoType *T) {
902 ID.AddInteger(T->getNumParams());
903 for (auto ParamType : T->getParamTypes())
904 AddQualType(ParamType);
905
906 VisitFunctionType(T);
907 }
908
909 void VisitInjectedClassNameType(const InjectedClassNameType *T) {
910 AddDecl(T->getDecl());
911 VisitType(T);
912 }
913
914 void VisitMemberPointerType(const MemberPointerType *T) {
915 AddQualType(T->getPointeeType());
916 AddType(T->getClass());
917 VisitType(T);
918 }
919
920 void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
921 AddQualType(T->getPointeeType());
922 VisitType(T);
923 }
924
925 void VisitObjCObjectType(const ObjCObjectType *T) {
926 AddDecl(T->getInterface());
927
928 auto TypeArgs = T->getTypeArgsAsWritten();
929 ID.AddInteger(TypeArgs.size());
930 for (auto Arg : TypeArgs) {
931 AddQualType(Arg);
932 }
933
934 auto Protocols = T->getProtocols();
935 ID.AddInteger(Protocols.size());
936 for (auto Protocol : Protocols) {
937 AddDecl(Protocol);
938 }
939
940 Hash.AddBoolean(T->isKindOfType());
941
942 VisitType(T);
943 }
944
945 void VisitObjCInterfaceType(const ObjCInterfaceType *T) {
946 // This type is handled by the parent type ObjCObjectType.
947 VisitObjCObjectType(T);
948 }
949
950 void VisitObjCTypeParamType(const ObjCTypeParamType *T) {
951 AddDecl(T->getDecl());
952 auto Protocols = T->getProtocols();
953 ID.AddInteger(Protocols.size());
954 for (auto Protocol : Protocols) {
955 AddDecl(Protocol);
956 }
957
958 VisitType(T);
959 }
960
961 void VisitPackExpansionType(const PackExpansionType *T) {
962 AddQualType(T->getPattern());
963 VisitType(T);
964 }
965
966 void VisitParenType(const ParenType *T) {
967 AddQualType(T->getInnerType());
968 VisitType(T);
969 }
970
971 void VisitPipeType(const PipeType *T) {
972 AddQualType(T->getElementType());
973 Hash.AddBoolean(T->isReadOnly());
974 VisitType(T);
975 }
976
977 void VisitPointerType(const PointerType *T) {
978 AddQualType(T->getPointeeType());
979 VisitType(T);
980 }
981
982 void VisitReferenceType(const ReferenceType *T) {
983 AddQualType(T->getPointeeTypeAsWritten());
984 VisitType(T);
985 }
986
987 void VisitLValueReferenceType(const LValueReferenceType *T) {
988 VisitReferenceType(T);
989 }
990
991 void VisitRValueReferenceType(const RValueReferenceType *T) {
992 VisitReferenceType(T);
993 }
994
995 void
996 VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
997 AddType(T->getReplacedParameter());
998 Hash.AddTemplateArgument(T->getArgumentPack());
999 VisitType(T);
1000 }
1001
1002 void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
1003 AddType(T->getReplacedParameter());
1004 AddQualType(T->getReplacementType());
1005 VisitType(T);
1006 }
1007
1008 void VisitTagType(const TagType *T) {
1009 AddDecl(T->getDecl());
1010 VisitType(T);
1011 }
1012
1013 void VisitRecordType(const RecordType *T) { VisitTagType(T); }
1014 void VisitEnumType(const EnumType *T) { VisitTagType(T); }
1015
1016 void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
1017 ID.AddInteger(T->getNumArgs());
1018 for (const auto &TA : T->template_arguments()) {
1019 Hash.AddTemplateArgument(TA);
1020 }
1021 Hash.AddTemplateName(T->getTemplateName());
1022 VisitType(T);
1023 }
1024
1025 void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
1026 ID.AddInteger(T->getDepth());
1027 ID.AddInteger(T->getIndex());
1028 Hash.AddBoolean(T->isParameterPack());
1029 AddDecl(T->getDecl());
1030 }
1031
1032 void VisitTypedefType(const TypedefType *T) {
1033 AddDecl(T->getDecl());
1034 QualType UnderlyingType = T->getDecl()->getUnderlyingType();
1035 VisitQualifiers(UnderlyingType.getQualifiers());
1036 while (true) {
1037 if (const TypedefType *Underlying =
1038 dyn_cast<TypedefType>(UnderlyingType.getTypePtr())) {
1039 UnderlyingType = Underlying->getDecl()->getUnderlyingType();
1040 continue;
1041 }
1042 if (const ElaboratedType *Underlying =
1043 dyn_cast<ElaboratedType>(UnderlyingType.getTypePtr())) {
1044 UnderlyingType = Underlying->getNamedType();
1045 continue;
1046 }
1047
1048 break;
1049 }
1050 AddType(UnderlyingType.getTypePtr());
1051 VisitType(T);
1052 }
1053
1054 void VisitTypeOfExprType(const TypeOfExprType *T) {
1055 AddStmt(T->getUnderlyingExpr());
1056 Hash.AddBoolean(T->isSugared());
1057 if (T->isSugared())
1058 AddQualType(T->desugar());
1059
1060 VisitType(T);
1061 }
1062 void VisitTypeOfType(const TypeOfType *T) {
1063 AddQualType(T->getUnderlyingType());
1064 VisitType(T);
1065 }
1066
1067 void VisitTypeWithKeyword(const TypeWithKeyword *T) {
1068 ID.AddInteger(T->getKeyword());
1069 VisitType(T);
1070 };
1071
1072 void VisitDependentNameType(const DependentNameType *T) {
1073 AddNestedNameSpecifier(T->getQualifier());
1074 AddIdentifierInfo(T->getIdentifier());
1075 VisitTypeWithKeyword(T);
1076 }
1077
1078 void VisitDependentTemplateSpecializationType(
1079 const DependentTemplateSpecializationType *T) {
1080 AddIdentifierInfo(T->getIdentifier());
1081 AddNestedNameSpecifier(T->getQualifier());
1082 ID.AddInteger(T->getNumArgs());
1083 for (const auto &TA : T->template_arguments()) {
1084 Hash.AddTemplateArgument(TA);
1085 }
1086 VisitTypeWithKeyword(T);
1087 }
1088
1089 void VisitElaboratedType(const ElaboratedType *T) {
1090 AddNestedNameSpecifier(T->getQualifier());
1091 AddQualType(T->getNamedType());
1092 VisitTypeWithKeyword(T);
1093 }
1094
1095 void VisitUnaryTransformType(const UnaryTransformType *T) {
1096 AddQualType(T->getUnderlyingType());
1097 AddQualType(T->getBaseType());
1098 VisitType(T);
1099 }
1100
1101 void VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
1102 AddDecl(T->getDecl());
1103 VisitType(T);
1104 }
1105
1106 void VisitVectorType(const VectorType *T) {
1107 AddQualType(T->getElementType());
1108 ID.AddInteger(T->getNumElements());
1109 ID.AddInteger(T->getVectorKind());
1110 VisitType(T);
1111 }
1112
1113 void VisitExtVectorType(const ExtVectorType * T) {
1114 VisitVectorType(T);
1115 }
1116 };
1117 } // namespace
1118
1119 void ODRHash::AddType(const Type *T) {
1120 assert(T && "Expecting non-null pointer.");
1121 ODRTypeVisitor(ID, *this).Visit(T);
1122 }
1123
1124 void ODRHash::AddQualType(QualType T) {
1125 AddBoolean(T.isNull());
1126 if (T.isNull())
1127 return;
1128 SplitQualType split = T.split();
1129 ID.AddInteger(split.Quals.getAsOpaqueValue());
1130 AddType(split.Ty);
1131 }
1132
1133 void ODRHash::AddBoolean(bool Value) {
1134 Bools.push_back(Value);
1135 }
clang::TypeConstraint::getImmediatelyDeclaredConstraint
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint, that is - the constraint expression that is added to the associated constraints of the enclosing declaration in practice.
Definition: ASTConcept.h:187
clang::PackExpansionType::getPattern
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5532
clang::DeducedType::getDeducedType
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4859
clang::ElaboratedType
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5285
clang::SplitQualType::Ty
const Type * Ty
The locally-unqualified type.
Definition: Type.h:595
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1783
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:685
clang::ODRHash
Definition: ODRHash.h:41
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
clang::ObjCObjectType::getTypeArgsAsWritten
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:5805
clang::PipeType::getElementType
QualType getElementType() const
Definition: Type.h:6173
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2627
clang::UnresolvedUsingType
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4210
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:654
clang::CXXRecordDecl::bases
base_class_range bases()
Definition: DeclCXX.h:587
TypeVisitor.h
clang::ODRHash::AddBoolean
void AddBoolean(bool value)
Definition: ODRHash.cpp:1133
clang::CXXRecordDecl::getNumBases
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:581
clang::ODRHash::AddDeclarationName
void AddDeclarationName(DeclarationName Name, bool TreatAsDecl=false)
Definition: ODRHash.cpp:34
ODRHash.h
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes...
clang::FunctionType::ExtInfo::Profile
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: Type.h:3642
clang::AutoType::getTypeConstraintArguments
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
Definition: Type.h:4904
clang::DecltypeType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4380
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:66
clang::FieldDecl::getBitWidth
Expr * getBitWidth() const
Definition: Decl.h:2818
clang::ODRHash::AddQualType
void AddQualType(QualType T)
Definition: ODRHash.cpp:1124
clang::BuiltinType::getKind
Kind getKind() const
Definition: Type.h:2495
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
clang::EnumConstantDecl
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2941
Base
clang::TypedefDecl
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:3173
clang::NestedNameSpecifier::Super
Microsoft&#39;s &#39;__super&#39; specifier, stored as a CXXRecordDecl* of the class it appeared in...
Definition: NestedNameSpecifier.h:99
clang::DependentNameType
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5368
clang::TemplateArgument::Expression
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:86
clang::TemplateArgumentList::size
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:299
clang::DependentNameType::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5387
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
clang::TagType::getDecl
TagDecl * getDecl() const
Definition: Type.cpp:3296
clang::TemplateParameterList::asArray
ArrayRef< NamedDecl * > asArray()
Definition: DeclTemplate.h:131
clang::DeclarationName::getObjCSelector
Selector getObjCSelector() const
Get the Objective-C selector stored in this declaration name.
Definition: DeclarationName.h:481
clang::NestedNameSpecifier::getPrefix
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Definition: NestedNameSpecifier.h:167
clang::DeclarationName::getCXXOverloadedOperator
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
Definition: DeclarationName.h:462
clang::AutoType
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:4874
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1450
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2889
clang::TemplateArgument::Declaration
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:63
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6227
clang::DeclarationName::isEmpty
bool isEmpty() const
Evaluates true when this declaration name is empty.
Definition: DeclarationName.h:372
clang::TemplateTypeParmType::getDecl
TemplateTypeParmDecl * getDecl() const
Definition: Type.h:4694
clang::TemplateName::SubstTemplateTemplateParm
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:223
clang::FunctionDecl::isVirtualAsWritten
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2096
clang::FunctionDecl::param_size
size_t param_size() const
Definition: Decl.h:2415
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2910
clang::NonTypeTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Definition: DeclTemplate.h:1472
Value
Value
Definition: UninitializedValues.cpp:101
clang::DeducedTemplateSpecializationType::getTemplateName
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
Definition: Type.h:4958
clang::NestedNameSpecifier::Identifier
An identifier, stored as an IdentifierInfo*.
Definition: NestedNameSpecifier.h:79
clang::FriendDecl
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:53
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:820
clang::RedeclarableTemplateDecl
Declaration of a redeclarable template.
Definition: DeclTemplate.h:751
clang::ObjCProtocolQualifiers::getProtocols
ArrayRef< ObjCProtocolDecl * > getProtocols() const
Retrieve all of the protocol qualifiers.
Definition: Type.h:5613
clang::FunctionDecl::getReturnType
QualType getReturnType() const
Definition: Decl.h:2445
clang::FunctionProtoType::getNumParams
unsigned getNumParams() const
Definition: Type.h:3964
clang::NonTypeTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1462
clang::TemplateArgument::Null
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:56
clang::DeclContext::decls
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2033
clang::DeducedTemplateSpecializationType
Represents a C++17 deduced template specialization type.
Definition: Type.h:4940
clang::DeclarationName::CXXUsingDirective
Definition: DeclarationName.h:215
clang::NestedNameSpecifier::Namespace
A namespace, stored as a NamespaceDecl*.
Definition: NestedNameSpecifier.h:82
clang::FunctionType::isConst
bool isConst() const
Definition: Type.h:3697
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::DeclarationName::ObjCOneArgSelector
Definition: DeclarationName.h:205
clang::NestedNameSpecifier::getKind
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
Definition: NestedNameSpecifier.cpp:142
clang::ODRHash::AddTemplateArgument
void AddTemplateArgument(TemplateArgument TA)
Definition: ODRHash.cpp:157
clang::CXXRecordDecl::hasDefinition
bool hasDefinition() const
Definition: DeclCXX.h:540
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1595
clang::SubstTemplateTypeParmType
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4728
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:143
clang::ODRHash::clear
void clear()
Definition: ODRHash.cpp:198
clang::PipeType
PipeType - OpenCL20.
Definition: Type.h:6159
clang::DeclarationName::CXXDeductionGuideName
Definition: DeclarationName.h:210
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
clang::AdjustedType::getOriginalType
QualType getOriginalType() const
Definition: Type.h:2678
clang::EnumDecl::getIntegerTypeSourceInfo
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3651
clang::ClassTemplateSpecializationDecl
Represents a class template specialization, which refers to a class template with a given set of temp...
Definition: DeclTemplate.h:1802
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:57
clang::FriendDecl::getFriendType
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:123
clang::StaticAssertDecl::getMessage
StringLiteral * getMessage()
Definition: DeclCXX.h:3789
clang::ObjCObjectType
Represents a class type in Objective C.
Definition: Type.h:5694
clang::BlockPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2731
clang::TemplateArgument::getAsExpr
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:329
clang::FunctionProtoType::getParamTypes
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3971
clang::TemplateArgument::Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:71
clang::TemplateName::getAsTemplateDecl
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
Definition: TemplateName.cpp:99
clang::DeclarationName::getNameKind
NameKind getNameKind() const
Determine what kind of name this is.
Definition: DeclarationName.h:384
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2729
clang::TemplateSpecializationType::getTemplateName
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:5059
clang::NestedNameSpecifier::getAsType
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Definition: NestedNameSpecifier.h:194
clang::TypeVisitor
An operation on a type.
Definition: TypeVisitor.h:64
clang::FriendDecl::getFriendDecl
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:138
clang::SubstTemplateTypeParmPackType
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4784
clang::TypeConstraint
Definition: ASTConcept.h:169
clang::ODRHash::AddTemplateParameterList
void AddTemplateParameterList(const TemplateParameterList *TPL)
Definition: ODRHash.cpp:189
clang::DeclarationName::ObjCZeroArgSelector
Definition: DeclarationName.h:204
clang::AccessSpecDecl
Represents an access specifier followed by colon &#39;:&#39;.
Definition: DeclCXX.h:85
clang::DeclarationName::CXXLiteralOperatorName
Definition: DeclarationName.h:212
clang::FunctionDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2399
clang::Selector::isUnarySelector
bool isUnarySelector() const
Definition: IdentifierTable.h:762
clang::RValueReferenceType
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2815
clang::UnresolvedUsingType::getDecl
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:4221
clang::FieldDecl::isBitField
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2807
clang::NestedNameSpecifier::getAsIdentifier
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
Definition: NestedNameSpecifier.h:174
clang::TemplateName::QualifiedTemplate
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:215
clang::FunctionDecl::getBody
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2894
clang::ODRHash::AddDecl
void AddDecl(const Decl *D)
Definition: ODRHash.cpp:630
GCCTypeClass::Pointer
clang::ODRHash::AddFunctionDecl
void AddFunctionDecl(const FunctionDecl *Function, bool SkipBody=false)
Definition: ODRHash.cpp:519
clang::TemplateName::AssumedTemplate
An unqualified-id that has been assumed to name a function template that will be found by ADL...
Definition: TemplateName.h:211
CHAR_BIT
#define CHAR_BIT
Definition: limits.h:63
clang::TemplateTypeParmDecl::getTypeConstraint
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
Definition: DeclTemplate.h:1345
clang::RedeclarableTemplateDecl::isMemberSpecialization
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:888
clang::NestedNameSpecifier::getAsNamespaceAlias
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
Definition: NestedNameSpecifier.cpp:176
clang::AutoType::isConstrained
bool isConstrained() const
Definition: Type.h:4912
clang::TypeOfExprType
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4300
clang::MemberPointerType::getClass
const Type * getClass() const
Definition: Type.h:2867
clang::InjectedClassNameType::getDecl
CXXRecordDecl * getDecl() const
Definition: Type.cpp:3386
clang::VarDecl::isConstexpr
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1412
remainder
#define remainder(__x, __y)
Definition: tgmath.h:1090
clang::VariableArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3058
clang::EnumConstantDecl::getInitExpr
const Expr * getInitExpr() const
Definition: Decl.h:2960
clang::TemplateTypeParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1248
clang::ObjCObjectType::getInterface
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5930
clang::TemplateTemplateParmDecl::isParameterPack
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
Definition: DeclTemplate.h:1669
clang::DependentSizedArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3115
clang::ReferenceType::getPointeeTypeAsWritten
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2769
clang::Decl::getCanonicalDecl
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:877
clang::DependentSizedExtVectorType::getElementType
QualType getElementType() const
Definition: Type.h:3211
clang::DependentSizedExtVectorType
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3195
clang::ODRHash::AddTemplateName
void AddTemplateName(TemplateName Name)
Definition: ODRHash.cpp:138
clang::FunctionNoProtoType
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3717
clang::DependentAddressSpaceType::getAddrSpaceExpr
Expr * getAddrSpaceExpr() const
Definition: Type.h:3166
Parent
NodeId Parent
Definition: ASTDiff.cpp:191
clang::TypeAliasDecl
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3193
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
clang::TemplateName::DependentTemplate
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:219
clang::NonTypeTemplateParmDecl::isParameterPack
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
Definition: DeclTemplate.h:1497
clang::ObjCTypeParamType::getDecl
ObjCTypeParamDecl * getDecl() const
Definition: Type.h:5663
clang::TemplateArgument::getAsDecl
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:263
clang::DependentSizedArrayType
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3093
clang::TemplateDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:421
clang::DeclContext::getLexicalParent
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1800
clang::ComplexType::getElementType
QualType getElementType() const
Definition: Type.h:2567
clang::FunctionDecl::isInlineSpecified
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2499
clang::DeclarationName::getCXXNameType
QualType getCXXNameType() const
If this name is one of the C++ names (of a constructor, destructor, or conversion function)...
Definition: DeclarationName.h:439
clang::DependentTemplateSpecializationType::getNumArgs
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:5455
clang::NestedNameSpecifier::getAsNamespace
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
Definition: NestedNameSpecifier.cpp:168
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
clang::FunctionDecl::isDefaulted
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2130
clang::Qualifiers::getAsOpaqueValue
unsigned getAsOpaqueValue() const
Definition: Type.h:256
clang::EnumDecl::isScopedUsingClassTag
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3678
clang::TemplateTypeParmDecl
Declaration of a template type parameter.
Definition: DeclTemplate.h:1177
clang::TemplateTypeParmType::getIndex
unsigned getIndex() const
Definition: Type.h:4691
clang::DependentDecltypeType
Internal representation of canonical, dependent decltype(expr) types.
Definition: Type.h:4398
clang::TemplateArgument::NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:67
clang::FunctionDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:2071
clang::Decl::isImplicit
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
clang::FunctionDecl::getTemplateSpecializationArgs
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3669
clang::DeclContext::isFileContext
bool isFileContext() const
Definition: DeclBase.h:1854
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:438
clang::UnaryTransformType::getBaseType
QualType getBaseType() const
Definition: Type.h:4439
clang::DependentNameType::getIdentifier
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:5394
clang::Stmt::ProcessODRHash
void ProcessODRHash(llvm::FoldingSetNodeID &ID, ODRHash &Hash) const
Calculate a unique representation for a statement that is stable across compiler invocations.
Definition: StmtProfile.cpp:2136
clang::FunctionDecl::getStorageClass
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2488
clang::TemplateArgumentList::asArray
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:293
clang::NonTypeTemplateParmDecl
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Definition: DeclTemplate.h:1383
DeclVisitor.h
clang::TemplateName
Represents a C++ template name within the type system.
Definition: TemplateName.h:191
clang::DecltypeType
Represents the type decltype(expr) (C++11).
Definition: Type.h:4370
clang::NestedNameSpecifier::NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
Definition: NestedNameSpecifier.h:85
clang::DeclarationName::getAsIdentifierInfo
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn&#39;t...
Definition: DeclarationName.h:410
clang::SplitQualType
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:593
clang::TypeOfExprType::desugar
QualType desugar() const
Remove a single level of sugar.
Definition: Type.cpp:3226
clang::UnaryTransformType
A unary type transform, which is a type constructed from another.
Definition: Type.h:4413
StmtVisitor.h
clang::SplitQualType::Quals
Qualifiers Quals
The local qualifiers.
Definition: Type.h:598
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1784
clang::TypeWithKeyword
A helper class for Type nodes having an ElaboratedTypeKeyword.
Definition: Type.h:5234
clang::VectorType
Represents a GCC generic vector type.
Definition: Type.h:3235
clang::ArrayType::getSizeModifier
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2912
clang::LValueReferenceType
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2797
clang::TemplateTemplateParmDecl
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Definition: DeclTemplate.h:1600
clang::Selector::getNumArgs
unsigned getNumArgs() const
Definition: IdentifierTable.cpp:430
clang::DeducedType
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4833
clang::ObjCSubstitutionContext::Result
The result type of a method or function.
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
clang::NestedNameSpecifier::TypeSpec
A type, stored as a Type*.
Definition: NestedNameSpecifier.h:88
clang::StaticAssertDecl::getAssertExpr
Expr * getAssertExpr()
Definition: DeclCXX.h:3786
clang::TemplateTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Definition: DeclTemplate.h:1731
clang::TypeOfExprType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4309
clang::QualType::split
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6264
clang::TemplateName::SubstTemplateTemplateParmPack
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:228
clang::DeclContext::getDeclKind
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1777
Kind
Kind
Definition: ChrootChecker.cpp:29
clang::TypeWithKeyword::getKeyword
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:5246
clang::Selector::getIdentifierInfoForSlot
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
Definition: IdentifierTable.cpp:441
clang::TemplateTypeParmDecl::isParameterPack
bool isParameterPack() const
Returns whether this is a parameter pack.
Definition: DeclTemplate.cpp:650
clang::FunctionTemplateDecl::getTemplatedDecl
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:1032
clang::ParenType
Sugar for parentheses used when specifying types.
Definition: Type.h:2584
clang::AdjustedType::getAdjustedType
QualType getAdjustedType() const
Definition: Type.h:2679
clang::FunctionType::getReturnType
QualType getReturnType() const
Definition: Type.h:3680
clang::DeclarationName::CXXConstructorName
Definition: DeclarationName.h:206
clang::FunctionDecl::isPure
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2105
clang::EnumType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4521
clang::DeclarationName::Identifier
Definition: DeclarationName.h:203
clang::TypeOfType
Represents typeof(type), a GCC extension.
Definition: Type.h:4343
clang::ObjCInterfaceType
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5894
clang::ODRHash::AddType
void AddType(const Type *T)
Definition: ODRHash.cpp:1119
clang::SubstTemplateTypeParmPackType::getArgumentPack
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3403
clang::ODRHash::AddIdentifierInfo
void AddIdentifierInfo(const IdentifierInfo *II)
Definition: ODRHash.cpp:29
clang::VectorType::getElementType
QualType getElementType() const
Definition: Type.h:3270
clang::FieldDecl::getInClassInitializer
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2876
clang::FunctionType::isRestrict
bool isRestrict() const
Definition: Type.h:3699
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
clang::NestedNameSpecifier
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Definition: NestedNameSpecifier.h:48
clang::TemplateTypeParmType::isParameterPack
bool isParameterPack() const
Definition: Type.h:4692
clang::TemplateArgument::pack_size
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:359
clang::SubstTemplateTypeParmPackType::getReplacedParameter
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4802
clang::AttributedType::getEquivalentType
QualType getEquivalentType() const
Definition: Type.h:4576
clang::EnumDecl::isScoped
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3675
clang::ParenType::getInnerType
QualType getInnerType() const
Definition: Type.h:2597
clang::TemplateTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1718
llvm::SmallVector
Definition: LLVM.h:35
clang::TemplateParameterList::size
unsigned size() const
Definition: DeclTemplate.h:129
clang::ElaboratedType::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5322
clang::FunctionDecl::getODRHash
unsigned getODRHash()
Returns ODRHash of the function.
Definition: Decl.cpp:3985
clang::AutoType::getKeyword
AutoTypeKeyword getKeyword() const
Definition: Type.h:4920
clang::ArrayType::getIndexTypeQualifiers
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2916
clang::Type::getTypeClass
TypeClass getTypeClass() const
Definition: Type.h:1876
clang::ODRHash::AddNestedNameSpecifier
void AddNestedNameSpecifier(const NestedNameSpecifier *NNS)
Definition: ODRHash.cpp:109
clang::DependentTemplateSpecializationType::template_arguments
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5461
clang::FunctionDecl::isExplicitlyDefaulted
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2135
clang::StaticAssertDecl
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3763
clang::ODRHash::AddSubDecl
void AddSubDecl(const Decl *D)
Definition: ODRHash.cpp:466
clang::ODRHash::AddEnumDecl
void AddEnumDecl(const EnumDecl *Enum)
Definition: ODRHash.cpp:602
clang::DecayedType
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2699
clang::InjectedClassNameType
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:5133
clang::DependentAddressSpaceType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:3167
clang::PackExpansionType
Represents a pack expansion of types.
Definition: Type.h:5511
clang::TemplateArgument::pack_elements
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:353
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:155
NestedNameSpecifier.h
clang::AutoType::getNumArgs
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:4898
clang::TypedefNameDecl
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3071
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:50
clang::AdjustedType
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2662
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::FunctionType::getExtInfo
ExtInfo getExtInfo() const
Definition: Type.h:3691
clang::TemplateArgumentLoc::getArgument
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:498
clang::FunctionDecl::isLateTemplateParsed
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:2109
clang::DependentTemplateSpecializationType::getQualifier
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5446
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
clang::TemplateDecl
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:402
clang::TemplateArgument::TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:79
clang::TypedefNameDecl::getUnderlyingType
QualType getUnderlyingType() const
Definition: Decl.h:3126
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
clang::VarDecl::getInit
const Expr * getInit() const
Definition: Decl.h:1229
clang::QualType::hasLocalQualifiers
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition: Type.h:756
clang::DecltypeType::getUnderlyingType
QualType getUnderlyingType() const
Definition: Type.h:4381
clang::ODRHash::AddCXXRecordDecl
void AddCXXRecordDecl(const CXXRecordDecl *Record)
Definition: ODRHash.cpp:472
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:145
clang::VectorType::getVectorKind
VectorKind getVectorKind() const
Definition: Type.h:3280
clang::Decl::getKind
Kind getKind() const
Definition: DeclBase.h:432
clang::Selector::isKeywordSelector
bool isKeywordSelector() const
Definition: IdentifierTable.h:758
clang::ObjCObjectType::isKindOfType
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:734
clang::EnumDecl
Represents an enum.
Definition: Decl.h:3481
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2833
clang::NonTypeTemplateParmDecl::getDefaultArgument
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1465
clang::DeclarationName::CXXDestructorName
Definition: DeclarationName.h:207
clang::DeclarationName::CXXConversionFunctionName
Definition: DeclarationName.h:208
clang::TemplateTypeParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Definition: DeclTemplate.h:1265
clang::NestedNameSpecifier::TypeSpecWithTemplate
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
Definition: NestedNameSpecifier.h:92
clang::SubstTemplateTypeParmType::getReplacedParameter
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4743
clang::UnaryTransformType::getUnderlyingType
QualType getUnderlyingType() const
Definition: Type.h:4438
clang::AttributedType::getModifiedType
QualType getModifiedType() const
Definition: Type.h:4575
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:5951
clang::BlockPointerType
Pointer to a block type.
Definition: Type.h:2716
clang::DeclarationName::ObjCMultiArgSelector
Definition: DeclarationName.h:217
clang::TypeOfExprType::isSugared
bool isSugared() const
Returns whether this type directly provides sugar.
Definition: Type.cpp:3222
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
clang::ComplexType
Complex values, per C99 6.2.5p11.
Definition: Type.h:2554
clang::TemplateSpecializationType::getNumArgs
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:5067
clang::ConstantArrayType::getSize
const llvm::APInt & getSize() const
Definition: Type.h:2958
clang::AttributedType::getAttrKind
Kind getAttrKind() const
Definition: Type.h:4571
clang::VarDecl::isStaticLocal
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1069
clang::ExtVectorType
ExtVectorType - Extended vector type.
Definition: Type.h:3354
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
clang::FunctionType::isVolatile
bool isVolatile() const
Definition: Type.h:3698
clang::ODRHash::CalculateHash
unsigned CalculateHash()
Definition: ODRHash.cpp:204
clang::TemplateArgument::Type
The template argument is a type.
Definition: TemplateBase.h:59
clang::TypeOfType::getUnderlyingType
QualType getUnderlyingType() const
Definition: Type.h:4358
clang::TemplateArgument::Pack
The template argument is actually a parameter pack.
Definition: TemplateBase.h:90
clang::TemplateTemplateParmDecl::getDefaultArgument
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1721
clang::TemplateArgumentList
A template argument list.
Definition: DeclTemplate.h:239
clang::CXXRecordDecl::getDescribedClassTemplate
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1692
clang::TypedefType::getDecl
TypedefNameDecl * getDecl() const
Definition: Type.h:4256
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:234
clang::TemplateTypeParmType::getDepth
unsigned getDepth() const
Definition: Type.h:4690
clang::AttributedType
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4550
clang::DeclarationName::getCXXDeductionGuideTemplate
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name...
Definition: DeclarationName.h:451
clang::ObjCTypeParamType
Represents a type parameter type in Objective C.
Definition: Type.h:5620
clang::FieldDecl::isMutable
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2804
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
clang::DependentTemplateSpecializationType
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5420
clang::TemplateSpecializationType::template_arguments
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5075
clang::TemplateArgument::Template
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:75
clang::IncompleteArrayType
Represents a C array with an unspecified size.
Definition: Type.h:2995
clang::ElaboratedType::getNamedType
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:5325
clang::Selector::isNull
bool isNull() const
Determine whether this is the empty selector.
Definition: IdentifierTable.h:755
clang::SubstTemplateTypeParmType::getReplacementType
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4749
clang::ClassTemplateDecl
Declaration of a class template.
Definition: DeclTemplate.h:2238
clang::BuiltinType
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2465
clang::EnumDecl::getIntegerType
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3635
clang::ODRHash::AddStmt
void AddStmt(const Stmt *S)
Definition: ODRHash.cpp:24
clang::TemplateName::getKind
NameKind getKind() const
Definition: TemplateName.cpp:80
clang::VectorType::getNumElements
unsigned getNumElements() const
Definition: Type.h:3271
clang::PipeType::isReadOnly
bool isReadOnly() const
Definition: Type.h:6192
clang::TemplateArgument::getAsType
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:256
clang::DependentAddressSpaceType
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:3153
clang::TemplateSpecializationType
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4996
clang::FunctionDecl::isDeleted
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2259
clang::TypedefType
Definition: Type.h:4240
clang::ODRHash::isWhitelistedDecl
static bool isWhitelistedDecl(const Decl *D, const DeclContext *Parent)
Definition: ODRHash.cpp:443
clang::TemplateTypeParmDecl::getDefaultArgument
QualType getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1251
clang::DeclarationName::getCXXLiteralIdentifier
IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it...
Definition: DeclarationName.h:472
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:630
clang::TemplateName::OverloadedTemplate
A set of overloaded template declarations.
Definition: TemplateName.h:207
clang::DeclarationName::CXXOperatorName
Definition: DeclarationName.h:209
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:223
clang::TagType
Definition: Type.h:4471
clang::TemplateTypeParmType
Definition: Type.h:4647
clang::VariableArrayType
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3039
clang::AutoType::getTypeConstraintConcept
ConceptDecl * getTypeConstraintConcept() const
Definition: Type.h:4908
clang::ConstDeclVisitor
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:73
clang::NestedNameSpecifier::Global
The global specifier &#39;::&#39;. There is no stored value.
Definition: NestedNameSpecifier.h:95
clang::TemplateArgument::getAsTemplateOrTemplatePattern
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:287
clang::VarDecl::hasInit
bool hasInit() const
Definition: Decl.cpp:2226
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2935
clang::FunctionTemplateDecl
Declaration of a template function.
Definition: DeclTemplate.h:977
clang::FunctionDecl::isDeletedAsWritten
bool isDeletedAsWritten() const
Definition: Decl.h:2263
clang::MemberPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2853
clang::TypeSourceInfo::getType
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6238
clang::TemplateName::Template
A single template declaration.
Definition: TemplateName.h:204
clang::DependentTemplateSpecializationType::getIdentifier
const IdentifierInfo * getIdentifier() const
Definition: Type.h:5447
clang::DependentSizedExtVectorType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3210
clang::ObjCObjectPointerType::getPointeeType
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5967