/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp

Bug Summary

File:	tools/clang/lib/AST/TypePrinter.cpp
Warning:	line 1540, column 11 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name TypePrinter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn373517/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn373517/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn373517=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-02-234743-9763-1 -x c++ /build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp
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//===----------------------------------------------------------------------===//

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>

45using namespace clang;

47namespace {

/// RAII object that enables printing of the ARC __strong lifetime
/// qualifier.
class IncludeStrongLifetimeRAII {
  PrintingPolicy &Policy;
  bool Old;

public:
  explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
      : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
      if (!Policy.SuppressLifetimeQualifiers)
        Policy.SuppressStrongLifetime = false;
  }

  ~IncludeStrongLifetimeRAII() {
    Policy.SuppressStrongLifetime = Old;
  }
};

class ParamPolicyRAII {
  PrintingPolicy &Policy;
  bool Old;

public:
  explicit ParamPolicyRAII(PrintingPolicy &Policy)
      : Policy(Policy), Old(Policy.SuppressSpecifiers) {
    Policy.SuppressSpecifiers = false;
  }

  ~ParamPolicyRAII() {
    Policy.SuppressSpecifiers = Old;
  }
};

class ElaboratedTypePolicyRAII {
  PrintingPolicy &Policy;
  bool SuppressTagKeyword;
  bool SuppressScope;

public:
  explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
    SuppressTagKeyword = Policy.SuppressTagKeyword;
    SuppressScope = Policy.SuppressScope;
    Policy.SuppressTagKeyword = true;
    Policy.SuppressScope = true;
  }

  ~ElaboratedTypePolicyRAII() {
    Policy.SuppressTagKeyword = SuppressTagKeyword;
    Policy.SuppressScope = SuppressScope;
  }
};

class TypePrinter {
  PrintingPolicy Policy;
  unsigned Indentation;
  bool HasEmptyPlaceHolder = false;
  bool InsideCCAttribute = false;

public:
  explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0)
      : Policy(Policy), Indentation(Indentation) {}

  void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
             StringRef PlaceHolder);
  void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);

  static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
  void spaceBeforePlaceHolder(raw_ostream &OS);
  void printTypeSpec(NamedDecl *D, raw_ostream &OS);

  void printBefore(QualType T, raw_ostream &OS);
  void printAfter(QualType T, raw_ostream &OS);
  void AppendScope(DeclContext *DC, raw_ostream &OS);
  void printTag(TagDecl *T, raw_ostream &OS);
  void printFunctionAfter(const FunctionType::ExtInfo &Info, raw_ostream &OS);
124#define ABSTRACT_TYPE(CLASS, PARENT)
125#define TYPE(CLASS, PARENT) \
  void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \
  void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
128#include "clang/AST/TypeNodes.inc"

private:
  void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
  void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
};

135} // namespace

137static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals,
                             bool HasRestrictKeyword) {
bool appendSpace = false;
if (TypeQuals & Qualifiers::Const) {
  OS << "const";
  appendSpace = true;
}
if (TypeQuals & Qualifiers::Volatile) {
  if (appendSpace) OS << ' ';
  OS << "volatile";
  appendSpace = true;
}
if (TypeQuals & Qualifiers::Restrict) {
  if (appendSpace) OS << ' ';
  if (HasRestrictKeyword) {
    OS << "restrict";
  } else {
    OS << "__restrict";
  }
}
157}

159void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
if (!HasEmptyPlaceHolder)
  OS << ' ';
162}

164static SplitQualType splitAccordingToPolicy(QualType QT,
                                          const PrintingPolicy &Policy) {
if (Policy.PrintCanonicalTypes)
  QT = QT.getCanonicalType();
return QT.split();
169}

171void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) {
SplitQualType split = splitAccordingToPolicy(t, Policy);
print(split.Ty, split.Quals, OS, PlaceHolder);
174}

176void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
                      StringRef PlaceHolder) {
if (!T) {
  OS << "NULL TYPE";
  return;
}

SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());

printBefore(T, Quals, OS);
OS << PlaceHolder;
printAfter(T, Quals, OS);
188}

190bool TypePrinter::canPrefixQualifiers(const Type *T,
                                    bool &NeedARCStrongQualifier) {
// CanPrefixQualifiers - We prefer to print type qualifiers before the type,
// so that we get "const int" instead of "int const", but we can't do this if
// the type is complex.  For example if the type is "int*", we *must* print
// "int * const", printing "const int *" is different.  Only do this when the
// type expands to a simple string.
bool CanPrefixQualifiers = false;
NeedARCStrongQualifier = false;
Type::TypeClass TC = T->getTypeClass();
if (const auto *AT = dyn_cast<AutoType>(T))
  TC = AT->desugar()->getTypeClass();
if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(T))
  TC = Subst->getReplacementType()->getTypeClass();

switch (TC) {
  case Type::Auto:
  case Type::Builtin:
  case Type::Complex:
  case Type::UnresolvedUsing:
  case Type::Typedef:
  case Type::TypeOfExpr:
  case Type::TypeOf:
  case Type::Decltype:
  case Type::UnaryTransform:
  case Type::Record:
  case Type::Enum:
  case Type::Elaborated:
  case Type::TemplateTypeParm:
  case Type::SubstTemplateTypeParmPack:
  case Type::DeducedTemplateSpecialization:
  case Type::TemplateSpecialization:
  case Type::InjectedClassName:
  case Type::DependentName:
  case Type::DependentTemplateSpecialization:
  case Type::ObjCObject:
  case Type::ObjCTypeParam:
  case Type::ObjCInterface:
  case Type::Atomic:
  case Type::Pipe:
    CanPrefixQualifiers = true;
    break;

  case Type::ObjCObjectPointer:
    CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
      T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
    break;

  case Type::ConstantArray:
  case Type::IncompleteArray:
  case Type::VariableArray:
  case Type::DependentSizedArray:
    NeedARCStrongQualifier = true;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];

  case Type::Adjusted:
  case Type::Decayed:
  case Type::Pointer:
  case Type::BlockPointer:
  case Type::LValueReference:
  case Type::RValueReference:
  case Type::MemberPointer:
  case Type::DependentAddressSpace:
  case Type::DependentVector:
  case Type::DependentSizedExtVector:
  case Type::Vector:
  case Type::ExtVector:
  case Type::FunctionProto:
  case Type::FunctionNoProto:
  case Type::Paren:
  case Type::PackExpansion:
  case Type::SubstTemplateTypeParm:
  case Type::MacroQualified:
    CanPrefixQualifiers = false;
    break;

  case Type::Attributed: {
    // We still want to print the address_space before the type if it is an
    // address_space attribute.
    const auto *AttrTy = cast<AttributedType>(T);
    CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace;
  }
}

return CanPrefixQualifiers;
275}

277void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
SplitQualType Split = splitAccordingToPolicy(T, Policy);

// If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
// at this level.
Qualifiers Quals = Split.Quals;
if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
  Quals -= QualType(Subst, 0).getQualifiers();

printBefore(Split.Ty, Quals, OS);
287}

289/// Prints the part of the type string before an identifier, e.g. for
290/// "int foo[10]" it prints "int ".
291void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
if (Policy.SuppressSpecifiers && T->isSpecifierType())
  return;

SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder);

// Print qualifiers as appropriate.

bool CanPrefixQualifiers = false;
bool NeedARCStrongQualifier = false;
CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier);

if (CanPrefixQualifiers && !Quals.empty()) {
  if (NeedARCStrongQualifier) {
    IncludeStrongLifetimeRAII Strong(Policy);
    Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
  } else {
    Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
  }
}

bool hasAfterQuals = false;
if (!CanPrefixQualifiers && !Quals.empty()) {
  hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy);
  if (hasAfterQuals)
    HasEmptyPlaceHolder = false;
}

switch (T->getTypeClass()) {
320#define ABSTRACT_TYPE(CLASS, PARENT)
321#define TYPE(CLASS, PARENT) case Type::CLASS: \
  print##CLASS##Before(cast<CLASS##Type>(T), OS); \
  break;
324#include "clang/AST/TypeNodes.inc"
}

if (hasAfterQuals) {
  if (NeedARCStrongQualifier) {
    IncludeStrongLifetimeRAII Strong(Policy);
    Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
  } else {
    Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
  }
}
335}

337void TypePrinter::printAfter(QualType t, raw_ostream &OS) {
SplitQualType split = splitAccordingToPolicy(t, Policy);
printAfter(split.Ty, split.Quals, OS);
340}

342/// Prints the part of the type string after an identifier, e.g. for
343/// "int foo[10]" it prints "[10]".
344void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
switch (T->getTypeClass()) {
346#define ABSTRACT_TYPE(CLASS, PARENT)
347#define TYPE(CLASS, PARENT) case Type::CLASS: \
  print##CLASS##After(cast<CLASS##Type>(T), OS); \
  break;
350#include "clang/AST/TypeNodes.inc"
}
352}

354void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
OS << T->getName(Policy);
spaceBeforePlaceHolder(OS);
357}

359void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {}

361void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
OS << "_Complex ";
printBefore(T->getElementType(), OS);
364}

366void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
printAfter(T->getElementType(), OS);
368}

370void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printBefore(T->getPointeeType(), OS);
// Handle things like 'int (*A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(T->getPointeeType()))
  OS << '(';
OS << '*';
379}

381void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
// Handle things like 'int (*A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(T->getPointeeType()))
  OS << ')';
printAfter(T->getPointeeType(), OS);
389}

391void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
                                        raw_ostream &OS) {
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printBefore(T->getPointeeType(), OS);
OS << '^';
396}

398void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
                                        raw_ostream &OS) {
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printAfter(T->getPointeeType(), OS);
402}

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.
406static QualType skipTopLevelReferences(QualType T) {
if (auto *Ref = T->getAs<ReferenceType>())
  return skipTopLevelReferences(Ref->getPointeeTypeAsWritten());
return T;
410}

412void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
                                           raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
printBefore(Inner, OS);
// Handle things like 'int (&A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(Inner))
  OS << '(';
OS << '&';
423}

425void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
                                          raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
// Handle things like 'int (&A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(Inner))
  OS << ')';
printAfter(Inner, OS);
435}

437void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
                                           raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
printBefore(Inner, OS);
// Handle things like 'int (&&A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(Inner))
  OS << '(';
OS << "&&";
448}

450void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
                                          raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
// Handle things like 'int (&&A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(Inner))
  OS << ')';
printAfter(Inner, OS);
460}

462void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
                                         raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printBefore(T->getPointeeType(), OS);
// Handle things like 'int (Cls::*A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(T->getPointeeType()))
  OS << '(';

PrintingPolicy InnerPolicy(Policy);
InnerPolicy.IncludeTagDefinition = false;
TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());

OS << "::*";
477}

479void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
                                        raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
// Handle things like 'int (Cls::*A)[4];' correctly.
// FIXME: this should include vectors, but vectors use attributes I guess.
if (isa<ArrayType>(T->getPointeeType()))
  OS << ')';
printAfter(T->getPointeeType(), OS);
488}

490void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
                                         raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printBefore(T->getElementType(), OS);
495}

497void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
                                        raw_ostream &OS) {
OS << '[';
if (T->getIndexTypeQualifiers().hasQualifiers()) {
  AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(),
                     Policy.Restrict);
  OS << ' ';
}

if (T->getSizeModifier() == ArrayType::Static)
  OS << "static ";

OS << T->getSize().getZExtValue() << ']';
printAfter(T->getElementType(), OS);
511}

513void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
                                           raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printBefore(T->getElementType(), OS);
518}

520void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
                                          raw_ostream &OS) {
OS << "[]";
printAfter(T->getElementType(), OS);
524}

526void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
                                         raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printBefore(T->getElementType(), OS);
531}

533void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
                                        raw_ostream &OS) {
OS << '[';
if (T->getIndexTypeQualifiers().hasQualifiers()) {
  AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict);
  OS << ' ';
}

if (T->getSizeModifier() == VariableArrayType::Static)
  OS << "static ";
else if (T->getSizeModifier() == VariableArrayType::Star)
  OS << '*';

if (T->getSizeExpr())
  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
OS << ']';

printAfter(T->getElementType(), OS);
551}

553void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) {
// Print the adjusted representation, otherwise the adjustment will be
// invisible.
printBefore(T->getAdjustedType(), OS);
557}

559void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
printAfter(T->getAdjustedType(), OS);
561}

563void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
// Print as though it's a pointer.
printAdjustedBefore(T, OS);
566}

568void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
printAdjustedAfter(T, OS);
570}

572void TypePrinter::printDependentSizedArrayBefore(
                                             const DependentSizedArrayType *T,
                                             raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
printBefore(T->getElementType(), OS);
578}

580void TypePrinter::printDependentSizedArrayAfter(
                                             const DependentSizedArrayType *T,
                                             raw_ostream &OS) {
OS << '[';
if (T->getSizeExpr())
  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
OS << ']';
printAfter(T->getElementType(), OS);
588}

590void TypePrinter::printDependentAddressSpaceBefore(
  const DependentAddressSpaceType *T, raw_ostream &OS) {
printBefore(T->getPointeeType(), OS);
593}

595void TypePrinter::printDependentAddressSpaceAfter(
  const DependentAddressSpaceType *T, raw_ostream &OS) {
OS << " __attribute__((address_space(";
if (T->getAddrSpaceExpr())
  T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy);
OS << ")))";
printAfter(T->getPointeeType(), OS);
602}

604void TypePrinter::printDependentSizedExtVectorBefore(
                                        const DependentSizedExtVectorType *T,
                                        raw_ostream &OS) {
printBefore(T->getElementType(), OS);
608}

610void TypePrinter::printDependentSizedExtVectorAfter(
                                        const DependentSizedExtVectorType *T,
                                        raw_ostream &OS) {
OS << " __attribute__((ext_vector_type(";
if (T->getSizeExpr())
  T->getSizeExpr()->printPretty(OS, nullptr, Policy);
OS << ")))";
printAfter(T->getElementType(), OS);
618}

620void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
switch (T->getVectorKind()) {
case VectorType::AltiVecPixel:
  OS << "__vector __pixel ";
  break;
case VectorType::AltiVecBool:
  OS << "__vector __bool ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::AltiVecVector:
  OS << "__vector ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::NeonVector:
  OS << "__attribute__((neon_vector_type("
     << T->getNumElements() << "))) ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::NeonPolyVector:
  OS << "__attribute__((neon_polyvector_type(" <<
        T->getNumElements() << "))) ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::GenericVector: {
  // FIXME: We prefer to print the size directly here, but have no way
  // to get the size of the type.
  OS << "__attribute__((__vector_size__("
     << T->getNumElements()
     << " * sizeof(";
  print(T->getElementType(), OS, StringRef());
  OS << ")))) ";
  printBefore(T->getElementType(), OS);
  break;
}
}
655}

657void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
printAfter(T->getElementType(), OS);
659}

661void TypePrinter::printDependentVectorBefore(
  const DependentVectorType *T, raw_ostream &OS) {
switch (T->getVectorKind()) {
case VectorType::AltiVecPixel:
  OS << "__vector __pixel ";
  break;
case VectorType::AltiVecBool:
  OS << "__vector __bool ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::AltiVecVector:
  OS << "__vector ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::NeonVector:
  OS << "__attribute__((neon_vector_type(";
  if (T->getSizeExpr())
    T->getSizeExpr()->printPretty(OS, nullptr, Policy);
  OS << "))) ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::NeonPolyVector:
  OS << "__attribute__((neon_polyvector_type(";
  if (T->getSizeExpr())
    T->getSizeExpr()->printPretty(OS, nullptr, Policy);
  OS << "))) ";
  printBefore(T->getElementType(), OS);
  break;
case VectorType::GenericVector: {
  // FIXME: We prefer to print the size directly here, but have no way
  // to get the size of the type.
  OS << "__attribute__((__vector_size__(";
  if (T->getSizeExpr())
    T->getSizeExpr()->printPretty(OS, nullptr, Policy);
  OS << " * sizeof(";
  print(T->getElementType(), OS, StringRef());
  OS << ")))) ";
  printBefore(T->getElementType(), OS);
  break;
}
}
702}

704void TypePrinter::printDependentVectorAfter(
  const DependentVectorType *T, raw_ostream &OS) {
printAfter(T->getElementType(), OS);
707}

709void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
                                     raw_ostream &OS) {
printBefore(T->getElementType(), OS);
712}

714void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
printAfter(T->getElementType(), OS);
OS << " __attribute__((ext_vector_type(";
OS << T->getNumElements();
OS << ")))";
719}

721void
722FunctionProtoType::printExceptionSpecification(raw_ostream &OS,
                                             const PrintingPolicy &Policy)
                                                                       const {
if (hasDynamicExceptionSpec()) {
  OS << " throw(";
  if (getExceptionSpecType() == EST_MSAny)
    OS << "...";
  else
    for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) {
      if (I)
        OS << ", ";

      OS << getExceptionType(I).stream(Policy);
    }
  OS << ')';
} else if (EST_NoThrow == getExceptionSpecType()) {
  OS << " __attribute__((nothrow))";
} else if (isNoexceptExceptionSpec(getExceptionSpecType())) {
  OS << " noexcept";
  // FIXME:Is it useful to print out the expression for a non-dependent
  // noexcept specification?
  if (isComputedNoexcept(getExceptionSpecType())) {
    OS << '(';
    if (getNoexceptExpr())
      getNoexceptExpr()->printPretty(OS, nullptr, Policy);
    OS << ')';
  }
}
750}

752void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
                                         raw_ostream &OS) {
if (T->hasTrailingReturn()) {
  OS << "auto ";
  if (!HasEmptyPlaceHolder)
    OS << '(';
} else {
  // If needed for precedence reasons, wrap the inner part in grouping parens.
  SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
  printBefore(T->getReturnType(), OS);
  if (!PrevPHIsEmpty.get())
    OS << '(';
}
765}

767StringRef clang::getParameterABISpelling(ParameterABI ABI) {
switch (ABI) {
case ParameterABI::Ordinary:
  llvm_unreachable("asking for spelling of ordinary parameter ABI")::llvm::llvm_unreachable_internal("asking for spelling of ordinary parameter ABI"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 770);
case ParameterABI::SwiftContext:
  return "swift_context";
case ParameterABI::SwiftErrorResult:
  return "swift_error_result";
case ParameterABI::SwiftIndirectResult:
  return "swift_indirect_result";
}
llvm_unreachable("bad parameter ABI kind")::llvm::llvm_unreachable_internal("bad parameter ABI kind", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 778);
779}

781void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
                                        raw_ostream &OS) {
// If needed for precedence reasons, wrap the inner part in grouping parens.
if (!HasEmptyPlaceHolder)
  OS << ')';
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);

OS << '(';
{
  ParamPolicyRAII ParamPolicy(Policy);
  for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) {
    if (i) OS << ", ";

    auto EPI = T->getExtParameterInfo(i);
    if (EPI.isConsumed()) OS << "__attribute__((ns_consumed)) ";
    if (EPI.isNoEscape())
      OS << "__attribute__((noescape)) ";
    auto ABI = EPI.getABI();
    if (ABI != ParameterABI::Ordinary)
      OS << "__attribute__((" << getParameterABISpelling(ABI) << ")) ";

    print(T->getParamType(i), OS, StringRef());
  }
}

if (T->isVariadic()) {
  if (T->getNumParams())
    OS << ", ";
  OS << "...";
} else if (T->getNumParams() == 0 && Policy.UseVoidForZeroParams) {
  // Do not emit int() if we have a proto, emit 'int(void)'.
  OS << "void";
}

OS << ')';

FunctionType::ExtInfo Info = T->getExtInfo();

printFunctionAfter(Info, OS);

if (!T->getMethodQuals().empty())
  OS << " " << T->getMethodQuals().getAsString();

switch (T->getRefQualifier()) {
case RQ_None:
  break;

case RQ_LValue:
  OS << " &";
  break;

case RQ_RValue:
  OS << " &&";
  break;
}
T->printExceptionSpecification(OS, Policy);

if (T->hasTrailingReturn()) {
  OS << " -> ";
  print(T->getReturnType(), OS, StringRef());
} else
  printAfter(T->getReturnType(), OS);
843}

845void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info,
                                   raw_ostream &OS) {
if (!InsideCCAttribute) {
  switch (Info.getCC()) {
  case CC_C:
    // The C calling convention is the default on the vast majority of platforms
    // we support.  If the user wrote it explicitly, it will usually be printed
    // while traversing the AttributedType.  If the type has been desugared, let
    // the canonical spelling be the implicit calling convention.
    // FIXME: It would be better to be explicit in certain contexts, such as a
    // cdecl function typedef used to declare a member function with the
    // Microsoft C++ ABI.
    break;
  case CC_X86StdCall:
    OS << " __attribute__((stdcall))";
    break;
  case CC_X86FastCall:
    OS << " __attribute__((fastcall))";
    break;
  case CC_X86ThisCall:
    OS << " __attribute__((thiscall))";
    break;
  case CC_X86VectorCall:
    OS << " __attribute__((vectorcall))";
    break;
  case CC_X86Pascal:
    OS << " __attribute__((pascal))";
    break;
  case CC_AAPCS:
    OS << " __attribute__((pcs(\"aapcs\")))";
    break;
  case CC_AAPCS_VFP:
    OS << " __attribute__((pcs(\"aapcs-vfp\")))";
    break;
  case CC_AArch64VectorCall:
    OS << "__attribute__((aarch64_vector_pcs))";
    break;
  case CC_IntelOclBicc:
    OS << " __attribute__((intel_ocl_bicc))";
    break;
  case CC_Win64:
    OS << " __attribute__((ms_abi))";
    break;
  case CC_X86_64SysV:
    OS << " __attribute__((sysv_abi))";
    break;
  case CC_X86RegCall:
    OS << " __attribute__((regcall))";
    break;
  case CC_SpirFunction:
  case CC_OpenCLKernel:
    // Do nothing. These CCs are not available as attributes.
    break;
  case CC_Swift:
    OS << " __attribute__((swiftcall))";
    break;
  case CC_PreserveMost:
    OS << " __attribute__((preserve_most))";
    break;
  case CC_PreserveAll:
    OS << " __attribute__((preserve_all))";
    break;
  }
}

if (Info.getNoReturn())
  OS << " __attribute__((noreturn))";
if (Info.getProducesResult())
  OS << " __attribute__((ns_returns_retained))";
if (Info.getRegParm())
  OS << " __attribute__((regparm ("
     << Info.getRegParm() << ")))";
if (Info.getNoCallerSavedRegs())
  OS << " __attribute__((no_caller_saved_registers))";
if (Info.getNoCfCheck())
  OS << " __attribute__((nocf_check))";
921}

923void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
                                           raw_ostream &OS) {
// If needed for precedence reasons, wrap the inner part in grouping parens.
SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
printBefore(T->getReturnType(), OS);
if (!PrevPHIsEmpty.get())
  OS << '(';
930}

932void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
                                          raw_ostream &OS) {
// If needed for precedence reasons, wrap the inner part in grouping parens.
if (!HasEmptyPlaceHolder)
  OS << ')';
SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);

OS << "()";
printFunctionAfter(T->getExtInfo(), OS);
printAfter(T->getReturnType(), OS);
942}

944void TypePrinter::printTypeSpec(NamedDecl *D, raw_ostream &OS) {

// Compute the full nested-name-specifier for this type.
// In C, this will always be empty except when the type
// being printed is anonymous within other Record.
if (!Policy.SuppressScope)
  AppendScope(D->getDeclContext(), OS);

IdentifierInfo *II = D->getIdentifier();
OS << II->getName();
spaceBeforePlaceHolder(OS);
955}

957void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
                                           raw_ostream &OS) {
printTypeSpec(T->getDecl(), OS);
960}

962void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
                                          raw_ostream &OS) {}

965void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
printTypeSpec(T->getDecl(), OS);
967}

969void TypePrinter::printMacroQualifiedBefore(const MacroQualifiedType *T,
                                          raw_ostream &OS) {
StringRef MacroName = T->getMacroIdentifier()->getName();
OS << MacroName << " ";

// Since this type is meant to print the macro instead of the whole attribute,
// we trim any attributes and go directly to the original modified type.
printBefore(T->getModifiedType(), OS);
977}

979void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T,
                                         raw_ostream &OS) {
printAfter(T->getModifiedType(), OS);
982}

984void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}

986void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
                                      raw_ostream &OS) {
OS << "typeof ";
if (T->getUnderlyingExpr())
  T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
spaceBeforePlaceHolder(OS);
992}

994void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
                                     raw_ostream &OS) {}

997void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
OS << "typeof(";
print(T->getUnderlyingType(), OS, StringRef());
OS << ')';
spaceBeforePlaceHolder(OS);
1002}

1004void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {}

1006void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
OS << "decltype(";
if (T->getUnderlyingExpr())
  T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
OS << ')';
spaceBeforePlaceHolder(OS);
1012}

1014void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}

1016void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
                                          raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);

switch (T->getUTTKind()) {
  case UnaryTransformType::EnumUnderlyingType:
    OS << "__underlying_type(";
    print(T->getBaseType(), OS, StringRef());
    OS << ')';
    spaceBeforePlaceHolder(OS);
    return;
}

printBefore(T->getBaseType(), OS);
1030}

1032void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
                                         raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);

switch (T->getUTTKind()) {
  case UnaryTransformType::EnumUnderlyingType:
    return;
}

printAfter(T->getBaseType(), OS);
1042}

1044void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
// If the type has been deduced, do not print 'auto'.
if (!T->getDeducedType().isNull()) {
  printBefore(T->getDeducedType(), OS);
} else {
  switch (T->getKeyword()) {
  case AutoTypeKeyword::Auto: OS << "auto"; break;
  case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
  case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break;
  }
  spaceBeforePlaceHolder(OS);
}
1056}

1058void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
// If the type has been deduced, do not print 'auto'.
if (!T->getDeducedType().isNull())
  printAfter(T->getDeducedType(), OS);
1062}

1064void TypePrinter::printDeducedTemplateSpecializationBefore(
  const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
// If the type has been deduced, print the deduced type.
if (!T->getDeducedType().isNull()) {
  printBefore(T->getDeducedType(), OS);
} else {
  IncludeStrongLifetimeRAII Strong(Policy);
  T->getTemplateName().print(OS, Policy);
  spaceBeforePlaceHolder(OS);
}
1074}

1076void TypePrinter::printDeducedTemplateSpecializationAfter(
  const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
// If the type has been deduced, print the deduced type.
if (!T->getDeducedType().isNull())
  printAfter(T->getDeducedType(), OS);
1081}

1083void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);

OS << "_Atomic(";
print(T->getValueType(), OS, StringRef());
OS << ')';
spaceBeforePlaceHolder(OS);
1090}

1092void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {}

1094void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);

if (T->isReadOnly())
  OS << "read_only ";
else
  OS << "write_only ";
OS << "pipe ";
print(T->getElementType(), OS, StringRef());
spaceBeforePlaceHolder(OS);
1104}

1106void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {}

1108/// Appends the given scope to the end of a string.
1109void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
if (DC->isTranslationUnit()) return;
if (DC->isFunctionOrMethod()) return;
AppendScope(DC->getParent(), OS);

if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
  if (Policy.SuppressUnwrittenScope &&
      (NS->isAnonymousNamespace() || NS->isInline()))
    return;
  if (NS->getIdentifier())
    OS << NS->getName() << "::";
  else
    OS << "(anonymous namespace)::";
} else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
  IncludeStrongLifetimeRAII Strong(Policy);
  OS << Spec->getIdentifier()->getName();
  const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
  printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
  OS << "::";
} else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
  if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
    OS << Typedef->getIdentifier()->getName() << "::";
  else if (Tag->getIdentifier())
    OS << Tag->getIdentifier()->getName() << "::";
  else
    return;
}
1136}

1138void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
if (Policy.IncludeTagDefinition) {
  PrintingPolicy SubPolicy = Policy;
  SubPolicy.IncludeTagDefinition = false;
  D->print(OS, SubPolicy, Indentation);
  spaceBeforePlaceHolder(OS);
  return;
}

bool HasKindDecoration = false;

// We don't print tags unless this is an elaborated type.
// In C, we just assume every RecordType is an elaborated type.
if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) {
  HasKindDecoration = true;
  OS << D->getKindName();
  OS << ' ';
}

// Compute the full nested-name-specifier for this type.
// In C, this will always be empty except when the type
// being printed is anonymous within other Record.
if (!Policy.SuppressScope)
  AppendScope(D->getDeclContext(), OS);

if (const IdentifierInfo *II = D->getIdentifier())
  OS << II->getName();
else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
  assert(Typedef->getIdentifier() && "Typedef without identifier?")((Typedef->getIdentifier() && "Typedef without identifier?"
) ? static_cast<void> (0) : __assert_fail ("Typedef->getIdentifier() && \"Typedef without identifier?\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 1166, __PRETTY_FUNCTION__));
  OS << Typedef->getIdentifier()->getName();
} else {
  // Make an unambiguous representation for anonymous types, e.g.
  //   (anonymous enum at /usr/include/string.h:120:9)
  OS << (Policy.MSVCFormatting ? '`' : '(');

  if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
    OS << "lambda";
    HasKindDecoration = true;
  } else {
    OS << "anonymous";
  }

  if (Policy.AnonymousTagLocations) {
    // Suppress the redundant tag keyword if we just printed one.
    // We don't have to worry about ElaboratedTypes here because you can't
    // refer to an anonymous type with one.
    if (!HasKindDecoration)
      OS << " " << D->getKindName();

    PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
        D->getLocation());
    if (PLoc.isValid()) {
      OS << " at ";
      StringRef File = PLoc.getFilename();
      if (Policy.RemapFilePaths)
        OS << Policy.remapPath(File);
      else
        OS << File;
      OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
    }
  }

  OS << (Policy.MSVCFormatting ? '\'' : ')');
}

// If this is a class template specialization, print the template
// arguments.
if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
  ArrayRef<TemplateArgument> Args;
  if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
    const TemplateSpecializationType *TST =
      cast<TemplateSpecializationType>(TAW->getType());
    Args = TST->template_arguments();
  } else {
    const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
    Args = TemplateArgs.asArray();
  }
  IncludeStrongLifetimeRAII Strong(Policy);
  printTemplateArgumentList(OS, Args, Policy);
}

spaceBeforePlaceHolder(OS);
1220}

1222void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
printTag(T->getDecl(), OS);
1224}

1226void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}

1228void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
printTag(T->getDecl(), OS);
1230}

1232void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}

1234void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
                                            raw_ostream &OS) {
if (IdentifierInfo *Id = T->getIdentifier())
  OS << Id->getName();
else {
  bool IsLambdaAutoParam = false;
  if (auto D = T->getDecl()) {
    if (auto M = dyn_cast_or_null<CXXMethodDecl>(D->getDeclContext()))
      IsLambdaAutoParam = D->isImplicit() && M->getParent()->isLambda();
  }

  if (IsLambdaAutoParam)
    OS << "auto";
  else
    OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
}
spaceBeforePlaceHolder(OS);
1251}

1253void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
                                           raw_ostream &OS) {}

1256void TypePrinter::printSubstTemplateTypeParmBefore(
                                           const SubstTemplateTypeParmType *T,
                                           raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
printBefore(T->getReplacementType(), OS);
1261}

1263void TypePrinter::printSubstTemplateTypeParmAfter(
                                           const SubstTemplateTypeParmType *T,
                                           raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
printAfter(T->getReplacementType(), OS);
1268}

1270void TypePrinter::printSubstTemplateTypeParmPackBefore(
                                      const SubstTemplateTypeParmPackType *T,
                                      raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1275}

1277void TypePrinter::printSubstTemplateTypeParmPackAfter(
                                      const SubstTemplateTypeParmPackType *T,
                                      raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1282}

1284void TypePrinter::printTemplateSpecializationBefore(
                                          const TemplateSpecializationType *T,
                                          raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);
T->getTemplateName().print(OS, Policy);

printTemplateArgumentList(OS, T->template_arguments(), Policy);
spaceBeforePlaceHolder(OS);
1292}

1294void TypePrinter::printTemplateSpecializationAfter(
                                          const TemplateSpecializationType *T,
                                          raw_ostream &OS) {}

1298void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
                                             raw_ostream &OS) {
printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1301}

1303void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
                                             raw_ostream &OS) {}

1306void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
                                      raw_ostream &OS) {
if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
  TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
  assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&((OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr
() && "OwnedTagDecl expected to be a declaration for the type"
) ? static_cast<void> (0) : __assert_fail ("OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() && \"OwnedTagDecl expected to be a declaration for the type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 1311, __PRETTY_FUNCTION__))
         "OwnedTagDecl expected to be a declaration for the type")((OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr
() && "OwnedTagDecl expected to be a declaration for the type"
) ? static_cast<void> (0) : __assert_fail ("OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() && \"OwnedTagDecl expected to be a declaration for the type\""
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 1311, __PRETTY_FUNCTION__));
  PrintingPolicy SubPolicy = Policy;
  SubPolicy.IncludeTagDefinition = false;
  OwnedTagDecl->print(OS, SubPolicy, Indentation);
  spaceBeforePlaceHolder(OS);
  return;
}

// The tag definition will take care of these.
if (!Policy.IncludeTagDefinition)
{
  OS << TypeWithKeyword::getKeywordName(T->getKeyword());
  if (T->getKeyword() != ETK_None)
    OS << " ";
  NestedNameSpecifier *Qualifier = T->getQualifier();
  if (Qualifier)
    Qualifier->print(OS, Policy);
}

ElaboratedTypePolicyRAII PolicyRAII(Policy);
printBefore(T->getNamedType(), OS);
1332}

1334void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
                                      raw_ostream &OS) {
if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
  return;
ElaboratedTypePolicyRAII PolicyRAII(Policy);
printAfter(T->getNamedType(), OS);
1340}

1342void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
  printBefore(T->getInnerType(), OS);
  OS << '(';
} else
  printBefore(T->getInnerType(), OS);
1348}

1350void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
  OS << ')';
  printAfter(T->getInnerType(), OS);
} else
  printAfter(T->getInnerType(), OS);
1356}

1358void TypePrinter::printDependentNameBefore(const DependentNameType *T,
                                         raw_ostream &OS) {
OS << TypeWithKeyword::getKeywordName(T->getKeyword());
if (T->getKeyword() != ETK_None)
  OS << " ";

T->getQualifier()->print(OS, Policy);

OS << T->getIdentifier()->getName();
spaceBeforePlaceHolder(OS);
1368}

1370void TypePrinter::printDependentNameAfter(const DependentNameType *T,
                                        raw_ostream &OS) {}

1373void TypePrinter::printDependentTemplateSpecializationBefore(
      const DependentTemplateSpecializationType *T, raw_ostream &OS) {
IncludeStrongLifetimeRAII Strong(Policy);

OS << TypeWithKeyword::getKeywordName(T->getKeyword());
if (T->getKeyword() != ETK_None)
  OS << " ";

if (T->getQualifier())
  T->getQualifier()->print(OS, Policy);
OS << T->getIdentifier()->getName();
printTemplateArgumentList(OS, T->template_arguments(), Policy);
spaceBeforePlaceHolder(OS);
1386}

1388void TypePrinter::printDependentTemplateSpecializationAfter(
      const DependentTemplateSpecializationType *T, raw_ostream &OS) {}

1391void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
                                         raw_ostream &OS) {
printBefore(T->getPattern(), OS);
1394}

1396void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
                                        raw_ostream &OS) {
printAfter(T->getPattern(), OS);
OS << "...";
1400}

1402void TypePrinter::printAttributedBefore(const AttributedType *T,
                                      raw_ostream &OS) {
// FIXME: Generate this with TableGen.

// Prefer the macro forms of the GC and ownership qualifiers.
if (T->getAttrKind() == attr::ObjCGC ||
    T->getAttrKind() == attr::ObjCOwnership)
  return printBefore(T->getEquivalentType(), OS);

if (T->getAttrKind() == attr::ObjCKindOf)
  OS << "__kindof ";

if (T->getAttrKind() == attr::AddressSpace)
  printBefore(T->getEquivalentType(), OS);
else
  printBefore(T->getModifiedType(), OS);

if (T->isMSTypeSpec()) {
  switch (T->getAttrKind()) {
  default: return;
  case attr::Ptr32: OS << " __ptr32"; break;
  case attr::Ptr64: OS << " __ptr64"; break;
  case attr::SPtr: OS << " __sptr"; break;
  case attr::UPtr: OS << " __uptr"; break;
  }
  spaceBeforePlaceHolder(OS);
}

// Print nullability type specifiers.
if (T->getImmediateNullability()) {
  if (T->getAttrKind() == attr::TypeNonNull)
    OS << " _Nonnull";
  else if (T->getAttrKind() == attr::TypeNullable)
    OS << " _Nullable";
  else if (T->getAttrKind() == attr::TypeNullUnspecified)
    OS << " _Null_unspecified";
  else
    llvm_unreachable("unhandled nullability")::llvm::llvm_unreachable_internal("unhandled nullability", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 1439);
  spaceBeforePlaceHolder(OS);
}
1442}

1444void TypePrinter::printAttributedAfter(const AttributedType *T,
                                     raw_ostream &OS) {
// FIXME: Generate this with TableGen.

// Prefer the macro forms of the GC and ownership qualifiers.
if (T->getAttrKind() == attr::ObjCGC ||
1
Assuming the condition is false→
3
←
Taking false branch→
    T->getAttrKind() == attr::ObjCOwnership)
2
←
Assuming the condition is false→
  return printAfter(T->getEquivalentType(), OS);

// If this is a calling convention attribute, don't print the implicit CC from
// the modified type.
SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());

printAfter(T->getModifiedType(), OS);

// Some attributes are printed as qualifiers before the type, so we have
// nothing left to do.
if (T->getAttrKind() == attr::ObjCKindOf ||
4
←
Assuming the condition is false→
6
←
Assuming the condition is false→
7
←
Taking false branch→
    T->isMSTypeSpec() || T->getImmediateNullability())
5
←
Assuming the condition is false→
  return;

// Don't print the inert __unsafe_unretained attribute at all.
if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained)
8
←
Assuming the condition is false→
9
←
Taking false branch→
  return;

// Don't print ns_returns_retained unless it had an effect.
if (T->getAttrKind() == attr::NSReturnsRetained &&
10
←
Assuming the condition is false→
11
←
Taking false branch→
    !T->getEquivalentType()->castAs<FunctionType>()
                           ->getExtInfo().getProducesResult())
  return;

if (T->getAttrKind() == attr::LifetimeBound) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
  OS << " [[clang::lifetimebound]]";
  return;
}

// The printing of the address_space attribute is handled by the qualifier
// since it is still stored in the qualifier. Return early to prevent printing
// this twice.
if (T->getAttrKind() == attr::AddressSpace)
14
←
Assuming the condition is false→
15
←
Taking false branch→
  return;

OS << " __attribute__((";
switch (T->getAttrKind()) {
16
←
Control jumps to 'case Pcs:'  at line 1535→
1488#define TYPE_ATTR(NAME)
1489#define DECL_OR_TYPE_ATTR(NAME)
1490#define ATTR(NAME) case attr::NAME:
1491#include "clang/Basic/AttrList.inc"
  llvm_unreachable("non-type attribute attached to type")::llvm::llvm_unreachable_internal("non-type attribute attached to type"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 1492);

case attr::OpenCLPrivateAddressSpace:
case attr::OpenCLGlobalAddressSpace:
case attr::OpenCLLocalAddressSpace:
case attr::OpenCLConstantAddressSpace:
case attr::OpenCLGenericAddressSpace:
  // FIXME: Update printAttributedBefore to print these once we generate
  // AttributedType nodes for them.
  break;

case attr::LifetimeBound:
case attr::TypeNonNull:
case attr::TypeNullable:
case attr::TypeNullUnspecified:
case attr::ObjCGC:
case attr::ObjCInertUnsafeUnretained:
case attr::ObjCKindOf:
case attr::ObjCOwnership:
case attr::Ptr32:
case attr::Ptr64:
case attr::SPtr:
case attr::UPtr:
case attr::AddressSpace:
  llvm_unreachable("This attribute should have been handled already")::llvm::llvm_unreachable_internal("This attribute should have been handled already"
, "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 1516);

case attr::NSReturnsRetained:
  OS << "ns_returns_retained";
  break;

// FIXME: When Sema learns to form this AttributedType, avoid printing the
// attribute again in printFunctionProtoAfter.
case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
case attr::CDecl: OS << "cdecl"; break;
case attr::FastCall: OS << "fastcall"; break;
case attr::StdCall: OS << "stdcall"; break;
case attr::ThisCall: OS << "thiscall"; break;
case attr::SwiftCall: OS << "swiftcall"; break;
case attr::VectorCall: OS << "vectorcall"; break;
case attr::Pascal: OS << "pascal"; break;
case attr::MSABI: OS << "ms_abi"; break;
case attr::SysVABI: OS << "sysv_abi"; break;
case attr::RegCall: OS << "regcall"; break;
case attr::Pcs: {
  OS << "pcs(";
 QualType t = T->getEquivalentType();
 while (!t->isFunctionType())
17
←
Loop condition is false. Execution continues on line 1540→
   t = t->getPointeeType();
 OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
18
←
Assuming the object is not a 'FunctionType'→
19
←
Called C++ object pointer is null
       "\"aapcs\"" : "\"aapcs-vfp\"");
 OS << ')';
 break;
}
case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
case attr::IntelOclBicc: OS << "inteloclbicc"; break;
case attr::PreserveMost:
  OS << "preserve_most";
  break;

case attr::PreserveAll:
  OS << "preserve_all";
  break;
case attr::NoDeref:
  OS << "noderef";
  break;
}
OS << "))";
1559}

1561void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
                                         raw_ostream &OS) {
OS << T->getDecl()->getName();
spaceBeforePlaceHolder(OS);
1565}

1567void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
                                        raw_ostream &OS) {}

1570void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
                                        raw_ostream &OS) {
OS << T->getDecl()->getName();
if (!T->qual_empty()) {
  bool isFirst = true;
  OS << '<';
  for (const auto *I : T->quals()) {
    if (isFirst)
      isFirst = false;
    else
      OS << ',';
    OS << I->getName();
  }
  OS << '>';
}

spaceBeforePlaceHolder(OS);
1587}

1589void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
                                        raw_ostream &OS) {}

1592void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
                                      raw_ostream &OS) {
if (T->qual_empty() && T->isUnspecializedAsWritten() &&
    !T->isKindOfTypeAsWritten())
  return printBefore(T->getBaseType(), OS);

if (T->isKindOfTypeAsWritten())
  OS << "__kindof ";

print(T->getBaseType(), OS, StringRef());

if (T->isSpecializedAsWritten()) {
  bool isFirst = true;
  OS << '<';
  for (auto typeArg : T->getTypeArgsAsWritten()) {
    if (isFirst)
      isFirst = false;
    else
      OS << ",";

    print(typeArg, OS, StringRef());
  }
  OS << '>';
}

if (!T->qual_empty()) {
  bool isFirst = true;
  OS << '<';
  for (const auto *I : T->quals()) {
    if (isFirst)
      isFirst = false;
    else
      OS << ',';
    OS << I->getName();
  }
  OS << '>';
}

spaceBeforePlaceHolder(OS);
1631}

1633void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
                                      raw_ostream &OS) {
if (T->qual_empty() && T->isUnspecializedAsWritten() &&
    !T->isKindOfTypeAsWritten())
  return printAfter(T->getBaseType(), OS);
1638}

1640void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
                                             raw_ostream &OS) {
printBefore(T->getPointeeType(), OS);

// If we need to print the pointer, print it now.
if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
    !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
  if (HasEmptyPlaceHolder)
    OS << ' ';
  OS << '*';
}
1651}

1653void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
                                            raw_ostream &OS) {}

1656static
1657const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }

1659static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
return A.getArgument();
1661}

1663static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
                        llvm::raw_ostream &OS) {
A.print(PP, OS);
1666}

1668static void printArgument(const TemplateArgumentLoc &A,
                        const PrintingPolicy &PP, llvm::raw_ostream &OS) {
const TemplateArgument::ArgKind &Kind = A.getArgument().getKind();
if (Kind == TemplateArgument::ArgKind::Type)
  return A.getTypeSourceInfo()->getType().print(OS, PP);
return A.getArgument().print(PP, OS);
1674}

1676template<typename TA>
1677static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
                  const PrintingPolicy &Policy, bool SkipBrackets) {
const char *Comma = Policy.MSVCFormatting ? "," : ", ";
if (!SkipBrackets)
  OS << '<';

bool NeedSpace = false;
bool FirstArg = true;
for (const auto &Arg : Args) {
  // Print the argument into a string.
  SmallString<128> Buf;
  llvm::raw_svector_ostream ArgOS(Buf);
  const TemplateArgument &Argument = getArgument(Arg);
  if (Argument.getKind() == TemplateArgument::Pack) {
    if (Argument.pack_size() && !FirstArg)
      OS << Comma;
    printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
  } else {
    if (!FirstArg)
      OS << Comma;
    // Tries to print the argument with location info if exists.
    printArgument(Arg, Policy, ArgOS);
  }
  StringRef ArgString = ArgOS.str();

  // If this is the first argument and its string representation
  // begins with the global scope specifier ('::foo'), add a space
  // to avoid printing the diagraph '<:'.
  if (FirstArg && !ArgString.empty() && ArgString[0] == ':')
    OS << ' ';

  OS << ArgString;

  NeedSpace = (!ArgString.empty() && ArgString.back() == '>');
  FirstArg = false;
}

// If the last character of our string is '>', add another space to
// keep the two '>''s separate tokens. We don't *have* to do this in
// C++0x, but it's still good hygiene.
if (NeedSpace)
  OS << ' ';

if (!SkipBrackets)
  OS << '>';
1722}

1724void clang::printTemplateArgumentList(raw_ostream &OS,
                                    const TemplateArgumentListInfo &Args,
                                    const PrintingPolicy &Policy) {
return printTo(OS, Args.arguments(), Policy, false);
1728}

1730void clang::printTemplateArgumentList(raw_ostream &OS,
                                    ArrayRef<TemplateArgument> Args,
                                    const PrintingPolicy &Policy) {
printTo(OS, Args, Policy, false);
1734}

1736void clang::printTemplateArgumentList(raw_ostream &OS,
                                    ArrayRef<TemplateArgumentLoc> Args,
                                    const PrintingPolicy &Policy) {
printTo(OS, Args, Policy, false);
1740}

1742std::string Qualifiers::getAsString() const {
LangOptions LO;
return getAsString(PrintingPolicy(LO));
1745}

1747// Appends qualifiers to the given string, separated by spaces.  Will
1748// prefix a space if the string is non-empty.  Will not append a final
1749// space.
1750std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
SmallString<64> Buf;
llvm::raw_svector_ostream StrOS(Buf);
print(StrOS, Policy);
return StrOS.str();
1755}

1757bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
if (getCVRQualifiers())
  return false;

if (getAddressSpace() != LangAS::Default)
  return false;

if (getObjCGCAttr())
  return false;

if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
  if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
    return false;

return true;
1772}

1774// Appends qualifiers to the given string, separated by spaces.  Will
1775// prefix a space if the string is non-empty.  Will not append a final
1776// space.
1777void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
                     bool appendSpaceIfNonEmpty) const {
bool addSpace = false;

unsigned quals = getCVRQualifiers();
if (quals) {
  AppendTypeQualList(OS, quals, Policy.Restrict);
  addSpace = true;
}
if (hasUnaligned()) {
  if (addSpace)
    OS << ' ';
  OS << "__unaligned";
  addSpace = true;
}
LangAS addrspace = getAddressSpace();
if (addrspace != LangAS::Default) {
  if (addrspace != LangAS::opencl_private) {
    if (addSpace)
      OS << ' ';
    addSpace = true;
    switch (addrspace) {
    case LangAS::opencl_global:
      OS << "__global";
      break;
    case LangAS::opencl_local:
      OS << "__local";
      break;
    case LangAS::opencl_private:
      break;
    case LangAS::opencl_constant:
      OS << "__constant";
      break;
    case LangAS::opencl_generic:
      OS << "__generic";
      break;
    case LangAS::cuda_device:
      OS << "__device__";
      break;
    case LangAS::cuda_constant:
      OS << "__constant__";
      break;
    case LangAS::cuda_shared:
      OS << "__shared__";
      break;
    default:
      OS << "__attribute__((address_space(";
      OS << toTargetAddressSpace(addrspace);
      OS << ")))";
    }
  }
}
if (Qualifiers::GC gc = getObjCGCAttr()) {
  if (addSpace)
    OS << ' ';
  addSpace = true;
  if (gc == Qualifiers::Weak)
    OS << "__weak";
  else
    OS << "__strong";
}
if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
  if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
    if (addSpace)
      OS << ' ';
    addSpace = true;
  }

  switch (lifetime) {
  case Qualifiers::OCL_None: llvm_unreachable("none but true")::llvm::llvm_unreachable_internal("none but true", "/build/llvm-toolchain-snapshot-10~svn373517/tools/clang/lib/AST/TypePrinter.cpp"
, 1846);
  case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
  case Qualifiers::OCL_Strong:
    if (!Policy.SuppressStrongLifetime)
      OS << "__strong";
    break;

  case Qualifiers::OCL_Weak: OS << "__weak"; break;
  case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
  }
}

if (appendSpaceIfNonEmpty && addSpace)
  OS << ' ';
1860}

1862std::string QualType::getAsString() const {
return getAsString(split(), LangOptions());
1864}

1866std::string QualType::getAsString(const PrintingPolicy &Policy) const {
std::string S;
getAsStringInternal(S, Policy);
return S;
1870}

1872std::string QualType::getAsString(const Type *ty, Qualifiers qs,
                                const PrintingPolicy &Policy) {
std::string buffer;
getAsStringInternal(ty, qs, buffer, Policy);
return buffer;
1877}

1879void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
                   const Twine &PlaceHolder, unsigned Indentation) const {
print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
      Indentation);
1883}

1885void QualType::print(const Type *ty, Qualifiers qs,
                   raw_ostream &OS, const PrintingPolicy &policy,
                   const Twine &PlaceHolder, unsigned Indentation) {
SmallString<128> PHBuf;
StringRef PH = PlaceHolder.toStringRef(PHBuf);

TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
1892}

1894void QualType::getAsStringInternal(std::string &Str,
                                 const PrintingPolicy &Policy) const {
return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
                           Policy);
1898}

1900void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
                                 std::string &buffer,
                                 const PrintingPolicy &policy) {
SmallString<256> Buf;
llvm::raw_svector_ostream StrOS(Buf);
TypePrinter(policy).print(ty, qs, StrOS, buffer);
std::string str = StrOS.str();
buffer.swap(str);
1908}