1 //===- 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
TEST(RecursiveASTVisitor,StmtCallbacks_TraverseCompoundAssignOperator)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
TEST(RecursiveASTVisitor,StmtCallbacks_TraverseCompoundAssignOperator_WalkUpFromCompoundAssignOperator)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
TEST(RecursiveASTVisitor,StmtCallbacks_WalkUpFromCompoundAssignOperator)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 }
212