clang 10.0.0git

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