clang/unittests/Tooling/RecursiveASTVisitorTests/CallbacksCompoundAssignOperator.cpp

   1 //===- unittests/Tooling/RecursiveASTVisitorTests/CallbacksCompoundAssignOperator.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_TraverseCompoundAssignOperator) {
  12   class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> {
  13   public:
  14     RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue)
  15         : RecordingVisitorBase(ShouldTraversePostOrderValue) {}
  16
  17     bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) {
  18       recordCallback(__func__, CAO, [&]() {
  19         RecordingVisitorBase::TraverseCompoundAssignOperator(CAO);
  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(int a) {
  33   1;
  34   a += 2;
  35   3;
  36 }
  37 )cpp";
  38
  39   EXPECT_TRUE(visitorCallbackLogEqual(
  40       RecordingVisitor(ShouldTraversePostOrder::No), Code,
  41       R"txt(
  42 WalkUpFromStmt CompoundStmt
  43 WalkUpFromStmt IntegerLiteral(1)
  44 TraverseCompoundAssignOperator CompoundAssignOperator(+=)
  45   WalkUpFromStmt CompoundAssignOperator(+=)
  46   WalkUpFromStmt DeclRefExpr(a)
  47   WalkUpFromStmt IntegerLiteral(2)
  48 WalkUpFromStmt IntegerLiteral(3)
  49 )txt"));
  50
  51   EXPECT_TRUE(visitorCallbackLogEqual(
  52       RecordingVisitor(ShouldTraversePostOrder::Yes), Code,
  53       R"txt(
  54 WalkUpFromStmt IntegerLiteral(1)
  55 TraverseCompoundAssignOperator CompoundAssignOperator(+=)
  56   WalkUpFromStmt DeclRefExpr(a)
  57   WalkUpFromStmt IntegerLiteral(2)
  58   WalkUpFromStmt CompoundAssignOperator(+=)
  59 WalkUpFromStmt IntegerLiteral(3)
  60 WalkUpFromStmt CompoundStmt
  61 )txt"));
  62 }
  63
  64 TEST(
  65     RecursiveASTVisitor,
  66     StmtCallbacks_TraverseCompoundAssignOperator_WalkUpFromCompoundAssignOperator) {
  67   class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> {
  68   public:
  69     RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue)
  70         : RecordingVisitorBase(ShouldTraversePostOrderValue) {}
  71
  72     bool TraverseCompoundAssignOperator(CompoundAssignOperator *CAO) {
  73       recordCallback(__func__, CAO, [&]() {
  74         RecordingVisitorBase::TraverseCompoundAssignOperator(CAO);
  75       });
  76       return true;
  77     }
  78
  79     bool WalkUpFromStmt(Stmt *S) {
  80       recordCallback(__func__, S,
  81                      [&]() { RecordingVisitorBase::WalkUpFromStmt(S); });
  82       return true;
  83     }
  84
  85     bool WalkUpFromExpr(Expr *E) {
  86       recordCallback(__func__, E,
  87                      [&]() { RecordingVisitorBase::WalkUpFromExpr(E); });
  88       return true;
  89     }
  90
  91     bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *CAO) {
  92       recordCallback(__func__, CAO, [&]() {
  93         RecordingVisitorBase::WalkUpFromCompoundAssignOperator(CAO);
  94       });
  95       return true;
  96     }
  97   };
  98
  99   StringRef Code = R"cpp(
 100 void test(int a) {
 101   1;
 102   a += 2;
 103   3;
 104 }
 105 )cpp";
 106
 107   EXPECT_TRUE(visitorCallbackLogEqual(
 108       RecordingVisitor(ShouldTraversePostOrder::No), Code,
 109       R"txt(
 110 WalkUpFromStmt CompoundStmt
 111 WalkUpFromExpr IntegerLiteral(1)
 112   WalkUpFromStmt IntegerLiteral(1)
 113 TraverseCompoundAssignOperator CompoundAssignOperator(+=)
 114   WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=)
 115     WalkUpFromExpr CompoundAssignOperator(+=)
 116       WalkUpFromStmt CompoundAssignOperator(+=)
 117   WalkUpFromExpr DeclRefExpr(a)
 118     WalkUpFromStmt DeclRefExpr(a)
 119   WalkUpFromExpr IntegerLiteral(2)
 120     WalkUpFromStmt IntegerLiteral(2)
 121 WalkUpFromExpr IntegerLiteral(3)
 122   WalkUpFromStmt IntegerLiteral(3)
 123 )txt"));
 124
 125   EXPECT_TRUE(visitorCallbackLogEqual(
 126       RecordingVisitor(ShouldTraversePostOrder::Yes), Code,
 127       R"txt(
 128 WalkUpFromExpr IntegerLiteral(1)
 129   WalkUpFromStmt IntegerLiteral(1)
 130 TraverseCompoundAssignOperator CompoundAssignOperator(+=)
 131   WalkUpFromExpr DeclRefExpr(a)
 132     WalkUpFromStmt DeclRefExpr(a)
 133   WalkUpFromExpr IntegerLiteral(2)
 134     WalkUpFromStmt IntegerLiteral(2)
 135   WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=)
 136     WalkUpFromExpr CompoundAssignOperator(+=)
 137       WalkUpFromStmt CompoundAssignOperator(+=)
 138 WalkUpFromExpr IntegerLiteral(3)
 139   WalkUpFromStmt IntegerLiteral(3)
 140 WalkUpFromStmt CompoundStmt
 141 )txt"));
 142 }
 143
 144 TEST(RecursiveASTVisitor, StmtCallbacks_WalkUpFromCompoundAssignOperator) {
 145   class RecordingVisitor : public RecordingVisitorBase<RecordingVisitor> {
 146   public:
 147     RecordingVisitor(ShouldTraversePostOrder ShouldTraversePostOrderValue)
 148         : RecordingVisitorBase(ShouldTraversePostOrderValue) {}
 149
 150     bool WalkUpFromStmt(Stmt *S) {
 151       recordCallback(__func__, S,
 152                      [&]() { RecordingVisitorBase::WalkUpFromStmt(S); });
 153       return true;
 154     }
 155
 156     bool WalkUpFromExpr(Expr *E) {
 157       recordCallback(__func__, E,
 158                      [&]() { RecordingVisitorBase::WalkUpFromExpr(E); });
 159       return true;
 160     }
 161
 162     bool WalkUpFromCompoundAssignOperator(CompoundAssignOperator *CAO) {
 163       recordCallback(__func__, CAO, [&]() {
 164         RecordingVisitorBase::WalkUpFromCompoundAssignOperator(CAO);
 165       });
 166       return true;
 167     }
 168   };
 169
 170   StringRef Code = R"cpp(
 171 void test(int a) {
 172   1;
 173   a += 2;
 174   3;
 175 }
 176 )cpp";
 177
 178   EXPECT_TRUE(visitorCallbackLogEqual(
 179       RecordingVisitor(ShouldTraversePostOrder::No), Code,
 180       R"txt(
 181 WalkUpFromStmt CompoundStmt
 182 WalkUpFromExpr IntegerLiteral(1)
 183   WalkUpFromStmt IntegerLiteral(1)
 184 WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=)
 185   WalkUpFromExpr CompoundAssignOperator(+=)
 186     WalkUpFromStmt CompoundAssignOperator(+=)
 187 WalkUpFromExpr DeclRefExpr(a)
 188   WalkUpFromStmt DeclRefExpr(a)
 189 WalkUpFromExpr IntegerLiteral(2)
 190   WalkUpFromStmt IntegerLiteral(2)
 191 WalkUpFromExpr IntegerLiteral(3)
 192   WalkUpFromStmt IntegerLiteral(3)
 193 )txt"));
 194
 195   EXPECT_TRUE(visitorCallbackLogEqual(
 196       RecordingVisitor(ShouldTraversePostOrder::Yes), Code,
 197       R"txt(
 198 WalkUpFromExpr IntegerLiteral(1)
 199   WalkUpFromStmt IntegerLiteral(1)
 200 WalkUpFromExpr DeclRefExpr(a)
 201   WalkUpFromStmt DeclRefExpr(a)
 202 WalkUpFromExpr IntegerLiteral(2)
 203   WalkUpFromStmt IntegerLiteral(2)
 204 WalkUpFromCompoundAssignOperator CompoundAssignOperator(+=)
 205   WalkUpFromExpr CompoundAssignOperator(+=)
 206     WalkUpFromStmt CompoundAssignOperator(+=)
 207 WalkUpFromExpr IntegerLiteral(3)
 208   WalkUpFromStmt IntegerLiteral(3)
 209 WalkUpFromStmt CompoundStmt
 210 )txt"));
 211 }