[clangAST] support TypeLoc in TextNodeDumper

[upsj]

Summary

TextNodeDumper currently doesn't support printing the TypeLoc hierarchy, which makes navigating clang-query output involving TypeLoc hard to understand.
This diff replicates the Type hierarchy as well as possible, relying on Type visitors for printing type-specific info.
The only exception where this doesn't work is most sugared types and any kinds of parameters (function or template), for which the TypeLoc is not easily accessible.

Example clang-query output:

clang-query> set output dump
clang-query> match typeLoc(loc(type().bind("type")))
...
Binding for "root":
QualifiedTypeLoc </home/tribizel/llvm-project/build/test.cpp:23:10, col:60> 'matrix::Dense<typename remove_complex_t<T>::type> *const' const
`-PointerTypeLoc <col:10, col:60> 'matrix::Dense<typename remove_complex_t<T>::type> *'
  `-ElaboratedTypeLoc <col:10, col:58> 'matrix::Dense<typename remove_complex_t<T>::type>'
    `-TemplateSpecializationTypeLoc <col:18, col:58> 'Dense<typename remove_complex_t<T>::type>' Dense

Binding for "type":
PointerType 0x261f2b0 'matrix::Dense<typename remove_complex_t<T>::type> *' dependent
`-ElaboratedType 0x261f250 'matrix::Dense<typename remove_complex_t<T>::type>' sugar dependent
  `-TemplateSpecializationType 0x261f210 'Dense<typename remove_complex_t<T>::type>' dependent Dense
    `-TemplateArgument type 'typename remove_complex_t<T>::type'
      `-DependentNameType 0x261f190 'typename remove_complex_t<T>::type' dependent

[aaron.ballman]

Thank you for working on this! Should we make similar changes to the JSONNodeDumper as well? (It doesn't seem to have TypeLoc support.)

clang/include/clang/AST/ASTDumperUtils.h

55–56

I don't know that we need a color specific to type locs; those should behave the same as a type node (after all, it's a type coupled with a source location, basically).

clang/include/clang/AST/TextNodeDumper.h

337

Should you also handle IncompleteArrayTypeLoc as well?

clang/lib/AST/TextNodeDumper.cpp

1643

These uses of dyn_cast can all be switched to cast instead because we already know the type we're going to find.

1652

This one is actually not quite right. You need to go through the ASTContext to get to an array type. This should use ASTContext::getAsConstantArrayType() instead.

1657

Similarly, ASTContext::getAsVariableArrayType()

1663

ASTContext::getAsDependentSizedArrayType()

clang/lib/AST/TypeLoc.cpp

70–72

It might make sense for this to return a StringRef instead so it's clear that the caller does not own the memory or have to worry about releasing it. WDYT?

[upsj]

I incorporated the cast, ASTContext and StringRef suggestions. About JSONDumper, I was surprised to see that it doesn't seem to use AddChild for the AST hierarchy at all, so I'm not quite clear how (if?) it builds a nested output. What's the easiest way to invoke it?

clang/include/clang/AST/TextNodeDumper.h

337

Not sure about this one, since it has no additional metadata - the type location visitor already prints out the type class name

[upsj]

Let me backtrack my previous question: I misremembered where AddChild is actually being called in the traversal (ASTNodeTraverser, not TextNodeDumper), so I'll see if adding this to the JSON output is feasible

clang/include/clang/AST/ASTDumperUtils.h

 static const TerminalColor AttrColor = {llvm::raw_ostream::BLUE, true};
 // Statement names (DeclStmt, ImplicitCastExpr, etc)
 static const TerminalColor StmtColor = {llvm::raw_ostream::MAGENTA, true};
 // Comment names (FullComment, ParagraphComment, TextComment, etc)
 static const TerminalColor CommentColor = {llvm::raw_ostream::BLUE, false};
 
 // Type names (int, float, etc, plus user defined types)
 static const TerminalColor TypeColor = {llvm::raw_ostream::GREEN, false};
+// Type location names (int, float, etc, plus user defined types)
+static const TerminalColor TypeLocColor = {llvm::raw_ostream::GREEN, false};
 
 // Pointer address
 static const TerminalColor AddressColor = {llvm::raw_ostream::YELLOW, false};
 // Source locations
 static const TerminalColor LocationColor = {llvm::raw_ostream::YELLOW, false};
 
 // lvalue/xvalue
 static const TerminalColor ValueKindColor = {llvm::raw_ostream::CYAN, false};

clang/include/clang/AST/ASTNodeTraverser.h

 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/AttrVisitor.h"
 #include "clang/AST/CommentVisitor.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/TemplateArgumentVisitor.h"
 #include "clang/AST/Type.h"
+#include "clang/AST/TypeLocVisitor.h"
 #include "clang/AST/TypeVisitor.h"
 
 namespace clang {
 
 class APValue;
 
 /**
 
struct {
 
   void Visit(const comments::Comment *C, const comments::FullComment *FC);
   void Visit(const Attr *A);
   void Visit(const TemplateArgument &TA, SourceRange R = {},
              const Decl *From = nullptr, StringRef Label = {});
   void Visit(const Stmt *Node);
   void Visit(const Type *T);
   void Visit(QualType T);
+  void Visit(TypeLoc TL);
   void Visit(const Decl *D);
   void Visit(const CXXCtorInitializer *Init);
   void Visit(const OMPClause *C);
   void Visit(const BlockDecl::Capture &C);
   void Visit(const GenericSelectionExpr::ConstAssociation &A);
   void Visit(const concepts::Requirement *R);
   void Visit(const APValue &Value, QualType Ty);
 };
 */
 template <typename Derived, typename NodeDelegateType>
 class ASTNodeTraverser
     : public ConstDeclVisitor<Derived>,
       public ConstStmtVisitor<Derived>,
       public comments::ConstCommentVisitor<Derived, void,
                                            const comments::FullComment *>,
       public TypeVisitor<Derived>,
+      public TypeLocVisitor<Derived>,
       public ConstAttrVisitor<Derived>,
       public ConstTemplateArgumentVisitor<Derived> {
 
   /// Indicates whether we should trigger deserialization of nodes that had
   /// not already been loaded.
   bool Deserialize = false;
 
   TraversalKind Traversal = TraversalKind::TK_AsIs;
getNodeDelegate().AddChild([=] {
 
       QualType SingleStepDesugar =
           T->getLocallyUnqualifiedSingleStepDesugaredType();
       if (SingleStepDesugar != QualType(T, 0))
         Visit(SingleStepDesugar);
     });
   }
 
+  void Visit(TypeLoc TL) {
+    getNodeDelegate().AddChild([=] {
+      getNodeDelegate().Visit(TL);
+      TypeLocVisitor<Derived>::Visit(TL);
+    });
+  }
+
   void Visit(const Attr *A) {
     getNodeDelegate().AddChild([=] {
       getNodeDelegate().Visit(A);
       ConstAttrVisitor<Derived>::Visit(A);
     });
   }
 
   void Visit(const CXXCtorInitializer *Init) {
void Visit(const DynTypedNode &N) {
     if (const auto *D = N.get<Decl>())
       Visit(D);
     else if (const auto *S = N.get<Stmt>())
       Visit(S);
     else if (const auto *QT = N.get<QualType>())
       Visit(*QT);
     else if (const auto *T = N.get<Type>())
       Visit(T);
+    else if (const auto *TL = N.get<TypeLoc>())
+      Visit(*TL);
     else if (const auto *C = N.get<CXXCtorInitializer>())
       Visit(C);
     else if (const auto *C = N.get<OMPClause>())
       Visit(C);
     else if (const auto *T = N.get<TemplateArgument>())
       Visit(*T);
   }
 
public:
   void VisitAdjustedType(const AdjustedType *T) { Visit(T->getOriginalType()); }
   void VisitPackExpansionType(const PackExpansionType *T) {
     if (!T->isSugared())
       Visit(T->getPattern());
   }
   // FIXME: ElaboratedType, DependentNameType,
   // DependentTemplateSpecializationType, ObjCObjectType
 
+  void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
+    Visit(TL.getUnqualifiedLoc());
+  }
+  void VisitComplexTypeLoc(ComplexTypeLoc TL) { Visit(TL.getType()); }
+  void VisitPointerTypeLoc(PointerTypeLoc TL) { Visit(TL.getPointeeLoc()); }
+  void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
+    Visit(TL.getPointeeLoc());
+  }
+  void VisitReferenceTypeLoc(ReferenceTypeLoc TL) { Visit(TL.getPointeeLoc()); }
+  void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
+    Visit(TL.getClass());
+    Visit(TL.getPointeeLoc());
+  }
+  void VisitArrayTypeLoc(ArrayTypeLoc TL) { Visit(TL.getElementLoc()); }
+  void VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
+    VisitArrayTypeLoc(TL);
+  }
+  void VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL) {
+    VisitArrayTypeLoc(TL);
+  }
+  void VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL) {
+    Visit(TL.getElementLoc());
+  }
+  void VisitVectorTypeLoc(VectorTypeLoc TL) { Visit(TL.getElementLoc()); }
+  void VisitFunctionTypeLoc(FunctionTypeLoc TL) { Visit(TL.getReturnLoc()); }
+  void VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
+    VisitFunctionTypeLoc(TL);
+    // FIXME: Parameter TypeLocs
+  }
+  void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
+    Visit(TL.getUnderlyingExpr());
+  }
+  void VisitDecltypeTypeLoc(const DecltypeTypeLoc TL) {
+    Visit(TL.getUnderlyingExpr());
+  }
+  void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
+    // FIXME: Transformed TypeLoc
+  }
+  void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
+    // FIXME: AttrKind
+    Visit(TL.getModifiedLoc());
+  }
+  void VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) {
+    Visit(TL.getWrappedLoc());
+  }
+  void VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL) {
+    // FIXME: Replaced Parameter
+  }
+  void
+  VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL) {
+    // FIXME: Replaced Parameter, Argument Pack
+  }
+  void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
+    // FIXME: Arguments
+  }
+  void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
+    Visit(TL.getPointeeLoc());
+  }
+  void VisitAtomicTypeLoc(AtomicTypeLoc TL) { Visit(TL.getValueLoc()); }
+  void VisitPipeTypeLoc(PipeTypeLoc TL) { Visit(TL.getValueLoc()); }
+  void VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { Visit(TL.getOriginalLoc()); }
+  void VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
+    Visit(TL.getPatternLoc());
+  }
+  void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
+    Visit(TL.getNamedTypeLoc());
+  }
+  // FIXME: DependentNameTypeLoc, DependentTemplateSpecializationTypeLoc,
+  // ObjCObjectTypeLoc
+
   void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); }
 
   void VisitEnumConstantDecl(const EnumConstantDecl *D) {
     if (const Expr *Init = D->getInitExpr())
       Visit(Init);
   }
 
   void VisitFunctionDecl(const FunctionDecl *D) {

clang/include/clang/AST/TextNodeDumper.h

 #define LLVM_CLANG_AST_TEXTNODEDUMPER_H
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDumperUtils.h"
 #include "clang/AST/AttrVisitor.h"
 #include "clang/AST/CommentCommandTraits.h"
 #include "clang/AST/CommentVisitor.h"
 #include "clang/AST/DeclVisitor.h"
-#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/TemplateArgumentVisitor.h"
 #include "clang/AST/Type.h"
+#include "clang/AST/TypeLocVisitor.h"
 #include "clang/AST/TypeVisitor.h"
 
 namespace clang {
 
 class APValue;
 
 class TextTreeStructure {
   raw_ostream &OS;

 class TextNodeDumper
     : public TextTreeStructure,
       public comments::ConstCommentVisitor<TextNodeDumper, void,
                                            const comments::FullComment *>,
       public ConstAttrVisitor<TextNodeDumper>,
       public ConstTemplateArgumentVisitor<TextNodeDumper>,
       public ConstStmtVisitor<TextNodeDumper>,
       public TypeVisitor<TextNodeDumper>,
+      public TypeLocVisitor<TextNodeDumper>,
       public ConstDeclVisitor<TextNodeDumper> {
   raw_ostream &OS;
   const bool ShowColors;
 
   /// Keep track of the last location we print out so that we can
   /// print out deltas from then on out.
   const char *LastLocFilename = "";
   unsigned LastLocLine = ~0U;
void Visit(const TemplateArgument &TA, SourceRange R,
              const Decl *From = nullptr, StringRef Label = {});
 
   void Visit(const Stmt *Node);
 
   void Visit(const Type *T);
 
   void Visit(QualType T);
 
+  void Visit(TypeLoc TL);
+
   void Visit(const Decl *D);
 
   void Visit(const CXXCtorInitializer *Init);
 
   void Visit(const OMPClause *C);
 
   void Visit(const BlockDecl::Capture &C);
 
#include "clang/AST/AttrTextNodeDump.inc"
   void VisitAutoType(const AutoType *T);
   void VisitDeducedTemplateSpecializationType(
       const DeducedTemplateSpecializationType *T);
   void VisitTemplateSpecializationType(const TemplateSpecializationType *T);
   void VisitInjectedClassNameType(const InjectedClassNameType *T);
   void VisitObjCInterfaceType(const ObjCInterfaceType *T);
   void VisitPackExpansionType(const PackExpansionType *T);
 
+  void VisitQualifiedTypeLoc(QualifiedTypeLoc TL);
+  void VisitRValueReferenceTypeLoc(ReferenceTypeLoc TL);
+  void VisitArrayTypeLoc(ArrayTypeLoc TL);
+  void VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL);
+  void VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL);
+  void VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL);
+  void VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL);
+  void VisitVectorTypeLoc(VectorTypeLoc TL);
+  void VisitFunctionTypeLoc(FunctionTypeLoc TL);
+  void VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL);
+  void VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL);
+  void VisitUsingTypeLoc(UsingTypeLoc TL);
+  void VisitTypedefTypeLoc(TypedefTypeLoc TL);
+  void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL);
+  void VisitTagTypeLoc(TagTypeLoc TL);
+  void VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL);
+  void VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL);
+  void VisitAutoTypeLoc(AutoTypeLoc TL);
+  void VisitDeducedTemplateSpecializationTypeLoc(
+      DeducedTemplateSpecializationTypeLoc TL);
+  void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL);
+  void VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL);
+  void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL);
+  void VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL);
+
   void VisitLabelDecl(const LabelDecl *D);
   void VisitTypedefDecl(const TypedefDecl *D);
   void VisitEnumDecl(const EnumDecl *D);
   void VisitRecordDecl(const RecordDecl *D);
   void VisitEnumConstantDecl(const EnumConstantDecl *D);
   void VisitIndirectFieldDecl(const IndirectFieldDecl *D);
   void VisitFunctionDecl(const FunctionDecl *D);
   void VisitFieldDecl(const FieldDecl *D);

clang/include/clang/AST/TypeLoc.h

#include "clang/AST/TypeNodes.inc"
     Qualified
   };
 
   TypeLocClass getTypeLocClass() const {
     if (getType().hasLocalQualifiers()) return Qualified;
     return (TypeLocClass) getType()->getTypeClass();
   }
 
+  const char *getTypeLocClassName() const;
+
   bool isNull() const { return !Ty; }
   explicit operator bool() const { return Ty; }
 
   /// Returns the size of type source info data block for the given type.
   static unsigned getFullDataSizeForType(QualType Ty);
 
   /// Returns the alignment of type source info data block for
   /// the given type.

clang/lib/AST/TextNodeDumper.cpp

 
 #include "clang/AST/TextNodeDumper.h"
 #include "clang/AST/APValue.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/AST/Type.h"
+#include "clang/AST/TypeLocVisitor.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TypeTraits.h"
 #include "llvm/ADT/StringExtras.h"
 
 #include <algorithm>
 #include <utility>

 void TextNodeDumper::Visit(QualType T) {
   OS << "QualType";
   dumpPointer(T.getAsOpaquePtr());
   OS << " ";
   dumpBareType(T, false);
   OS << " " << T.split().Quals.getAsString();
 }
 
+void TextNodeDumper::Visit(TypeLoc TL) {
+  {
+    ColorScope Color(OS, ShowColors, TypeLocColor);
+    OS << TL.getTypeLocClassName() << "TypeLoc";
+  }
+  dumpSourceRange(TL.getSourceRange());
+  OS << " ";
+  dumpBareType(TL.getType(), false);
+
+  TypeLocVisitor<TextNodeDumper>::Visit(TL);
+}
+
 void TextNodeDumper::Visit(const Decl *D) {
   if (!D) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>>";
     return;
   }
 
   {
void TextNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
   dumpDeclRef(T->getDecl());
 }
 
 void TextNodeDumper::VisitPackExpansionType(const PackExpansionType *T) {
   if (auto N = T->getNumExpansions())
     OS << " expansions " << *N;
 }
 
+void TextNodeDumper::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
+  OS << " " << TL.getType().split().Quals.getAsString();
+}
+
+void TextNodeDumper::VisitRValueReferenceTypeLoc(ReferenceTypeLoc TL) {
+  VisitReferenceType(dyn_cast<ReferenceType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitArrayTypeLoc(ArrayTypeLoc TL) {
+  VisitArrayType(dyn_cast<ArrayType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
+  VisitConstantArrayType(
+      dyn_cast<ConstantArrayType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
+  VisitVariableArrayType(
+      dyn_cast<VariableArrayType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitDependentSizedArrayTypeLoc(
+    DependentSizedArrayTypeLoc TL) {
+  VisitDependentSizedArrayType(
+      dyn_cast<DependentSizedArrayType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitDependentSizedExtVectorTypeLoc(
+    DependentSizedExtVectorTypeLoc TL) {
+  VisitDependentSizedExtVectorType(
+      dyn_cast<DependentSizedExtVectorType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitVectorTypeLoc(VectorTypeLoc TL) {
+  VisitVectorType(dyn_cast<VectorType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
+  VisitFunctionType(dyn_cast<FunctionType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
+  VisitFunctionProtoType(
+      dyn_cast<FunctionProtoType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
+  VisitUnresolvedUsingType(
+      dyn_cast<UnresolvedUsingType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitUsingTypeLoc(UsingTypeLoc TL) {
+  VisitUsingType(dyn_cast<UsingType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
+  VisitTypedefType(dyn_cast<TypedefType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
+  VisitUnaryTransformType(
+      dyn_cast<UnaryTransformType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitTagTypeLoc(TagTypeLoc TL) {
+  VisitTagType(dyn_cast<TagType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
+  VisitTemplateTypeParmType(
+      dyn_cast<TemplateTypeParmType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitSubstTemplateTypeParmTypeLoc(
+    SubstTemplateTypeParmTypeLoc TL) {
+  VisitSubstTemplateTypeParmType(
+      dyn_cast<SubstTemplateTypeParmType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitAutoTypeLoc(AutoTypeLoc TL) {
+  VisitAutoType(dyn_cast<AutoType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitDeducedTemplateSpecializationTypeLoc(
+    DeducedTemplateSpecializationTypeLoc TL) {
+  VisitDeducedTemplateSpecializationType(
+      dyn_cast<DeducedTemplateSpecializationType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitTemplateSpecializationTypeLoc(
+    TemplateSpecializationTypeLoc TL) {
+  VisitTemplateSpecializationType(
+      dyn_cast<TemplateSpecializationType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitInjectedClassNameTypeLoc(
+    InjectedClassNameTypeLoc TL) {
+  VisitInjectedClassNameType(
+      dyn_cast<InjectedClassNameType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
+  VisitObjCInterfaceType(
+      dyn_cast<ObjCInterfaceType>(TL.getType().getTypePtr()));
+}
+
+void TextNodeDumper::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
+  VisitPackExpansionType(
+      dyn_cast<PackExpansionType>(TL.getType().getTypePtr()));
+}
+
 void TextNodeDumper::VisitLabelDecl(const LabelDecl *D) { dumpName(D); }
 
 void TextNodeDumper::VisitTypedefDecl(const TypedefDecl *D) {
   dumpName(D);
   dumpType(D->getUnderlyingType());
   if (D->isModulePrivate())
     OS << " __module_private__";
 }

clang/lib/AST/TypeLoc.cpp

 
 SourceRange TypeLoc::getLocalSourceRangeImpl(TypeLoc TL) {
   if (TL.isNull()) return SourceRange();
   return TypeLocRanger().Visit(TL);
 }
 
 namespace {
 
+class TypeNamer : public TypeLocVisitor<TypeNamer, const char *> {
+public:
+#define ABSTRACT_TYPELOC(CLASS, PARENT)
+#define TYPELOC(CLASS, PARENT)                                                 \
+  const char *Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { return #CLASS; }
+#include "clang/AST/TypeLocNodes.def"
+};
+
+} // namespace
+
+const char *TypeLoc::getTypeLocClassName() const {
+  return TypeNamer().Visit(*this);
+}
+
+namespace {
+
 class TypeAligner : public TypeLocVisitor<TypeAligner, unsigned> {
 public:
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
 #define TYPELOC(CLASS, PARENT) \
   unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
     return TyLoc.getLocalDataAlignment(); \
   }
 #include "clang/AST/TypeLocNodes.def"