[RecursiveASTVisitor] Fix post-order traversal of UnaryOperator

[teemperor]

Looks good to me. I'll add Richard because he also merged/approved the original post-order patch.

cfe/trunk/include/clang/AST/RecursiveASTVisitor.h

 #include "clang/AST/StmtNodes.inc"
 
 // Define Traverse*(), WalkUpFrom*(), and Visit*() for unary
 // operator methods.  Unary operators are not classes in themselves
 // (they're all opcodes in UnaryOperator) but do have visitors.
 #define OPERATOR(NAME)                                                         \
   bool TraverseUnary##NAME(UnaryOperator *S,                                   \
                            DataRecursionQueue *Queue = nullptr) {              \
-    TRY_TO(WalkUpFromUnary##NAME(S));                                          \
+    if (!getDerived().shouldTraversePostOrder())                               \
+      TRY_TO(WalkUpFromUnary##NAME(S));                                        \
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getSubExpr());                          \
     return true;                                                               \
   }                                                                            \
   bool WalkUpFromUnary##NAME(UnaryOperator *S) {                               \
     TRY_TO(WalkUpFromUnaryOperator(S));                                        \
     TRY_TO(VisitUnary##NAME(S));                                               \
     return true;                                                               \
   }                                                                            \

cfe/trunk/unittests/AST/PostOrderASTVisitor.cpp

explicit RecordingVisitor(bool VisitPostOrder)
       : VisitPostOrder(VisitPostOrder) {
     }
 
     // List of visited nodes during traversal.
     std::vector<std::string> VisitedNodes;
 
     bool shouldTraversePostOrder() const { return VisitPostOrder; }
 
+    bool VisitUnaryOperator(UnaryOperator *Op) {
+      VisitedNodes.push_back(Op->getOpcodeStr(Op->getOpcode()));
+      return true;
+    }
+
     bool VisitBinaryOperator(BinaryOperator *Op) {
       VisitedNodes.push_back(Op->getOpcodeStr());
       return true;
     }
 
     bool VisitIntegerLiteral(IntegerLiteral *Lit) {
       VisitedNodes.push_back(Lit->getValue().toString(10, false));
       return true;
namespace {
   };
 
 }
 
 TEST(RecursiveASTVisitor, PostOrderTraversal) {
   auto ASTUnit = tooling::buildASTFromCode(
     "class A {"
     "  class B {"
-    "    int foo() { while(4) { int i = 9; } return (1 + 3) + 2; }"
+    "    int foo() { while(4) { int i = 9; int j = -i; } return (1 + 3) + 2; }"
     "  };"
     "};"
   );
   auto TU = ASTUnit->getASTContext().getTranslationUnitDecl();
   // We traverse the translation unit and store all
   // visited nodes.
   RecordingVisitor Visitor(true);
   Visitor.TraverseTranslationUnitDecl(TU);
 
   std::vector<std::string> expected = {
-    "4", "9", "i", "1", "3", "+", "2", "+", "return", "A::B::foo", "A::B", "A"
+    "4", "9", "i", "-", "j", "1", "3", "+", "2", "+", "return", "A::B::foo", "A::B", "A"
   };
   // Compare the list of actually visited nodes
   // with the expected list of visited nodes.
   ASSERT_EQ(expected.size(), Visitor.VisitedNodes.size());
   for (std::size_t I = 0; I < expected.size(); I++) {
     ASSERT_EQ(expected[I], Visitor.VisitedNodes[I]);
   }
 }