clang 8.0.0

TypePrinter.cpp
Go to the documentation of this file.
1 //===- TypePrinter.cpp - Pretty-Print Clang Types -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to print types from Clang's type system.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/PrettyPrinter.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclBase.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/NestedNameSpecifier.h"
23 #include "clang/AST/TemplateBase.h"
24 #include "clang/AST/TemplateName.h"
25 #include "clang/AST/Type.h"
26 #include "clang/Basic/AddressSpaces.h"
27 #include "clang/Basic/ExceptionSpecificationType.h"
28 #include "clang/Basic/IdentifierTable.h"
29 #include "clang/Basic/LLVM.h"
30 #include "clang/Basic/LangOptions.h"
31 #include "clang/Basic/SourceLocation.h"
32 #include "clang/Basic/SourceManager.h"
33 #include "clang/Basic/Specifiers.h"
34 #include "llvm/ADT/ArrayRef.h"
35 #include "llvm/ADT/SmallString.h"
36 #include "llvm/ADT/StringRef.h"
37 #include "llvm/ADT/Twine.h"
38 #include "llvm/Support/Casting.h"
39 #include "llvm/Support/Compiler.h"
40 #include "llvm/Support/ErrorHandling.h"
41 #include "llvm/Support/SaveAndRestore.h"
42 #include "llvm/Support/raw_ostream.h"
43 #include <cassert>
44 #include <string>
45
46 using namespace clang;
47
48 namespace {
49
50 /// RAII object that enables printing of the ARC __strong lifetime
51 /// qualifier.
52 class IncludeStrongLifetimeRAII {
53 PrintingPolicy &Policy;
54 bool Old;
55
56 public:
57 explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
58 : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
59 if (!Policy.SuppressLifetimeQualifiers)
60 Policy.SuppressStrongLifetime = false;
61 }
62
63 ~IncludeStrongLifetimeRAII() {
64 Policy.SuppressStrongLifetime = Old;
65 }
66 };
67
68 class ParamPolicyRAII {
69 PrintingPolicy &Policy;
70 bool Old;
71
72 public:
73 explicit ParamPolicyRAII(PrintingPolicy &Policy)
74 : Policy(Policy), Old(Policy.SuppressSpecifiers) {
75 Policy.SuppressSpecifiers = false;
76 }
77
78 ~ParamPolicyRAII() {
79 Policy.SuppressSpecifiers = Old;
80 }
81 };
82
83 class ElaboratedTypePolicyRAII {
84 PrintingPolicy &Policy;
85 bool SuppressTagKeyword;
86 bool SuppressScope;
87
88 public:
89 explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
90 SuppressTagKeyword = Policy.SuppressTagKeyword;
91 SuppressScope = Policy.SuppressScope;
92 Policy.SuppressTagKeyword = true;
93 Policy.SuppressScope = true;
94 }
95
96 ~ElaboratedTypePolicyRAII() {
97 Policy.SuppressTagKeyword = SuppressTagKeyword;
98 Policy.SuppressScope = SuppressScope;
99 }
100 };
101
102 class TypePrinter {
103 PrintingPolicy Policy;
104 unsigned Indentation;
105 bool HasEmptyPlaceHolder = false;
106 bool InsideCCAttribute = false;
107
108 public:
109 explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0)
110 : Policy(Policy), Indentation(Indentation) {}
111
112 void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
113 StringRef PlaceHolder);
114 void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
115
116 static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
117 void spaceBeforePlaceHolder(raw_ostream &OS);
118 void printTypeSpec(NamedDecl *D, raw_ostream &OS);
119
120 void printBefore(QualType T, raw_ostream &OS);
121 void printAfter(QualType T, raw_ostream &OS);
122 void AppendScope(DeclContext *DC, raw_ostream &OS);
123 void printTag(TagDecl *T, raw_ostream &OS);
124 void printFunctionAfter(const FunctionType::ExtInfo &Info, raw_ostream &OS);
125 #define ABSTRACT_TYPE(CLASS, PARENT)
126 #define TYPE(CLASS, PARENT) \
127 void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \
128 void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
129 #include "clang/AST/TypeNodes.def"
130
131 private:
132 void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
133 void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
134 };
135
136 } // namespace
137
138 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals,
139 bool HasRestrictKeyword) {
140 bool appendSpace = false;
141 if (TypeQuals & Qualifiers::Const) {
142 OS << "const";
143 appendSpace = true;
144 }
145 if (TypeQuals & Qualifiers::Volatile) {
146 if (appendSpace) OS << ' ';
147 OS << "volatile";
148 appendSpace = true;
149 }
150 if (TypeQuals & Qualifiers::Restrict) {
151 if (appendSpace) OS << ' ';
152 if (HasRestrictKeyword) {
153 OS << "restrict";
154 } else {
155 OS << "__restrict";
156 }
157 }
158 }
159
160 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
161 if (!HasEmptyPlaceHolder)
162 OS << ' ';
163 }
164
165 static SplitQualType splitAccordingToPolicy(QualType QT,
166 const PrintingPolicy &Policy) {
167 if (Policy.PrintCanonicalTypes)
168 QT = QT.getCanonicalType();
169 return QT.split();
170 }
171
172 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) {
173 SplitQualType split = splitAccordingToPolicy(t, Policy);
174 print(split.Ty, split.Quals, OS, PlaceHolder);
175 }
176
177 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
178 StringRef PlaceHolder) {
179 if (!T) {
180 OS << "NULL TYPE";
181 return;
182 }
183
184 SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());
185
186 printBefore(T, Quals, OS);
187 OS << PlaceHolder;
188 printAfter(T, Quals, OS);
189 }
190
191 bool TypePrinter::canPrefixQualifiers(const Type *T,
192 bool &NeedARCStrongQualifier) {
193 // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
194 // so that we get "const int" instead of "int const", but we can't do this if
195 // the type is complex. For example if the type is "int*", we *must* print
196 // "int * const", printing "const int *" is different. Only do this when the
197 // type expands to a simple string.
198 bool CanPrefixQualifiers = false;
199 NeedARCStrongQualifier = false;
200 Type::TypeClass TC = T->getTypeClass();
201 if (const auto *AT = dyn_cast<AutoType>(T))
202 TC = AT->desugar()->getTypeClass();
203 if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(T))
204 TC = Subst->getReplacementType()->getTypeClass();
205
206 switch (TC) {
207 case Type::Auto:
208 case Type::Builtin:
209 case Type::Complex:
210 case Type::UnresolvedUsing:
211 case Type::Typedef:
212 case Type::TypeOfExpr:
213 case Type::TypeOf:
214 case Type::Decltype:
215 case Type::UnaryTransform:
216 case Type::Record:
217 case Type::Enum:
218 case Type::Elaborated:
219 case Type::TemplateTypeParm:
220 case Type::SubstTemplateTypeParmPack:
221 case Type::DeducedTemplateSpecialization:
222 case Type::TemplateSpecialization:
223 case Type::InjectedClassName:
224 case Type::DependentName:
225 case Type::DependentTemplateSpecialization:
226 case Type::ObjCObject:
227 case Type::ObjCTypeParam:
228 case Type::ObjCInterface:
229 case Type::Atomic:
230 case Type::Pipe:
231 CanPrefixQualifiers = true;
232 break;
233
234 case Type::ObjCObjectPointer:
235 CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
236 T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
237 break;
238
239 case Type::ConstantArray:
240 case Type::IncompleteArray:
241 case Type::VariableArray:
242 case Type::DependentSizedArray:
243 NeedARCStrongQualifier = true;
244 LLVM_FALLTHROUGH;
245
246 case Type::Adjusted:
247 case Type::Decayed:
248 case Type::Pointer:
249 case Type::BlockPointer:
250 case Type::LValueReference:
251 case Type::RValueReference:
252 case Type::MemberPointer:
253 case Type::DependentAddressSpace:
254 case Type::DependentVector:
255 case Type::DependentSizedExtVector:
256 case Type::Vector:
257 case Type::ExtVector:
258 case Type::FunctionProto:
259 case Type::FunctionNoProto:
260 case Type::Paren:
261 case Type::Attributed:
262 case Type::PackExpansion:
263 case Type::SubstTemplateTypeParm:
264 CanPrefixQualifiers = false;
265 break;
266 }
267
268 return CanPrefixQualifiers;
269 }
270
271 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
272 SplitQualType Split = splitAccordingToPolicy(T, Policy);
273
274 // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
275 // at this level.
276 Qualifiers Quals = Split.Quals;
277 if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
278 Quals -= QualType(Subst, 0).getQualifiers();
279
280 printBefore(Split.Ty, Quals, OS);
281 }
282
283 /// Prints the part of the type string before an identifier, e.g. for
284 /// "int foo[10]" it prints "int ".
285 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
286 if (Policy.SuppressSpecifiers && T->isSpecifierType())
287 return;
288
289 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder);
290
291 // Print qualifiers as appropriate.
292
293 bool CanPrefixQualifiers = false;
294 bool NeedARCStrongQualifier = false;
295 CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier);
296
297 if (CanPrefixQualifiers && !Quals.empty()) {
298 if (NeedARCStrongQualifier) {
299 IncludeStrongLifetimeRAII Strong(Policy);
300 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
301 } else {
302 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
303 }
304 }
305
306 bool hasAfterQuals = false;
307 if (!CanPrefixQualifiers && !Quals.empty()) {
308 hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy);
309 if (hasAfterQuals)
310 HasEmptyPlaceHolder = false;
311 }
312
313 switch (T->getTypeClass()) {
314 #define ABSTRACT_TYPE(CLASS, PARENT)
315 #define TYPE(CLASS, PARENT) case Type::CLASS: \
316 print##CLASS##Before(cast<CLASS##Type>(T), OS); \
317 break;
318 #include "clang/AST/TypeNodes.def"
319 }
320
321 if (hasAfterQuals) {
322 if (NeedARCStrongQualifier) {
323 IncludeStrongLifetimeRAII Strong(Policy);
324 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
325 } else {
326 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
327 }
328 }
329 }
330
331 void TypePrinter::printAfter(QualType t, raw_ostream &OS) {
332 SplitQualType split = splitAccordingToPolicy(t, Policy);
333 printAfter(split.Ty, split.Quals, OS);
334 }
335
336 /// Prints the part of the type string after an identifier, e.g. for
337 /// "int foo[10]" it prints "[10]".
338 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
339 switch (T->getTypeClass()) {
340 #define ABSTRACT_TYPE(CLASS, PARENT)
341 #define TYPE(CLASS, PARENT) case Type::CLASS: \
342 print##CLASS##After(cast<CLASS##Type>(T), OS); \
343 break;
344 #include "clang/AST/TypeNodes.def"
345 }
346 }
347
348 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
349 OS << T->getName(Policy);
350 spaceBeforePlaceHolder(OS);
351 }
352
353 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {}
354
355 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
356 OS << "_Complex ";
357 printBefore(T->getElementType(), OS);
358 }
359
360 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
361 printAfter(T->getElementType(), OS);
362 }
363
364 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
365 IncludeStrongLifetimeRAII Strong(Policy);
366 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
367 printBefore(T->getPointeeType(), OS);
368 // Handle things like 'int (*A)[4];' correctly.
369 // FIXME: this should include vectors, but vectors use attributes I guess.
370 if (isa<ArrayType>(T->getPointeeType()))
371 OS << '(';
372 OS << '*';
373 }
374
375 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
376 IncludeStrongLifetimeRAII Strong(Policy);
377 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
378 // Handle things like 'int (*A)[4];' correctly.
379 // FIXME: this should include vectors, but vectors use attributes I guess.
380 if (isa<ArrayType>(T->getPointeeType()))
381 OS << ')';
382 printAfter(T->getPointeeType(), OS);
383 }
384
385 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
386 raw_ostream &OS) {
387 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
388 printBefore(T->getPointeeType(), OS);
389 OS << '^';
390 }
391
392 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
393 raw_ostream &OS) {
394 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
395 printAfter(T->getPointeeType(), OS);
396 }
397
398 // When printing a reference, the referenced type might also be a reference.
399 // If so, we want to skip that before printing the inner type.
400 static QualType skipTopLevelReferences(QualType T) {
401 if (auto *Ref = T->getAs<ReferenceType>())
402 return skipTopLevelReferences(Ref->getPointeeTypeAsWritten());
403 return T;
404 }
405
406 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
407 raw_ostream &OS) {
408 IncludeStrongLifetimeRAII Strong(Policy);
409 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
410 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
411 printBefore(Inner, OS);
412 // Handle things like 'int (&A)[4];' correctly.
413 // FIXME: this should include vectors, but vectors use attributes I guess.
414 if (isa<ArrayType>(Inner))
415 OS << '(';
416 OS << '&';
417 }
418
419 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
420 raw_ostream &OS) {
421 IncludeStrongLifetimeRAII Strong(Policy);
422 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
423 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
424 // Handle things like 'int (&A)[4];' correctly.
425 // FIXME: this should include vectors, but vectors use attributes I guess.
426 if (isa<ArrayType>(Inner))
427 OS << ')';
428 printAfter(Inner, OS);
429 }
430
431 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
432 raw_ostream &OS) {
433 IncludeStrongLifetimeRAII Strong(Policy);
434 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
435 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
436 printBefore(Inner, OS);
437 // Handle things like 'int (&&A)[4];' correctly.
438 // FIXME: this should include vectors, but vectors use attributes I guess.
439 if (isa<ArrayType>(Inner))
440 OS << '(';
441 OS << "&&";
442 }
443
444 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
445 raw_ostream &OS) {
446 IncludeStrongLifetimeRAII Strong(Policy);
447 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
448 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
449 // Handle things like 'int (&&A)[4];' correctly.
450 // FIXME: this should include vectors, but vectors use attributes I guess.
451 if (isa<ArrayType>(Inner))
452 OS << ')';
453 printAfter(Inner, OS);
454 }
455
456 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
457 raw_ostream &OS) {
458 IncludeStrongLifetimeRAII Strong(Policy);
459 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
460 printBefore(T->getPointeeType(), OS);
461 // Handle things like 'int (Cls::*A)[4];' correctly.
462 // FIXME: this should include vectors, but vectors use attributes I guess.
463 if (isa<ArrayType>(T->getPointeeType()))
464 OS << '(';
465
466 PrintingPolicy InnerPolicy(Policy);
467 InnerPolicy.IncludeTagDefinition = false;
468 TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());
469
470 OS << "::*";
471 }
472
473 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
474 raw_ostream &OS) {
475 IncludeStrongLifetimeRAII Strong(Policy);
476 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
477 // Handle things like 'int (Cls::*A)[4];' correctly.
478 // FIXME: this should include vectors, but vectors use attributes I guess.
479 if (isa<ArrayType>(T->getPointeeType()))
480 OS << ')';
481 printAfter(T->getPointeeType(), OS);
482 }
483
484 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
485 raw_ostream &OS) {
486 IncludeStrongLifetimeRAII Strong(Policy);
487 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
488 printBefore(T->getElementType(), OS);
489 }
490
491 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
492 raw_ostream &OS) {
493 OS << '[';
494 if (T->getIndexTypeQualifiers().hasQualifiers()) {
495 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(),
496 Policy.Restrict);
497 OS << ' ';
498 }
499
500 if (T->getSizeModifier() == ArrayType::Static)
501 OS << "static ";
502
503 OS << T->getSize().getZExtValue() << ']';
504 printAfter(T->getElementType(), OS);
505 }
506
507 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
508 raw_ostream &OS) {
509 IncludeStrongLifetimeRAII Strong(Policy);
510 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
511 printBefore(T->getElementType(), OS);
512 }
513
514 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
515 raw_ostream &OS) {
516 OS << "[]";
517 printAfter(T->getElementType(), OS);
518 }
519
520 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
521 raw_ostream &OS) {
522 IncludeStrongLifetimeRAII Strong(Policy);
523 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
524 printBefore(T->getElementType(), OS);
525 }
526
527 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
528 raw_ostream &OS) {
529 OS << '[';
530 if (T->getIndexTypeQualifiers().hasQualifiers()) {
531 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict);
532 OS << ' ';
533 }
534
535 if (T->getSizeModifier() == VariableArrayType::Static)
536 OS << "static ";
537 else if (T->getSizeModifier() == VariableArrayType::Star)
538 OS << '*';
539
540 if (T->getSizeExpr())
541 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
542 OS << ']';
543
544 printAfter(T->getElementType(), OS);
545 }
546
547 void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) {
548 // Print the adjusted representation, otherwise the adjustment will be
549 // invisible.
550 printBefore(T->getAdjustedType(), OS);
551 }
552
553 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
554 printAfter(T->getAdjustedType(), OS);
555 }
556
557 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
558 // Print as though it's a pointer.
559 printAdjustedBefore(T, OS);
560 }
561
562 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
563 printAdjustedAfter(T, OS);
564 }
565
566 void TypePrinter::printDependentSizedArrayBefore(
567 const DependentSizedArrayType *T,
568 raw_ostream &OS) {
569 IncludeStrongLifetimeRAII Strong(Policy);
570 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
571 printBefore(T->getElementType(), OS);
572 }
573
574 void TypePrinter::printDependentSizedArrayAfter(
575 const DependentSizedArrayType *T,
576 raw_ostream &OS) {
577 OS << '[';
578 if (T->getSizeExpr())
579 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
580 OS << ']';
581 printAfter(T->getElementType(), OS);
582 }
583
584 void TypePrinter::printDependentAddressSpaceBefore(
585 const DependentAddressSpaceType *T, raw_ostream &OS) {
586 printBefore(T->getPointeeType(), OS);
587 }
588
589 void TypePrinter::printDependentAddressSpaceAfter(
590 const DependentAddressSpaceType *T, raw_ostream &OS) {
591 OS << " __attribute__((address_space(";
592 if (T->getAddrSpaceExpr())
593 T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy);
594 OS << ")))";
595 printAfter(T->getPointeeType(), OS);
596 }
597
598 void TypePrinter::printDependentSizedExtVectorBefore(
599 const DependentSizedExtVectorType *T,
600 raw_ostream &OS) {
601 printBefore(T->getElementType(), OS);
602 }
603
604 void TypePrinter::printDependentSizedExtVectorAfter(
605 const DependentSizedExtVectorType *T,
606 raw_ostream &OS) {
607 OS << " __attribute__((ext_vector_type(";
608 if (T->getSizeExpr())
609 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
610 OS << ")))";
611 printAfter(T->getElementType(), OS);
612 }
613
614 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
615 switch (T->getVectorKind()) {
616 case VectorType::AltiVecPixel:
617 OS << "__vector __pixel ";
618 break;
619 case VectorType::AltiVecBool:
620 OS << "__vector __bool ";
621 printBefore(T->getElementType(), OS);
622 break;
623 case VectorType::AltiVecVector:
624 OS << "__vector ";
625 printBefore(T->getElementType(), OS);
626 break;
627 case VectorType::NeonVector:
628 OS << "__attribute__((neon_vector_type("
629 << T->getNumElements() << "))) ";
630 printBefore(T->getElementType(), OS);
631 break;
632 case VectorType::NeonPolyVector:
633 OS << "__attribute__((neon_polyvector_type(" <<
634 T->getNumElements() << "))) ";
635 printBefore(T->getElementType(), OS);
636 break;
637 case VectorType::GenericVector: {
638 // FIXME: We prefer to print the size directly here, but have no way
639 // to get the size of the type.
640 OS << "__attribute__((__vector_size__("
641 << T->getNumElements()
642 << " * sizeof(";
643 print(T->getElementType(), OS, StringRef());
644 OS << ")))) ";
645 printBefore(T->getElementType(), OS);
646 break;
647 }
648 }
649 }
650
651 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
652 printAfter(T->getElementType(), OS);
653 }
654
655 void TypePrinter::printDependentVectorBefore(
656 const DependentVectorType *T, raw_ostream &OS) {
657 switch (T->getVectorKind()) {
658 case VectorType::AltiVecPixel:
659 OS << "__vector __pixel ";
660 break;
661 case VectorType::AltiVecBool:
662 OS << "__vector __bool ";
663 printBefore(T->getElementType(), OS);
664 break;
665 case VectorType::AltiVecVector:
666 OS << "__vector ";
667 printBefore(T->getElementType(), OS);
668 break;
669 case VectorType::NeonVector:
670 OS << "__attribute__((neon_vector_type(";
671 if (T->getSizeExpr())
672 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
673 OS << "))) ";
674 printBefore(T->getElementType(), OS);
675 break;
676 case VectorType::NeonPolyVector:
677 OS << "__attribute__((neon_polyvector_type(";
678 if (T->getSizeExpr())
679 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
680 OS << "))) ";
681 printBefore(T->getElementType(), OS);
682 break;
683 case VectorType::GenericVector: {
684 // FIXME: We prefer to print the size directly here, but have no way
685 // to get the size of the type.
686 OS << "__attribute__((__vector_size__(";
687 if (T->getSizeExpr())
688 T->getSizeExpr()->printPretty(OS, nullptr, Policy);
689 OS << " * sizeof(";
690 print(T->getElementType(), OS, StringRef());
691 OS << ")))) ";
692 printBefore(T->getElementType(), OS);
693 break;
694 }
695 }
696 }
697
698 void TypePrinter::printDependentVectorAfter(
699 const DependentVectorType *T, raw_ostream &OS) {
700 printAfter(T->getElementType(), OS);
701 }
702
703 void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
704 raw_ostream &OS) {
705 printBefore(T->getElementType(), OS);
706 }
707
708 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
709 printAfter(T->getElementType(), OS);
710 OS << " __attribute__((ext_vector_type(";
711 OS << T->getNumElements();
712 OS << ")))";
713 }
714
715 void
716 FunctionProtoType::printExceptionSpecification(raw_ostream &OS,
717 const PrintingPolicy &Policy)
718 const {
719 if (hasDynamicExceptionSpec()) {
720 OS << " throw(";
721 if (getExceptionSpecType() == EST_MSAny)
722 OS << "...";
723 else
724 for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) {
725 if (I)
726 OS << ", ";
727
728 OS << getExceptionType(I).stream(Policy);
729 }
730 OS << ')';
731 } else if (isNoexceptExceptionSpec(getExceptionSpecType())) {
732 OS << " noexcept";
733 // FIXME:Is it useful to print out the expression for a non-dependent
734 // noexcept specification?
735 if (isComputedNoexcept(getExceptionSpecType())) {
736 OS << '(';
737 if (getNoexceptExpr())
738 getNoexceptExpr()->printPretty(OS, nullptr, Policy);
739 OS << ')';
740 }
741 }
742 }
743
744 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
745 raw_ostream &OS) {
746 if (T->hasTrailingReturn()) {
747 OS << "auto ";
748 if (!HasEmptyPlaceHolder)
749 OS << '(';
750 } else {
751 // If needed for precedence reasons, wrap the inner part in grouping parens.
752 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
753 printBefore(T->getReturnType(), OS);
754 if (!PrevPHIsEmpty.get())
755 OS << '(';
756 }
757 }
758
759 StringRef clang::getParameterABISpelling(ParameterABI ABI) {
760 switch (ABI) {
761 case ParameterABI::Ordinary:
762 llvm_unreachable("asking for spelling of ordinary parameter ABI");
763 case ParameterABI::SwiftContext:
764 return "swift_context";
765 case ParameterABI::SwiftErrorResult:
766 return "swift_error_result";
767 case ParameterABI::SwiftIndirectResult:
768 return "swift_indirect_result";
769 }
770 llvm_unreachable("bad parameter ABI kind");
771 }
772
773 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
774 raw_ostream &OS) {
775 // If needed for precedence reasons, wrap the inner part in grouping parens.
776 if (!HasEmptyPlaceHolder)
777 OS << ')';
778 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
779
780 OS << '(';
781 {
782 ParamPolicyRAII ParamPolicy(Policy);
783 for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) {
784 if (i) OS << ", ";
785
786 auto EPI = T->getExtParameterInfo(i);
787 if (EPI.isConsumed()) OS << "__attribute__((ns_consumed)) ";
788 if (EPI.isNoEscape())
789 OS << "__attribute__((noescape)) ";
790 auto ABI = EPI.getABI();
791 if (ABI != ParameterABI::Ordinary)
792 OS << "__attribute__((" << getParameterABISpelling(ABI) << ")) ";
793
794 print(T->getParamType(i), OS, StringRef());
795 }
796 }
797
798 if (T->isVariadic()) {
799 if (T->getNumParams())
800 OS << ", ";
801 OS << "...";
802 } else if (T->getNumParams() == 0 && Policy.UseVoidForZeroParams) {
803 // Do not emit int() if we have a proto, emit 'int(void)'.
804 OS << "void";
805 }
806
807 OS << ')';
808
809 FunctionType::ExtInfo Info = T->getExtInfo();
810
811 printFunctionAfter(Info, OS);
812
813 if (!T->getTypeQuals().empty())
814 OS << " " << T->getTypeQuals().getAsString();
815
816 switch (T->getRefQualifier()) {
817 case RQ_None:
818 break;
819
820 case RQ_LValue:
821 OS << " &";
822 break;
823
824 case RQ_RValue:
825 OS << " &&";
826 break;
827 }
828 T->printExceptionSpecification(OS, Policy);
829
830 if (T->hasTrailingReturn()) {
831 OS << " -> ";
832 print(T->getReturnType(), OS, StringRef());
833 } else
834 printAfter(T->getReturnType(), OS);
835 }
836
837 void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info,
838 raw_ostream &OS) {
839 if (!InsideCCAttribute) {
840 switch (Info.getCC()) {
841 case CC_C:
842 // The C calling convention is the default on the vast majority of platforms
843 // we support. If the user wrote it explicitly, it will usually be printed
844 // while traversing the AttributedType. If the type has been desugared, let
845 // the canonical spelling be the implicit calling convention.
846 // FIXME: It would be better to be explicit in certain contexts, such as a
847 // cdecl function typedef used to declare a member function with the
848 // Microsoft C++ ABI.
849 break;
850 case CC_X86StdCall:
851 OS << " __attribute__((stdcall))";
852 break;
853 case CC_X86FastCall:
854 OS << " __attribute__((fastcall))";
855 break;
856 case CC_X86ThisCall:
857 OS << " __attribute__((thiscall))";
858 break;
859 case CC_X86VectorCall:
860 OS << " __attribute__((vectorcall))";
861 break;
862 case CC_X86Pascal:
863 OS << " __attribute__((pascal))";
864 break;
865 case CC_AAPCS:
866 OS << " __attribute__((pcs(\"aapcs\")))";
867 break;
868 case CC_AAPCS_VFP:
869 OS << " __attribute__((pcs(\"aapcs-vfp\")))";
870 break;
871 case CC_AArch64VectorCall:
872 OS << "__attribute__((aarch64_vector_pcs))";
873 break;
874 case CC_IntelOclBicc:
875 OS << " __attribute__((intel_ocl_bicc))";
876 break;
877 case CC_Win64:
878 OS << " __attribute__((ms_abi))";
879 break;
880 case CC_X86_64SysV:
881 OS << " __attribute__((sysv_abi))";
882 break;
883 case CC_X86RegCall:
884 OS << " __attribute__((regcall))";
885 break;
886 case CC_SpirFunction:
887 case CC_OpenCLKernel:
888 // Do nothing. These CCs are not available as attributes.
889 break;
890 case CC_Swift:
891 OS << " __attribute__((swiftcall))";
892 break;
893 case CC_PreserveMost:
894 OS << " __attribute__((preserve_most))";
895 break;
896 case CC_PreserveAll:
897 OS << " __attribute__((preserve_all))";
898 break;
899 }
900 }
901
902 if (Info.getNoReturn())
903 OS << " __attribute__((noreturn))";
904 if (Info.getProducesResult())
905 OS << " __attribute__((ns_returns_retained))";
906 if (Info.getRegParm())
907 OS << " __attribute__((regparm ("
908 << Info.getRegParm() << ")))";
909 if (Info.getNoCallerSavedRegs())
910 OS << " __attribute__((no_caller_saved_registers))";
911 if (Info.getNoCfCheck())
912 OS << " __attribute__((nocf_check))";
913 }
914
915 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
916 raw_ostream &OS) {
917 // If needed for precedence reasons, wrap the inner part in grouping parens.
918 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
919 printBefore(T->getReturnType(), OS);
920 if (!PrevPHIsEmpty.get())
921 OS << '(';
922 }
923
924 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
925 raw_ostream &OS) {
926 // If needed for precedence reasons, wrap the inner part in grouping parens.
927 if (!HasEmptyPlaceHolder)
928 OS << ')';
929 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
930
931 OS << "()";
932 printFunctionAfter(T->getExtInfo(), OS);
933 printAfter(T->getReturnType(), OS);
934 }
935
936 void TypePrinter::printTypeSpec(NamedDecl *D, raw_ostream &OS) {
937
938 // Compute the full nested-name-specifier for this type.
939 // In C, this will always be empty except when the type
940 // being printed is anonymous within other Record.
941 if (!Policy.SuppressScope)
942 AppendScope(D->getDeclContext(), OS);
943
944 IdentifierInfo *II = D->getIdentifier();
945 OS << II->getName();
946 spaceBeforePlaceHolder(OS);
947 }
948
949 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
950 raw_ostream &OS) {
951 printTypeSpec(T->getDecl(), OS);
952 }
953
954 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
955 raw_ostream &OS) {}
956
957 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
958 printTypeSpec(T->getDecl(), OS);
959 }
960
961 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}
962
963 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
964 raw_ostream &OS) {
965 OS << "typeof ";
966 if (T->getUnderlyingExpr())
967 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
968 spaceBeforePlaceHolder(OS);
969 }
970
971 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
972 raw_ostream &OS) {}
973
974 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
975 OS << "typeof(";
976 print(T->getUnderlyingType(), OS, StringRef());
977 OS << ')';
978 spaceBeforePlaceHolder(OS);
979 }
980
981 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {}
982
983 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
984 OS << "decltype(";
985 if (T->getUnderlyingExpr())
986 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
987 OS << ')';
988 spaceBeforePlaceHolder(OS);
989 }
990
991 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
992
993 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
994 raw_ostream &OS) {
995 IncludeStrongLifetimeRAII Strong(Policy);
996
997 switch (T->getUTTKind()) {
998 case UnaryTransformType::EnumUnderlyingType:
999 OS << "__underlying_type(";
1000 print(T->getBaseType(), OS, StringRef());
1001 OS << ')';
1002 spaceBeforePlaceHolder(OS);
1003 return;
1004 }
1005
1006 printBefore(T->getBaseType(), OS);
1007 }
1008
1009 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
1010 raw_ostream &OS) {
1011 IncludeStrongLifetimeRAII Strong(Policy);
1012
1013 switch (T->getUTTKind()) {
1014 case UnaryTransformType::EnumUnderlyingType:
1015 return;
1016 }
1017
1018 printAfter(T->getBaseType(), OS);
1019 }
1020
1021 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
1022 // If the type has been deduced, do not print 'auto'.
1023 if (!T->getDeducedType().isNull()) {
1024 printBefore(T->getDeducedType(), OS);
1025 } else {
1026 switch (T->getKeyword()) {
1027 case AutoTypeKeyword::Auto: OS << "auto"; break;
1028 case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
1029 case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break;
1030 }
1031 spaceBeforePlaceHolder(OS);
1032 }
1033 }
1034
1035 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
1036 // If the type has been deduced, do not print 'auto'.
1037 if (!T->getDeducedType().isNull())
1038 printAfter(T->getDeducedType(), OS);
1039 }
1040
1041 void TypePrinter::printDeducedTemplateSpecializationBefore(
1042 const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1043 // If the type has been deduced, print the deduced type.
1044 if (!T->getDeducedType().isNull()) {
1045 printBefore(T->getDeducedType(), OS);
1046 } else {
1047 IncludeStrongLifetimeRAII Strong(Policy);
1048 T->getTemplateName().print(OS, Policy);
1049 spaceBeforePlaceHolder(OS);
1050 }
1051 }
1052
1053 void TypePrinter::printDeducedTemplateSpecializationAfter(
1054 const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1055 // If the type has been deduced, print the deduced type.
1056 if (!T->getDeducedType().isNull())
1057 printAfter(T->getDeducedType(), OS);
1058 }
1059
1060 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
1061 IncludeStrongLifetimeRAII Strong(Policy);
1062
1063 OS << "_Atomic(";
1064 print(T->getValueType(), OS, StringRef());
1065 OS << ')';
1066 spaceBeforePlaceHolder(OS);
1067 }
1068
1069 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {}
1070
1071 void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) {
1072 IncludeStrongLifetimeRAII Strong(Policy);
1073
1074 if (T->isReadOnly())
1075 OS << "read_only ";
1076 else
1077 OS << "write_only ";
1078 OS << "pipe ";
1079 print(T->getElementType(), OS, StringRef());
1080 spaceBeforePlaceHolder(OS);
1081 }
1082
1083 void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {}
1084
1085 /// Appends the given scope to the end of a string.
1086 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
1087 if (DC->isTranslationUnit()) return;
1088 if (DC->isFunctionOrMethod()) return;
1089 AppendScope(DC->getParent(), OS);
1090
1091 if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
1092 if (Policy.SuppressUnwrittenScope &&
1093 (NS->isAnonymousNamespace() || NS->isInline()))
1094 return;
1095 if (NS->getIdentifier())
1096 OS << NS->getName() << "::";
1097 else
1098 OS << "(anonymous namespace)::";
1099 } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1100 IncludeStrongLifetimeRAII Strong(Policy);
1101 OS << Spec->getIdentifier()->getName();
1102 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1103 printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1104 OS << "::";
1105 } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
1106 if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
1107 OS << Typedef->getIdentifier()->getName() << "::";
1108 else if (Tag->getIdentifier())
1109 OS << Tag->getIdentifier()->getName() << "::";
1110 else
1111 return;
1112 }
1113 }
1114
1115 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
1116 if (Policy.IncludeTagDefinition) {
1117 PrintingPolicy SubPolicy = Policy;
1118 SubPolicy.IncludeTagDefinition = false;
1119 D->print(OS, SubPolicy, Indentation);
1120 spaceBeforePlaceHolder(OS);
1121 return;
1122 }
1123
1124 bool HasKindDecoration = false;
1125
1126 // We don't print tags unless this is an elaborated type.
1127 // In C, we just assume every RecordType is an elaborated type.
1128 if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) {
1129 HasKindDecoration = true;
1130 OS << D->getKindName();
1131 OS << ' ';
1132 }
1133
1134 // Compute the full nested-name-specifier for this type.
1135 // In C, this will always be empty except when the type
1136 // being printed is anonymous within other Record.
1137 if (!Policy.SuppressScope)
1138 AppendScope(D->getDeclContext(), OS);
1139
1140 if (const IdentifierInfo *II = D->getIdentifier())
1141 OS << II->getName();
1142 else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
1143 assert(Typedef->getIdentifier() && "Typedef without identifier?");
1144 OS << Typedef->getIdentifier()->getName();
1145 } else {
1146 // Make an unambiguous representation for anonymous types, e.g.
1147 // (anonymous enum at /usr/include/string.h:120:9)
1148 OS << (Policy.MSVCFormatting ? '`' : '(');
1149
1150 if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
1151 OS << "lambda";
1152 HasKindDecoration = true;
1153 } else {
1154 OS << "anonymous";
1155 }
1156
1157 if (Policy.AnonymousTagLocations) {
1158 // Suppress the redundant tag keyword if we just printed one.
1159 // We don't have to worry about ElaboratedTypes here because you can't
1160 // refer to an anonymous type with one.
1161 if (!HasKindDecoration)
1162 OS << " " << D->getKindName();
1163
1164 PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
1165 D->getLocation());
1166 if (PLoc.isValid()) {
1167 OS << " at ";
1168 StringRef File = PLoc.getFilename();
1169 if (Policy.RemapFilePaths)
1170 OS << Policy.remapPath(File);
1171 else
1172 OS << File;
1173 OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
1174 }
1175 }
1176
1177 OS << (Policy.MSVCFormatting ? '\'' : ')');
1178 }
1179
1180 // If this is a class template specialization, print the template
1181 // arguments.
1182 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
1183 ArrayRef<TemplateArgument> Args;
1184 if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
1185 const TemplateSpecializationType *TST =
1186 cast<TemplateSpecializationType>(TAW->getType());
1187 Args = TST->template_arguments();
1188 } else {
1189 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1190 Args = TemplateArgs.asArray();
1191 }
1192 IncludeStrongLifetimeRAII Strong(Policy);
1193 printTemplateArgumentList(OS, Args, Policy);
1194 }
1195
1196 spaceBeforePlaceHolder(OS);
1197 }
1198
1199 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
1200 printTag(T->getDecl(), OS);
1201 }
1202
1203 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
1204
1205 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
1206 printTag(T->getDecl(), OS);
1207 }
1208
1209 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
1210
1211 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
1212 raw_ostream &OS) {
1213 if (IdentifierInfo *Id = T->getIdentifier())
1214 OS << Id->getName();
1215 else
1216 OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
1217 spaceBeforePlaceHolder(OS);
1218 }
1219
1220 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
1221 raw_ostream &OS) {}
1222
1223 void TypePrinter::printSubstTemplateTypeParmBefore(
1224 const SubstTemplateTypeParmType *T,
1225 raw_ostream &OS) {
1226 IncludeStrongLifetimeRAII Strong(Policy);
1227 printBefore(T->getReplacementType(), OS);
1228 }
1229
1230 void TypePrinter::printSubstTemplateTypeParmAfter(
1231 const SubstTemplateTypeParmType *T,
1232 raw_ostream &OS) {
1233 IncludeStrongLifetimeRAII Strong(Policy);
1234 printAfter(T->getReplacementType(), OS);
1235 }
1236
1237 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1238 const SubstTemplateTypeParmPackType *T,
1239 raw_ostream &OS) {
1240 IncludeStrongLifetimeRAII Strong(Policy);
1241 printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1242 }
1243
1244 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1245 const SubstTemplateTypeParmPackType *T,
1246 raw_ostream &OS) {
1247 IncludeStrongLifetimeRAII Strong(Policy);
1248 printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1249 }
1250
1251 void TypePrinter::printTemplateSpecializationBefore(
1252 const TemplateSpecializationType *T,
1253 raw_ostream &OS) {
1254 IncludeStrongLifetimeRAII Strong(Policy);
1255 T->getTemplateName().print(OS, Policy);
1256
1257 printTemplateArgumentList(OS, T->template_arguments(), Policy);
1258 spaceBeforePlaceHolder(OS);
1259 }
1260
1261 void TypePrinter::printTemplateSpecializationAfter(
1262 const TemplateSpecializationType *T,
1263 raw_ostream &OS) {}
1264
1265 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1266 raw_ostream &OS) {
1267 printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1268 }
1269
1270 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1271 raw_ostream &OS) {}
1272
1273 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1274 raw_ostream &OS) {
1275 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
1276 TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
1277 assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&
1278 "OwnedTagDecl expected to be a declaration for the type");
1279 PrintingPolicy SubPolicy = Policy;
1280 SubPolicy.IncludeTagDefinition = false;
1281 OwnedTagDecl->print(OS, SubPolicy, Indentation);
1282 spaceBeforePlaceHolder(OS);
1283 return;
1284 }
1285
1286 // The tag definition will take care of these.
1287 if (!Policy.IncludeTagDefinition)
1288 {
1289 OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1290 if (T->getKeyword() != ETK_None)
1291 OS << " ";
1292 NestedNameSpecifier *Qualifier = T->getQualifier();
1293 if (Qualifier)
1294 Qualifier->print(OS, Policy);
1295 }
1296
1297 ElaboratedTypePolicyRAII PolicyRAII(Policy);
1298 printBefore(T->getNamedType(), OS);
1299 }
1300
1301 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1302 raw_ostream &OS) {
1303 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
1304 return;
1305 ElaboratedTypePolicyRAII PolicyRAII(Policy);
1306 printAfter(T->getNamedType(), OS);
1307 }
1308
1309 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1310 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1311 printBefore(T->getInnerType(), OS);
1312 OS << '(';
1313 } else
1314 printBefore(T->getInnerType(), OS);
1315 }
1316
1317 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1318 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1319 OS << ')';
1320 printAfter(T->getInnerType(), OS);
1321 } else
1322 printAfter(T->getInnerType(), OS);
1323 }
1324
1325 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1326 raw_ostream &OS) {
1327 OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1328 if (T->getKeyword() != ETK_None)
1329 OS << " ";
1330
1331 T->getQualifier()->print(OS, Policy);
1332
1333 OS << T->getIdentifier()->getName();
1334 spaceBeforePlaceHolder(OS);
1335 }
1336
1337 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1338 raw_ostream &OS) {}
1339
1340 void TypePrinter::printDependentTemplateSpecializationBefore(
1341 const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1342 IncludeStrongLifetimeRAII Strong(Policy);
1343
1344 OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1345 if (T->getKeyword() != ETK_None)
1346 OS << " ";
1347
1348 if (T->getQualifier())
1349 T->getQualifier()->print(OS, Policy);
1350 OS << T->getIdentifier()->getName();
1351 printTemplateArgumentList(OS, T->template_arguments(), Policy);
1352 spaceBeforePlaceHolder(OS);
1353 }
1354
1355 void TypePrinter::printDependentTemplateSpecializationAfter(
1356 const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
1357
1358 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1359 raw_ostream &OS) {
1360 printBefore(T->getPattern(), OS);
1361 }
1362
1363 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1364 raw_ostream &OS) {
1365 printAfter(T->getPattern(), OS);
1366 OS << "...";
1367 }
1368
1369 void TypePrinter::printAttributedBefore(const AttributedType *T,
1370 raw_ostream &OS) {
1371 // FIXME: Generate this with TableGen.
1372
1373 // Prefer the macro forms of the GC and ownership qualifiers.
1374 if (T->getAttrKind() == attr::ObjCGC ||
1375 T->getAttrKind() == attr::ObjCOwnership)
1376 return printBefore(T->getEquivalentType(), OS);
1377
1378 if (T->getAttrKind() == attr::ObjCKindOf)
1379 OS << "__kindof ";
1380
1381 printBefore(T->getModifiedType(), OS);
1382
1383 if (T->isMSTypeSpec()) {
1384 switch (T->getAttrKind()) {
1385 default: return;
1386 case attr::Ptr32: OS << " __ptr32"; break;
1387 case attr::Ptr64: OS << " __ptr64"; break;
1388 case attr::SPtr: OS << " __sptr"; break;
1389 case attr::UPtr: OS << " __uptr"; break;
1390 }
1391 spaceBeforePlaceHolder(OS);
1392 }
1393
1394 // Print nullability type specifiers.
1395 if (T->getImmediateNullability()) {
1396 if (T->getAttrKind() == attr::TypeNonNull)
1397 OS << " _Nonnull";
1398 else if (T->getAttrKind() == attr::TypeNullable)
1399 OS << " _Nullable";
1400 else if (T->getAttrKind() == attr::TypeNullUnspecified)
1401 OS << " _Null_unspecified";
1402 else
1403 llvm_unreachable("unhandled nullability");
1404 spaceBeforePlaceHolder(OS);
1405 }
1406 }
1407
1408 void TypePrinter::printAttributedAfter(const AttributedType *T,
1409 raw_ostream &OS) {
1410 // FIXME: Generate this with TableGen.
1411
1412 // Prefer the macro forms of the GC and ownership qualifiers.
1413 if (T->getAttrKind() == attr::ObjCGC ||
1414 T->getAttrKind() == attr::ObjCOwnership)
1415 return printAfter(T->getEquivalentType(), OS);
1416
1417 // If this is a calling convention attribute, don't print the implicit CC from
1418 // the modified type.
1419 SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1420
1421 printAfter(T->getModifiedType(), OS);
1422
1423 // Some attributes are printed as qualifiers before the type, so we have
1424 // nothing left to do.
1425 if (T->getAttrKind() == attr::ObjCKindOf ||
1426 T->isMSTypeSpec() || T->getImmediateNullability())
1427 return;
1428
1429 // Don't print the inert __unsafe_unretained attribute at all.
1430 if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained)
1431 return;
1432
1433 // Don't print ns_returns_retained unless it had an effect.
1434 if (T->getAttrKind() == attr::NSReturnsRetained &&
1435 !T->getEquivalentType()->castAs<FunctionType>()
1436 ->getExtInfo().getProducesResult())
1437 return;
1438
1439 if (T->getAttrKind() == attr::LifetimeBound) {
1440 OS << " [[clang::lifetimebound]]";
1441 return;
1442 }
1443
1444 // The printing of the address_space attribute is handled by the qualifier
1445 // since it is still stored in the qualifier. Return early to prevent printing
1446 // this twice.
1447 if (T->getAttrKind() == attr::AddressSpace)
1448 return;
1449
1450 OS << " __attribute__((";
1451 switch (T->getAttrKind()) {
1452 #define TYPE_ATTR(NAME)
1453 #define DECL_OR_TYPE_ATTR(NAME)
1454 #define ATTR(NAME) case attr::NAME:
1455 #include "clang/Basic/AttrList.inc"
1456 llvm_unreachable("non-type attribute attached to type");
1457
1458 case attr::OpenCLPrivateAddressSpace:
1459 case attr::OpenCLGlobalAddressSpace:
1460 case attr::OpenCLLocalAddressSpace:
1461 case attr::OpenCLConstantAddressSpace:
1462 case attr::OpenCLGenericAddressSpace:
1463 // FIXME: Update printAttributedBefore to print these once we generate
1464 // AttributedType nodes for them.
1465 break;
1466
1467 case attr::LifetimeBound:
1468 case attr::TypeNonNull:
1469 case attr::TypeNullable:
1470 case attr::TypeNullUnspecified:
1471 case attr::ObjCGC:
1472 case attr::ObjCInertUnsafeUnretained:
1473 case attr::ObjCKindOf:
1474 case attr::ObjCOwnership:
1475 case attr::Ptr32:
1476 case attr::Ptr64:
1477 case attr::SPtr:
1478 case attr::UPtr:
1479 case attr::AddressSpace:
1480 llvm_unreachable("This attribute should have been handled already");
1481
1482 case attr::NSReturnsRetained:
1483 OS << "ns_returns_retained";
1484 break;
1485
1486 // FIXME: When Sema learns to form this AttributedType, avoid printing the
1487 // attribute again in printFunctionProtoAfter.
1488 case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
1489 case attr::CDecl: OS << "cdecl"; break;
1490 case attr::FastCall: OS << "fastcall"; break;
1491 case attr::StdCall: OS << "stdcall"; break;
1492 case attr::ThisCall: OS << "thiscall"; break;
1493 case attr::SwiftCall: OS << "swiftcall"; break;
1494 case attr::VectorCall: OS << "vectorcall"; break;
1495 case attr::Pascal: OS << "pascal"; break;
1496 case attr::MSABI: OS << "ms_abi"; break;
1497 case attr::SysVABI: OS << "sysv_abi"; break;
1498 case attr::RegCall: OS << "regcall"; break;
1499 case attr::Pcs: {
1500 OS << "pcs(";
1501 QualType t = T->getEquivalentType();
1502 while (!t->isFunctionType())
1503 t = t->getPointeeType();
1504 OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1505 "\"aapcs\"" : "\"aapcs-vfp\"");
1506 OS << ')';
1507 break;
1508 }
1509 case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
1510 case attr::IntelOclBicc: OS << "inteloclbicc"; break;
1511 case attr::PreserveMost:
1512 OS << "preserve_most";
1513 break;
1514
1515 case attr::PreserveAll:
1516 OS << "preserve_all";
1517 break;
1518 case attr::NoDeref:
1519 OS << "noderef";
1520 break;
1521 }
1522 OS << "))";
1523 }
1524
1525 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1526 raw_ostream &OS) {
1527 OS << T->getDecl()->getName();
1528 spaceBeforePlaceHolder(OS);
1529 }
1530
1531 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1532 raw_ostream &OS) {}
1533
1534 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
1535 raw_ostream &OS) {
1536 OS << T->getDecl()->getName();
1537 if (!T->qual_empty()) {
1538 bool isFirst = true;
1539 OS << '<';
1540 for (const auto *I : T->quals()) {
1541 if (isFirst)
1542 isFirst = false;
1543 else
1544 OS << ',';
1545 OS << I->getName();
1546 }
1547 OS << '>';
1548 }
1549
1550 spaceBeforePlaceHolder(OS);
1551 }
1552
1553 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
1554 raw_ostream &OS) {}
1555
1556 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1557 raw_ostream &OS) {
1558 if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1559 !T->isKindOfTypeAsWritten())
1560 return printBefore(T->getBaseType(), OS);
1561
1562 if (T->isKindOfTypeAsWritten())
1563 OS << "__kindof ";
1564
1565 print(T->getBaseType(), OS, StringRef());
1566
1567 if (T->isSpecializedAsWritten()) {
1568 bool isFirst = true;
1569 OS << '<';
1570 for (auto typeArg : T->getTypeArgsAsWritten()) {
1571 if (isFirst)
1572 isFirst = false;
1573 else
1574 OS << ",";
1575
1576 print(typeArg, OS, StringRef());
1577 }
1578 OS << '>';
1579 }
1580
1581 if (!T->qual_empty()) {
1582 bool isFirst = true;
1583 OS << '<';
1584 for (const auto *I : T->quals()) {
1585 if (isFirst)
1586 isFirst = false;
1587 else
1588 OS << ',';
1589 OS << I->getName();
1590 }
1591 OS << '>';
1592 }
1593
1594 spaceBeforePlaceHolder(OS);
1595 }
1596
1597 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1598 raw_ostream &OS) {
1599 if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1600 !T->isKindOfTypeAsWritten())
1601 return printAfter(T->getBaseType(), OS);
1602 }
1603
1604 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1605 raw_ostream &OS) {
1606 printBefore(T->getPointeeType(), OS);
1607
1608 // If we need to print the pointer, print it now.
1609 if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1610 !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1611 if (HasEmptyPlaceHolder)
1612 OS << ' ';
1613 OS << '*';
1614 }
1615 }
1616
1617 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1618 raw_ostream &OS) {}
1619
1620 static
1621 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1622
1623 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1624 return A.getArgument();
1625 }
1626
1627 template<typename TA>
1628 static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
1629 const PrintingPolicy &Policy, bool SkipBrackets) {
1630 const char *Comma = Policy.MSVCFormatting ? "," : ", ";
1631 if (!SkipBrackets)
1632 OS << '<';
1633
1634 bool NeedSpace = false;
1635 bool FirstArg = true;
1636 for (const auto &Arg : Args) {
1637 // Print the argument into a string.
1638 SmallString<128> Buf;
1639 llvm::raw_svector_ostream ArgOS(Buf);
1640 const TemplateArgument &Argument = getArgument(Arg);
1641 if (Argument.getKind() == TemplateArgument::Pack) {
1642 if (Argument.pack_size() && !FirstArg)
1643 OS << Comma;
1644 printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
1645 } else {
1646 if (!FirstArg)
1647 OS << Comma;
1648 Argument.print(Policy, ArgOS);
1649 }
1650 StringRef ArgString = ArgOS.str();
1651
1652 // If this is the first argument and its string representation
1653 // begins with the global scope specifier ('::foo'), add a space
1654 // to avoid printing the diagraph '<:'.
1655 if (FirstArg && !ArgString.empty() && ArgString[0] == ':')
1656 OS << ' ';
1657
1658 OS << ArgString;
1659
1660 NeedSpace = (!ArgString.empty() && ArgString.back() == '>');
1661 FirstArg = false;
1662 }
1663
1664 // If the last character of our string is '>', add another space to
1665 // keep the two '>''s separate tokens. We don't *have* to do this in
1666 // C++0x, but it's still good hygiene.
1667 if (NeedSpace)
1668 OS << ' ';
1669
1670 if (!SkipBrackets)
1671 OS << '>';
1672 }
1673
1674 void clang::printTemplateArgumentList(raw_ostream &OS,
1675 const TemplateArgumentListInfo &Args,
1676 const PrintingPolicy &Policy) {
1677 return printTo(OS, Args.arguments(), Policy, false);
1678 }
1679
1680 void clang::printTemplateArgumentList(raw_ostream &OS,
1681 ArrayRef<TemplateArgument> Args,
1682 const PrintingPolicy &Policy) {
1683 printTo(OS, Args, Policy, false);
1684 }
1685
1686 void clang::printTemplateArgumentList(raw_ostream &OS,
1687 ArrayRef<TemplateArgumentLoc> Args,
1688 const PrintingPolicy &Policy) {
1689 printTo(OS, Args, Policy, false);
1690 }
1691
1692 std::string Qualifiers::getAsString() const {
1693 LangOptions LO;
1694 return getAsString(PrintingPolicy(LO));
1695 }
1696
1697 // Appends qualifiers to the given string, separated by spaces. Will
1698 // prefix a space if the string is non-empty. Will not append a final
1699 // space.
1700 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1701 SmallString<64> Buf;
1702 llvm::raw_svector_ostream StrOS(Buf);
1703 print(StrOS, Policy);
1704 return StrOS.str();
1705 }
1706
1707 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1708 if (getCVRQualifiers())
1709 return false;
1710
1711 if (getAddressSpace() != LangAS::Default)
1712 return false;
1713
1714 if (getObjCGCAttr())
1715 return false;
1716
1717 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1718 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1719 return false;
1720
1721 return true;
1722 }
1723
1724 // Appends qualifiers to the given string, separated by spaces. Will
1725 // prefix a space if the string is non-empty. Will not append a final
1726 // space.
1727 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1728 bool appendSpaceIfNonEmpty) const {
1729 bool addSpace = false;
1730
1731 unsigned quals = getCVRQualifiers();
1732 if (quals) {
1733 AppendTypeQualList(OS, quals, Policy.Restrict);
1734 addSpace = true;
1735 }
1736 if (hasUnaligned()) {
1737 if (addSpace)
1738 OS << ' ';
1739 OS << "__unaligned";
1740 addSpace = true;
1741 }
1742 LangAS addrspace = getAddressSpace();
1743 if (addrspace != LangAS::Default) {
1744 if (addrspace != LangAS::opencl_private) {
1745 if (addSpace)
1746 OS << ' ';
1747 addSpace = true;
1748 switch (addrspace) {
1749 case LangAS::opencl_global:
1750 OS << "__global";
1751 break;
1752 case LangAS::opencl_local:
1753 OS << "__local";
1754 break;
1755 case LangAS::opencl_private:
1756 break;
1757 case LangAS::opencl_constant:
1758 case LangAS::cuda_constant:
1759 OS << "__constant";
1760 break;
1761 case LangAS::opencl_generic:
1762 OS << "__generic";
1763 break;
1764 case LangAS::cuda_device:
1765 OS << "__device";
1766 break;
1767 case LangAS::cuda_shared:
1768 OS << "__shared";
1769 break;
1770 default:
1771 OS << "__attribute__((address_space(";
1772 OS << toTargetAddressSpace(addrspace);
1773 OS << ")))";
1774 }
1775 }
1776 }
1777 if (Qualifiers::GC gc = getObjCGCAttr()) {
1778 if (addSpace)
1779 OS << ' ';
1780 addSpace = true;
1781 if (gc == Qualifiers::Weak)
1782 OS << "__weak";
1783 else
1784 OS << "__strong";
1785 }
1786 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1787 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1788 if (addSpace)
1789 OS << ' ';
1790 addSpace = true;
1791 }
1792
1793 switch (lifetime) {
1794 case Qualifiers::OCL_None: llvm_unreachable("none but true");
1795 case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1796 case Qualifiers::OCL_Strong:
1797 if (!Policy.SuppressStrongLifetime)
1798 OS << "__strong";
1799 break;
1800
1801 case Qualifiers::OCL_Weak: OS << "__weak"; break;
1802 case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1803 }
1804 }
1805
1806 if (appendSpaceIfNonEmpty && addSpace)
1807 OS << ' ';
1808 }
1809
1810 std::string QualType::getAsString() const {
1811 return getAsString(split(), LangOptions());
1812 }
1813
1814 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1815 std::string S;
1816 getAsStringInternal(S, Policy);
1817 return S;
1818 }
1819
1820 std::string QualType::getAsString(const Type *ty, Qualifiers qs,
1821 const PrintingPolicy &Policy) {
1822 std::string buffer;
1823 getAsStringInternal(ty, qs, buffer, Policy);
1824 return buffer;
1825 }
1826
1827 void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
1828 const Twine &PlaceHolder, unsigned Indentation) const {
1829 print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
1830 Indentation);
1831 }
1832
1833 void QualType::print(const Type *ty, Qualifiers qs,
1834 raw_ostream &OS, const PrintingPolicy &policy,
1835 const Twine &PlaceHolder, unsigned Indentation) {
1836 SmallString<128> PHBuf;
1837 StringRef PH = PlaceHolder.toStringRef(PHBuf);
1838
1839 TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
1840 }
1841
1842 void QualType::getAsStringInternal(std::string &Str,
1843 const PrintingPolicy &Policy) const {
1844 return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
1845 Policy);
1846 }
1847
1848 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1849 std::string &buffer,
1850 const PrintingPolicy &policy) {
1851 SmallString<256> Buf;
1852 llvm::raw_svector_ostream StrOS(Buf);
1853 TypePrinter(policy).print(ty, qs, StrOS, buffer);
1854 std::string str = StrOS.str();
1855 buffer.swap(str);
1856 }
clang::CC_OpenCLKernel
Definition: Specifiers.h:250
clang::TypeWithKeyword::getKeywordName
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition: Type.cpp:2582
clang::CC_X86RegCall
Definition: Specifiers.h:245
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:5376
ASTContext.h
Defines the clang::ASTContext interface.
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:4735
clang::ElaboratedType
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5129
clang::ObjCSubstitutionContext::Ordinary
An ordinary type.
clang::SplitQualType::Ty
const Type * Ty
The locally-unqualified type.
Definition: Type.h:579
clang::CC_X86VectorCall
Definition: Specifiers.h:241
AppendTypeQualList
static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, bool HasRestrictKeyword)
Definition: TypePrinter.cpp:138
clang::InjectedClassNameType::getInjectedTST
const TemplateSpecializationType * getInjectedTST() const
Definition: Type.h:5012
clang::BuiltinType::getName
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2656
clang::FunctionProtoType::getRefQualifier
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:4023
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2537
clang::PipeType::getElementType
QualType getElementType() const
Definition: Type.h:6016
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2550
clang::UnresolvedUsingType
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4121
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:638
clang::FunctionType::ExtInfo::getNoCfCheck
bool getNoCfCheck() const
Definition: Type.h:3515
clang::AutoTypeKeyword::GNUAutoType
__auto_type (GNU extension)
clang::DecltypeType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4256
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3355
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
Type.h
C Language Family Type Representation.
SourceManager.h
Defines the SourceManager interface.
clang::DependentNameType
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5212
clang::DependentNameType::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5231
clang::CC_SpirFunction
Definition: Specifiers.h:249
clang::TypeDecl::getTypeForDecl
const Type * getTypeForDecl() const
Definition: Decl.h:2898
clang::FunctionProtoType::isVariadic
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4002
DeclTemplate.h
Defines the C++ template declaration subclasses.
clang::AutoType
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4749
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1407
DeclObjC.h
clang::TypeSourceInfo
A container of type source information.
Definition: Decl.h:87
clang::AtomicType::getValueType
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5983
clang::AutoTypeKeyword::Auto
auto
clang::CC_X86StdCall
Definition: Specifiers.h:238
clang::FunctionProtoType::printExceptionSpecification
void printExceptionSpecification(raw_ostream &OS, const PrintingPolicy &Policy) const
Definition: TypePrinter.cpp:716
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2847
clang::DeducedTemplateSpecializationType::getTemplateName
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
Definition: Type.h:4803
clang::FunctionProtoType::getNumParams
unsigned getNumParams() const
Definition: Type.h:3888
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6748
PrettyPrinter.h
clang::DeducedTemplateSpecializationType
Represents a C++17 deduced template specialization type.
Definition: Type.h:4785
clang::AttributedType::isCallingConv
bool isCallingConv() const
Definition: Type.cpp:3231
clang::PrintingPolicy
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
clang::SubstTemplateTypeParmType
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4603
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:141
clang::isNoexceptExceptionSpec
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
Definition: ExceptionSpecificationType.h:44
clang::PipeType
PipeType - OpenCL20.
Definition: Type.h:6002
clang::NamedDecl::getIdentifier
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:58
clang::PrintingPolicy::SuppressLifetimeQualifiers
unsigned SuppressLifetimeQualifiers
When true, suppress printing of lifetime qualifier in ARC.
Definition: PrettyPrinter.h:152
clang::TemplateName::print
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool SuppressNNS=false) const
Print the template name.
Definition: TemplateName.cpp:209
clang::FunctionType::ExtInfo::getRegParm
unsigned getRegParm() const
Definition: Type.h:3518
clang::Decl::print
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
Definition: DeclPrinter.cpp:116
clang::BlockPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2654
clang::VectorType::NeonVector
is ARM Neon vector
Definition: Type.h:3184
clang::Type::isObjCIdType
bool isObjCIdType() const
Definition: Type.h:6422
clang::TemplateSpecializationType::getTemplateName
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4904
ExceptionSpecificationType.h
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
clang::ArrayType::Static
Definition: Type.h:2819
clang::SubstTemplateTypeParmPackType
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4659
clang::ElaboratedType::getOwnedTagDecl
TagDecl * getOwnedTagDecl() const
Return the (re)declaration of this type owned by this occurrence of this type, or nullptr if there is...
Definition: Type.h:5179
clang::CC_IntelOclBicc
Definition: Specifiers.h:248
clang::Type::isObjCQualifiedClassType
bool isObjCQualifiedClassType() const
Definition: Type.h:6416
clang::PrintingPolicy::SuppressStrongLifetime
unsigned SuppressStrongLifetime
When true, suppress printing of the __strong lifetime qualifier in ARC.
Definition: PrettyPrinter.h:149
clang::FunctionType::ExtInfo::getProducesResult
bool getProducesResult() const
Definition: Type.h:3513
clang::ParameterABI::SwiftContext
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment...
clang::RValueReferenceType
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2738
clang::UnresolvedUsingType::getDecl
UnresolvedUsingTypenameDecl * getDecl() const
Definition: Type.h:4132
clang::AttributedType::isMSTypeSpec
bool isMSTypeSpec() const
Definition: Type.cpp:3218
clang::RQ_LValue
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1363
clang::EST_MSAny
Microsoft throw(...) extension.
Definition: ExceptionSpecificationType.h:25
LLVM.h
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
clang::CC_Swift
Definition: Specifiers.h:251
clang::CC_AArch64VectorCall
Definition: Specifiers.h:254
clang::TypeOfExprType
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4176
clang::CC_X86_64SysV
Definition: Specifiers.h:244
clang::MemberPointerType::getClass
const Type * getClass() const
Definition: Type.h:2790
clang::VariableArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:2991
clang::QualType::getTypePtr
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6072
TemplateName.h
llvm::ArrayRef
Definition: LLVM.h:32
clang::FunctionType::ExtInfo::getNoReturn
bool getNoReturn() const
Definition: Type.h:3512
clang::NestedNameSpecifier::print
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const
Print this nested name specifier to the given output stream.
Definition: NestedNameSpecifier.cpp:274
clang::VectorType::NeonPolyVector
is ARM Neon polynomial vector
Definition: Type.h:3187
clang::FunctionProtoType::getTypeQuals
Qualifiers getTypeQuals() const
Definition: Type.h:4015
clang::DependentSizedArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3048
clang::FunctionType::ExtInfo::getNoCallerSavedRegs
bool getNoCallerSavedRegs() const
Definition: Type.h:3514
clang::ReferenceType::getPointeeTypeAsWritten
QualType getPointeeTypeAsWritten() const
Definition: Type.h:2692
clang::DependentVectorType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3258
clang::DependentSizedExtVectorType::getElementType
QualType getElementType() const
Definition: Type.h:3144
clang::ParameterABI::SwiftErrorResult
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
clang::PrintingPolicy::PrintCanonicalTypes
unsigned PrintCanonicalTypes
Whether to print types as written or canonically.
Definition: PrettyPrinter.h:232
clang::DependentSizedExtVectorType
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3128
clang::PrintingPolicy::IncludeTagDefinition
unsigned IncludeTagDefinition
When true, include the body of a tag definition.
Definition: PrettyPrinter.h:103
clang::FunctionNoProtoType
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3650
clang::DependentAddressSpaceType::getAddrSpaceExpr
Expr * getAddrSpaceExpr() const
Definition: Type.h:3099
AddressSpaces.h
Provides definitions for the various language-specific address spaces.
clang::getParameterABISpelling
llvm::StringRef getParameterABISpelling(ParameterABI kind)
Definition: TypePrinter.cpp:759
clang::Qualifiers::Restrict
Definition: Type.h:145
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3687
clang::ObjCProtocolQualifiers::quals
qual_range quals() const
Definition: Type.h:5438
splitAccordingToPolicy
static SplitQualType splitAccordingToPolicy(QualType QT, const PrintingPolicy &Policy)
Definition: TypePrinter.cpp:165
clang::CC_X86ThisCall
Definition: Specifiers.h:240
clang::ObjCTypeParamType::getDecl
ObjCTypeParamDecl * getDecl() const
Definition: Type.h:5507
clang::ArrayType::Star
Definition: Type.h:2819
clang::DependentSizedArrayType
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3026
clang::PresumedLoc::isValid
bool isValid() const
Definition: SourceLocation.h:300
clang::ComplexType::getElementType
QualType getElementType() const
Definition: Type.h:2490
clang::PrintingPolicy::SuppressTagKeyword
unsigned SuppressTagKeyword
Whether type printing should skip printing the tag keyword.
Definition: PrettyPrinter.h:93
clang::TemplateTypeParmType::getIdentifier
IdentifierInfo * getIdentifier() const
Definition: Type.cpp:3259
LangOptions.h
Defines the clang::LangOptions interface.
clang::TagDecl::getKindName
StringRef getKindName() const
Definition: Decl.h:3239
Id
int Id
Definition: ASTDiff.cpp:191
clang::AutoTypeKeyword::DecltypeAuto
decltype(auto)
clang::TemplateTypeParmType::getIndex
unsigned getIndex() const
Definition: Type.h:4566
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6811
clang::PresumedLoc::getLine
unsigned getLine() const
Return the presumed line number of this location.
Definition: SourceLocation.h:313
DeclBase.h
clang::Qualifiers::print
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
Definition: TypePrinter.cpp:1727
clang::Type::isObjCClassType
bool isObjCClassType() const
Definition: Type.h:6428
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:427
clang::UnaryTransformType::getBaseType
QualType getBaseType() const
Definition: Type.h:4315
clang::DependentNameType::getIdentifier
const IdentifierInfo * getIdentifier() const
Retrieve the type named by the typename specifier as an identifier.
Definition: Type.h:5238
clang::TemplateArgumentList::asArray
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:264
clang::DecltypeType
Represents the type decltype(expr) (C++11).
Definition: Type.h:4246
clang::printTemplateArgumentList
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
Definition: TypePrinter.cpp:1680
clang::SplitQualType
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:577
IdentifierTable.h
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
clang::DeclContext::isFunctionOrMethod
bool isFunctionOrMethod() const
Definition: DeclBase.h:1800
clang::UnaryTransformType
A unary type transform, which is a type constructed from another.
Definition: Type.h:4289
clang::SplitQualType::Quals
Qualifiers Quals
The local qualifiers.
Definition: Type.h:582
clang::Type::isSpecifierType
bool isSpecifierType() const
Returns true if this type can be represented by some set of type specifiers.
Definition: Type.cpp:2488
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1752
clang::PresumedLoc
Represents an unpacked "presumed" location which can be presented to the user.
Definition: SourceLocation.h:285
clang::VectorType
Represents a GCC generic vector type.
Definition: Type.h:3168
clang::ArrayType::getSizeModifier
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2849
clang::LValueReferenceType
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2720
clang::PrintingPolicy::SuppressSpecifiers
unsigned SuppressSpecifiers
Whether we should suppress printing of the actual specifiers for the given type or declaration...
Definition: PrettyPrinter.h:83
clang::UnaryTransformType::getUTTKind
UTTKind getUTTKind() const
Definition: Type.h:4317
clang::CC_PreserveMost
Definition: Specifiers.h:252
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:703
clang::TypeOfExprType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4185
clang::FunctionProtoType::hasTrailingReturn
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:4013
clang::Qualifiers::hasQualifiers
bool hasQualifiers() const
Return true if the set contains any qualifiers.
Definition: Type.h:413
clang::QualType::split
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6080
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4380
clang::PresumedLoc::getFilename
const char * getFilename() const
Return the presumed filename of this location.
Definition: SourceLocation.h:305
clang::CC_X86Pascal
Definition: Specifiers.h:242
clang::isComputedNoexcept
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
Definition: ExceptionSpecificationType.h:39
clang::Qualifiers::Const
Definition: Type.h:144
clang::VectorType::AltiVecPixel
is AltiVec &#39;vector Pixel&#39;
Definition: Type.h:3178
clang::QualType::getCanonicalType
QualType getCanonicalType() const
Definition: Type.h:6111
clang::VectorType::GenericVector
not a target-specific vector type
Definition: Type.h:3172
clang::FunctionProtoType::getExtParameterInfo
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:4078
clang::TypeWithKeyword::getKeyword
ElaboratedTypeKeyword getKeyword() const
Definition: Type.h:5090
clang::PresumedLoc::getColumn
unsigned getColumn() const
Return the presumed column number of this location.
Definition: SourceLocation.h:321
clang::ObjCInterfaceType::getDecl
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5751
clang::ParenType
Sugar for parentheses used when specifying types.
Definition: Type.h:2507
clang::AdjustedType::getAdjustedType
QualType getAdjustedType() const
Definition: Type.h:2602
clang::FunctionType::getReturnType
QualType getReturnType() const
Definition: Type.h:3613
clang::EnumType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4396
clang::TypeOfType
Represents typeof(type), a GCC extension.
Definition: Type.h:4219
clang::ObjCInterfaceType
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5738
clang::PrintingPolicy::SuppressScope
unsigned SuppressScope
Suppresses printing of scope specifiers.
Definition: PrettyPrinter.h:106
clang::FunctionType::ExtParameterInfo::getABI
ParameterABI getABI() const
Return the ABI treatment of this parameter.
Definition: Type.h:3394
clang::TagDecl
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3064
clang::Decl::getASTContext
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
clang::FunctionType::ExtInfo::getCC
CallingConv getCC() const
Definition: Type.h:3525
clang::VectorType::getElementType
QualType getElementType() const
Definition: Type.h:3203
clang::DependentVectorType
Represents a vector type where either the type or size is dependent.
Definition: Type.h:3245
clang::CC_X86FastCall
Definition: Specifiers.h:239
clang::NestedNameSpecifier
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Definition: NestedNameSpecifier.h:49
clang::RQ_None
No ref-qualifier was provided.
Definition: Type.h:1360
clang::SubstTemplateTypeParmPackType::getReplacedParameter
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4677
clang::AttributedType::getEquivalentType
QualType getEquivalentType() const
Definition: Type.h:4451
Paren
Definition: PPMacroExpansion.cpp:619
clang::ParenType::getInnerType
QualType getInnerType() const
Definition: Type.h:2520
clang::VectorType::AltiVecBool
is AltiVec &#39;vector bool ...&#39;
Definition: Type.h:3181
clang::ElaboratedType::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the qualification on this type.
Definition: Type.h:5166
clang::VectorType::AltiVecVector
is AltiVec vector
Definition: Type.h:3175
clang::AutoType::getKeyword
AutoTypeKeyword getKeyword() const
Definition: Type.h:4764
clang::ArrayType::getIndexTypeQualifiers
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2853
clang::Type::getTypeClass
TypeClass getTypeClass() const
Definition: Type.h:1811
clang::DependentTemplateSpecializationType::template_arguments
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5305
clang::AtomicType
Definition: Type.h:5968
clang::EnumType::getDecl
EnumDecl * getDecl() const
Definition: Type.h:4403
clang::RQ_RValue
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1366
clang::ParameterABI
ParameterABI
Kinds of parameter ABI.
Definition: Specifiers.h:309
clang::Qualifiers::getAsString
std::string getAsString() const
Definition: TypePrinter.cpp:1692
clang::DecayedType
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2622
clang::InjectedClassNameType
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4978
clang::DependentAddressSpaceType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:3100
clang::PackExpansionType
Represents a pack expansion of types.
Definition: Type.h:5355
Specifiers.h
Defines various enumerations that describe declaration and type specifiers.
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:156
NestedNameSpecifier.h
clang::TypedefNameDecl
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2916
DwarfFissionKind::Split
clang::AdjustedType
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2585
Decl.h
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::FunctionType::getExtInfo
ExtInfo getExtInfo() const
Definition: Type.h:3624
clang::DependentTemplateSpecializationType::getQualifier
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5290
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
llvm::SaveAndRestore
Definition: LLVM.h:42
clang::CC_C
Definition: Specifiers.h:237
clang::VectorType::getVectorKind
VectorKind getVectorKind() const
Definition: Type.h:3213
clang::Qualifiers::Volatile
Definition: Type.h:146
clang::SourceManager::getPresumedLoc
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
Definition: SourceManager.cpp:1414
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2756
clang::CC_PreserveAll
Definition: Specifiers.h:253
clang::AttributedType::getModifiedType
QualType getModifiedType() const
Definition: Type.h:4450
clang::BlockPointerType
Pointer to a block type.
Definition: Type.h:2639
clang::CC_AAPCS
Definition: Specifiers.h:246
clang::Type::TypeClass
TypeClass
Definition: Type.h:1409
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4370
clang::ComplexType
Complex values, per C99 6.2.5p11.
Definition: Type.h:2477
clang::ArrayType::getIndexTypeCVRQualifiers
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2857
TemplateBase.h
clang::Qualifiers::empty
bool empty() const
Definition: Type.h:414
clang::ConstantArrayType::getSize
const llvm::APInt & getSize() const
Definition: Type.h:2890
clang::AttributedType::getAttrKind
Kind getAttrKind() const
Definition: Type.h:4446
clang::Type::isFunctionType
bool isFunctionType() const
Definition: Type.h:6292
clang::Type::isObjCQualifiedIdType
bool isObjCQualifiedIdType() const
Definition: Type.h:6410
clang::ExtVectorType
ExtVectorType - Extended vector type.
Definition: Type.h:3287
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2673
clang::CC_Win64
Definition: Specifiers.h:243
clang::Qualifiers::isEmptyWhenPrinted
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
Definition: TypePrinter.cpp:1707
clang::TypeOfType::getUnderlyingType
QualType getUnderlyingType() const
Definition: Type.h:4234
clang::CC_AAPCS_VFP
Definition: Specifiers.h:247
clang::ASTContext::getSourceManager
SourceManager & getSourceManager()
Definition: ASTContext.h:662
clang::TemplateArgumentList
A template argument list.
Definition: DeclTemplate.h:210
clang::DependentVectorType::getVectorKind
VectorType::VectorKind getVectorKind() const
Definition: Type.h:3261
clang::TypedefType::getDecl
TypedefNameDecl * getDecl() const
Definition: Type.h:4167
clang::TemplateTypeParmType::getDepth
unsigned getDepth() const
Definition: Type.h:4565
clang::AttributedType
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4425
DeclCXX.h
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
clang::FunctionProtoType::getParamType
QualType getParamType(unsigned i) const
Definition: Type.h:3890
clang::ObjCTypeParamType
Represents a type parameter type in Objective C.
Definition: Type.h:5464
clang::Stmt::printPretty
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
Definition: StmtPrinter.cpp:2383
SourceLocation.h
Defines the clang::SourceLocation class and associated facilities.
clang::TagDecl::getTypedefNameForAnonDecl
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3274
clang::DependentTemplateSpecializationType
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5264
clang::TemplateSpecializationType::template_arguments
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:4920
clang::IncompleteArrayType
Represents a C array with an unspecified size.
Definition: Type.h:2926
clang::QualType::getQualifiers
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6099
clang::ElaboratedType::getNamedType
QualType getNamedType() const
Retrieve the type named by the qualified-id.
Definition: Type.h:5169
clang::UnaryTransformType::EnumUnderlyingType
Definition: Type.h:4292
clang::SubstTemplateTypeParmType::getReplacementType
QualType getReplacementType() const
Gets the type that was substituted for the template parameter.
Definition: Type.h:4624
Expr.h
clang::BuiltinType
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2391
skipTopLevelReferences
static QualType skipTopLevelReferences(QualType T)
Definition: TypePrinter.cpp:400
clang::ObjCProtocolQualifiers::qual_empty
bool qual_empty() const
Definition: Type.h:5442
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:276
clang::VectorType::getNumElements
unsigned getNumElements() const
Definition: Type.h:3204
clang::PipeType::isReadOnly
bool isReadOnly() const
Definition: Type.h:6035
clang::DependentAddressSpaceType
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:3086
clang::TemplateSpecializationType
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4841
clang::TypedefType
Definition: Type.h:4151
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:249
clang::DeclContext::isTranslationUnit
bool isTranslationUnit() const
Definition: DeclBase.h:1823
clang::TemplateTypeParmType
Definition: Type.h:4522
clang::VariableArrayType
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2971
clang::ETK_None
No keyword precedes the qualified type name.
Definition: Type.h:5071
clang::DependentVectorType::getElementType
QualType getElementType() const
Definition: Type.h:3259
clang::AttributedType::getImmediateNullability
llvm::Optional< NullabilityKind > getImmediateNullability() const
Definition: Type.cpp:3823
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2872
clang::FunctionType::ExtInfo
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3466
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:418
clang::MemberPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2776
clang::ParameterABI::SwiftIndirectResult
This parameter (which must have pointer type) is a Swift indirect result parameter.
clang::DependentTemplateSpecializationType::getIdentifier
const IdentifierInfo * getIdentifier() const
Definition: Type.h:5291
clang::DependentSizedExtVectorType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3143