Author: Dmitri Gribenko Date: 2020-07-06T13:38:01+02:00 New Revision: 5689b38c6a4220cc5f6ba68a56486229b10071bf
URL: https://github.com/llvm/llvm-project/commit/5689b38c6a4220cc5f6ba68a56486229b10071bf DIFF: https://github.com/llvm/llvm-project/commit/5689b38c6a4220cc5f6ba68a56486229b10071bf.diff LOG: Removed a RecursiveASTVisitor feature to visit operator kinds with different methods Summary: This feature was only used in two places, but contributed a non-trivial amount to the complexity of RecursiveASTVisitor, and was buggy (see my recent patches where I was fixing the bugs that I noticed). I don't think the convenience benefit of this feature is worth the complexity. Besides complexity, another issue with the current state of RecursiveASTVisitor is the non-uniformity in how it handles different AST nodes. All AST nodes follow a regular pattern, but operators are special -- and this special behavior not documented. Correct usage of RecursiveASTVisitor relies on shadowing member functions with specific names and signatures. Near misses don't cause any compile-time errors, incorrectly named or typed methods are just silently ignored. Therefore, predictability of RecursiveASTVisitor API is quite important. This change reduces the size of the `clang` binary by 38 KB (0.2%) in release mode, and by 7 MB (0.3%) in debug mode. The `clang-tidy` binary is reduced by 205 KB (0.3%) in release mode, and by 5 MB (0.4%) in debug mode. I don't think these code size improvements are significant enough to justify this change on its own (for me, the primary motivation is reducing code complexity), but they I think are a nice side-effect. Reviewers: rsmith, sammccall, ymandel, aaron.ballman Reviewed By: rsmith, sammccall, ymandel, aaron.ballman Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D82921 Added: Modified: clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h clang/docs/ReleaseNotes.rst clang/include/clang/AST/RecursiveASTVisitor.h clang/lib/ARCMigrate/TransProperties.cpp clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp Removed: ################################################################################ diff --git a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp index 67f281b3ed1f..56d4cceb6002 100644 --- a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp +++ b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp @@ -500,7 +500,7 @@ void ForLoopIndexUseVisitor::addUsage(const Usage &U) { /// int k = *i + 2; /// } /// \endcode -bool ForLoopIndexUseVisitor::TraverseUnaryDeref(UnaryOperator *Uop) { +bool ForLoopIndexUseVisitor::TraverseUnaryOperator(UnaryOperator *Uop) { // If we dereference an iterator that's actually a pointer, count the // occurrence. if (isDereferenceOfUop(Uop, IndexVar)) { diff --git a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h index b2cba8c0172a..4f75c9c7522f 100644 --- a/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h +++ b/clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.h @@ -346,7 +346,7 @@ class ForLoopIndexUseVisitor bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C, Expr *Init); bool TraverseMemberExpr(MemberExpr *Member); - bool TraverseUnaryDeref(UnaryOperator *Uop); + bool TraverseUnaryOperator(UnaryOperator *Uop); bool VisitDeclRefExpr(DeclRefExpr *E); bool VisitDeclStmt(DeclStmt *S); bool TraverseStmt(Stmt *S); diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index d0328b0ef54c..8a9a58aa01f8 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -243,6 +243,34 @@ These are major API changes that have happened since the 10.0.0 release of Clang. If upgrading an external codebase that uses Clang as a library, this section should help get you past the largest hurdles of upgrading. +- ``RecursiveASTVisitor`` no longer calls separate methods to visit specific + operator kinds. Previously, ``RecursiveASTVisitor`` treated unary, binary, + and compound assignment operators as if they were subclasses of the + corresponding AST node. For example, the binary operator plus was treated as + if it was a ``BinAdd`` subclass of the ``BinaryOperator`` class: during AST + traversal of a ``BinaryOperator`` AST node that had a ``BO_Add`` opcode, + ``RecursiveASTVisitor`` was calling the ``TraverseBinAdd`` method instead of + ``TraverseBinaryOperator``. This feature was contributing a non-trivial + amount of complexity to the implementation of ``RecursiveASTVisitor``, it was + used only in a minor way in Clang, was not tested, and as a result it was + buggy. Furthermore, this feature was creating a non-uniformity in the API. + Since this feature was not documented, it was quite diff icult to figure out + how to use ``RecursiveASTVisitor`` to visit operators. + + To update your code to the new uniform API, move the code from separate + visitation methods into methods that correspond to the actual AST node and + perform case analysis based on the operator opcode as needed: + + * ``TraverseUnary*() => TraverseUnaryOperator()`` + * ``WalkUpFromUnary*() => WalkUpFromUnaryOperator()`` + * ``VisitUnary*() => VisiUnaryOperator()`` + * ``TraverseBin*() => TraverseBinaryOperator()`` + * ``WalkUpFromBin*() => WalkUpFromBinaryOperator()`` + * ``VisitBin*() => VisiBinaryOperator()`` + * ``TraverseBin*Assign() => TraverseCompoundAssignOperator()`` + * ``WalkUpFromBin*Assign() => WalkUpFromCompoundAssignOperator()`` + * ``VisitBin*Assign() => VisiCompoundAssignOperator()`` + Build System Changes -------------------- diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h index 0d7c2b81512c..3dcfc9fee629 100644 --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -48,29 +48,6 @@ #include <cstddef> #include <type_traits> -// The following three macros are used for meta programming. The code -// using them is responsible for defining macro OPERATOR(). - -// All unary operators. -#define UNARYOP_LIST() \ - OPERATOR(PostInc) OPERATOR(PostDec) OPERATOR(PreInc) OPERATOR(PreDec) \ - OPERATOR(AddrOf) OPERATOR(Deref) OPERATOR(Plus) OPERATOR(Minus) \ - OPERATOR(Not) OPERATOR(LNot) OPERATOR(Real) OPERATOR(Imag) \ - OPERATOR(Extension) OPERATOR(Coawait) - -// All binary operators (excluding compound assign operators). -#define BINOP_LIST() \ - OPERATOR(PtrMemD) OPERATOR(PtrMemI) OPERATOR(Mul) OPERATOR(Div) \ - OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) OPERATOR(Shl) OPERATOR(Shr) \ - OPERATOR(LT) OPERATOR(GT) OPERATOR(LE) OPERATOR(GE) OPERATOR(EQ) \ - OPERATOR(NE) OPERATOR(Cmp) OPERATOR(And) OPERATOR(Xor) OPERATOR(Or) \ - OPERATOR(LAnd) OPERATOR(LOr) OPERATOR(Assign) OPERATOR(Comma) - -// All compound assign operators. -#define CAO_LIST() \ - OPERATOR(Mul) OPERATOR(Div) OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) \ - OPERATOR(Shl) OPERATOR(Shr) OPERATOR(And) OPERATOR(Or) OPERATOR(Xor) - namespace clang { // A helper macro to implement short-circuiting when recursing. It @@ -407,64 +384,6 @@ template <typename Derived> class RecursiveASTVisitor { bool Visit##CLASS(CLASS *S) { return true; } #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) { \ - if (!getDerived().shouldTraversePostOrder()) \ - TRY_TO(WalkUpFromUnary##NAME(S)); \ - TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getSubExpr()); \ - if (!Queue && getDerived().shouldTraversePostOrder()) \ - TRY_TO(WalkUpFromUnary##NAME(S)); \ - return true; \ - } \ - bool WalkUpFromUnary##NAME(UnaryOperator *S) { \ - TRY_TO(WalkUpFromUnaryOperator(S)); \ - TRY_TO(VisitUnary##NAME(S)); \ - return true; \ - } \ - bool VisitUnary##NAME(UnaryOperator *S) { return true; } - - UNARYOP_LIST() -#undef OPERATOR - -// Define Traverse*(), WalkUpFrom*(), and Visit*() for binary -// operator methods. Binary operators are not classes in themselves -// (they're all opcodes in BinaryOperator) but do have visitors. -#define GENERAL_BINOP_FALLBACK(NAME, BINOP_TYPE) \ - bool TraverseBin##NAME(BINOP_TYPE *S, DataRecursionQueue *Queue = nullptr) { \ - if (!getDerived().shouldTraversePostOrder()) \ - TRY_TO(WalkUpFromBin##NAME(S)); \ - TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getLHS()); \ - TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getRHS()); \ - if (!Queue && getDerived().shouldTraversePostOrder()) \ - TRY_TO(WalkUpFromBin##NAME(S)); \ - return true; \ - } \ - bool WalkUpFromBin##NAME(BINOP_TYPE *S) { \ - TRY_TO(WalkUpFrom##BINOP_TYPE(S)); \ - TRY_TO(VisitBin##NAME(S)); \ - return true; \ - } \ - bool VisitBin##NAME(BINOP_TYPE *S) { return true; } - -#define OPERATOR(NAME) GENERAL_BINOP_FALLBACK(NAME, BinaryOperator) - BINOP_LIST() -#undef OPERATOR - -// Define Traverse*(), WalkUpFrom*(), and Visit*() for compound -// assignment methods. Compound assignment operators are not -// classes in themselves (they're all opcodes in -// CompoundAssignOperator) but do have visitors. -#define OPERATOR(NAME) \ - GENERAL_BINOP_FALLBACK(NAME##Assign, CompoundAssignOperator) - - CAO_LIST() -#undef OPERATOR -#undef GENERAL_BINOP_FALLBACK - // ---- Methods on Types ---- // FIXME: revamp to take TypeLoc's rather than Types. @@ -583,39 +502,6 @@ template <typename Derived> class RecursiveASTVisitor { template <typename Derived> bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S, DataRecursionQueue *Queue) { -#define DISPATCH_STMT(NAME, CLASS, VAR) \ - return TRAVERSE_STMT_BASE(NAME, CLASS, VAR, Queue); - - // If we have a binary expr, dispatch to the subcode of the binop. A smart - // optimizer (e.g. LLVM) will fold this comparison into the switch stmt - // below. - if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(S)) { - switch (BinOp->getOpcode()) { -#define OPERATOR(NAME) \ - case BO_##NAME: \ - DISPATCH_STMT(Bin##NAME, BinaryOperator, S); - - BINOP_LIST() -#undef OPERATOR - -#define OPERATOR(NAME) \ - case BO_##NAME##Assign: \ - DISPATCH_STMT(Bin##NAME##Assign, CompoundAssignOperator, S); - - CAO_LIST() -#undef OPERATOR - } - } else if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S)) { - switch (UnOp->getOpcode()) { -#define OPERATOR(NAME) \ - case UO_##NAME: \ - DISPATCH_STMT(Unary##NAME, UnaryOperator, S); - - UNARYOP_LIST() -#undef OPERATOR - } - } - // Top switch stmt: dispatch to TraverseFooStmt for each concrete FooStmt. switch (S->getStmtClass()) { case Stmt::NoStmtClass: @@ -623,7 +509,7 @@ bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S, #define ABSTRACT_STMT(STMT) #define STMT(CLASS, PARENT) \ case Stmt::CLASS##Class: \ - DISPATCH_STMT(CLASS, CLASS, S); + return TRAVERSE_STMT_BASE(CLASS, CLASS, S, Queue); #include "clang/AST/StmtNodes.inc" } @@ -650,48 +536,6 @@ bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) { // user did not override the Traverse##STMT method. We implement the override // check with isSameMethod calls below. - if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(S)) { - switch (BinOp->getOpcode()) { -#define OPERATOR(NAME) \ - case BO_##NAME: \ - if (::clang::detail::isSameMethod(&RecursiveASTVisitor::TraverseBin##NAME, \ - &Derived::TraverseBin##NAME)) { \ - TRY_TO(WalkUpFromBin##NAME(static_cast<BinaryOperator *>(S))); \ - } \ - return true; - - BINOP_LIST() -#undef OPERATOR - -#define OPERATOR(NAME) \ - case BO_##NAME##Assign: \ - if (::clang::detail::isSameMethod( \ - &RecursiveASTVisitor::TraverseBin##NAME##Assign, \ - &Derived::TraverseBin##NAME##Assign)) { \ - TRY_TO(WalkUpFromBin##NAME##Assign( \ - static_cast<CompoundAssignOperator *>(S))); \ - } \ - return true; - - CAO_LIST() -#undef OPERATOR - } - } else if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S)) { - switch (UnOp->getOpcode()) { -#define OPERATOR(NAME) \ - case UO_##NAME: \ - if (::clang::detail::isSameMethod( \ - &RecursiveASTVisitor::TraverseUnary##NAME, \ - &Derived::TraverseUnary##NAME)) { \ - TRY_TO(WalkUpFromUnary##NAME(static_cast<UnaryOperator *>(S))); \ - } \ - return true; - - UNARYOP_LIST() -#undef OPERATOR - } - } - switch (S->getStmtClass()) { case Stmt::NoStmtClass: break; @@ -3711,10 +3555,6 @@ bool RecursiveASTVisitor<Derived>::VisitOMPAffinityClause( #undef TRY_TO -#undef UNARYOP_LIST -#undef BINOP_LIST -#undef CAO_LIST - } // end namespace clang #endif // LLVM_CLANG_AST_RECURSIVEASTVISITOR_H diff --git a/clang/lib/ARCMigrate/TransProperties.cpp b/clang/lib/ARCMigrate/TransProperties.cpp index adfb4bd77ac6..cba2256ef97b 100644 --- a/clang/lib/ARCMigrate/TransProperties.cpp +++ b/clang/lib/ARCMigrate/TransProperties.cpp @@ -287,7 +287,10 @@ class PropertiesRewriter { public: PlusOneAssign(ObjCIvarDecl *D) : Ivar(D) {} - bool VisitBinAssign(BinaryOperator *E) { + bool VisitBinaryOperator(BinaryOperator *E) { + if (E->getOpcode() != BO_Assign) + return true; + Expr *lhs = E->getLHS()->IgnoreParenImpCasts(); if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(lhs)) { if (RE->getDecl() != Ivar) diff --git a/clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp b/clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp index 70c7eb37ad4c..71f2bf6be599 100644 --- a/clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp +++ b/clang/unittests/Tooling/RecursiveASTVisitorTests/Callbacks.cpp @@ -403,622 +403,40 @@ void test() { } )cpp"; - // TraverseUnaryOperator is not called because RecursiveASTVisitor treats - // individual operators as subclasses, for which it calls their Traverse - // methods. EXPECT_TRUE(visitorCallbackLogEqual( RecordingVisitor(ShouldTraversePostOrder::No), Code, R"txt( WalkUpFromStmt CompoundStmt WalkUpFromStmt IntegerLiteral(1) -WalkUpFromStmt UnaryOperator(-) -WalkUpFromStmt IntegerLiteral(2) -WalkUpFromStmt IntegerLiteral(3) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromStmt IntegerLiteral(1) -WalkUpFromStmt IntegerLiteral(2) -WalkUpFromStmt UnaryOperator(-) -WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, - StmtCallbacks_TraverseUnaryOperator_WalkUpFromUnaryOperator) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool TraverseUnaryOperator(UnaryOperator *UO) { - recordCallback(__func__, UO, [&]() { - RecordingVisitorBase::TraverseUnaryOperator(UO); - }); - return true; - } - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - - bool WalkUpFromExpr(Expr *E) { - recordCallback(__func__, E, - [&]() { RecordingVisitorBase::WalkUpFromExpr(E); }); - return true; - } - - bool WalkUpFromUnaryOperator(UnaryOperator *UO) { - recordCallback(__func__, UO, [&]() { - RecordingVisitorBase::WalkUpFromUnaryOperator(UO); - }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - -2; - 3; -} -)cpp"; - - // TraverseUnaryOperator is not called because RecursiveASTVisitor treats - // individual operators as subclasses, for which it calls their Traverse - // methods. - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromUnaryOperator UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromUnaryOperator UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromUnaryOperator) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - - bool WalkUpFromExpr(Expr *E) { - recordCallback(__func__, E, - [&]() { RecordingVisitorBase::WalkUpFromExpr(E); }); - return true; - } - - bool WalkUpFromUnaryOperator(UnaryOperator *UO) { - recordCallback(__func__, UO, [&]() { - RecordingVisitorBase::WalkUpFromUnaryOperator(UO); - }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - -2; - 3; -} -)cpp"; - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromUnaryOperator UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromUnaryOperator UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, StmtCallbacks_TraverseUnaryMinus) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool TraverseUnaryMinus(UnaryOperator *UO) { - recordCallback(__func__, UO, - [&]() { RecordingVisitorBase::TraverseUnaryMinus(UO); }); - return true; - } - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - -2; - 3; -} -)cpp"; - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromStmt IntegerLiteral(1) -TraverseUnaryMinus UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromStmt IntegerLiteral(3) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromStmt IntegerLiteral(1) -TraverseUnaryMinus UnaryOperator(-) - WalkUpFromStmt IntegerLiteral(2) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, - StmtCallbacks_TraverseUnaryMinus_WalkUpFromUnaryMinus) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool TraverseUnaryMinus(UnaryOperator *UO) { - recordCallback(__func__, UO, - [&]() { RecordingVisitorBase::TraverseUnaryMinus(UO); }); - return true; - } - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - - bool WalkUpFromExpr(Expr *E) { - recordCallback(__func__, E, - [&]() { RecordingVisitorBase::WalkUpFromExpr(E); }); - return true; - } - - bool WalkUpFromUnaryMinus(UnaryOperator *UO) { - recordCallback(__func__, UO, - [&]() { RecordingVisitorBase::WalkUpFromUnaryMinus(UO); }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - -2; - 3; -} -)cpp"; - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -TraverseUnaryMinus UnaryOperator(-) - WalkUpFromUnaryMinus UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) - WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -TraverseUnaryMinus UnaryOperator(-) - WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) - WalkUpFromUnaryMinus UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromUnaryMinus) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - - bool WalkUpFromExpr(Expr *E) { - recordCallback(__func__, E, - [&]() { RecordingVisitorBase::WalkUpFromExpr(E); }); - return true; - } - - bool WalkUpFromUnaryMinus(UnaryOperator *UO) { - recordCallback(__func__, UO, - [&]() { RecordingVisitorBase::WalkUpFromUnaryMinus(UO); }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - -2; - 3; -} -)cpp"; - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromUnaryMinus UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromUnaryMinus UnaryOperator(-) - WalkUpFromExpr UnaryOperator(-) - WalkUpFromStmt UnaryOperator(-) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinaryOperator) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool TraverseBinaryOperator(BinaryOperator *BO) { - recordCallback(__func__, BO, [&]() { - RecordingVisitorBase::TraverseBinaryOperator(BO); - }); - return true; - } - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - 2 + 3; - 4; -} -)cpp"; - - // TraverseBinaryOperator is not called because RecursiveASTVisitor treats - // individual operators as subclasses, for which it calls their Traverse - // methods. - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromStmt IntegerLiteral(1) -WalkUpFromStmt BinaryOperator(+) -WalkUpFromStmt IntegerLiteral(2) -WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt IntegerLiteral(4) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromStmt IntegerLiteral(1) -WalkUpFromStmt IntegerLiteral(2) -WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt BinaryOperator(+) -WalkUpFromStmt IntegerLiteral(4) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, - StmtCallbacks_TraverseBinaryOperator_WalkUpFromBinaryOperator) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool TraverseBinaryOperator(BinaryOperator *BO) { - recordCallback(__func__, BO, [&]() { - RecordingVisitorBase::TraverseBinaryOperator(BO); - }); - return true; - } - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - - bool WalkUpFromExpr(Expr *E) { - recordCallback(__func__, E, - [&]() { RecordingVisitorBase::WalkUpFromExpr(E); }); - return true; - } - - bool WalkUpFromBinaryOperator(BinaryOperator *BO) { - recordCallback(__func__, BO, [&]() { - RecordingVisitorBase::WalkUpFromBinaryOperator(BO); - }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - 2 + 3; - 4; -} -)cpp"; - - // TraverseBinaryOperator is not called because RecursiveASTVisitor treats - // individual operators as subclasses, for which it calls their Traverse - // methods. - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromBinaryOperator BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromBinaryOperator BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinaryOperator) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - - bool WalkUpFromExpr(Expr *E) { - recordCallback(__func__, E, - [&]() { RecordingVisitorBase::WalkUpFromExpr(E); }); - return true; - } - - bool WalkUpFromBinaryOperator(BinaryOperator *BO) { - recordCallback(__func__, BO, [&]() { - RecordingVisitorBase::WalkUpFromBinaryOperator(BO); - }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - 2 + 3; - 4; -} -)cpp"; - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromBinaryOperator BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) -)txt")); - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::Yes), Code, - R"txt( -WalkUpFromExpr IntegerLiteral(1) - WalkUpFromStmt IntegerLiteral(1) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromBinaryOperator BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) -WalkUpFromStmt CompoundStmt -)txt")); -} - -TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinAdd) { - class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { - public: - RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) - : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - - bool TraverseBinAdd(BinaryOperator *BO) { - recordCallback(__func__, BO, - [&]() { RecordingVisitorBase::TraverseBinAdd(BO); }); - return true; - } - - bool WalkUpFromStmt(Stmt *S) { - recordCallback(__func__, S, - [&]() { RecordingVisitorBase::WalkUpFromStmt(S); }); - return true; - } - }; - - StringRef Code = R"cpp( -void test() { - 1; - 2 + 3; - 4; -} -)cpp"; - - EXPECT_TRUE(visitorCallbackLogEqual( - RecordingVisitor(ShouldTraversePostOrder::No), Code, - R"txt( -WalkUpFromStmt CompoundStmt -WalkUpFromStmt IntegerLiteral(1) -TraverseBinAdd BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) +TraverseUnaryOperator UnaryOperator(-) + WalkUpFromStmt UnaryOperator(-) WalkUpFromStmt IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromStmt IntegerLiteral(4) +WalkUpFromStmt IntegerLiteral(3) )txt")); EXPECT_TRUE(visitorCallbackLogEqual( RecordingVisitor(ShouldTraversePostOrder::Yes), Code, R"txt( WalkUpFromStmt IntegerLiteral(1) -TraverseBinAdd BinaryOperator(+) +TraverseUnaryOperator UnaryOperator(-) WalkUpFromStmt IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(3) - WalkUpFromStmt BinaryOperator(+) -WalkUpFromStmt IntegerLiteral(4) + WalkUpFromStmt UnaryOperator(-) +WalkUpFromStmt IntegerLiteral(3) WalkUpFromStmt CompoundStmt )txt")); } -TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinAdd_WalkUpFromBinAdd) { +TEST(RecursiveASTVisitor, + StmtCallbacks_TraverseUnaryOperator_WalkUpFromUnaryOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - bool TraverseBinAdd(BinaryOperator *BO) { - recordCallback(__func__, BO, - [&]() { RecordingVisitorBase::TraverseBinAdd(BO); }); + bool TraverseUnaryOperator(UnaryOperator *UO) { + recordCallback(__func__, UO, [&]() { + RecordingVisitorBase::TraverseUnaryOperator(UO); + }); return true; } @@ -1034,9 +452,10 @@ TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinAdd_WalkUpFromBinAdd) { return true; } - bool WalkUpFromBinAdd(BinaryOperator *BO) { - recordCallback(__func__, BO, - [&]() { RecordingVisitorBase::WalkUpFromBinAdd(BO); }); + bool WalkUpFromUnaryOperator(UnaryOperator *UO) { + recordCallback(__func__, UO, [&]() { + RecordingVisitorBase::WalkUpFromUnaryOperator(UO); + }); return true; } }; @@ -1044,8 +463,8 @@ TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinAdd_WalkUpFromBinAdd) { StringRef Code = R"cpp( void test() { 1; - 2 + 3; - 4; + -2; + 3; } )cpp"; @@ -1055,16 +474,14 @@ void test() { WalkUpFromStmt CompoundStmt WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -TraverseBinAdd BinaryOperator(+) - WalkUpFromBinAdd BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) +TraverseUnaryOperator UnaryOperator(-) + WalkUpFromUnaryOperator UnaryOperator(-) + WalkUpFromExpr UnaryOperator(-) + WalkUpFromStmt UnaryOperator(-) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) - WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) +WalkUpFromExpr IntegerLiteral(3) + WalkUpFromStmt IntegerLiteral(3) )txt")); EXPECT_TRUE(visitorCallbackLogEqual( @@ -1072,21 +489,19 @@ WalkUpFromExpr IntegerLiteral(4) R"txt( WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -TraverseBinAdd BinaryOperator(+) +TraverseUnaryOperator UnaryOperator(-) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) - WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) - WalkUpFromBinAdd BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) + WalkUpFromUnaryOperator UnaryOperator(-) + WalkUpFromExpr UnaryOperator(-) + WalkUpFromStmt UnaryOperator(-) +WalkUpFromExpr IntegerLiteral(3) + WalkUpFromStmt IntegerLiteral(3) WalkUpFromStmt CompoundStmt )txt")); } -TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinAdd) { +TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromUnaryOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) @@ -1104,9 +519,10 @@ TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinAdd) { return true; } - bool WalkUpFromBinAdd(BinaryOperator *BO) { - recordCallback(__func__, BO, - [&]() { RecordingVisitorBase::WalkUpFromBinAdd(BO); }); + bool WalkUpFromUnaryOperator(UnaryOperator *UO) { + recordCallback(__func__, UO, [&]() { + RecordingVisitorBase::WalkUpFromUnaryOperator(UO); + }); return true; } }; @@ -1114,8 +530,8 @@ TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinAdd) { StringRef Code = R"cpp( void test() { 1; - 2 + 3; - 4; + -2; + 3; } )cpp"; @@ -1125,15 +541,13 @@ void test() { WalkUpFromStmt CompoundStmt WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -WalkUpFromBinAdd BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) +WalkUpFromUnaryOperator UnaryOperator(-) + WalkUpFromExpr UnaryOperator(-) + WalkUpFromStmt UnaryOperator(-) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) WalkUpFromExpr IntegerLiteral(3) WalkUpFromStmt IntegerLiteral(3) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) )txt")); EXPECT_TRUE(visitorCallbackLogEqual( @@ -1143,26 +557,24 @@ WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) +WalkUpFromUnaryOperator UnaryOperator(-) + WalkUpFromExpr UnaryOperator(-) + WalkUpFromStmt UnaryOperator(-) WalkUpFromExpr IntegerLiteral(3) WalkUpFromStmt IntegerLiteral(3) -WalkUpFromBinAdd BinaryOperator(+) - WalkUpFromExpr BinaryOperator(+) - WalkUpFromStmt BinaryOperator(+) -WalkUpFromExpr IntegerLiteral(4) - WalkUpFromStmt IntegerLiteral(4) WalkUpFromStmt CompoundStmt )txt")); } -TEST(RecursiveASTVisitor, StmtCallbacks_TraverseCompoundAssignOperator) { +TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinaryOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) { - recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::TraverseCompoundAssignOperator(CAO); + bool TraverseBinaryOperator(BinaryOperator *BO) { + recordCallback(__func__, BO, [&]() { + RecordingVisitorBase::TraverseBinaryOperator(BO); }); return true; } @@ -1175,50 +587,48 @@ TEST(RecursiveASTVisitor, StmtCallbacks_TraverseCompoundAssignOperator) { }; StringRef Code = R"cpp( -void test(int a) { +void test() { 1; - a += 2; - 3; + 2 + 3; + 4; } )cpp"; - // TraverseCompoundAssignOperator is not called because RecursiveASTVisitor - // treats individual operators as subclasses, for which it calls their - // Traverse methods. EXPECT_TRUE(visitorCallbackLogEqual( RecordingVisitor(ShouldTraversePostOrder::No), Code, R"txt( WalkUpFromStmt CompoundStmt WalkUpFromStmt IntegerLiteral(1) -WalkUpFromStmt CompoundAssignOperator(+=) -WalkUpFromStmt DeclRefExpr(a) -WalkUpFromStmt IntegerLiteral(2) -WalkUpFromStmt IntegerLiteral(3) +TraverseBinaryOperator BinaryOperator(+) + WalkUpFromStmt BinaryOperator(+) + WalkUpFromStmt IntegerLiteral(2) + WalkUpFromStmt IntegerLiteral(3) +WalkUpFromStmt IntegerLiteral(4) )txt")); EXPECT_TRUE(visitorCallbackLogEqual( RecordingVisitor(ShouldTraversePostOrder::Yes), Code, R"txt( WalkUpFromStmt IntegerLiteral(1) -WalkUpFromStmt DeclRefExpr(a) -WalkUpFromStmt IntegerLiteral(2) -WalkUpFromStmt CompoundAssignOperator(+=) -WalkUpFromStmt IntegerLiteral(3) +TraverseBinaryOperator BinaryOperator(+) + WalkUpFromStmt IntegerLiteral(2) + WalkUpFromStmt IntegerLiteral(3) + WalkUpFromStmt BinaryOperator(+) +WalkUpFromStmt IntegerLiteral(4) WalkUpFromStmt CompoundStmt )txt")); } -TEST( - RecursiveASTVisitor, - StmtCallbacks_TraverseCompoundAssignOperator_WalkUpFromCompoundAssignOperator) { +TEST(RecursiveASTVisitor, + StmtCallbacks_TraverseBinaryOperator_WalkUpFromBinaryOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) { - recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::TraverseCompoundAssignOperator(CAO); + bool TraverseBinaryOperator(BinaryOperator *BO) { + recordCallback(__func__, BO, [&]() { + RecordingVisitorBase::TraverseBinaryOperator(BO); }); return true; } @@ -1235,40 +645,38 @@ TEST( return true; } - bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *CAO) { - recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::WalkUpFromCompoundAssignOperator(CAO); + bool WalkUpFromBinaryOperator(BinaryOperator *BO) { + recordCallback(__func__, BO, [&]() { + RecordingVisitorBase::WalkUpFromBinaryOperator(BO); }); return true; } }; StringRef Code = R"cpp( -void test(int a) { +void test() { 1; - a += 2; - 3; + 2 + 3; + 4; } )cpp"; - // TraverseCompoundAssignOperator is not called because RecursiveASTVisitor - // treats individual operators as subclasses, for which it calls their - // Traverse methods. EXPECT_TRUE(visitorCallbackLogEqual( RecordingVisitor(ShouldTraversePostOrder::No), Code, R"txt( WalkUpFromStmt CompoundStmt WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) - WalkUpFromExpr CompoundAssignOperator(+=) - WalkUpFromStmt CompoundAssignOperator(+=) -WalkUpFromExpr DeclRefExpr(a) - WalkUpFromStmt DeclRefExpr(a) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) +TraverseBinaryOperator BinaryOperator(+) + WalkUpFromBinaryOperator BinaryOperator(+) + WalkUpFromExpr BinaryOperator(+) + WalkUpFromStmt BinaryOperator(+) + WalkUpFromExpr IntegerLiteral(2) + WalkUpFromStmt IntegerLiteral(2) + WalkUpFromExpr IntegerLiteral(3) + WalkUpFromStmt IntegerLiteral(3) +WalkUpFromExpr IntegerLiteral(4) + WalkUpFromStmt IntegerLiteral(4) )txt")); EXPECT_TRUE(visitorCallbackLogEqual( @@ -1276,20 +684,21 @@ WalkUpFromExpr IntegerLiteral(3) R"txt( WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -WalkUpFromExpr DeclRefExpr(a) - WalkUpFromStmt DeclRefExpr(a) -WalkUpFromExpr IntegerLiteral(2) - WalkUpFromStmt IntegerLiteral(2) -WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) - WalkUpFromExpr CompoundAssignOperator(+=) - WalkUpFromStmt CompoundAssignOperator(+=) -WalkUpFromExpr IntegerLiteral(3) - WalkUpFromStmt IntegerLiteral(3) +TraverseBinaryOperator BinaryOperator(+) + WalkUpFromExpr IntegerLiteral(2) + WalkUpFromStmt IntegerLiteral(2) + WalkUpFromExpr IntegerLiteral(3) + WalkUpFromStmt IntegerLiteral(3) + WalkUpFromBinaryOperator BinaryOperator(+) + WalkUpFromExpr BinaryOperator(+) + WalkUpFromStmt BinaryOperator(+) +WalkUpFromExpr IntegerLiteral(4) + WalkUpFromStmt IntegerLiteral(4) WalkUpFromStmt CompoundStmt )txt")); } -TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromCompoundAssignOperator) { +TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinaryOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) @@ -1307,19 +716,19 @@ TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromCompoundAssignOperator) { return true; } - bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *CAO) { - recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::WalkUpFromCompoundAssignOperator(CAO); + bool WalkUpFromBinaryOperator(BinaryOperator *BO) { + recordCallback(__func__, BO, [&]() { + RecordingVisitorBase::WalkUpFromBinaryOperator(BO); }); return true; } }; StringRef Code = R"cpp( -void test(int a) { +void test() { 1; - a += 2; - 3; + 2 + 3; + 4; } )cpp"; @@ -1329,15 +738,15 @@ void test(int a) { WalkUpFromStmt CompoundStmt WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) - WalkUpFromExpr CompoundAssignOperator(+=) - WalkUpFromStmt CompoundAssignOperator(+=) -WalkUpFromExpr DeclRefExpr(a) - WalkUpFromStmt DeclRefExpr(a) +WalkUpFromBinaryOperator BinaryOperator(+) + WalkUpFromExpr BinaryOperator(+) + WalkUpFromStmt BinaryOperator(+) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) WalkUpFromExpr IntegerLiteral(3) WalkUpFromStmt IntegerLiteral(3) +WalkUpFromExpr IntegerLiteral(4) + WalkUpFromStmt IntegerLiteral(4) )txt")); EXPECT_TRUE(visitorCallbackLogEqual( @@ -1345,28 +754,28 @@ WalkUpFromExpr IntegerLiteral(3) R"txt( WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -WalkUpFromExpr DeclRefExpr(a) - WalkUpFromStmt DeclRefExpr(a) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) -WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) - WalkUpFromExpr CompoundAssignOperator(+=) - WalkUpFromStmt CompoundAssignOperator(+=) WalkUpFromExpr IntegerLiteral(3) WalkUpFromStmt IntegerLiteral(3) +WalkUpFromBinaryOperator BinaryOperator(+) + WalkUpFromExpr BinaryOperator(+) + WalkUpFromStmt BinaryOperator(+) +WalkUpFromExpr IntegerLiteral(4) + WalkUpFromStmt IntegerLiteral(4) WalkUpFromStmt CompoundStmt )txt")); } -TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinAddAssign) { +TEST(RecursiveASTVisitor, StmtCallbacks_TraverseCompoundAssignOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - bool TraverseBinAddAssign(CompoundAssignOperator *CAO) { + bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) { recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::TraverseBinAddAssign(CAO); + RecordingVisitorBase::TraverseCompoundAssignOperator(CAO); }); return true; } @@ -1391,7 +800,7 @@ void test(int a) { R"txt( WalkUpFromStmt CompoundStmt WalkUpFromStmt IntegerLiteral(1) -TraverseBinAddAssign CompoundAssignOperator(+=) +TraverseCompoundAssignOperator CompoundAssignOperator(+=) WalkUpFromStmt CompoundAssignOperator(+=) WalkUpFromStmt DeclRefExpr(a) WalkUpFromStmt IntegerLiteral(2) @@ -1402,7 +811,7 @@ WalkUpFromStmt IntegerLiteral(3) RecordingVisitor(ShouldTraversePostOrder::Yes), Code, R"txt( WalkUpFromStmt IntegerLiteral(1) -TraverseBinAddAssign CompoundAssignOperator(+=) +TraverseCompoundAssignOperator CompoundAssignOperator(+=) WalkUpFromStmt DeclRefExpr(a) WalkUpFromStmt IntegerLiteral(2) WalkUpFromStmt CompoundAssignOperator(+=) @@ -1411,16 +820,17 @@ WalkUpFromStmt CompoundStmt )txt")); } -TEST(RecursiveASTVisitor, - StmtCallbacks_TraverseBinAddAssign_WalkUpFromBinAddAssign) { +TEST( + RecursiveASTVisitor, + StmtCallbacks_TraverseCompoundAssignOperator_WalkUpFromCompoundAssignOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) : RecordingVisitorBase(ShouldTraversePostOrderValue) {} - bool TraverseBinAddAssign(CompoundAssignOperator *CAO) { + bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) { recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::TraverseBinAddAssign(CAO); + RecordingVisitorBase::TraverseCompoundAssignOperator(CAO); }); return true; } @@ -1437,9 +847,9 @@ TEST(RecursiveASTVisitor, return true; } - bool WalkUpFromBinAddAssign(CompoundAssignOperator *CAO) { + bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *CAO) { recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::WalkUpFromBinAddAssign(CAO); + RecordingVisitorBase::WalkUpFromCompoundAssignOperator(CAO); }); return true; } @@ -1459,8 +869,8 @@ void test(int a) { WalkUpFromStmt CompoundStmt WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -TraverseBinAddAssign CompoundAssignOperator(+=) - WalkUpFromBinAddAssign CompoundAssignOperator(+=) +TraverseCompoundAssignOperator CompoundAssignOperator(+=) + WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) WalkUpFromExpr CompoundAssignOperator(+=) WalkUpFromStmt CompoundAssignOperator(+=) WalkUpFromExpr DeclRefExpr(a) @@ -1476,12 +886,12 @@ WalkUpFromExpr IntegerLiteral(3) R"txt( WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -TraverseBinAddAssign CompoundAssignOperator(+=) +TraverseCompoundAssignOperator CompoundAssignOperator(+=) WalkUpFromExpr DeclRefExpr(a) WalkUpFromStmt DeclRefExpr(a) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) - WalkUpFromBinAddAssign CompoundAssignOperator(+=) + WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) WalkUpFromExpr CompoundAssignOperator(+=) WalkUpFromStmt CompoundAssignOperator(+=) WalkUpFromExpr IntegerLiteral(3) @@ -1490,7 +900,7 @@ WalkUpFromStmt CompoundStmt )txt")); } -TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinAddAssign) { +TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromCompoundAssignOperator) { class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> { public: RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue) @@ -1508,9 +918,9 @@ TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinAddAssign) { return true; } - bool WalkUpFromBinAddAssign(CompoundAssignOperator *CAO) { + bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *CAO) { recordCallback(__func__, CAO, [&]() { - RecordingVisitorBase::WalkUpFromBinAddAssign(CAO); + RecordingVisitorBase::WalkUpFromCompoundAssignOperator(CAO); }); return true; } @@ -1530,7 +940,7 @@ void test(int a) { WalkUpFromStmt CompoundStmt WalkUpFromExpr IntegerLiteral(1) WalkUpFromStmt IntegerLiteral(1) -WalkUpFromBinAddAssign CompoundAssignOperator(+=) +WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) WalkUpFromExpr CompoundAssignOperator(+=) WalkUpFromStmt CompoundAssignOperator(+=) WalkUpFromExpr DeclRefExpr(a) @@ -1550,7 +960,7 @@ WalkUpFromExpr DeclRefExpr(a) WalkUpFromStmt DeclRefExpr(a) WalkUpFromExpr IntegerLiteral(2) WalkUpFromStmt IntegerLiteral(2) -WalkUpFromBinAddAssign CompoundAssignOperator(+=) +WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=) WalkUpFromExpr CompoundAssignOperator(+=) WalkUpFromStmt CompoundAssignOperator(+=) WalkUpFromExpr IntegerLiteral(3) _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
