1 files changed, 465 insertions, 0 deletions
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index c4d2f4c7517..9c20e08b902 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -77,6 +77,60 @@ void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
   ConstTemplateArgumentVisitor<TextNodeDumper>::Visit(TA);
 }
 
+void TextNodeDumper::Visit(const Stmt *Node) {
+  if (!Node) {
+    ColorScope Color(OS, ShowColors, NullColor);
+    OS << "<<<NULL>>>";
+    return;
+  }
+  {
+    ColorScope Color(OS, ShowColors, StmtColor);
+    OS << Node->getStmtClassName();
+  }
+  dumpPointer(Node);
+  dumpSourceRange(Node->getSourceRange());
+
+  if (const auto *E = dyn_cast<Expr>(Node)) {
+    dumpType(E->getType());
+
+    {
+      ColorScope Color(OS, ShowColors, ValueKindColor);
+      switch (E->getValueKind()) {
+      case VK_RValue:
+        break;
+      case VK_LValue:
+        OS << " lvalue";
+        break;
+      case VK_XValue:
+        OS << " xvalue";
+        break;
+      }
+    }
+
+    {
+      ColorScope Color(OS, ShowColors, ObjectKindColor);
+      switch (E->getObjectKind()) {
+      case OK_Ordinary:
+        break;
+      case OK_BitField:
+        OS << " bitfield";
+        break;
+      case OK_ObjCProperty:
+        OS << " objcproperty";
+        break;
+      case OK_ObjCSubscript:
+        OS << " objcsubscript";
+        break;
+      case OK_VectorComponent:
+        OS << " vectorcomponent";
+        break;
+      }
+    }
+  }
+
+  ConstStmtVisitor<TextNodeDumper>::Visit(Node);
+}
+
 void TextNodeDumper::dumpPointer(const void *Ptr) {
   ColorScope Color(OS, ShowColors, AddressColor);
   OS << ' ' << Ptr;
@@ -372,3 +426,414 @@ void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
 void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &) {
   OS << " pack";
 }
+
+static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
+  if (Node->path_empty())
+    return;
+
+  OS << " (";
+  bool First = true;
+  for (CastExpr::path_const_iterator I = Node->path_begin(),
+                                     E = Node->path_end();
+       I != E; ++I) {
+    const CXXBaseSpecifier *Base = *I;
+    if (!First)
+      OS << " -> ";
+
+    const CXXRecordDecl *RD =
+        cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
+
+    if (Base->isVirtual())
+      OS << "virtual ";
+    OS << RD->getName();
+    First = false;
+  }
+
+  OS << ')';
+}
+
+void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
+  if (Node->hasInitStorage())
+    OS << " has_init";
+  if (Node->hasVarStorage())
+    OS << " has_var";
+  if (Node->hasElseStorage())
+    OS << " has_else";
+}
+
+void TextNodeDumper::VisitSwitchStmt(const SwitchStmt *Node) {
+  if (Node->hasInitStorage())
+    OS << " has_init";
+  if (Node->hasVarStorage())
+    OS << " has_var";
+}
+
+void TextNodeDumper::VisitWhileStmt(const WhileStmt *Node) {
+  if (Node->hasVarStorage())
+    OS << " has_var";
+}
+
+void TextNodeDumper::VisitLabelStmt(const LabelStmt *Node) {
+  OS << " '" << Node->getName() << "'";
+}
+
+void TextNodeDumper::VisitGotoStmt(const GotoStmt *Node) {
+  OS << " '" << Node->getLabel()->getName() << "'";
+  dumpPointer(Node->getLabel());
+}
+
+void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
+  if (Node->caseStmtIsGNURange())
+    OS << " gnu_range";
+}
+
+void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
+  if (Node->usesADL())
+    OS << " adl";
+}
+
+void TextNodeDumper::VisitCastExpr(const CastExpr *Node) {
+  OS << " <";
+  {
+    ColorScope Color(OS, ShowColors, CastColor);
+    OS << Node->getCastKindName();
+  }
+  dumpBasePath(OS, Node);
+  OS << ">";
+}
+
+void TextNodeDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
+  VisitCastExpr(Node);
+  if (Node->isPartOfExplicitCast())
+    OS << " part_of_explicit_cast";
+}
+
+void TextNodeDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
+  OS << " ";
+  dumpBareDeclRef(Node->getDecl());
+  if (Node->getDecl() != Node->getFoundDecl()) {
+    OS << " (";
+    dumpBareDeclRef(Node->getFoundDecl());
+    OS << ")";
+  }
+}
+
+void TextNodeDumper::VisitUnresolvedLookupExpr(
+    const UnresolvedLookupExpr *Node) {
+  OS << " (";
+  if (!Node->requiresADL())
+    OS << "no ";
+  OS << "ADL) = '" << Node->getName() << '\'';
+
+  UnresolvedLookupExpr::decls_iterator I = Node->decls_begin(),
+                                       E = Node->decls_end();
+  if (I == E)
+    OS << " empty";
+  for (; I != E; ++I)
+    dumpPointer(*I);
+}
+
+void TextNodeDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
+  {
+    ColorScope Color(OS, ShowColors, DeclKindNameColor);
+    OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
+  }
+  OS << "='" << *Node->getDecl() << "'";
+  dumpPointer(Node->getDecl());
+  if (Node->isFreeIvar())
+    OS << " isFreeIvar";
+}
+
+void TextNodeDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
+  OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
+}
+
+void TextNodeDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
+  ColorScope Color(OS, ShowColors, ValueColor);
+  OS << " " << Node->getValue();
+}
+
+void TextNodeDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
+  bool isSigned = Node->getType()->isSignedIntegerType();
+  ColorScope Color(OS, ShowColors, ValueColor);
+  OS << " " << Node->getValue().toString(10, isSigned);
+}
+
+void TextNodeDumper::VisitFixedPointLiteral(const FixedPointLiteral *Node) {
+  ColorScope Color(OS, ShowColors, ValueColor);
+  OS << " " << Node->getValueAsString(/*Radix=*/10);
+}
+
+void TextNodeDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
+  ColorScope Color(OS, ShowColors, ValueColor);
+  OS << " " << Node->getValueAsApproximateDouble();
+}
+
+void TextNodeDumper::VisitStringLiteral(const StringLiteral *Str) {
+  ColorScope Color(OS, ShowColors, ValueColor);
+  OS << " ";
+  Str->outputString(OS);
+}
+
+void TextNodeDumper::VisitInitListExpr(const InitListExpr *ILE) {
+  if (auto *Field = ILE->getInitializedFieldInUnion()) {
+    OS << " field ";
+    dumpBareDeclRef(Field);
+  }
+}
+
+void TextNodeDumper::VisitUnaryOperator(const UnaryOperator *Node) {
+  OS << " " << (Node->isPostfix() ? "postfix" : "prefix") << " '"
+     << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
+  if (!Node->canOverflow())
+    OS << " cannot overflow";
+}
+
+void TextNodeDumper::VisitUnaryExprOrTypeTraitExpr(
+    const UnaryExprOrTypeTraitExpr *Node) {
+  switch (Node->getKind()) {
+  case UETT_SizeOf:
+    OS << " sizeof";
+    break;
+  case UETT_AlignOf:
+    OS << " alignof";
+    break;
+  case UETT_VecStep:
+    OS << " vec_step";
+    break;
+  case UETT_OpenMPRequiredSimdAlign:
+    OS << " __builtin_omp_required_simd_align";
+    break;
+  case UETT_PreferredAlignOf:
+    OS << " __alignof";
+    break;
+  }
+  if (Node->isArgumentType())
+    dumpType(Node->getArgumentType());
+}
+
+void TextNodeDumper::VisitMemberExpr(const MemberExpr *Node) {
+  OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
+  dumpPointer(Node->getMemberDecl());
+}
+
+void TextNodeDumper::VisitExtVectorElementExpr(
+    const ExtVectorElementExpr *Node) {
+  OS << " " << Node->getAccessor().getNameStart();
+}
+
+void TextNodeDumper::VisitBinaryOperator(const BinaryOperator *Node) {
+  OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
+}
+
+void TextNodeDumper::VisitCompoundAssignOperator(
+    const CompoundAssignOperator *Node) {
+  OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
+     << "' ComputeLHSTy=";
+  dumpBareType(Node->getComputationLHSType());
+  OS << " ComputeResultTy=";
+  dumpBareType(Node->getComputationResultType());
+}
+
+void TextNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
+  OS << " " << Node->getLabel()->getName();
+  dumpPointer(Node->getLabel());
+}
+
+void TextNodeDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
+  OS << " " << Node->getCastName() << "<"
+     << Node->getTypeAsWritten().getAsString() << ">"
+     << " <" << Node->getCastKindName();
+  dumpBasePath(OS, Node);
+  OS << ">";
+}
+
+void TextNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
+  OS << " " << (Node->getValue() ? "true" : "false");
+}
+
+void TextNodeDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
+  OS << " this";
+}
+
+void TextNodeDumper::VisitCXXFunctionalCastExpr(
+    const CXXFunctionalCastExpr *Node) {
+  OS << " functional cast to " << Node->getTypeAsWritten().getAsString() << " <"
+     << Node->getCastKindName() << ">";
+}
+
+void TextNodeDumper::VisitCXXUnresolvedConstructExpr(
+    const CXXUnresolvedConstructExpr *Node) {
+  dumpType(Node->getTypeAsWritten());
+  if (Node->isListInitialization())
+    OS << " list";
+}
+
+void TextNodeDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
+  CXXConstructorDecl *Ctor = Node->getConstructor();
+  dumpType(Ctor->getType());
+  if (Node->isElidable())
+    OS << " elidable";
+  if (Node->isListInitialization())
+    OS << " list";
+  if (Node->isStdInitListInitialization())
+    OS << " std::initializer_list";
+  if (Node->requiresZeroInitialization())
+    OS << " zeroing";
+}
+
+void TextNodeDumper::VisitCXXBindTemporaryExpr(
+    const CXXBindTemporaryExpr *Node) {
+  OS << " ";
+  dumpCXXTemporary(Node->getTemporary());
+}
+
+void TextNodeDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
+  if (Node->isGlobalNew())
+    OS << " global";
+  if (Node->isArray())
+    OS << " array";
+  if (Node->getOperatorNew()) {
+    OS << ' ';
+    dumpBareDeclRef(Node->getOperatorNew());
+  }
+  // We could dump the deallocation function used in case of error, but it's
+  // usually not that interesting.
+}
+
+void TextNodeDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
+  if (Node->isGlobalDelete())
+    OS << " global";
+  if (Node->isArrayForm())
+    OS << " array";
+  if (Node->getOperatorDelete()) {
+    OS << ' ';
+    dumpBareDeclRef(Node->getOperatorDelete());
+  }
+}
+
+void TextNodeDumper::VisitMaterializeTemporaryExpr(
+    const MaterializeTemporaryExpr *Node) {
+  if (const ValueDecl *VD = Node->getExtendingDecl()) {
+    OS << " extended by ";
+    dumpBareDeclRef(VD);
+  }
+}
+
+void TextNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
+  for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
+    dumpDeclRef(Node->getObject(i), "cleanup");
+}
+
+void TextNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
+  dumpPointer(Node->getPack());
+  dumpName(Node->getPack());
+}
+
+void TextNodeDumper::VisitCXXDependentScopeMemberExpr(
+    const CXXDependentScopeMemberExpr *Node) {
+  OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
+}
+
+void TextNodeDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
+  OS << " selector=";
+  Node->getSelector().print(OS);
+  switch (Node->getReceiverKind()) {
+  case ObjCMessageExpr::Instance:
+    break;
+
+  case ObjCMessageExpr::Class:
+    OS << " class=";
+    dumpBareType(Node->getClassReceiver());
+    break;
+
+  case ObjCMessageExpr::SuperInstance:
+    OS << " super (instance)";
+    break;
+
+  case ObjCMessageExpr::SuperClass:
+    OS << " super (class)";
+    break;
+  }
+}
+
+void TextNodeDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
+  if (auto *BoxingMethod = Node->getBoxingMethod()) {
+    OS << " selector=";
+    BoxingMethod->getSelector().print(OS);
+  }
+}
+
+void TextNodeDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
+  if (!Node->getCatchParamDecl())
+    OS << " catch all";
+}
+
+void TextNodeDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
+  dumpType(Node->getEncodedType());
+}
+
+void TextNodeDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
+  OS << " ";
+  Node->getSelector().print(OS);
+}
+
+void TextNodeDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
+  OS << ' ' << *Node->getProtocol();
+}
+
+void TextNodeDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
+  if (Node->isImplicitProperty()) {
+    OS << " Kind=MethodRef Getter=\"";
+    if (Node->getImplicitPropertyGetter())
+      Node->getImplicitPropertyGetter()->getSelector().print(OS);
+    else
+      OS << "(null)";
+
+    OS << "\" Setter=\"";
+    if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
+      Setter->getSelector().print(OS);
+    else
+      OS << "(null)";
+    OS << "\"";
+  } else {
+    OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty()
+       << '"';
+  }
+
+  if (Node->isSuperReceiver())
+    OS << " super";
+
+  OS << " Messaging=";
+  if (Node->isMessagingGetter() && Node->isMessagingSetter())
+    OS << "Getter&Setter";
+  else if (Node->isMessagingGetter())
+    OS << "Getter";
+  else if (Node->isMessagingSetter())
+    OS << "Setter";
+}
+
+void TextNodeDumper::VisitObjCSubscriptRefExpr(
+    const ObjCSubscriptRefExpr *Node) {
+  if (Node->isArraySubscriptRefExpr())
+    OS << " Kind=ArraySubscript GetterForArray=\"";
+  else
+    OS << " Kind=DictionarySubscript GetterForDictionary=\"";
+  if (Node->getAtIndexMethodDecl())
+    Node->getAtIndexMethodDecl()->getSelector().print(OS);
+  else
+    OS << "(null)";
+
+  if (Node->isArraySubscriptRefExpr())
+    OS << "\" SetterForArray=\"";
+  else
+    OS << "\" SetterForDictionary=\"";
+  if (Node->setAtIndexMethodDecl())
+    Node->setAtIndexMethodDecl()->getSelector().print(OS);
+  else
+    OS << "(null)";
+}
+
+void TextNodeDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
+  OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
+}