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