xref: /llvm-project/clang-tools-extra/unittests/clang-tidy/AddConstTest.cpp (revision 1b0fcf1e42e05611ec37aa7956988ae6317ad116) 
1 #include "../clang-tidy/utils/FixItHintUtils.h"
2 #include "ClangTidyDiagnosticConsumer.h"
3 #include "ClangTidyTest.h"
4 #include "clang/ASTMatchers/ASTMatchFinder.h"
5 #include "clang/ASTMatchers/ASTMatchers.h"
6 #include "clang/Tooling/Tooling.h"
7 #include "gtest/gtest.h"
8 #include <optional>
9 
10 namespace clang {
11 namespace tidy {
12 
13 namespace {
14 using namespace clang::ast_matchers;
15 using namespace utils::fixit;
16 
17 template <QualifierTarget CT, QualifierPolicy CP>
18 class ConstTransform : public ClangTidyCheck {
19 public:
20   ConstTransform(StringRef CheckName, ClangTidyContext *Context)
21       : ClangTidyCheck(CheckName, Context) {}
22 
23   void registerMatchers(MatchFinder *Finder) override {
24     Finder->addMatcher(varDecl(hasName("target")).bind("var"), this);
25   }
26 
27   void check(const MatchFinder::MatchResult &Result) override {
28     const auto *D = Result.Nodes.getNodeAs<VarDecl>("var");
29     using utils::fixit::addQualifierToVarDecl;
30     std::optional<FixItHint> Fix =
31         addQualifierToVarDecl(*D, *Result.Context, Qualifiers::Const, CT, CP);
32     auto Diag = diag(D->getBeginLoc(), "doing const transformation");
33     if (Fix)
34       Diag << *Fix;
35   }
36 };
37 } // namespace
38 
39 namespace test {
40 using PointeeLTransform =
41     ConstTransform<QualifierTarget::Pointee, QualifierPolicy::Left>;
42 using PointeeRTransform =
43     ConstTransform<QualifierTarget::Pointee, QualifierPolicy::Right>;
44 
45 using ValueLTransform =
46     ConstTransform<QualifierTarget::Value, QualifierPolicy::Left>;
47 using ValueRTransform =
48     ConstTransform<QualifierTarget::Value, QualifierPolicy::Right>;
49 
50 // ----------------------------------------------------------------------------
51 // Test Value-like types. Everything with indirection is done later.
52 // ----------------------------------------------------------------------------
53 
54 TEST(Values, Builtin) {
55   StringRef Snippet = "int target = 0;";
56 
57   EXPECT_EQ("const int target = 0;", runCheckOnCode<ValueLTransform>(Snippet));
58   EXPECT_EQ("const int target = 0;",
59             runCheckOnCode<PointeeLTransform>(Snippet));
60 
61   EXPECT_EQ("int const target = 0;", runCheckOnCode<ValueRTransform>(Snippet));
62   EXPECT_EQ("int const target = 0;",
63             runCheckOnCode<PointeeRTransform>(Snippet));
64 }
65 TEST(Values, TypedefBuiltin) {
66   StringRef T = "typedef int MyInt;";
67   StringRef S = "MyInt target = 0;";
68   auto Cat = [&T](StringRef S) { return (T + S).str(); };
69 
70   EXPECT_EQ(Cat("const MyInt target = 0;"),
71             runCheckOnCode<ValueLTransform>(Cat(S)));
72   EXPECT_EQ(Cat("const MyInt target = 0;"),
73             runCheckOnCode<PointeeLTransform>(Cat(S)));
74 
75   EXPECT_EQ(Cat("MyInt const target = 0;"),
76             runCheckOnCode<ValueRTransform>(Cat(S)));
77   EXPECT_EQ(Cat("MyInt const target = 0;"),
78             runCheckOnCode<PointeeRTransform>(Cat(S)));
79 }
80 TEST(Values, TypedefBuiltinPointer) {
81   StringRef T = "typedef int* MyInt;";
82   StringRef S = "MyInt target = nullptr;";
83   auto Cat = [&T](StringRef S) { return (T + S).str(); };
84 
85   EXPECT_EQ(Cat("const MyInt target = nullptr;"),
86             runCheckOnCode<ValueLTransform>(Cat(S)));
87   EXPECT_EQ(Cat("const MyInt target = nullptr;"),
88             runCheckOnCode<PointeeLTransform>(Cat(S)));
89 
90   EXPECT_EQ(Cat("MyInt const target = nullptr;"),
91             runCheckOnCode<ValueRTransform>(Cat(S)));
92   EXPECT_EQ(Cat("MyInt const target = nullptr;"),
93             runCheckOnCode<PointeeRTransform>(Cat(S)));
94 }
95 TEST(Values, UsingBuiltin) {
96   StringRef T = "using MyInt = int;";
97   StringRef S = "MyInt target = 0;";
98   auto Cat = [&T](StringRef S) { return (T + S).str(); };
99 
100   EXPECT_EQ(Cat("const MyInt target = 0;"),
101             runCheckOnCode<ValueLTransform>(Cat(S)));
102   EXPECT_EQ(Cat("const MyInt target = 0;"),
103             runCheckOnCode<PointeeLTransform>(Cat(S)));
104 
105   EXPECT_EQ(Cat("MyInt const target = 0;"),
106             runCheckOnCode<ValueRTransform>(Cat(S)));
107   EXPECT_EQ(Cat("MyInt const target = 0;"),
108             runCheckOnCode<PointeeRTransform>(Cat(S)));
109 }
110 TEST(Values, UsingBuiltinPointer) {
111   StringRef T = "using MyInt = int*;";
112   StringRef S = "MyInt target = nullptr;";
113   auto Cat = [&T](StringRef S) { return (T + S).str(); };
114 
115   EXPECT_EQ(Cat("const MyInt target = nullptr;"),
116             runCheckOnCode<ValueLTransform>(Cat(S)));
117   EXPECT_EQ(Cat("const MyInt target = nullptr;"),
118             runCheckOnCode<PointeeLTransform>(Cat(S)));
119 
120   EXPECT_EQ(Cat("MyInt const target = nullptr;"),
121             runCheckOnCode<ValueRTransform>(Cat(S)));
122   EXPECT_EQ(Cat("MyInt const target = nullptr;"),
123             runCheckOnCode<PointeeRTransform>(Cat(S)));
124 }
125 TEST(Values, AutoValue) {
126   StringRef T = "int f() { return 42; }\n";
127   StringRef S = "auto target = f();";
128   auto Cat = [&T](StringRef S) { return (T + S).str(); };
129 
130   EXPECT_EQ(Cat("const auto target = f();"),
131             runCheckOnCode<ValueLTransform>(Cat(S)));
132   EXPECT_EQ(Cat("const auto target = f();"),
133             runCheckOnCode<PointeeLTransform>(Cat(S)));
134 
135   EXPECT_EQ(Cat("auto const target = f();"),
136             runCheckOnCode<ValueRTransform>(Cat(S)));
137   EXPECT_EQ(Cat("auto const target = f();"),
138             runCheckOnCode<PointeeRTransform>(Cat(S)));
139 }
140 TEST(Values, AutoPointer) {
141   StringRef T = "int* f() { return nullptr; }\n";
142   StringRef S = "auto target = f();";
143   auto Cat = [&T](StringRef S) { return (T + S).str(); };
144 
145   EXPECT_EQ(Cat("const auto target = f();"),
146             runCheckOnCode<ValueLTransform>(Cat(S)));
147   EXPECT_EQ(Cat("const auto target = f();"),
148             runCheckOnCode<PointeeLTransform>(Cat(S)));
149 
150   EXPECT_EQ(Cat("auto const target = f();"),
151             runCheckOnCode<ValueRTransform>(Cat(S)));
152   EXPECT_EQ(Cat("auto const target = f();"),
153             runCheckOnCode<PointeeRTransform>(Cat(S)));
154 }
155 TEST(Values, AutoReference) {
156   StringRef T = "static int global = 42; int& f() { return global; }\n";
157   StringRef S = "auto target = f();";
158   auto Cat = [&T](StringRef S) { return (T + S).str(); };
159 
160   EXPECT_EQ(Cat("const auto target = f();"),
161             runCheckOnCode<ValueLTransform>(Cat(S)));
162   EXPECT_EQ(Cat("const auto target = f();"),
163             runCheckOnCode<PointeeLTransform>(Cat(S)));
164 
165   EXPECT_EQ(Cat("auto const target = f();"),
166             runCheckOnCode<ValueRTransform>(Cat(S)));
167   EXPECT_EQ(Cat("auto const target = f();"),
168             runCheckOnCode<PointeeRTransform>(Cat(S)));
169 }
170 TEST(Values, DeclTypeValue) {
171   StringRef T = "int f() { return 42; }\n";
172   StringRef S = "decltype(f()) target = f();";
173   auto Cat = [&T](StringRef S) { return (T + S).str(); };
174 
175   EXPECT_EQ(Cat("const decltype(f()) target = f();"),
176             runCheckOnCode<ValueLTransform>(Cat(S)));
177   EXPECT_EQ(Cat("const decltype(f()) target = f();"),
178             runCheckOnCode<PointeeLTransform>(Cat(S)));
179 
180   EXPECT_EQ(Cat("decltype(f()) const target = f();"),
181             runCheckOnCode<ValueRTransform>(Cat(S)));
182   EXPECT_EQ(Cat("decltype(f()) const target = f();"),
183             runCheckOnCode<PointeeRTransform>(Cat(S)));
184 }
185 TEST(Values, DeclTypePointer) {
186   // The pointer itself will be changed to 'const'. There is no
187   // way to make the pointee 'const' with this syntax.
188   StringRef T = "int* f() { return nullptr; }\n";
189   StringRef S = "decltype(f()) target = f();";
190   auto Cat = [&T](StringRef S) { return (T + S).str(); };
191 
192   EXPECT_EQ(Cat("const decltype(f()) target = f();"),
193             runCheckOnCode<ValueLTransform>(Cat(S)));
194   EXPECT_EQ(Cat("const decltype(f()) target = f();"),
195             runCheckOnCode<PointeeLTransform>(Cat(S)));
196 
197   EXPECT_EQ(Cat("decltype(f()) const target = f();"),
198             runCheckOnCode<ValueRTransform>(Cat(S)));
199   EXPECT_EQ(Cat("decltype(f()) const target = f();"),
200             runCheckOnCode<PointeeRTransform>(Cat(S)));
201 }
202 TEST(Values, DeclTypeReference) {
203   // Same as pointer, but the reference itself will be marked 'const'.
204   // This has no effect and will result in a warning afterwards. The
205   // transformation itself is still correct.
206   StringRef T = "static int global = 42; int& f() { return global; }\n";
207   StringRef S = "decltype(f()) target = f();";
208   auto Cat = [&T](StringRef S) { return (T + S).str(); };
209 
210   EXPECT_EQ(Cat("const decltype(f()) target = f();"),
211             runCheckOnCode<ValueLTransform>(Cat(S)));
212   EXPECT_EQ(Cat("const decltype(f()) target = f();"),
213             runCheckOnCode<PointeeLTransform>(Cat(S)));
214 
215   EXPECT_EQ(Cat("decltype(f()) const target = f();"),
216             runCheckOnCode<ValueRTransform>(Cat(S)));
217   EXPECT_EQ(Cat("decltype(f()) const target = f();"),
218             runCheckOnCode<PointeeRTransform>(Cat(S)));
219 }
220 TEST(Values, Parens) {
221   StringRef Snippet = "int ((target)) = 0;";
222 
223   EXPECT_EQ("const int ((target)) = 0;",
224             runCheckOnCode<ValueLTransform>(Snippet));
225   EXPECT_EQ("const int ((target)) = 0;",
226             runCheckOnCode<PointeeLTransform>(Snippet));
227 
228   EXPECT_EQ("int const ((target)) = 0;",
229             runCheckOnCode<ValueRTransform>(Snippet));
230   EXPECT_EQ("int const ((target)) = 0;",
231             runCheckOnCode<PointeeRTransform>(Snippet));
232 }
233 
234 // ----------------------------------------------------------------------------
235 // Test builtin-arrays
236 // ----------------------------------------------------------------------------
237 
238 TEST(Arrays, Builtin) {
239   StringRef Snippet = "int target[][1] = {{1}, {2}, {3}};";
240 
241   EXPECT_EQ("const int target[][1] = {{1}, {2}, {3}};",
242             runCheckOnCode<PointeeLTransform>(Snippet));
243   EXPECT_EQ("const int target[][1] = {{1}, {2}, {3}};",
244             runCheckOnCode<ValueLTransform>(Snippet));
245 
246   EXPECT_EQ("int const target[][1] = {{1}, {2}, {3}};",
247             runCheckOnCode<PointeeRTransform>(Snippet));
248   EXPECT_EQ("int const target[][1] = {{1}, {2}, {3}};",
249             runCheckOnCode<ValueRTransform>(Snippet));
250 }
251 TEST(Arrays, BuiltinParens) {
252   StringRef Snippet = "int ((target))[][1] = {{1}, {2}, {3}};";
253 
254   EXPECT_EQ("const int ((target))[][1] = {{1}, {2}, {3}};",
255             runCheckOnCode<PointeeLTransform>(Snippet));
256   EXPECT_EQ("const int ((target))[][1] = {{1}, {2}, {3}};",
257             runCheckOnCode<ValueLTransform>(Snippet));
258 
259   EXPECT_EQ("int const ((target))[][1] = {{1}, {2}, {3}};",
260             runCheckOnCode<PointeeRTransform>(Snippet));
261   EXPECT_EQ("int const ((target))[][1] = {{1}, {2}, {3}};",
262             runCheckOnCode<ValueRTransform>(Snippet));
263 }
264 TEST(Arrays, Pointers) {
265   StringRef Snippet = "int x; int* target[] = {&x, &x, &x};";
266 
267   EXPECT_EQ("int x; const int* target[] = {&x, &x, &x};",
268             runCheckOnCode<PointeeLTransform>(Snippet));
269   EXPECT_EQ("int x; int const* target[] = {&x, &x, &x};",
270             runCheckOnCode<PointeeRTransform>(Snippet));
271 
272   EXPECT_EQ("int x; int* const target[] = {&x, &x, &x};",
273             runCheckOnCode<ValueLTransform>(Snippet));
274   EXPECT_EQ("int x; int* const target[] = {&x, &x, &x};",
275             runCheckOnCode<ValueRTransform>(Snippet));
276 }
277 TEST(Arrays, PointerPointers) {
278   StringRef Snippet = "int* x = nullptr; int** target[] = {&x, &x, &x};";
279 
280   EXPECT_EQ("int* x = nullptr; int* const* target[] = {&x, &x, &x};",
281             runCheckOnCode<PointeeLTransform>(Snippet));
282   EXPECT_EQ("int* x = nullptr; int** const target[] = {&x, &x, &x};",
283             runCheckOnCode<ValueLTransform>(Snippet));
284 
285   EXPECT_EQ("int* x = nullptr; int* const* target[] = {&x, &x, &x};",
286             runCheckOnCode<PointeeRTransform>(Snippet));
287   EXPECT_EQ("int* x = nullptr; int** const target[] = {&x, &x, &x};",
288             runCheckOnCode<ValueRTransform>(Snippet));
289 }
290 TEST(Arrays, PointersParens) {
291   StringRef Snippet = "int x; int* (target)[] = {&x, &x, &x};";
292 
293   EXPECT_EQ("int x; const int* (target)[] = {&x, &x, &x};",
294             runCheckOnCode<PointeeLTransform>(Snippet));
295   EXPECT_EQ("int x; int const* (target)[] = {&x, &x, &x};",
296             runCheckOnCode<PointeeRTransform>(Snippet));
297 
298   EXPECT_EQ("int x; int* const (target)[] = {&x, &x, &x};",
299             runCheckOnCode<ValueLTransform>(Snippet));
300   EXPECT_EQ("int x; int* const (target)[] = {&x, &x, &x};",
301             runCheckOnCode<ValueRTransform>(Snippet));
302 }
303 
304 // ----------------------------------------------------------------------------
305 // Test reference types. This does not include pointers and arrays.
306 // ----------------------------------------------------------------------------
307 
308 TEST(Reference, LValueBuiltin) {
309   StringRef Snippet = "int x = 42; int& target = x;";
310 
311   EXPECT_EQ("int x = 42; const int& target = x;",
312             runCheckOnCode<ValueLTransform>(Snippet));
313   EXPECT_EQ("int x = 42; const int& target = x;",
314             runCheckOnCode<PointeeLTransform>(Snippet));
315 
316   EXPECT_EQ("int x = 42; int const& target = x;",
317             runCheckOnCode<ValueRTransform>(Snippet));
318   EXPECT_EQ("int x = 42; int const& target = x;",
319             runCheckOnCode<PointeeRTransform>(Snippet));
320 }
321 TEST(Reference, RValueBuiltin) {
322   StringRef Snippet = "int&& target = 42;";
323   EXPECT_EQ("const int&& target = 42;",
324             runCheckOnCode<ValueLTransform>(Snippet));
325   EXPECT_EQ("const int&& target = 42;",
326             runCheckOnCode<PointeeLTransform>(Snippet));
327 
328   EXPECT_EQ("int const&& target = 42;",
329             runCheckOnCode<ValueRTransform>(Snippet));
330   EXPECT_EQ("int const&& target = 42;",
331             runCheckOnCode<PointeeRTransform>(Snippet));
332 }
333 TEST(Reference, LValueToPointer) {
334   StringRef Snippet = "int* p; int *& target = p;";
335   EXPECT_EQ("int* p; int * const& target = p;",
336             runCheckOnCode<ValueLTransform>(Snippet));
337   EXPECT_EQ("int* p; int * const& target = p;",
338             runCheckOnCode<PointeeLTransform>(Snippet));
339 
340   EXPECT_EQ("int* p; int * const& target = p;",
341             runCheckOnCode<ValueRTransform>(Snippet));
342   EXPECT_EQ("int* p; int * const& target = p;",
343             runCheckOnCode<PointeeRTransform>(Snippet));
344 }
345 TEST(Reference, LValueParens) {
346   StringRef Snippet = "int x = 42; int ((& target)) = x;";
347 
348   EXPECT_EQ("int x = 42; const int ((& target)) = x;",
349             runCheckOnCode<ValueLTransform>(Snippet));
350   EXPECT_EQ("int x = 42; const int ((& target)) = x;",
351             runCheckOnCode<PointeeLTransform>(Snippet));
352 
353   EXPECT_EQ("int x = 42; int  const((& target)) = x;",
354             runCheckOnCode<ValueRTransform>(Snippet));
355   EXPECT_EQ("int x = 42; int  const((& target)) = x;",
356             runCheckOnCode<PointeeRTransform>(Snippet));
357 }
358 TEST(Reference, ToArray) {
359   StringRef ArraySnippet = "int a[4] = {1, 2, 3, 4};";
360   StringRef Snippet = "int (&target)[4] = a;";
361   auto Cat = [&ArraySnippet](StringRef S) { return (ArraySnippet + S).str(); };
362 
363   EXPECT_EQ(Cat("const int (&target)[4] = a;"),
364             runCheckOnCode<ValueLTransform>(Cat(Snippet)));
365   EXPECT_EQ(Cat("const int (&target)[4] = a;"),
366             runCheckOnCode<PointeeLTransform>(Cat(Snippet)));
367 
368   EXPECT_EQ(Cat("int  const(&target)[4] = a;"),
369             runCheckOnCode<ValueRTransform>(Cat(Snippet)));
370   EXPECT_EQ(Cat("int  const(&target)[4] = a;"),
371             runCheckOnCode<PointeeRTransform>(Cat(Snippet)));
372 }
373 TEST(Reference, Auto) {
374   StringRef T = "static int global = 42; int& f() { return global; }\n";
375   StringRef S = "auto& target = f();";
376   auto Cat = [&T](StringRef S) { return (T + S).str(); };
377 
378   EXPECT_EQ(Cat("const auto& target = f();"),
379             runCheckOnCode<ValueLTransform>(Cat(S)));
380   EXPECT_EQ(Cat("auto const& target = f();"),
381             runCheckOnCode<ValueRTransform>(Cat(S)));
382 
383   EXPECT_EQ(Cat("const auto& target = f();"),
384             runCheckOnCode<PointeeLTransform>(Cat(S)));
385   EXPECT_EQ(Cat("auto const& target = f();"),
386             runCheckOnCode<PointeeRTransform>(Cat(S)));
387 }
388 
389 // ----------------------------------------------------------------------------
390 // Test pointers types.
391 // ----------------------------------------------------------------------------
392 
393 TEST(Pointers, SingleBuiltin) {
394   StringRef Snippet = "int* target = nullptr;";
395 
396   EXPECT_EQ("int* const target = nullptr;",
397             runCheckOnCode<ValueLTransform>(Snippet));
398   EXPECT_EQ("int* const target = nullptr;",
399             runCheckOnCode<ValueRTransform>(Snippet));
400 
401   EXPECT_EQ("const int* target = nullptr;",
402             runCheckOnCode<PointeeLTransform>(Snippet));
403   EXPECT_EQ("int const* target = nullptr;",
404             runCheckOnCode<PointeeRTransform>(Snippet));
405 }
406 TEST(Pointers, MultiBuiltin) {
407   StringRef Snippet = "int** target = nullptr;";
408 
409   EXPECT_EQ("int** const target = nullptr;",
410             runCheckOnCode<ValueLTransform>(Snippet));
411   EXPECT_EQ("int** const target = nullptr;",
412             runCheckOnCode<ValueRTransform>(Snippet));
413 
414   EXPECT_EQ("int* const* target = nullptr;",
415             runCheckOnCode<PointeeLTransform>(Snippet));
416   EXPECT_EQ("int* const* target = nullptr;",
417             runCheckOnCode<PointeeRTransform>(Snippet));
418 }
419 TEST(Pointers, ToArray) {
420   StringRef ArraySnippet = "int a[4] = {1, 2, 3, 4};";
421   StringRef Snippet = "int (*target)[4] = &a;";
422   auto Cat = [&ArraySnippet](StringRef S) { return (ArraySnippet + S).str(); };
423 
424   EXPECT_EQ(Cat("int (*const target)[4] = &a;"),
425             runCheckOnCode<ValueLTransform>(Cat(Snippet)));
426   EXPECT_EQ(Cat("const int (*target)[4] = &a;"),
427             runCheckOnCode<PointeeLTransform>(Cat(Snippet)));
428 
429   EXPECT_EQ(Cat("int (*const target)[4] = &a;"),
430             runCheckOnCode<ValueRTransform>(Cat(Snippet)));
431   EXPECT_EQ(Cat("int  const(*target)[4] = &a;"),
432             runCheckOnCode<PointeeRTransform>(Cat(Snippet)));
433 }
434 TEST(Pointers, Parens) {
435   StringRef Snippet = "int ((**target)) = nullptr;";
436 
437   EXPECT_EQ("int ((**const target)) = nullptr;",
438             runCheckOnCode<ValueLTransform>(Snippet));
439   EXPECT_EQ("int ((**const target)) = nullptr;",
440             runCheckOnCode<ValueRTransform>(Snippet));
441 
442   EXPECT_EQ("int ((* const*target)) = nullptr;",
443             runCheckOnCode<PointeeLTransform>(Snippet));
444   EXPECT_EQ("int ((* const*target)) = nullptr;",
445             runCheckOnCode<PointeeRTransform>(Snippet));
446 }
447 TEST(Pointers, Auto) {
448   StringRef T = "int* f() { return nullptr; }\n";
449   StringRef S = "auto* target = f();";
450   auto Cat = [&T](StringRef S) { return (T + S).str(); };
451 
452   EXPECT_EQ(Cat("auto* const target = f();"),
453             runCheckOnCode<ValueLTransform>(Cat(S)));
454   EXPECT_EQ(Cat("auto* const target = f();"),
455             runCheckOnCode<ValueRTransform>(Cat(S)));
456 
457   EXPECT_EQ(Cat("const auto* target = f();"),
458             runCheckOnCode<PointeeLTransform>(Cat(S)));
459   EXPECT_EQ(Cat("auto const* target = f();"),
460             runCheckOnCode<PointeeRTransform>(Cat(S)));
461 }
462 TEST(Pointers, AutoParens) {
463   StringRef T = "int* f() { return nullptr; }\n";
464   StringRef S = "auto (((* target))) = f();";
465   auto Cat = [&T](StringRef S) { return (T + S).str(); };
466 
467   EXPECT_EQ(Cat("auto (((* const target))) = f();"),
468             runCheckOnCode<ValueLTransform>(Cat(S)));
469   EXPECT_EQ(Cat("auto (((* const target))) = f();"),
470             runCheckOnCode<ValueRTransform>(Cat(S)));
471 
472   EXPECT_EQ(Cat("const auto (((* target))) = f();"),
473             runCheckOnCode<PointeeLTransform>(Cat(S)));
474   EXPECT_EQ(Cat("auto  const(((* target))) = f();"),
475             runCheckOnCode<PointeeRTransform>(Cat(S)));
476 }
477 TEST(Pointers, FunctionPointer) {
478   StringRef S = "int (*target)(float, int, double) = nullptr;";
479 
480   EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
481             runCheckOnCode<ValueLTransform>(S));
482   EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
483             runCheckOnCode<ValueRTransform>(S));
484 
485   EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
486             runCheckOnCode<PointeeLTransform>(S));
487   EXPECT_EQ("int (*const target)(float, int, double) = nullptr;",
488             runCheckOnCode<PointeeRTransform>(S));
489 
490   S = "int (((*target)))(float, int, double) = nullptr;";
491   EXPECT_EQ("int (((*const target)))(float, int, double) = nullptr;",
492             runCheckOnCode<PointeeRTransform>(S));
493 }
494 TEST(Pointers, MemberFunctionPointer) {
495   StringRef T = "struct A { int f() { return 1; } };";
496   StringRef S = "int (A::*target)() = &A::f;";
497   auto Cat = [&T](StringRef S) { return (T + S).str(); };
498 
499   EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
500             runCheckOnCode<ValueLTransform>(Cat(S)));
501   EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
502             runCheckOnCode<ValueRTransform>(Cat(S)));
503 
504   EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
505             runCheckOnCode<PointeeLTransform>(Cat(S)));
506   EXPECT_EQ(Cat("int (A::*const target)() = &A::f;"),
507             runCheckOnCode<PointeeRTransform>(Cat(S)));
508 
509   S = "int (A::*((target)))() = &A::f;";
510   EXPECT_EQ(Cat("int (A::*const ((target)))() = &A::f;"),
511             runCheckOnCode<ValueLTransform>(Cat(S)));
512 }
513 TEST(Pointers, MemberDataPointer) {
514   StringRef T = "struct A { int member = 0; };";
515   StringRef S = "int A::*target = &A::member;";
516   auto Cat = [&T](StringRef S) { return (T + S).str(); };
517 
518   EXPECT_EQ(Cat("int A::*const target = &A::member;"),
519             runCheckOnCode<ValueLTransform>(Cat(S)));
520   EXPECT_EQ(Cat("int A::*const target = &A::member;"),
521             runCheckOnCode<ValueRTransform>(Cat(S)));
522 
523   EXPECT_EQ(Cat("int A::*const target = &A::member;"),
524             runCheckOnCode<PointeeLTransform>(Cat(S)));
525   EXPECT_EQ(Cat("int A::*const target = &A::member;"),
526             runCheckOnCode<PointeeRTransform>(Cat(S)));
527 
528   S = "int A::*((target)) = &A::member;";
529   EXPECT_EQ(Cat("int A::*const ((target)) = &A::member;"),
530             runCheckOnCode<PointeeRTransform>(Cat(S)));
531 }
532 
533 // ----------------------------------------------------------------------------
534 // Test TagTypes (struct, class, unions, enums)
535 // ----------------------------------------------------------------------------
536 
537 TEST(TagTypes, Struct) {
538   StringRef T = "struct Foo { int data; int method(); };\n";
539   StringRef S = "struct Foo target{0};";
540   auto Cat = [&T](StringRef S) { return (T + S).str(); };
541 
542   EXPECT_EQ(Cat("const struct Foo target{0};"),
543             runCheckOnCode<ValueLTransform>(Cat(S)));
544   EXPECT_EQ(Cat("const struct Foo target{0};"),
545             runCheckOnCode<PointeeLTransform>(Cat(S)));
546 
547   EXPECT_EQ(Cat("struct Foo const target{0};"),
548             runCheckOnCode<ValueRTransform>(Cat(S)));
549   EXPECT_EQ(Cat("struct Foo const target{0};"),
550             runCheckOnCode<PointeeRTransform>(Cat(S)));
551 
552   S = "Foo target{0};";
553   EXPECT_EQ(Cat("const Foo target{0};"),
554             runCheckOnCode<ValueLTransform>(Cat(S)));
555   EXPECT_EQ(Cat("const Foo target{0};"),
556             runCheckOnCode<PointeeLTransform>(Cat(S)));
557 
558   EXPECT_EQ(Cat("Foo const target{0};"),
559             runCheckOnCode<ValueRTransform>(Cat(S)));
560   EXPECT_EQ(Cat("Foo const target{0};"),
561             runCheckOnCode<PointeeRTransform>(Cat(S)));
562 
563   S = "Foo (target){0};";
564   EXPECT_EQ(Cat("const Foo (target){0};"),
565             runCheckOnCode<ValueLTransform>(Cat(S)));
566   EXPECT_EQ(Cat("const Foo (target){0};"),
567             runCheckOnCode<PointeeLTransform>(Cat(S)));
568 
569   EXPECT_EQ(Cat("Foo const (target){0};"),
570             runCheckOnCode<ValueRTransform>(Cat(S)));
571   EXPECT_EQ(Cat("Foo const (target){0};"),
572             runCheckOnCode<PointeeRTransform>(Cat(S)));
573 
574   S = "struct S { int i; } target = { 0 };";
575   EXPECT_EQ("const struct S { int i; } target = { 0 };",
576             runCheckOnCode<ValueLTransform>(S));
577   EXPECT_EQ("const struct S { int i; } target = { 0 };",
578             runCheckOnCode<PointeeLTransform>(S));
579 
580   EXPECT_EQ("struct S { int i; } const target = { 0 };",
581             runCheckOnCode<PointeeRTransform>(S));
582   EXPECT_EQ("struct S { int i; } const target = { 0 };",
583             runCheckOnCode<PointeeRTransform>(S));
584 
585   S = "struct { int i; } target = { 0 };";
586   EXPECT_EQ("const struct { int i; } target = { 0 };",
587             runCheckOnCode<ValueLTransform>(S));
588   EXPECT_EQ("const struct { int i; } target = { 0 };",
589             runCheckOnCode<PointeeLTransform>(S));
590 
591   EXPECT_EQ("struct { int i; } const target = { 0 };",
592             runCheckOnCode<PointeeRTransform>(S));
593   EXPECT_EQ("struct { int i; } const target = { 0 };",
594             runCheckOnCode<PointeeRTransform>(S));
595 }
596 TEST(TagTypes, Class) {
597   StringRef T = "class Foo { int data; int method(); };\n";
598   StringRef S = "class Foo target;";
599   auto Cat = [&T](StringRef S) { return (T + S).str(); };
600 
601   EXPECT_EQ(Cat("const class Foo target;"),
602             runCheckOnCode<ValueLTransform>(Cat(S)));
603   EXPECT_EQ(Cat("const class Foo target;"),
604             runCheckOnCode<PointeeLTransform>(Cat(S)));
605 
606   EXPECT_EQ(Cat("class Foo const target;"),
607             runCheckOnCode<ValueRTransform>(Cat(S)));
608   EXPECT_EQ(Cat("class Foo const target;"),
609             runCheckOnCode<PointeeRTransform>(Cat(S)));
610 
611   S = "Foo target;";
612   EXPECT_EQ(Cat("const Foo target;"), runCheckOnCode<ValueLTransform>(Cat(S)));
613   EXPECT_EQ(Cat("const Foo target;"),
614             runCheckOnCode<PointeeLTransform>(Cat(S)));
615 
616   EXPECT_EQ(Cat("Foo const target;"), runCheckOnCode<ValueRTransform>(Cat(S)));
617   EXPECT_EQ(Cat("Foo const target;"),
618             runCheckOnCode<PointeeRTransform>(Cat(S)));
619 
620   S = "Foo (target);";
621   EXPECT_EQ(Cat("const Foo (target);"),
622             runCheckOnCode<ValueLTransform>(Cat(S)));
623   EXPECT_EQ(Cat("const Foo (target);"),
624             runCheckOnCode<PointeeLTransform>(Cat(S)));
625 
626   EXPECT_EQ(Cat("Foo const (target);"),
627             runCheckOnCode<ValueRTransform>(Cat(S)));
628   EXPECT_EQ(Cat("Foo const (target);"),
629             runCheckOnCode<PointeeRTransform>(Cat(S)));
630 }
631 TEST(TagTypes, Enum) {
632   StringRef T = "enum Foo { N_ONE, N_TWO, N_THREE };\n";
633   StringRef S = "enum Foo target;";
634   auto Cat = [&T](StringRef S) { return (T + S).str(); };
635 
636   EXPECT_EQ(Cat("const enum Foo target;"),
637             runCheckOnCode<ValueLTransform>(Cat(S)));
638   EXPECT_EQ(Cat("const enum Foo target;"),
639             runCheckOnCode<PointeeLTransform>(Cat(S)));
640 
641   EXPECT_EQ(Cat("enum Foo const target;"),
642             runCheckOnCode<ValueRTransform>(Cat(S)));
643   EXPECT_EQ(Cat("enum Foo const target;"),
644             runCheckOnCode<PointeeRTransform>(Cat(S)));
645 
646   S = "Foo target;";
647   EXPECT_EQ(Cat("const Foo target;"), runCheckOnCode<ValueLTransform>(Cat(S)));
648   EXPECT_EQ(Cat("const Foo target;"),
649             runCheckOnCode<PointeeLTransform>(Cat(S)));
650 
651   EXPECT_EQ(Cat("Foo const target;"), runCheckOnCode<ValueRTransform>(Cat(S)));
652   EXPECT_EQ(Cat("Foo const target;"),
653             runCheckOnCode<PointeeRTransform>(Cat(S)));
654 
655   S = "Foo (target);";
656   EXPECT_EQ(Cat("const Foo (target);"),
657             runCheckOnCode<ValueLTransform>(Cat(S)));
658   EXPECT_EQ(Cat("const Foo (target);"),
659             runCheckOnCode<PointeeLTransform>(Cat(S)));
660 
661   EXPECT_EQ(Cat("Foo const (target);"),
662             runCheckOnCode<ValueRTransform>(Cat(S)));
663   EXPECT_EQ(Cat("Foo const (target);"),
664             runCheckOnCode<PointeeRTransform>(Cat(S)));
665 }
666 TEST(TagTypes, Union) {
667   StringRef T = "union Foo { int yay; float nej; };\n";
668   StringRef S = "union Foo target;";
669   auto Cat = [&T](StringRef S) { return (T + S).str(); };
670 
671   EXPECT_EQ(Cat("const union Foo target;"),
672             runCheckOnCode<ValueLTransform>(Cat(S)));
673   EXPECT_EQ(Cat("const union Foo target;"),
674             runCheckOnCode<PointeeLTransform>(Cat(S)));
675 
676   EXPECT_EQ(Cat("union Foo const target;"),
677             runCheckOnCode<ValueRTransform>(Cat(S)));
678   EXPECT_EQ(Cat("union Foo const target;"),
679             runCheckOnCode<PointeeRTransform>(Cat(S)));
680 
681   S = "Foo target;";
682   EXPECT_EQ(Cat("const Foo target;"), runCheckOnCode<ValueLTransform>(Cat(S)));
683   EXPECT_EQ(Cat("const Foo target;"),
684             runCheckOnCode<PointeeLTransform>(Cat(S)));
685 
686   EXPECT_EQ(Cat("Foo const target;"), runCheckOnCode<ValueRTransform>(Cat(S)));
687   EXPECT_EQ(Cat("Foo const target;"),
688             runCheckOnCode<PointeeRTransform>(Cat(S)));
689 
690   S = "Foo (target);";
691   EXPECT_EQ(Cat("const Foo (target);"),
692             runCheckOnCode<ValueLTransform>(Cat(S)));
693   EXPECT_EQ(Cat("const Foo (target);"),
694             runCheckOnCode<PointeeLTransform>(Cat(S)));
695 
696   EXPECT_EQ(Cat("Foo const (target);"),
697             runCheckOnCode<ValueRTransform>(Cat(S)));
698   EXPECT_EQ(Cat("Foo const (target);"),
699             runCheckOnCode<PointeeRTransform>(Cat(S)));
700 }
701 
702 // ----------------------------------------------------------------------------
703 // Test Macro expansions.
704 // ----------------------------------------------------------------------------
705 
706 TEST(Macro, AllInMacro) {
707   StringRef T = "#define DEFINE_VARIABLE int target = 42\n";
708   StringRef S = "DEFINE_VARIABLE;";
709   auto Cat = [&T](StringRef S) { return (T + S).str(); };
710 
711   EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<ValueLTransform>(Cat(S)));
712   EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<ValueRTransform>(Cat(S)));
713 
714   EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<PointeeLTransform>(Cat(S)));
715   EXPECT_EQ(Cat("DEFINE_VARIABLE;"), runCheckOnCode<PointeeRTransform>(Cat(S)));
716 }
717 TEST(Macro, MacroParameter) {
718   StringRef T = "#define DEFINE_VARIABLE(X) int X = 42\n";
719   StringRef S = "DEFINE_VARIABLE(target);";
720   auto Cat = [&T](StringRef S) { return (T + S).str(); };
721 
722   EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
723             runCheckOnCode<ValueLTransform>(Cat(S)));
724   EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
725             runCheckOnCode<ValueRTransform>(Cat(S)));
726 
727   EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
728             runCheckOnCode<PointeeLTransform>(Cat(S)));
729   EXPECT_EQ(Cat("DEFINE_VARIABLE(target);"),
730             runCheckOnCode<PointeeRTransform>(Cat(S)));
731 }
732 TEST(Macro, MacroTypeValue) {
733   StringRef T = "#define BAD_TYPEDEF int\n";
734   StringRef S = "BAD_TYPEDEF target = 42;";
735   auto Cat = [&T](StringRef S) { return (T + S).str(); };
736 
737   EXPECT_EQ(Cat("BAD_TYPEDEF target = 42;"),
738             runCheckOnCode<ValueLTransform>(Cat(S)));
739   EXPECT_EQ(Cat("BAD_TYPEDEF target = 42;"),
740             runCheckOnCode<PointeeLTransform>(Cat(S)));
741 
742   EXPECT_EQ(Cat("BAD_TYPEDEF const target = 42;"),
743             runCheckOnCode<PointeeRTransform>(Cat(S)));
744   EXPECT_EQ(Cat("BAD_TYPEDEF const target = 42;"),
745             runCheckOnCode<ValueRTransform>(Cat(S)));
746 }
747 TEST(Macro, MacroTypePointer) {
748   StringRef T = "#define BAD_TYPEDEF int *\n";
749   StringRef S = "BAD_TYPEDEF target = nullptr;";
750   auto Cat = [&T](StringRef S) { return (T + S).str(); };
751 
752   EXPECT_EQ(Cat("BAD_TYPEDEF const target = nullptr;"),
753             runCheckOnCode<ValueLTransform>(Cat(S)));
754   EXPECT_EQ(Cat("BAD_TYPEDEF const target = nullptr;"),
755             runCheckOnCode<ValueRTransform>(Cat(S)));
756 
757   // FIXME: Failing even all parts seem to bail-out in for isMacroID()
758   // The macro itself is changed here and below which is not intended.
759   EXPECT_NE(Cat("BAD_TYPEDEF target = nullptr;"),
760             runCheckOnCode<PointeeRTransform>(Cat(S)));
761   EXPECT_EQ(Cat("BAD_TYPEDEF target = nullptr;"),
762             runCheckOnCode<PointeeLTransform>(Cat(S)));
763 }
764 TEST(Macro, MacroTypeReference) {
765   StringRef T = "static int g = 42;\n#define BAD_TYPEDEF int&\n";
766   StringRef S = "BAD_TYPEDEF target = g;";
767   auto Cat = [&T](StringRef S) { return (T + S).str(); };
768 
769   EXPECT_EQ(Cat("BAD_TYPEDEF target = g;"),
770             runCheckOnCode<ValueLTransform>(Cat(S)));
771   // FIXME: Failing even all parts seem to bail-out in for isMacroID()
772   EXPECT_NE(Cat("BAD_TYPEDEF target = g;"),
773             runCheckOnCode<ValueRTransform>(Cat(S)));
774 
775   EXPECT_EQ(Cat("BAD_TYPEDEF target = g;"),
776             runCheckOnCode<PointeeLTransform>(Cat(S)));
777   // FIXME: Failing even all parts seem to bail-out in for isMacroID()
778   EXPECT_NE(Cat("BAD_TYPEDEF target = g;"),
779             runCheckOnCode<PointeeRTransform>(Cat(S)));
780 }
781 // This failed in LLVM.
782 TEST(Macro, Variable) {
783   StringRef M = "#define DEBUG(X) do { if (1) { X; } } while (0)\n";
784   StringRef F = "void foo() ";
785   StringRef V = "{ DEBUG(int target = 42;); }";
786 
787   auto Cat = [&](StringRef S) { return (M + F + V).str(); };
788 
789   EXPECT_EQ(Cat("{ DEBUG(const int target = 42;); }"),
790             runCheckOnCode<ValueLTransform>(Cat(V)));
791   EXPECT_EQ(Cat("{ DEBUG(int const target = 42;); }"),
792             runCheckOnCode<ValueRTransform>(Cat(V)));
793 }
794 TEST(Macro, RangeLoop) {
795   StringRef M = "#define DEBUG(X) do { if (1) { X; }} while (false)\n";
796   StringRef F = "void foo() { char array[] = {'a', 'b', 'c'}; ";
797   StringRef V = "DEBUG( for(auto& target: array) 10 + target; );";
798   StringRef E = "}";
799 
800   auto Cat = [&](StringRef S) { return (M + F + V + E).str(); };
801 
802   EXPECT_EQ(Cat("DEBUG( for(const auto& target: array); );"),
803             runCheckOnCode<ValueLTransform>(Cat(V)));
804   EXPECT_EQ(Cat("DEBUG( for(auto const& target: array); );"),
805             runCheckOnCode<ValueRTransform>(Cat(V)));
806 }
807 
808 // ----------------------------------------------------------------------------
809 // Test template code.
810 // ----------------------------------------------------------------------------
811 
812 TEST(Template, TemplateVariable) {
813   StringRef T = "template <typename T> T target = 3.1415;";
814 
815   EXPECT_EQ("template <typename T> const T target = 3.1415;",
816             runCheckOnCode<ValueLTransform>(T));
817   EXPECT_EQ("template <typename T> T const target = 3.1415;",
818             runCheckOnCode<ValueRTransform>(T));
819 
820   EXPECT_EQ("template <typename T> const T target = 3.1415;",
821             runCheckOnCode<PointeeLTransform>(T));
822   EXPECT_EQ("template <typename T> T const target = 3.1415;",
823             runCheckOnCode<PointeeRTransform>(T));
824 }
825 TEST(Template, FunctionValue) {
826   StringRef T = "template <typename T> void f(T v) \n";
827   StringRef S = "{ T target = v; }";
828   auto Cat = [&T](StringRef S) { return (T + S).str(); };
829 
830   EXPECT_EQ(Cat("{ const T target = v; }"),
831             runCheckOnCode<ValueLTransform>(Cat(S)));
832   EXPECT_EQ(Cat("{ T const target = v; }"),
833             runCheckOnCode<ValueRTransform>(Cat(S)));
834 
835   EXPECT_EQ(Cat("{ const T target = v; }"),
836             runCheckOnCode<PointeeLTransform>(Cat(S)));
837   EXPECT_EQ(Cat("{ T const target = v; }"),
838             runCheckOnCode<PointeeRTransform>(Cat(S)));
839 }
840 TEST(Template, FunctionPointer) {
841   StringRef T = "template <typename T> void f(T* v) \n";
842   StringRef S = "{ T* target = v; }";
843   auto Cat = [&T](StringRef S) { return (T + S).str(); };
844 
845   EXPECT_EQ(Cat("{ T* const target = v; }"),
846             runCheckOnCode<ValueLTransform>(Cat(S)));
847   EXPECT_EQ(Cat("{ T* const target = v; }"),
848             runCheckOnCode<ValueRTransform>(Cat(S)));
849 
850   EXPECT_EQ(Cat("{ const T* target = v; }"),
851             runCheckOnCode<PointeeLTransform>(Cat(S)));
852   EXPECT_EQ(Cat("{ T const* target = v; }"),
853             runCheckOnCode<PointeeRTransform>(Cat(S)));
854 }
855 TEST(Template, FunctionReference) {
856   StringRef T = "template <typename T> void f(T& v) \n";
857   StringRef S = "{ T& target = v; }";
858   auto Cat = [&T](StringRef S) { return (T + S).str(); };
859 
860   EXPECT_EQ(Cat("{ const T& target = v; }"),
861             runCheckOnCode<ValueLTransform>(Cat(S)));
862   EXPECT_EQ(Cat("{ T const& target = v; }"),
863             runCheckOnCode<ValueRTransform>(Cat(S)));
864 
865   EXPECT_EQ(Cat("{ const T& target = v; }"),
866             runCheckOnCode<PointeeLTransform>(Cat(S)));
867   EXPECT_EQ(Cat("{ T const& target = v; }"),
868             runCheckOnCode<PointeeRTransform>(Cat(S)));
869 }
870 TEST(Template, MultiInstantiationsFunction) {
871   StringRef T = "template <typename T> void f(T v) \n";
872   StringRef S = "{ T target = v; }";
873   StringRef InstantStart = "void calls() {\n";
874   StringRef InstValue = "f<int>(42);\n";
875   StringRef InstConstValue = "f<const int>(42);\n";
876   StringRef InstPointer = "f<int*>(nullptr);\n";
877   StringRef InstPointerConst = "f<int* const>(nullptr);\n";
878   StringRef InstConstPointer = "f<const int*>(nullptr);\n";
879   StringRef InstConstPointerConst = "f<const int* const>(nullptr);\n";
880   StringRef InstRef = "int i = 42;\nf<int&>(i);\n";
881   StringRef InstConstRef = "f<const int&>(i);\n";
882   StringRef InstantEnd = "}";
883   auto Cat = [&](StringRef Target) {
884     return (T + Target + InstantStart + InstValue + InstConstValue +
885             InstPointer + InstPointerConst + InstConstPointer +
886             InstConstPointerConst + InstRef + InstConstRef + InstantEnd)
887         .str();
888   };
889 
890   EXPECT_EQ(Cat("{ const T target = v; }"),
891             runCheckOnCode<ValueLTransform>(Cat(S)));
892   EXPECT_EQ(Cat("{ T const target = v; }"),
893             runCheckOnCode<ValueRTransform>(Cat(S)));
894 
895   EXPECT_EQ(Cat("{ const T target = v; }"),
896             runCheckOnCode<PointeeLTransform>(Cat(S)));
897   EXPECT_EQ(Cat("{ T const target = v; }"),
898             runCheckOnCode<PointeeRTransform>(Cat(S)));
899 }
900 
901 TEST(Template, StructValue) {
902   StringRef T = "template <typename T> struct S { void f(T& v) \n";
903   StringRef S = "{ T target = v; }";
904   StringRef End = "\n};";
905   auto Cat = [&T, &End](StringRef S) { return (T + S + End).str(); };
906 
907   EXPECT_EQ(Cat("{ const T target = v; }"),
908             runCheckOnCode<ValueLTransform>(Cat(S)));
909   EXPECT_EQ(Cat("{ T const target = v; }"),
910             runCheckOnCode<ValueRTransform>(Cat(S)));
911 
912   EXPECT_EQ(Cat("{ const T target = v; }"),
913             runCheckOnCode<PointeeLTransform>(Cat(S)));
914   EXPECT_EQ(Cat("{ T const target = v; }"),
915             runCheckOnCode<PointeeRTransform>(Cat(S)));
916 }
917 TEST(Template, StructPointer) {
918   StringRef T = "template <typename T> struct S { void f(T* v) \n";
919   StringRef S = "{ T* target = v; }";
920   StringRef End = "\n};";
921   auto Cat = [&T, &End](StringRef S) { return (T + S + End).str(); };
922 
923   EXPECT_EQ(Cat("{ T* const target = v; }"),
924             runCheckOnCode<ValueLTransform>(Cat(S)));
925   EXPECT_EQ(Cat("{ T* const target = v; }"),
926             runCheckOnCode<ValueRTransform>(Cat(S)));
927 
928   EXPECT_EQ(Cat("{ const T* target = v; }"),
929             runCheckOnCode<PointeeLTransform>(Cat(S)));
930   EXPECT_EQ(Cat("{ T const* target = v; }"),
931             runCheckOnCode<PointeeRTransform>(Cat(S)));
932 }
933 TEST(Template, StructReference) {
934   StringRef T = "template <typename T> struct S { void f(T& v) \n";
935   StringRef S = "{ T& target = v; }";
936   StringRef End = "\n};";
937   auto Cat = [&T, &End](StringRef S) { return (T + S + End).str(); };
938 
939   EXPECT_EQ(Cat("{ const T& target = v; }"),
940             runCheckOnCode<ValueLTransform>(Cat(S)));
941   EXPECT_EQ(Cat("{ T const& target = v; }"),
942             runCheckOnCode<ValueRTransform>(Cat(S)));
943 
944   EXPECT_EQ(Cat("{ const T& target = v; }"),
945             runCheckOnCode<PointeeLTransform>(Cat(S)));
946   EXPECT_EQ(Cat("{ T const& target = v; }"),
947             runCheckOnCode<PointeeRTransform>(Cat(S)));
948 }
949 TEST(Template, DependentReturnFunction) {
950   StringRef TS = "template <typename T> struct TS { using value_type = T; };";
951   StringRef T = "template <typename T> void foo() ";
952   StringRef S = "{ typename T::value_type target; }";
953   auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
954 
955   EXPECT_EQ(Cat("{ const typename T::value_type target; }"),
956             runCheckOnCode<ValueLTransform>(Cat(S)));
957   EXPECT_EQ(Cat("{ typename T::value_type const target; }"),
958             runCheckOnCode<ValueRTransform>(Cat(S)));
959 
960   EXPECT_EQ(Cat("{ const typename T::value_type target; }"),
961             runCheckOnCode<PointeeLTransform>(Cat(S)));
962   EXPECT_EQ(Cat("{ typename T::value_type const target; }"),
963             runCheckOnCode<PointeeRTransform>(Cat(S)));
964 }
965 TEST(Template, DependentReturnPointerFunction) {
966   StringRef TS = "template <typename T> struct TS { using value_type = T; };";
967   StringRef T = "template <typename T> void foo() ";
968   StringRef S = "{ typename T::value_type *target; }";
969   auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
970 
971   EXPECT_EQ(Cat("{ typename T::value_type *const target; }"),
972             runCheckOnCode<ValueLTransform>(Cat(S)));
973   EXPECT_EQ(Cat("{ typename T::value_type *const target; }"),
974             runCheckOnCode<ValueRTransform>(Cat(S)));
975 
976   EXPECT_EQ(Cat("{ const typename T::value_type *target; }"),
977             runCheckOnCode<PointeeLTransform>(Cat(S)));
978   EXPECT_EQ(Cat("{ typename T::value_type  const*target; }"),
979             runCheckOnCode<PointeeRTransform>(Cat(S)));
980 }
981 TEST(Template, DependentReturnReferenceFunction) {
982   StringRef TS = "template <typename T> struct TS { using value_type = T; };";
983   StringRef T = "template <typename T> void foo(T& f) ";
984   StringRef S = "{ typename T::value_type &target = f; }";
985   auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
986 
987   EXPECT_EQ(Cat("{ const typename T::value_type &target = f; }"),
988             runCheckOnCode<ValueLTransform>(Cat(S)));
989   EXPECT_EQ(Cat("{ typename T::value_type  const&target = f; }"),
990             runCheckOnCode<ValueRTransform>(Cat(S)));
991 
992   EXPECT_EQ(Cat("{ const typename T::value_type &target = f; }"),
993             runCheckOnCode<PointeeLTransform>(Cat(S)));
994   EXPECT_EQ(Cat("{ typename T::value_type  const&target = f; }"),
995             runCheckOnCode<PointeeRTransform>(Cat(S)));
996 }
997 TEST(Template, VectorLikeType) {
998   StringRef TS = "template <typename T> struct TS { TS(const T&) {} }; ";
999   StringRef T = "void foo() ";
1000   StringRef S = "{ TS<int> target(42); }";
1001   auto Cat = [&TS, &T](StringRef S) { return (TS + T + S).str(); };
1002 
1003   EXPECT_EQ(Cat("{ const TS<int> target(42); }"),
1004             runCheckOnCode<ValueLTransform>(Cat(S)));
1005   EXPECT_EQ(Cat("{ TS<int> const target(42); }"),
1006             runCheckOnCode<ValueRTransform>(Cat(S)));
1007 
1008   EXPECT_EQ(Cat("{ const TS<int> target(42); }"),
1009             runCheckOnCode<PointeeLTransform>(Cat(S)));
1010   EXPECT_EQ(Cat("{ TS<int> const target(42); }"),
1011             runCheckOnCode<PointeeRTransform>(Cat(S)));
1012 }
1013 TEST(Template, SpecializedTemplate) {
1014   StringRef TS = "template <typename T = int> struct TS { TS(const T&) {} }; ";
1015   StringRef TS2 = "template <> struct TS<double> { TS(const double&) {} }; ";
1016   StringRef T = "void foo() ";
1017   StringRef S = "{ TS<double> target(42.42); }";
1018   auto Cat = [&](StringRef S) { return (TS + TS2 + T + S).str(); };
1019 
1020   EXPECT_EQ(Cat("{ const TS<double> target(42.42); }"),
1021             runCheckOnCode<ValueLTransform>(Cat(S)));
1022   EXPECT_EQ(Cat("{ TS<double> const target(42.42); }"),
1023             runCheckOnCode<ValueRTransform>(Cat(S)));
1024 
1025   EXPECT_EQ(Cat("{ const TS<double> target(42.42); }"),
1026             runCheckOnCode<PointeeLTransform>(Cat(S)));
1027   EXPECT_EQ(Cat("{ TS<double> const target(42.42); }"),
1028             runCheckOnCode<PointeeRTransform>(Cat(S)));
1029 }
1030 
1031 // -----------------------------------------------------------------------------
1032 // ObjC Pointers
1033 // -----------------------------------------------------------------------------
1034 
1035 TEST(ObjC, SimplePointers) {
1036   StringRef S = "int * target = 0;";
1037   EXPECT_EQ(runCheckOnCode<PointeeLTransform>(S, nullptr, "input.m"),
1038             "const int * target = 0;");
1039   EXPECT_EQ(runCheckOnCode<PointeeRTransform>(S, nullptr, "input.m"),
1040             "int  const* target = 0;");
1041   EXPECT_EQ(runCheckOnCode<ValueLTransform>(S, nullptr, "input.m"),
1042             "int * const target = 0;");
1043   EXPECT_EQ(runCheckOnCode<ValueRTransform>(S, nullptr, "input.m"),
1044             "int * const target = 0;");
1045 }
1046 TEST(ObjC, ClassPointer) {
1047   StringRef TB = "@class Object;\nint main() {\n";
1048   StringRef S = "Object *target;";
1049   StringRef TE = "\n}";
1050   auto Cat = [&](StringRef S) { return (TB + S + TE).str(); };
1051 
1052   // FIXME: Not done properly for some reason.
1053   EXPECT_NE(runCheckOnCode<PointeeLTransform>(Cat(S), nullptr, "input.m"),
1054             Cat("const Object *target;"));
1055   EXPECT_NE(runCheckOnCode<PointeeRTransform>(Cat(S), nullptr, "input.m"),
1056             Cat("Object  const*target;"));
1057   EXPECT_NE(runCheckOnCode<ValueLTransform>(Cat(S), nullptr, "input.m"),
1058             Cat("Object *const target;"));
1059   EXPECT_NE(runCheckOnCode<ValueRTransform>(Cat(S), nullptr, "input.m"),
1060             Cat("Object *const target;"));
1061 }
1062 TEST(ObjC, InterfacePointer) {
1063   StringRef TB = "@interface I\n";
1064   StringRef S = "- (void) foo: (int *) target;";
1065   StringRef TE = "\n@end";
1066   auto Cat = [&](StringRef S) { return (TB + S + TE).str(); };
1067 
1068   EXPECT_EQ(runCheckOnCode<PointeeLTransform>(Cat(S), nullptr, "input.m"),
1069             Cat("- (void) foo: (const int *) target;"));
1070   EXPECT_EQ(runCheckOnCode<PointeeRTransform>(Cat(S), nullptr, "input.m"),
1071             Cat("- (void) foo: (int  const*) target;"));
1072   // FIXME: These transformations are incorrect. ObjC seems to need
1073   // RParenSkipping which is not implemented.
1074   EXPECT_NE(runCheckOnCode<ValueLTransform>(Cat(S), nullptr, "input.m"),
1075             Cat("- (void) foo: (int * const) target;"));
1076   EXPECT_NE(runCheckOnCode<ValueRTransform>(Cat(S), nullptr, "input.m"),
1077             Cat("- (void) foo: (int * const) target;"));
1078 }
1079 
1080 } // namespace test
1081 } // namespace tidy
1082 } // namespace clang
1083