clang/unittests/Tooling/RecursiveASTVisitorTests/CallbacksBinaryOperator.cpp

   1 //===- unittests/Tooling/RecursiveASTVisitorTests/CallbacksBinaryOperator.cpp -===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "CallbacksCommon.h"
  10
  11 TEST(RecursiveASTVisitor, StmtCallbacks_TraverseBinaryOperator) {
  12   class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> {
  13   public:
  14     RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue)
  15         : RecordingVisitorBase(ShouldTraversePostOrderValue) {}
  16
  17     bool TraverseBinaryOperator(BinaryOperator *BO) {
  18       recordCallback(__func__, BO, [&]() {
  19         RecordingVisitorBase::TraverseBinaryOperator(BO);
  20       });
  21       return true;
  22     }
  23
  24     bool WalkUpFromStmt(Stmt *S) {
  25       recordCallback(__func__, S,
  26                      [&]() { RecordingVisitorBase::WalkUpFromStmt(S); });
  27       return true;
  28     }
  29   };
  30
  31   StringRef Code = R"cpp(
  32 void test() {
  33   1;
  34   2 + 3;
  35   4;
  36 }
  37 )cpp";
  38
  39   EXPECT_TRUE(visitorCallbackLogEqual(
  40       RecordingVisitor(ShouldTraversePostOrder::No), Code,
  41       R"txt(
  42 WalkUpFromStmt CompoundStmt
  43 WalkUpFromStmt IntegerLiteral(1)
  44 TraverseBinaryOperator BinaryOperator(+)
  45   WalkUpFromStmt BinaryOperator(+)
  46   WalkUpFromStmt IntegerLiteral(2)
  47   WalkUpFromStmt IntegerLiteral(3)
  48 WalkUpFromStmt IntegerLiteral(4)
  49 )txt"));
  50
  51   EXPECT_TRUE(visitorCallbackLogEqual(
  52       RecordingVisitor(ShouldTraversePostOrder::Yes), Code,
  53       R"txt(
  54 WalkUpFromStmt IntegerLiteral(1)
  55 TraverseBinaryOperator BinaryOperator(+)
  56   WalkUpFromStmt IntegerLiteral(2)
  57   WalkUpFromStmt IntegerLiteral(3)
  58   WalkUpFromStmt BinaryOperator(+)
  59 WalkUpFromStmt IntegerLiteral(4)
  60 WalkUpFromStmt CompoundStmt
  61 )txt"));
  62 }
  63
  64 TEST(RecursiveASTVisitor,
  65      StmtCallbacks_TraverseBinaryOperator_WalkUpFromBinaryOperator) {
  66   class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> {
  67   public:
  68     RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue)
  69         : RecordingVisitorBase(ShouldTraversePostOrderValue) {}
  70
  71     bool TraverseBinaryOperator(BinaryOperator *BO) {
  72       recordCallback(__func__, BO, [&]() {
  73         RecordingVisitorBase::TraverseBinaryOperator(BO);
  74       });
  75       return true;
  76     }
  77
  78     bool WalkUpFromStmt(Stmt *S) {
  79       recordCallback(__func__, S,
  80                      [&]() { RecordingVisitorBase::WalkUpFromStmt(S); });
  81       return true;
  82     }
  83
  84     bool WalkUpFromExpr(Expr *E) {
  85       recordCallback(__func__, E,
  86                      [&]() { RecordingVisitorBase::WalkUpFromExpr(E); });
  87       return true;
  88     }
  89
  90     bool WalkUpFromBinaryOperator(BinaryOperator *BO) {
  91       recordCallback(__func__, BO, [&]() {
  92         RecordingVisitorBase::WalkUpFromBinaryOperator(BO);
  93       });
  94       return true;
  95     }
  96   };
  97
  98   StringRef Code = R"cpp(
  99 void test() {
 100   1;
 101   2 + 3;
 102   4;
 103 }
 104 )cpp";
 105
 106   EXPECT_TRUE(visitorCallbackLogEqual(
 107       RecordingVisitor(ShouldTraversePostOrder::No), Code,
 108       R"txt(
 109 WalkUpFromStmt CompoundStmt
 110 WalkUpFromExpr IntegerLiteral(1)
 111   WalkUpFromStmt IntegerLiteral(1)
 112 TraverseBinaryOperator BinaryOperator(+)
 113   WalkUpFromBinaryOperator BinaryOperator(+)
 114     WalkUpFromExpr BinaryOperator(+)
 115       WalkUpFromStmt BinaryOperator(+)
 116   WalkUpFromExpr IntegerLiteral(2)
 117     WalkUpFromStmt IntegerLiteral(2)
 118   WalkUpFromExpr IntegerLiteral(3)
 119     WalkUpFromStmt IntegerLiteral(3)
 120 WalkUpFromExpr IntegerLiteral(4)
 121   WalkUpFromStmt IntegerLiteral(4)
 122 )txt"));
 123
 124   EXPECT_TRUE(visitorCallbackLogEqual(
 125       RecordingVisitor(ShouldTraversePostOrder::Yes), Code,
 126       R"txt(
 127 WalkUpFromExpr IntegerLiteral(1)
 128   WalkUpFromStmt IntegerLiteral(1)
 129 TraverseBinaryOperator BinaryOperator(+)
 130   WalkUpFromExpr IntegerLiteral(2)
 131     WalkUpFromStmt IntegerLiteral(2)
 132   WalkUpFromExpr IntegerLiteral(3)
 133     WalkUpFromStmt IntegerLiteral(3)
 134   WalkUpFromBinaryOperator BinaryOperator(+)
 135     WalkUpFromExpr BinaryOperator(+)
 136       WalkUpFromStmt BinaryOperator(+)
 137 WalkUpFromExpr IntegerLiteral(4)
 138   WalkUpFromStmt IntegerLiteral(4)
 139 WalkUpFromStmt CompoundStmt
 140 )txt"));
 141 }
 142
 143 TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromBinaryOperator) {
 144   class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> {
 145   public:
 146     RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue)
 147         : RecordingVisitorBase(ShouldTraversePostOrderValue) {}
 148
 149     bool WalkUpFromStmt(Stmt *S) {
 150       recordCallback(__func__, S,
 151                      [&]() { RecordingVisitorBase::WalkUpFromStmt(S); });
 152       return true;
 153     }
 154
 155     bool WalkUpFromExpr(Expr *E) {
 156       recordCallback(__func__, E,
 157                      [&]() { RecordingVisitorBase::WalkUpFromExpr(E); });
 158       return true;
 159     }
 160
 161     bool WalkUpFromBinaryOperator(BinaryOperator *BO) {
 162       recordCallback(__func__, BO, [&]() {
 163         RecordingVisitorBase::WalkUpFromBinaryOperator(BO);
 164       });
 165       return true;
 166     }
 167   };
 168
 169   StringRef Code = R"cpp(
 170 void test() {
 171   1;
 172   2 + 3;
 173   4;
 174 }
 175 )cpp";
 176
 177   EXPECT_TRUE(visitorCallbackLogEqual(
 178       RecordingVisitor(ShouldTraversePostOrder::No), Code,
 179       R"txt(
 180 WalkUpFromStmt CompoundStmt
 181 WalkUpFromExpr IntegerLiteral(1)
 182   WalkUpFromStmt IntegerLiteral(1)
 183 WalkUpFromBinaryOperator BinaryOperator(+)
 184   WalkUpFromExpr BinaryOperator(+)
 185     WalkUpFromStmt BinaryOperator(+)
 186 WalkUpFromExpr IntegerLiteral(2)
 187   WalkUpFromStmt IntegerLiteral(2)
 188 WalkUpFromExpr IntegerLiteral(3)
 189   WalkUpFromStmt IntegerLiteral(3)
 190 WalkUpFromExpr IntegerLiteral(4)
 191   WalkUpFromStmt IntegerLiteral(4)
 192 )txt"));
 193
 194   EXPECT_TRUE(visitorCallbackLogEqual(
 195       RecordingVisitor(ShouldTraversePostOrder::Yes), Code,
 196       R"txt(
 197 WalkUpFromExpr IntegerLiteral(1)
 198   WalkUpFromStmt IntegerLiteral(1)
 199 WalkUpFromExpr IntegerLiteral(2)
 200   WalkUpFromStmt IntegerLiteral(2)
 201 WalkUpFromExpr IntegerLiteral(3)
 202   WalkUpFromStmt IntegerLiteral(3)
 203 WalkUpFromBinaryOperator BinaryOperator(+)
 204   WalkUpFromExpr BinaryOperator(+)
 205     WalkUpFromStmt BinaryOperator(+)
 206 WalkUpFromExpr IntegerLiteral(4)
 207   WalkUpFromStmt IntegerLiteral(4)
 208 WalkUpFromStmt CompoundStmt
 209 )txt"));
 210 }