[clang] Add a raw_ostream operator<< overload for QualType

[njames93]

Summary

Under the hood this prints the same as QualType::getAsString() but cuts out the middle-man when that string is sent to another raw_ostream.

Also cleaned up all the call sites where this occurs.

[aaron.ballman]

Thanks for this! LGTM with some small nits.

clang/include/clang/AST/Type.h

1319

Cleaning up the declaration a bit, but the important change is not making QT a const ref (the type is small and meant to be passed by value cheaply).

clang/lib/AST/TypePrinter.cpp

2313

Please spell out the type.

[njames93]

Address nits.

[njames93]

clang/include/clang/AST/Type.h

1319

I knew it needed cleaning, Just had issues with the declaration not matching the definition so added all qualifiers.

clang/include/clang/AST/Type.h

private:
   static DestructionKind isDestructedTypeImpl(QualType type);
 
   /// Check if \param RD is or contains a non-trivial C union.
   static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
   static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
   static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
 };
 
+raw_ostream &operator<<(raw_ostream &OS, QualType QT);
+
 } // namespace clang
 
 namespace llvm {
 
 /// Implement simplify_type for QualType, so that we can dyn_cast from QualType
 /// to a specific Type class.
 template<> struct simplify_type< ::clang::QualType> {
   using SimpleType = const ::clang::Type *;

clang/include/clang/StaticAnalyzer/Checkers/SValExplainer.h

public:
 
   std::string VisitStringRegion(const StringRegion *R) {
     return "string literal " + R->getString();
   }
 
   std::string VisitElementRegion(const ElementRegion *R) {
     std::string Str;
     llvm::raw_string_ostream OS(Str);
-    OS << "element of type '" << R->getElementType().getAsString()
-       << "' with index ";
+    OS << "element of type '" << R->getElementType() << "' with index ";
     // For concrete index: omit type of the index integer.
     if (auto I = R->getIndex().getAs<nonloc::ConcreteInt>())
       OS << I->getValue();
     else
       OS << "'" << Visit(R->getIndex()) << "'";
     OS << " of " + Visit(R->getSuperRegion());
     return Str;
   }

clang/lib/AST/RecordLayoutBuilder.cpp

static void DumpRecordLayout(raw_ostream &OS, const RecordDecl *RD,
                              unsigned IndentLevel,
                              const char* Description,
                              bool PrintSizeInfo,
                              bool IncludeVirtualBases) {
   const ASTRecordLayout &Layout = C.getASTRecordLayout(RD);
   auto CXXRD = dyn_cast<CXXRecordDecl>(RD);
 
   PrintOffset(OS, Offset, IndentLevel);
-  OS << C.getTypeDeclType(const_cast<RecordDecl*>(RD)).getAsString();
+  OS << C.getTypeDeclType(const_cast<RecordDecl *>(RD));
   if (Description)
     OS << ' ' << Description;
   if (CXXRD && CXXRD->isEmpty())
     OS << " (empty)";
   OS << '\n';
 
   IndentLevel++;
 
if (Field.isBitField()) {
       unsigned Width = Field.getBitWidthValue(C);
       PrintBitFieldOffset(OS, FieldOffset, Begin, Width, IndentLevel);
     } else {
       PrintOffset(OS, FieldOffset, IndentLevel);
     }
     const QualType &FieldType = C.getLangOpts().DumpRecordLayoutsCanonical
                                     ? Field.getType().getCanonicalType()
                                     : Field.getType();
-    OS << FieldType.getAsString() << ' ' << Field << '\n';
+    OS << FieldType << ' ' << Field << '\n';
   }
 
   // Dump virtual bases.
   if (CXXRD && IncludeVirtualBases) {
     const ASTRecordLayout::VBaseOffsetsMapTy &VtorDisps =
       Layout.getVBaseOffsetsMap();
 
     for (const CXXBaseSpecifier &Base : CXXRD->vbases()) {
void ASTContext::DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS,
   // The "simple" format is designed to be parsed by the
   // layout-override testing code.  There shouldn't be any external
   // uses of this format --- when LLDB overrides a layout, it sets up
   // the data structures directly --- so feel free to adjust this as
   // you like as long as you also update the rudimentary parser for it
   // in libFrontend.
 
   const ASTRecordLayout &Info = getASTRecordLayout(RD);
-  OS << "Type: " << getTypeDeclType(RD).getAsString() << "\n";
+  OS << "Type: " << getTypeDeclType(RD) << "\n";
   OS << "\nLayout: ";
   OS << "<ASTRecordLayout\n";
   OS << "  Size:" << toBits(Info.getSize()) << "\n";
   if (!isMsLayout(*this))
     OS << "  DataSize:" << toBits(Info.getDataSize()) << "\n";
   OS << "  Alignment:" << toBits(Info.getAlignment()) << "\n";
   if (Target->defaultsToAIXPowerAlignment())
     OS << "  PreferredAlignment:" << toBits(Info.getPreferredAlignment())

clang/lib/AST/TypePrinter.cpp

void 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 = std::string(StrOS.str());
   buffer.swap(str);
 }
+
+raw_ostream &clang::operator<<(raw_ostream &OS, QualType QT) {
+  SplitQualType S = QT.split();
+  TypePrinter(LangOptions()).print(S.Ty, S.Quals, OS, /*PlaceHolder=*/"");
+  return OS;
+}

clang/lib/AST/VTableBuilder.cpp

static void dumpMicrosoftThunkAdjustment(const ThunkInfo &TI, raw_ostream &Out,
                                          bool ContinueFirstLine) {
   const ReturnAdjustment &R = TI.Return;
   bool Multiline = false;
   const char *LinePrefix = "\n       ";
   if (!R.isEmpty() || TI.Method) {
     if (!ContinueFirstLine)
       Out << LinePrefix;
     Out << "[return adjustment (to type '"
-        << TI.Method->getReturnType().getCanonicalType().getAsString()
-        << "'): ";
+        << TI.Method->getReturnType().getCanonicalType() << "'): ";
     if (R.Virtual.Microsoft.VBPtrOffset)
       Out << "vbptr at offset " << R.Virtual.Microsoft.VBPtrOffset << ", ";
     if (R.Virtual.Microsoft.VBIndex)
       Out << "vbase #" << R.Virtual.Microsoft.VBIndex << ", ";
     Out << R.NonVirtual << " non-virtual]";
     Multiline = true;
   }
 

clang/lib/Analysis/AnalysisDeclContext.cpp

if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 
     // In C++, there are overloads.
 
     if (Ctx.getLangOpts().CPlusPlus) {
       OS << '(';
       for (const auto &P : FD->parameters()) {
         if (P != *FD->param_begin())
           OS << ", ";
-        OS << P->getType().getAsString();
+        OS << P->getType();
       }
       OS << ')';
     }
 
   } else if (isa<BlockDecl>(D)) {
     PresumedLoc Loc = Ctx.getSourceManager().getPresumedLoc(D->getLocation());
 
     if (Loc.isValid()) {

clang/lib/Analysis/CFG.cpp

if (auto VTC = E.getAs<CFGCXXRecordTypedCall>()) {
       OS << " (OperatorCall)";
     } else if (isa<CXXBindTemporaryExpr>(S)) {
       OS << " (BindTemporary)";
     } else if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(S)) {
       OS << " (CXXConstructExpr";
       if (Optional<CFGConstructor> CE = E.getAs<CFGConstructor>()) {
         print_construction_context(OS, Helper, CE->getConstructionContext());
       }
-      OS << ", " << CCE->getType().getAsString() << ")";
+      OS << ", " << CCE->getType() << ")";
     } else if (const CastExpr *CE = dyn_cast<CastExpr>(S)) {
-      OS << " (" << CE->getStmtClassName() << ", "
-         << CE->getCastKindName()
-         << ", " << CE->getType().getAsString()
-         << ")";
+      OS << " (" << CE->getStmtClassName() << ", " << CE->getCastKindName()
+         << ", " << CE->getType() << ")";
     }
 
     // Expressions need a newline.
     if (isa<Expr>(S))
       OS << '\n';
 
     break;
   }

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

 }
 
 Value *Environment::createValue(QualType Type) {
   llvm::DenseSet<QualType> Visited;
   int CreatedValuesCount = 0;
   Value *Val = createValueUnlessSelfReferential(Type, Visited, /*Depth=*/0,
                                                 CreatedValuesCount);
   if (CreatedValuesCount > MaxCompositeValueSize) {
-    llvm::errs() << "Attempting to initialize a huge value of type: "
-                 << Type.getAsString() << "\n";
+    llvm::errs() << "Attempting to initialize a huge value of type: " << Type
+                 << '\n';
   }
   return Val;
 }
 
 Value *Environment::createValueUnlessSelfReferential(
     QualType Type, llvm::DenseSet<QualType> &Visited, int Depth,
     int &CreatedValuesCount) {
   assert(!Type.isNull());

clang/lib/Sema/CodeCompleteConsumer.cpp

 }
 
 void PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(
     Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results,
     unsigned NumResults) {
   std::stable_sort(Results, Results + NumResults);
 
   if (!Context.getPreferredType().isNull())
-    OS << "PREFERRED-TYPE: " << Context.getPreferredType().getAsString()
-       << "\n";
+    OS << "PREFERRED-TYPE: " << Context.getPreferredType() << '\n';
 
   StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
   // Print the completions.
   for (unsigned I = 0; I != NumResults; ++I) {
     if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
       continue;
     OS << "COMPLETION: ";
     switch (Results[I].Kind) {

clang/lib/Sema/SemaInit.cpp

case EK_LambdaCapture:
     break;
   }
 
   if (auto *D = getDecl()) {
     OS << " ";
     D->printQualifiedName(OS);
   }
 
-  OS << " '" << getType().getAsString() << "'\n";
+  OS << " '" << getType() << "'\n";
 
   return Depth + 1;
 }
 
 LLVM_DUMP_METHOD void InitializedEntity::dump() const {
   dumpImpl(llvm::errs());
 }
 
case SK_OCLSamplerInit:
       OS << "OpenCL sampler_t from integer constant";
       break;
 
     case SK_OCLZeroOpaqueType:
       OS << "OpenCL opaque type from zero";
       break;
     }
 
-    OS << " [" << S->Type.getAsString() << ']';
+    OS << " [" << S->Type << ']';
   }
 
   OS << '\n';
 }
 
 void InitializationSequence::dump() const {
   dump(llvm::errs());
 }

clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp

case MemRegion::BlockCodeRegionKind:
     os << "block text";
     return true;
   case MemRegion::BlockDataRegionKind:
     os << "a block";
     return true;
   case MemRegion::CXXThisRegionKind:
   case MemRegion::CXXTempObjectRegionKind:
     os << "a C++ temp object of type "
-       << cast<TypedValueRegion>(MR)->getValueType().getAsString();
+       << cast<TypedValueRegion>(MR)->getValueType();
     return true;
   case MemRegion::NonParamVarRegionKind:
-    os << "a variable of type"
-       << cast<TypedValueRegion>(MR)->getValueType().getAsString();
+    os << "a variable of type" << cast<TypedValueRegion>(MR)->getValueType();
     return true;
   case MemRegion::ParamVarRegionKind:
-    os << "a parameter of type"
-       << cast<TypedValueRegion>(MR)->getValueType().getAsString();
+    os << "a parameter of type" << cast<TypedValueRegion>(MR)->getValueType();
     return true;
   case MemRegion::FieldRegionKind:
-    os << "a field of type "
-       << cast<TypedValueRegion>(MR)->getValueType().getAsString();
+    os << "a field of type " << cast<TypedValueRegion>(MR)->getValueType();
     return true;
   case MemRegion::ObjCIvarRegionKind:
     os << "an instance variable of type "
-       << cast<TypedValueRegion>(MR)->getValueType().getAsString();
+       << cast<TypedValueRegion>(MR)->getValueType();
     return true;
   default:
     return false;
   }
 }
 
 bool CStringChecker::memsetAux(const Expr *DstBuffer, SVal CharVal,
                                const Expr *Size, CheckerContext &C,
checker->Filter.CheckName##name = mgr.getCurrentCheckerName();             \
                                                                                \
   bool ento::shouldRegister##name(const CheckerManager &mgr) { return true; }
 
 REGISTER_CHECKER(CStringNullArg)
 REGISTER_CHECKER(CStringOutOfBounds)
 REGISTER_CHECKER(CStringBufferOverlap)
 REGISTER_CHECKER(CStringNotNullTerm)
 REGISTER_CHECKER(CStringUninitializedRead)
 No newline at end of file

clang/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp

if (!AreTypesCompatible(ResDerived, ResAncestor, Ctx)) {
     llvm::raw_string_ostream os(sbuf);
 
     os << "The Objective-C class '"
        << *MethDerived->getClassInterface()
        << "', which is derived from class '"
        << *MethAncestor->getClassInterface()
        << "', defines the instance method '";
     MethDerived->getSelector().print(os);
-    os << "' whose return type is '"
-       << ResDerived.getAsString()
+    os << "' whose return type is '" << ResDerived
        << "'.  A method with the same name (same selector) is also defined in "
           "class '"
-       << *MethAncestor->getClassInterface()
-       << "' and has a return type of '"
-       << ResAncestor.getAsString()
+       << *MethAncestor->getClassInterface() << "' and has a return type of '"
+       << ResAncestor
        << "'.  These two types are incompatible, and may result in undefined "
           "behavior for clients of these classes.";
 
     PathDiagnosticLocation MethDLoc =
       PathDiagnosticLocation::createBegin(MethDerived,
                                           BR.getSourceManager());
 
     BR.EmitBasicReport(

clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp

void WalkAST::checkLoopConditionForFloat(const ForStmt *FS) {
   // referenced the compared variable.
   const DeclRefExpr *drCond = vdLHS == vdInc ? drLHS : drRHS;
 
   SmallVector<SourceRange, 2> ranges;
   SmallString<256> sbuf;
   llvm::raw_svector_ostream os(sbuf);
 
   os << "Variable '" << drCond->getDecl()->getName()
-     << "' with floating point type '" << drCond->getType().getAsString()
+     << "' with floating point type '" << drCond->getType()
      << "' should not be used as a loop counter";
 
   ranges.push_back(drCond->getSourceRange());
   ranges.push_back(drInc->getSourceRange());
 
   const char *bugType = "Floating point variable used as loop counter";
 
   PathDiagnosticLocation FSLoc =

clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp

PathDiagnosticPieceRef InnerPointerChecker::InnerPointerBRVisitor::VisitNode(
 
   const MemRegion *ObjRegion =
       allocation_state::getContainerObjRegion(N->getState(), PtrToBuf);
   const auto *TypedRegion = cast<TypedValueRegion>(ObjRegion);
   QualType ObjTy = TypedRegion->getValueType();
 
   SmallString<256> Buf;
   llvm::raw_svector_ostream OS(Buf);
-  OS << "Pointer to inner buffer of '" << ObjTy.getAsString()
-     << "' obtained here";
+  OS << "Pointer to inner buffer of '" << ObjTy << "' obtained here";
   PathDiagnosticLocation Pos(S, BRC.getSourceManager(),
                              N->getLocationContext());
   return std::make_shared<PathDiagnosticEventPiece>(Pos, OS.str(), true);
 }
 
 void ento::registerInnerPointerChecker(CheckerManager &Mgr) {
   registerInnerPointerCheckerAux(Mgr);
   Mgr.registerChecker<InnerPointerChecker>();
 }
 
 bool ento::shouldRegisterInnerPointerChecker(const CheckerManager &mgr) {
   return true;
 }

clang/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp

for (SmallVectorImpl<FieldDecl*>::iterator I=FieldChain.begin(),
          E=FieldChain.end(); I!=E; ++I) {
       if (!isFirst)
         os << '.';
       else
         isFirst = false;
       os << (*I)->getName();
     }
   }
-  os << " (type " << FieldChain.back()->getType().getAsString() << ")";
+  os << " (type " << FieldChain.back()->getType() << ")";
 
   // Note that this will fire for every translation unit that uses this
   // class.  This is suboptimal, but at least scan-build will merge
   // duplicate HTML reports.  In the future we need a unified way of merging
   // duplicate reports across translation units.  For C++ classes we cannot
   // just report warnings when we see an out-of-line method definition for a
   // class, as that heuristic doesn't always work (the complete definition of
   // the class may be in the header file, for example).

clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

if (isAllocated(RSCurr, RSPrev, S)) {
           StackHint = std::make_unique<StackHintGeneratorForSymbol>(
               Sym, "Returning; memory was released");
           break;
         case AF_InnerBuffer: {
           const MemRegion *ObjRegion =
               allocation_state::getContainerObjRegion(statePrev, Sym);
           const auto *TypedRegion = cast<TypedValueRegion>(ObjRegion);
           QualType ObjTy = TypedRegion->getValueType();
-          OS << "Inner buffer of '" << ObjTy.getAsString() << "' ";
+          OS << "Inner buffer of '" << ObjTy << "' ";
 
           if (N->getLocation().getKind() == ProgramPoint::PostImplicitCallKind) {
             OS << "deallocated by call to destructor";
             StackHint = std::make_unique<StackHintGeneratorForSymbol>(
                 Sym, "Returning; inner buffer was deallocated");
           } else {
             OS << "reallocated by call to '";
             const Stmt *S = RSCurr->getStmt();

clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp

for (CastedAllocFinder::CallVec::iterator i = Finder.Calls.begin(),
         llvm::raw_svector_ostream OS(buf);
 
         OS << "Result of ";
         const FunctionDecl *Callee = i->AllocCall->getDirectCallee();
         if (Callee && Callee->getIdentifier())
           OS << '\'' << Callee->getIdentifier()->getName() << '\'';
         else
           OS << "call";
-        OS << " is converted to a pointer of type '"
-            << PointeeType.getAsString() << "', which is incompatible with "
-            << "sizeof operand type '" << SizeofType.getAsString() << "'";
+        OS << " is converted to a pointer of type '" << PointeeType
+           << "', which is incompatible with "
+           << "sizeof operand type '" << SizeofType << "'";
         SmallVector<SourceRange, 4> Ranges;
         Ranges.push_back(i->AllocCall->getCallee()->getSourceRange());
         Ranges.push_back(SFinder.Sizeofs[0]->getSourceRange());
         if (TSI)
           Ranges.push_back(TSI->getTypeLoc().getSourceRange());
 
         PathDiagnosticLocation L =
             PathDiagnosticLocation::createBegin(i->AllocCall->getCallee(),

clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp

ObjT = ACtx.getPointerType(
         ObjT->getPointeeType().getCanonicalType().getUnqualifiedType());
   }
 
   if (IsComparison)
     OS << "Comparing ";
   else
     OS << "Converting ";
 
-  OS << "a pointer value of type '" << ObjT.getAsString() << "' to a ";
+  OS << "a pointer value of type '" << ObjT << "' to a ";
 
   std::string EuphemismForPlain = "primitive";
   std::string SuggestedApi = IsObjC ? (IsInteger ? "" : "-boolValue")
                            : IsCpp ? (IsOSNumber ? "" : "getValue()")
                            : "CFNumberGetValue()";
   if (SuggestedApi.empty()) {
     // A generic message if we're not sure what API should be called.
     // FIXME: Pattern-match the integer type to make a better guess?

clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp

if (Arg) {
     SmallString<64> BufName;
     llvm::raw_svector_ostream OsName(BufName);
     OsName << " Invalid use of '" << Name << "'" ;
 
     SmallString<256> Buf;
     llvm::raw_svector_ostream Os(Buf);
     // Use "second" and "third" since users will expect 1-based indexing
     // for parameter names when mentioned in prose.
-    Os << " The "<< ((ArgNum == 1) ? "second" : "third") << " argument to '"
-        << Name << "' must be a C array of pointer-sized values, not '"
-        << Arg->getType().getAsString() << "'";
+    Os << " The " << ((ArgNum == 1) ? "second" : "third") << " argument to '"
+       << Arg->getType() << "'";
 
     PathDiagnosticLocation CELoc =
         PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), AC);
     BR.EmitBasicReport(AC->getDecl(), Checker, OsName.str(),
                        categories::CoreFoundationObjectiveC, Os.str(), CELoc,
                        Arg->getSourceRange());
   }
 

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

 }
 
 static ProgramStateRef removeRefBinding(ProgramStateRef State, SymbolRef Sym) {
   return State->remove<RefBindings>(Sym);
 }
 
 void RefVal::print(raw_ostream &Out) const {
   if (!T.isNull())
-    Out << "Tracked " << T.getAsString() << " | ";
+    Out << "Tracked " << T << " | ";
 
   switch (getKind()) {
     default: llvm_unreachable("Invalid RefVal kind");
     case Owned: {
       Out << "Owned";
       unsigned cnt = getCount();
       if (cnt) Out << " (+ " << cnt << ")";
       break;

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

static void generateDiagnosticsForCallLike(ProgramStateRef CurrSt,
   // If index is not found, we assume that the symbol was returned.
   if (!Idx) {
     os << " returns ";
   } else {
     os << " writes ";
   }
 
   if (CurrV.getObjKind() == ObjKind::CF) {
-    os << "a Core Foundation object of type '"
-       << Sym->getType().getAsString() << "' with a ";
+    os << "a Core Foundation object of type '" << Sym->getType() << "' with a ";
   } else if (CurrV.getObjKind() == ObjKind::OS) {
     os << "an OSObject of type '" << findAllocatedObjectName(S, Sym->getType())
        << "' with a ";
   } else if (CurrV.getObjKind() == ObjKind::Generalized) {
-    os << "an object of type '" << Sym->getType().getAsString()
-       << "' with a ";
+    os << "an object of type '" << Sym->getType() << "' with a ";
   } else {
     assert(CurrV.getObjKind() == ObjKind::ObjC);
     QualType T = Sym->getType();
     if (!isa<ObjCObjectPointerType>(T)) {
       os << "an Objective-C object with a ";
     } else {
       const ObjCObjectPointerType *PT = cast<ObjCObjectPointerType>(T);
-      os << "an instance of " << PT->getPointeeType().getAsString()
-         << " with a ";
+      os << "an instance of " << PT->getPointeeType() << " with a ";
     }
   }
 
   if (CurrV.isOwned()) {
     os << "+1 retain count";
   } else {
     assert(CurrV.isNotOwned());
     os << "+0 retain count";

clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp

if (Ex) {
         if (!I)
           OS << "a value that is";
         else if (I->isUnsigned())
           OS << '\'' << I->getZExtValue() << "\', which is";
         else
           OS << '\'' << I->getSExtValue() << "\', which is";
 
         OS << " greater or equal to the width of type '"
-           << B->getLHS()->getType().getAsString() << "'.";
+           << B->getLHS()->getType() << "'.";
       } else if (B->getOpcode() == BinaryOperatorKind::BO_Shl &&
                  C.isNegative(B->getLHS())) {
         OS << "The result of the left shift is undefined because the left "
               "operand is negative";
         Ex = B->getLHS();
       } else if (B->getOpcode() == BinaryOperatorKind::BO_Shl &&
                  isLeftShiftResultUnrepresentable(B, C)) {
         ProgramStateRef State = C.getState();
         SValBuilder &SB = C.getSValBuilder();
         const llvm::APSInt *LHS =
             SB.getKnownValue(State, C.getSVal(B->getLHS()));
         const llvm::APSInt *RHS =
             SB.getKnownValue(State, C.getSVal(B->getRHS()));
         OS << "The result of the left shift is undefined due to shifting \'"
            << LHS->getSExtValue() << "\' by \'" << RHS->getZExtValue()
            << "\', which is unrepresentable in the unsigned version of "
-           << "the return type \'" << B->getLHS()->getType().getAsString()
-           << "\'";
+           << "the return type \'" << B->getLHS()->getType() << "\'";
         Ex = B->getLHS();
       } else {
         OS << "The result of the '"
            << BinaryOperator::getOpcodeStr(B->getOpcode())
            << "' expression is undefined";
       }
     }
     auto report = std::make_unique<PathSensitiveBugReport>(*BT, OS.str(), N);

clang/lib/StaticAnalyzer/Core/DynamicType.cpp

static raw_ostream &printJson(const DynamicTypeInfo &DTI, raw_ostream &Out,
   Out << "\"dyn_type\": ";
   if (!DTI.isValid()) {
     Out << "null";
   } else {
     QualType ToPrint = DTI.getType();
     if (ToPrint->isAnyPointerType())
       ToPrint = ToPrint->getPointeeType();
 
-    Out << '\"' << ToPrint.getAsString() << "\", \"sub_classable\": "
+    Out << '\"' << ToPrint << "\", \"sub_classable\": "
         << (DTI.canBeASubClass() ? "true" : "false");
   }
   return Out;
 }
 
 static raw_ostream &printJson(const DynamicCastInfo &DCI, raw_ostream &Out,
                               const char *NL, unsigned int Space, bool IsDot) {
-  return Out << "\"from\": \"" << DCI.from().getAsString() << "\", \"to\": \""
-             << DCI.to().getAsString() << "\", \"kind\": \""
-             << (DCI.succeeds() ? "success" : "fail") << "\"";
+  return Out << "\"from\": \"" << DCI.from() << "\", \"to\": \"" << DCI.to()
+             << "\", \"kind\": \"" << (DCI.succeeds() ? "success" : "fail")
+             << "\"";
 }
 
 template <class T, class U>
 static raw_ostream &printJson(const std::pair<T, U> &Pair, raw_ostream &Out,
                               const char *NL, unsigned int Space, bool IsDot) {
   printJson(Pair.first, Out, NL, Space, IsDot) << ", ";
   return printJson(Pair.second, Out, NL, Space, IsDot);
 }

clang/lib/StaticAnalyzer/Core/MemRegion.cpp

 }
 
 void CompoundLiteralRegion::dumpToStream(raw_ostream &os) const {
   // FIXME: More elaborate pretty-printing.
   os << "{ S" << CL->getID(getContext()) <<  " }";
 }
 
 void CXXTempObjectRegion::dumpToStream(raw_ostream &os) const {
-  os << "temp_object{" << getValueType().getAsString() << ", "
+  os << "temp_object{" << getValueType() << ", "
      << "S" << Ex->getID(getContext()) << '}';
 }
 
 void CXXBaseObjectRegion::dumpToStream(raw_ostream &os) const {
   os << "Base{" << superRegion << ',' << getDecl()->getName() << '}';
 }
 
 void CXXDerivedObjectRegion::dumpToStream(raw_ostream &os) const {
   os << "Derived{" << superRegion << ',' << getDecl()->getName() << '}';
 }
 
 void CXXThisRegion::dumpToStream(raw_ostream &os) const {
   os << "this";
 }
 
 void ElementRegion::dumpToStream(raw_ostream &os) const {
-  os << "Element{" << superRegion << ','
-     << Index << ',' << getElementType().getAsString() << '}';
+  os << "Element{" << superRegion << ',' << Index << ',' << getElementType()
+     << '}';
 }
 
 void FieldRegion::dumpToStream(raw_ostream &os) const {
   os << superRegion << "." << *getDecl();
 }
 
 void ObjCIvarRegion::dumpToStream(raw_ostream &os) const {
   os << "Ivar{" << superRegion << ',' << *getDecl() << '}';

clang/lib/StaticAnalyzer/Core/SVals.cpp

case nonloc::PointerToMemberKind: {
       bool first = true;
       for (const auto &I : CastRes) {
         if (first) {
           os << ' '; first = false;
         }
         else
           os << ", ";
 
-        os << (*I).getType().getAsString();
+        os << I->getType();
       }
 
       os << '}';
       break;
     }
     default:
       assert(false && "Pretty-printed not implemented for this NonLoc.");
       break;

clang/lib/StaticAnalyzer/Core/SymbolManager.cpp

 }
 
 void BinarySymExpr::dumpToStreamImpl(raw_ostream &OS,
                                      BinaryOperator::Opcode Op) {
   OS << ' ' << BinaryOperator::getOpcodeStr(Op) << ' ';
 }
 
 void SymbolCast::dumpToStream(raw_ostream &os) const {
-  os << '(' << ToTy.getAsString() << ") (";
+  os << '(' << ToTy << ") (";
   Operand->dumpToStream(os);
   os << ')';
 }
 
 void SymbolConjured::dumpToStream(raw_ostream &os) const {
-  os << getKindStr() << getSymbolID() << '{' << T.getAsString() << ", LC"
-     << LCtx->getID();
+  os << getKindStr() << getSymbolID() << '{' << T << ", LC" << LCtx->getID();
   if (S)
     os << ", S" << S->getID(LCtx->getDecl()->getASTContext());
   else
     os << ", no stmt";
   os << ", #" << Count << '}';
 }
 
 void SymbolDerived::dumpToStream(raw_ostream &os) const {
   os << getKindStr() << getSymbolID() << '{' << getParentSymbol() << ','
      << getRegion() << '}';
 }
 
 void SymbolExtent::dumpToStream(raw_ostream &os) const {
   os << getKindStr() << getSymbolID() << '{' << getRegion() << '}';
 }
 
 void SymbolMetadata::dumpToStream(raw_ostream &os) const {
-  os << getKindStr() << getSymbolID() << '{' << getRegion() << ','
-     << T.getAsString() << '}';
+  os << getKindStr() << getSymbolID() << '{' << getRegion() << ',' << T << '}';
 }
 
 void SymbolData::anchor() {}
 
 void SymbolRegionValue::dumpToStream(raw_ostream &os) const {
-  os << getKindStr() << getSymbolID() << '<' << getType().getAsString() << ' '
-     << R << '>';
+  os << getKindStr() << getSymbolID() << '<' << getType() << ' ' << R << '>';
 }
 
 bool SymExpr::symbol_iterator::operator==(const symbol_iterator &X) const {
   return itr == X.itr;
 }
 
 bool SymExpr::symbol_iterator::operator!=(const symbol_iterator &X) const {
   return itr != X.itr;

clang/unittests/AST/ASTTraverserTest.cpp

void Visit(const comments::Comment *C, const comments::FullComment *FC) {
     OS << C->getCommentKindName();
   }
 
   void Visit(const CXXCtorInitializer *Init) {
     OS << "CXXCtorInitializer";
     if (const auto *F = Init->getAnyMember()) {
       OS << " '" << F->getNameAsString() << "'";
     } else if (auto const *TSI = Init->getTypeSourceInfo()) {
-      OS << " '" << TSI->getType().getAsString() << "'";
+      OS << " '" << TSI->getType() << "'";
     }
   }
 
   void Visit(const Attr *A) {
     switch (A->getKind()) {
 #define ATTR(X)                                                                \
   case attr::X:                                                                \
     OS << #X;                                                                  \
     break;
 #include "clang/Basic/AttrList.inc"
     }
     OS << "Attr";
   }
 
   void Visit(const OMPClause *C) { OS << "OMPClause"; }
   void Visit(const TemplateArgument &A, SourceRange R = {},
              const Decl *From = nullptr, const char *Label = nullptr) {
     OS << "TemplateArgument";
     switch (A.getKind()) {
     case TemplateArgument::Type: {
-      OS << " type " << A.getAsType().getAsString();
+      OS << " type " << A.getAsType();
       break;
     }
     default:
       break;
     }
   }
 
   template <typename... T> void Visit(T...) {}