?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[mlir][acc] Update LegalizeDataValues pass to allow MappableType (#125134)
[llvm-project.git] / clang-tools-extra / unittests / clang-change-namespace / ChangeNamespaceTests.cpp
blob4a6352cd5975e67fec72e3b5633c9b687265f39e
1 //===-- ChangeNamespaceTests.cpp - Change namespace unit tests ---*- C++ -*-===//
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 "ChangeNamespace.h"
10 #include "unittests/Tooling/RewriterTestContext.h"
11 #include "clang/ASTMatchers/ASTMatchFinder.h"
12 #include "clang/Basic/FileManager.h"
13 #include "clang/Basic/FileSystemOptions.h"
14 #include "clang/Format/Format.h"
15 #include "clang/Frontend/CompilerInstance.h"
16 #include "clang/Frontend/PCHContainerOperations.h"
17 #include "clang/Tooling/Refactoring.h"
18 #include "clang/Tooling/Tooling.h"
19 #include "llvm/ADT/IntrusiveRefCntPtr.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/Support/MemoryBuffer.h"
22 #include "llvm/Support/VirtualFileSystem.h"
23 #include "gtest/gtest.h"
24 #include <memory>
25 #include <string>
26 #include <vector>
27
28 namespace clang {
29 namespace change_namespace {
30 namespace {
31
32 class ChangeNamespaceTest : public ::testing::Test {
33 public:
34 std::string runChangeNamespaceOnCode(llvm::StringRef Code) {
35 clang::RewriterTestContext Context;
36 clang::FileID ID = Context.createInMemoryFile(FileName, Code);
37
38 std::map<std::string, tooling::Replacements> FileToReplacements;
39 change_namespace::ChangeNamespaceTool NamespaceTool(
40 OldNamespace, NewNamespace, FilePattern,
41 /*AllowedSymbolPatterns*/ {}, &FileToReplacements);
42 ast_matchers::MatchFinder Finder;
43 NamespaceTool.registerMatchers(&Finder);
44 std::unique_ptr<tooling::FrontendActionFactory> Factory =
45 tooling::newFrontendActionFactory(&Finder);
46 if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, {"-std=c++11"},
47 FileName))
48 return "";
49 formatAndApplyAllReplacements(FileToReplacements, Context.Rewrite);
50 return format(Context.getRewrittenText(ID));
51 }
52
53 std::string format(llvm::StringRef Code) {
54 tooling::Replacements Replaces = format::reformat(
55 format::getLLVMStyle(), Code, {tooling::Range(0, Code.size())});
56 auto ChangedCode = tooling::applyAllReplacements(Code, Replaces);
57 EXPECT_TRUE(static_cast<bool>(ChangedCode));
58 if (!ChangedCode) {
59 llvm::errs() << llvm::toString(ChangedCode.takeError());
60 return "";
61 }
62 return *ChangedCode;
63 }
64
65 protected:
66 std::string FileName = "input.cc";
67 std::string OldNamespace = "na::nb";
68 std::string NewNamespace = "x::y";
69 std::string FilePattern = "input.cc";
70 };
71
72 TEST_F(ChangeNamespaceTest, NoMatchingNamespace) {
73 std::string Code = "namespace na {\n"
74 "namespace nx {\n"
75 "class A {};\n"
76 "} // namespace nx\n"
77 "} // namespace na\n";
78 std::string Expected = "namespace na {\n"
79 "namespace nx {\n"
80 "class A {};\n"
81 "} // namespace nx\n"
82 "} // namespace na\n";
83 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
84 }
85
86 TEST_F(ChangeNamespaceTest, SimpleMoveWithoutTypeRefs) {
87 std::string Code = "namespace na {\n"
88 "namespace nb {\n"
89 "class A {};\n"
90 "} // namespace nb\n"
91 "} // namespace na\n";
92 std::string Expected = "\n\n"
93 "namespace x {\n"
94 "namespace y {\n"
95 "class A {};\n"
96 "} // namespace y\n"
97 "} // namespace x\n";
98 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
99 }
100
101 TEST_F(ChangeNamespaceTest, NewNsNestedInOldNs) {
102 NewNamespace = "na::nb::nc";
103 std::string Code = "namespace na {\n"
104 "namespace nb {\n"
105 "class A {};\n"
106 "} // namespace nb\n"
107 "} // namespace na\n";
108 std::string Expected = "namespace na {\n"
109 "namespace nb {\n"
110 "namespace nc {\n"
111 "class A {};\n"
112 "} // namespace nc\n"
113 "} // namespace nb\n"
114 "} // namespace na\n";
115 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
116 }
117
118 TEST_F(ChangeNamespaceTest, NewNsNestedInOldNsWithSurroundingNewLines) {
119 NewNamespace = "na::nb::nc";
120 std::string Code = "namespace na {\n"
121 "namespace nb {\n"
122 "\n"
123 "class A {};\n"
124 "\n"
125 "} // namespace nb\n"
126 "} // namespace na\n";
127 std::string Expected = "namespace na {\n"
128 "namespace nb {\n"
129 "namespace nc {\n"
130 "\n"
131 "class A {};\n"
132 "\n"
133 "} // namespace nc\n"
134 "} // namespace nb\n"
135 "} // namespace na\n";
136 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
137 }
138
139 TEST_F(ChangeNamespaceTest, MoveOldNsWithSurroundingNewLines) {
140 NewNamespace = "nx::ny";
141 std::string Code = "namespace na {\n"
142 "namespace nb {\n"
143 "\n"
144 "class A {};\n"
145 "\n"
146 "} // namespace nb\n"
147 "} // namespace na\n";
148 std::string Expected = "\n\n"
149 "namespace nx {\n"
150 "namespace ny {\n"
151 "\n"
152 "class A {};\n"
153 "\n"
154 "} // namespace ny\n"
155 "} // namespace nx\n";
156 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
157 }
158
159 TEST_F(ChangeNamespaceTest, NewNsNestedInOldNsWithRefs) {
160 NewNamespace = "na::nb::nc";
161 std::string Code = "namespace na {\n"
162 "class A {};\n"
163 "namespace nb {\n"
164 "class B {};\n"
165 "class C {};\n"
166 "void f() { A a; B b; }\n"
167 "} // namespace nb\n"
168 "} // namespace na\n";
169 std::string Expected = "namespace na {\n"
170 "class A {};\n"
171 "namespace nb {\n"
172 "namespace nc {\n"
173 "class B {};\n"
174 "class C {};\n"
175 "void f() { A a; B b; }\n"
176 "} // namespace nc\n"
177 "} // namespace nb\n"
178 "} // namespace na\n";
179 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
180 }
181
182 TEST_F(ChangeNamespaceTest, SimpleMoveIntoAnotherNestedNamespace) {
183 NewNamespace = "na::nc";
184 std::string Code = "namespace na {\n"
185 "namespace nb {\n"
186 "class A {};\n"
187 "} // namespace nb\n"
188 "} // namespace na\n";
189 std::string Expected = "namespace na {\n"
190 "\n"
191 "namespace nc {\n"
192 "class A {};\n"
193 "} // namespace nc\n"
194 "} // namespace na\n";
195 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
196 }
197
198 TEST_F(ChangeNamespaceTest, MoveIntoAnotherNestedNamespaceWithRef) {
199 NewNamespace = "na::nc";
200 std::string Code = "namespace na {\n"
201 "class A {};\n"
202 "namespace nb {\n"
203 "class X { A a; };\n"
204 "} // namespace nb\n"
205 "} // namespace na\n";
206 std::string Expected = "namespace na {\n"
207 "class A {};\n"
208 "\n"
209 "namespace nc {\n"
210 "class X { A a; };\n"
211 "} // namespace nc\n"
212 "} // namespace na\n";
213 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
214 }
215
216 TEST_F(ChangeNamespaceTest, MoveIntoExistingNamespaceAndShortenRefs) {
217 std::string Code = "namespace x {\n"
218 "namespace z {\n"
219 "class Z {};\n"
220 "} // namespace z\n"
221 "namespace y {\n"
222 "class T {};\n"
223 "} // namespace y\n"
224 "} // namespace x\n"
225 "namespace na {\n"
226 "class A{};\n"
227 "namespace nb {\n"
228 "class X { A a; x::z::Z zz; x::y::T t; };\n"
229 "} // namespace nb\n"
230 "} // namespace na\n";
231 std::string Expected = "namespace x {\n"
232 "namespace z {\n"
233 "class Z {};\n"
234 "} // namespace z\n"
235 "namespace y {\n"
236 "class T {};\n"
237 "} // namespace y\n"
238 "} // namespace x\n"
239 "namespace na {\n"
240 "class A {};\n\n"
241 "} // namespace na\n"
242 "namespace x {\n"
243 "namespace y {\n"
244 "class X { na::A a; z::Z zz; T t; };\n"
245 "} // namespace y\n"
246 "} // namespace x\n";
247 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
248 }
249
250 TEST_F(ChangeNamespaceTest, SimpleMoveNestedNamespace) {
251 NewNamespace = "na::x::y";
252 std::string Code = "namespace na {\n"
253 "class A {};\n"
254 "namespace nb {\n"
255 "class B {};\n"
256 "} // namespace nb\n"
257 "} // namespace na\n";
258 std::string Expected = "namespace na {\n"
259 "class A {};\n"
260 "\n"
261 "namespace x {\n"
262 "namespace y {\n"
263 "class B {};\n"
264 "} // namespace y\n"
265 "} // namespace x\n"
266 "} // namespace na\n";
267 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
268 }
269
270 TEST_F(ChangeNamespaceTest, SimpleMoveWithTypeRefs) {
271 std::string Code = "namespace na {\n"
272 "class C_A {};\n"
273 "namespace nc {\n"
274 "class C_C {};"
275 "} // namespace nc\n"
276 "namespace nb {\n"
277 "class C_X {\n"
278 "public:\n"
279 " C_A a;\n"
280 " nc::C_C c;\n"
281 "};\n"
282 "class C_Y {\n"
283 " C_X x;\n"
284 "};\n"
285 "} // namespace nb\n"
286 "} // namespace na\n";
287 std::string Expected = "namespace na {\n"
288 "class C_A {};\n"
289 "namespace nc {\n"
290 "class C_C {};"
291 "} // namespace nc\n"
292 "\n"
293 "} // namespace na\n"
294 "namespace x {\n"
295 "namespace y {\n"
296 "class C_X {\n"
297 "public:\n"
298 " na::C_A a;\n"
299 " na::nc::C_C c;\n"
300 "};\n"
301 "class C_Y {\n"
302 " C_X x;\n"
303 "};\n"
304 "} // namespace y\n"
305 "} // namespace x\n";
306 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
307 }
308
309 TEST_F(ChangeNamespaceTest, TypeLocInTemplateSpecialization) {
310 std::string Code = "namespace na {\n"
311 "class A {};\n"
312 "template <typename T>\n"
313 "class B {};\n"
314 "template <typename T1, typename T2>\n"
315 "class Two {};\n"
316 "namespace nc { class C {}; }\n"
317 "} // na\n"
318 "\n"
319 "namespace na {\n"
320 "namespace nb {\n"
321 "void f() {\n"
322 " B<A> b;\n"
323 " B<nc::C> b_c;\n"
324 " Two<A, nc::C> two;\n"
325 "}\n"
326 "} // nb\n"
327 "} // na\n";
328 std::string Expected = "namespace na {\n"
329 "class A {};\n"
330 "template <typename T>\n"
331 "class B {};\n"
332 "template <typename T1, typename T2>\n"
333 "class Two {};\n"
334 "namespace nc { class C {}; }\n"
335 "} // na\n"
336 "\n"
337 "\n"
338 "namespace x {\n"
339 "namespace y {\n"
340 "void f() {\n"
341 " na::B<na::A> b;\n"
342 " na::B<na::nc::C> b_c;\n"
343 " na::Two<na::A, na::nc::C> two;\n"
344 "}\n"
345 "} // namespace y\n"
346 "} // namespace x\n";
347 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
348 }
349
350 TEST_F(ChangeNamespaceTest, LeaveForwardDeclarationBehind) {
351 std::string Code = "namespace na {\n"
352 "namespace nb {\n"
353 "class FWD;\n"
354 "class FWD2;\n"
355 "class A {\n"
356 " FWD *fwd;\n"
357 "};\n"
358 "} // namespace nb\n"
359 "} // namespace na\n";
360 std::string Expected = "namespace na {\n"
361 "namespace nb {\n"
362 "class FWD;\n"
363 "class FWD2;\n"
364 "} // namespace nb\n"
365 "} // namespace na\n"
366 "namespace x {\n"
367 "namespace y {\n"
368 "\n"
369 "class A {\n"
370 " na::nb::FWD *fwd;\n"
371 "};\n"
372 "} // namespace y\n"
373 "} // namespace x\n";
374 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
375 }
376
377 TEST_F(ChangeNamespaceTest, InsertForwardDeclsProperly) {
378 std::string Code = "namespace na {\n"
379 "namespace nb {\n"
380 "\n"
381 "class FWD;\n"
382 "class FWD2;\n"
383 "class A {\n"
384 " FWD *fwd;\n"
385 "};\n"
386 "\n"
387 "} // namespace nb\n"
388 "} // namespace na\n";
389 std::string Expected = "namespace na {\n"
390 "namespace nb {\n"
391 "class FWD;\n"
392 "class FWD2;\n"
393 "} // namespace nb\n"
394 "} // namespace na\n"
395 "namespace x {\n"
396 "namespace y {\n"
397 "\n"
398 "class A {\n"
399 " na::nb::FWD *fwd;\n"
400 "};\n"
401 "\n"
402 "} // namespace y\n"
403 "} // namespace x\n";
404 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
405 }
406
407 TEST_F(ChangeNamespaceTest, TemplateClassForwardDeclaration) {
408 std::string Code = "namespace na {\n"
409 "namespace nb {\n"
410 "class FWD;\n"
411 "template<typename T> class FWD_TEMP;\n"
412 "class A {\n"
413 " FWD *fwd;\n"
414 "};\n"
415 "template<typename T> class TEMP {};\n"
416 "} // namespace nb\n"
417 "} // namespace na\n";
418 std::string Expected = "namespace na {\n"
419 "namespace nb {\n"
420 "class FWD;\n"
421 "template<typename T> class FWD_TEMP;\n"
422 "} // namespace nb\n"
423 "} // namespace na\n"
424 "namespace x {\n"
425 "namespace y {\n"
426 "\n"
427 "class A {\n"
428 " na::nb::FWD *fwd;\n"
429 "};\n"
430 "template<typename T> class TEMP {};\n"
431 "} // namespace y\n"
432 "} // namespace x\n";
433 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
434 }
435
436 TEST_F(ChangeNamespaceTest, DontMoveForwardDeclarationInClass) {
437 std::string Code = "namespace na {\n"
438 "namespace nb {\n"
439 "class A {\n"
440 " class FWD;\n"
441 " FWD *fwd;\n"
442 " template<typename T> class FWD_TEMP;\n"
443 "};\n"
444 "} // namespace nb\n"
445 "} // namespace na\n";
446 std::string Expected = "\n\n"
447 "namespace x {\n"
448 "namespace y {\n"
449 "class A {\n"
450 " class FWD;\n"
451 " FWD *fwd;\n"
452 " template<typename T> class FWD_TEMP;\n"
453 "};\n"
454 "} // namespace y\n"
455 "} // namespace x\n";
456 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
457 }
458
459 TEST_F(ChangeNamespaceTest, MoveFunctions) {
460 std::string Code = "namespace na {\n"
461 "class C_A {};\n"
462 "namespace nc {\n"
463 "class C_C {};"
464 "} // namespace nc\n"
465 "namespace nb {\n"
466 "void fwd();\n"
467 "void f(C_A ca, nc::C_C cc) {\n"
468 " C_A ca_1 = ca;\n"
469 "}\n"
470 "} // namespace nb\n"
471 "} // namespace na\n";
472
473 std::string Expected = "namespace na {\n"
474 "class C_A {};\n"
475 "namespace nc {\n"
476 "class C_C {};"
477 "} // namespace nc\n"
478 "\n"
479 "} // namespace na\n"
480 "namespace x {\n"
481 "namespace y {\n"
482 "void fwd();\n"
483 "void f(na::C_A ca, na::nc::C_C cc) {\n"
484 " na::C_A ca_1 = ca;\n"
485 "}\n"
486 "} // namespace y\n"
487 "} // namespace x\n";
488 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
489 }
490
491 TEST_F(ChangeNamespaceTest, FixUsingShadowDecl) {
492 std::string Code = "class GLOB {};\n"
493 "using BLOG = GLOB;\n"
494 "namespace na {\n"
495 "namespace nc {\n"
496 "class SAME {};\n"
497 "}\n"
498 "namespace nd {\n"
499 "class SAME {};\n"
500 "}\n"
501 "namespace nb {\n"
502 "using nc::SAME;\n"
503 "using YO = nd::SAME;\n"
504 "typedef nd::SAME IDENTICAL;\n"
505 "void f(nd::SAME Same) {}\n"
506 "} // namespace nb\n"
507 "} // namespace na\n";
508
509 std::string Expected = "class GLOB {};\n"
510 "using BLOG = GLOB;\n"
511 "namespace na {\n"
512 "namespace nc {\n"
513 "class SAME {};\n"
514 "}\n"
515 "namespace nd {\n"
516 "class SAME {};\n"
517 "}\n"
518 "\n"
519 "} // namespace na\n"
520 "namespace x {\n"
521 "namespace y {\n"
522 "using ::na::nc::SAME;\n"
523 "using YO = na::nd::SAME;\n"
524 "typedef na::nd::SAME IDENTICAL;\n"
525 "void f(na::nd::SAME Same) {}\n"
526 "} // namespace y\n"
527 "} // namespace x\n";
528 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
529 }
530
531 TEST_F(ChangeNamespaceTest, DontFixUsingShadowDeclInClasses) {
532 std::string Code = "namespace na {\n"
533 "class A {};\n"
534 "class Base { public: Base() {} void m() {} };\n"
535 "namespace nb {\n"
536 "class D : public Base {\n"
537 "public:\n"
538 " using AA = A; using B = Base;\n"
539 " using Base::m; using Base::Base;\n"
540 "};"
541 "} // namespace nb\n"
542 "} // namespace na\n";
543
544 std::string Expected = "namespace na {\n"
545 "class A {};\n"
546 "class Base { public: Base() {} void m() {} };\n"
547 "\n"
548 "} // namespace na\n"
549 "namespace x {\n"
550 "namespace y {\n"
551 "class D : public na::Base {\n"
552 "public:\n"
553 " using AA = na::A; using B = na::Base;\n"
554 " using Base::m; using Base::Base;\n"
555 "};"
556 "} // namespace y\n"
557 "} // namespace x\n";
558 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
559 }
560
561 TEST_F(ChangeNamespaceTest, TypeInNestedNameSpecifier) {
562 std::string Code =
563 "namespace na {\n"
564 "class C_A {\n"
565 "public:\n"
566 " class Nested {\n"
567 " public:\n"
568 " static int NestedX;\n"
569 " static void nestedFunc() {}\n"
570 " };\n"
571 "};\n"
572 "namespace nb {\n"
573 "class C_X {\n"
574 " C_A na;\n"
575 " C_A::Nested nested;\n"
576 " void f() {\n"
577 " C_A::Nested::nestedFunc();\n"
578 " int X = C_A::Nested::NestedX;\n"
579 " }\n"
580 "};\n"
581 "} // namespace nb\n"
582 "} // namespace na\n";
583 std::string Expected =
584 "namespace na {\n"
585 "class C_A {\n"
586 "public:\n"
587 " class Nested {\n"
588 " public:\n"
589 " static int NestedX;\n"
590 " static void nestedFunc() {}\n"
591 " };\n"
592 "};\n"
593 "\n"
594 "} // namespace na\n"
595 "namespace x {\n"
596 "namespace y {\n"
597 "class C_X {\n"
598 " na::C_A na;\n"
599 " na::C_A::Nested nested;\n"
600 " void f() {\n"
601 " na::C_A::Nested::nestedFunc();\n"
602 " int X = na::C_A::Nested::NestedX;\n"
603 " }\n"
604 "};\n"
605 "} // namespace y\n"
606 "} // namespace x\n";
607 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
608 }
609
610 TEST_F(ChangeNamespaceTest, FixFunctionNameSpecifiers) {
611 std::string Code =
612 "namespace na {\n"
613 "class A {\n"
614 "public:\n"
615 " static void f() {}\n"
616 " static void g();\n"
617 "};\n"
618 "void A::g() {}"
619 "void a_f() {}\n"
620 "static void static_f() {}\n"
621 "namespace nb {\n"
622 "void f() { a_f(); static_f(); A::f(); }\n"
623 "void g() { f(); A::g(); }\n"
624 "} // namespace nb\n"
625 "} // namespace na\n";
626 std::string Expected =
627 "namespace na {\n"
628 "class A {\n"
629 "public:\n"
630 " static void f() {}\n"
631 " static void g();\n"
632 "};\n"
633 "void A::g() {}"
634 "void a_f() {}\n"
635 "static void static_f() {}\n"
636 "\n"
637 "} // namespace na\n"
638 "namespace x {\n"
639 "namespace y {\n"
640 "void f() { na::a_f(); na::static_f(); na::A::f(); }\n"
641 "void g() { f(); na::A::g(); }\n"
642 "} // namespace y\n"
643 "} // namespace x\n";
644 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
645 }
646
647 TEST_F(ChangeNamespaceTest, FixOverloadedOperatorFunctionNameSpecifiers) {
648 std::string Code =
649 "namespace na {\n"
650 "class A {\n"
651 "public:\n"
652 " int x;\n"
653 " bool operator==(const A &RHS) const { return x == RHS.x; }\n"
654 "};\n"
655 "bool operator<(const A &LHS, const A &RHS) { return LHS.x == RHS.x; }\n"
656 "namespace nb {\n"
657 "bool f() {\n"
658 " A x, y;\n"
659 " auto f = operator<;\n"
660 " return (x == y) && (x < y) && (operator<(x, y));\n"
661 "}\n"
662 "} // namespace nb\n"
663 "} // namespace na\n";
664 std::string Expected =
665 "namespace na {\n"
666 "class A {\n"
667 "public:\n"
668 " int x;\n"
669 " bool operator==(const A &RHS) const { return x == RHS.x; }\n"
670 "};\n"
671 "bool operator<(const A &LHS, const A &RHS) { return LHS.x == RHS.x; }\n"
672 "\n"
673 "} // namespace na\n"
674 "namespace x {\n"
675 "namespace y {\n"
676 "bool f() {\n"
677 " na::A x, y;\n"
678 " auto f = na::operator<;\n"
679 // FIXME: function calls to overloaded operators are not fixed now even if
680 // they are referenced by qualified names.
681 " return (x == y) && (x < y) && (operator<(x,y));\n"
682 "}\n"
683 "} // namespace y\n"
684 "} // namespace x\n";
685 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
686 }
687
688 TEST_F(ChangeNamespaceTest, FixNonCallingFunctionReferences) {
689 std::string Code = "namespace na {\n"
690 "class A {\n"
691 "public:\n"
692 " static void f() {}\n"
693 "};\n"
694 "void a_f() {}\n"
695 "static void s_f() {}\n"
696 "namespace nb {\n"
697 "void f() {\n"
698 " auto *ref1 = A::f;\n"
699 " auto *ref2 = a_f;\n"
700 " auto *ref3 = s_f;\n"
701 "}\n"
702 "} // namespace nb\n"
703 "} // namespace na\n";
704 std::string Expected =
705 "namespace na {\n"
706 "class A {\n"
707 "public:\n"
708 " static void f() {}\n"
709 "};\n"
710 "void a_f() {}\n"
711 "static void s_f() {}\n"
712 "\n"
713 "} // namespace na\n"
714 "namespace x {\n"
715 "namespace y {\n"
716 "void f() {\n"
717 " auto *ref1 = na::A::f;\n"
718 " auto *ref2 = na::a_f;\n"
719 " auto *ref3 = na::s_f;\n"
720 "}\n"
721 "} // namespace y\n"
722 "} // namespace x\n";
723 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
724 }
725
726 TEST_F(ChangeNamespaceTest, MoveAndFixGlobalVariables) {
727 std::string Code = "namespace na {\n"
728 "int GlobA;\n"
729 "static int GlobAStatic = 0;\n"
730 "namespace nc { int GlobC; }\n"
731 "namespace nb {\n"
732 "int GlobB;\n"
733 "void f() {\n"
734 " int a = GlobA;\n"
735 " int b = GlobAStatic;\n"
736 " int c = nc::GlobC;\n"
737 "}\n"
738 "} // namespace nb\n"
739 "} // namespace na\n";
740
741 std::string Expected = "namespace na {\n"
742 "int GlobA;\n"
743 "static int GlobAStatic = 0;\n"
744 "namespace nc { int GlobC; }\n"
745 "\n"
746 "} // namespace na\n"
747 "namespace x {\n"
748 "namespace y {\n"
749 "int GlobB;\n"
750 "void f() {\n"
751 " int a = na::GlobA;\n"
752 " int b = na::GlobAStatic;\n"
753 " int c = na::nc::GlobC;\n"
754 "}\n"
755 "} // namespace y\n"
756 "} // namespace x\n";
757
758 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
759 }
760
761 TEST_F(ChangeNamespaceTest, DoNotFixStaticVariableOfClass) {
762 std::string Code = "namespace na {\n"
763 "class A {\n"
764 "public:\n"
765 "static int A1;\n"
766 "static int A2;\n"
767 "};\n"
768 "int A::A1 = 0;\n"
769 "namespace nb {\n"
770 "void f() {\n"
771 " int a = A::A1; int b = A::A2;\n"
772 "}\n"
773 "} // namespace nb\n"
774 "} // namespace na\n";
775
776 std::string Expected = "namespace na {\n"
777 "class A {\n"
778 "public:\n"
779 "static int A1;\n"
780 "static int A2;\n"
781 "};\n"
782 "int A::A1 = 0;\n"
783 "\n"
784 "} // namespace na\n"
785 "namespace x {\n"
786 "namespace y {\n"
787 "void f() {\n"
788 " int a = na::A::A1; int b = na::A::A2;\n"
789 "}\n"
790 "} // namespace y\n"
791 "} // namespace x\n";
792
793 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
794 }
795
796 TEST_F(ChangeNamespaceTest, NoMisplaceAtEOF) {
797 std::string Code = "namespace na {\n"
798 "namespace nb {\n"
799 "class A;\n"
800 "class B {};\n"
801 "}"
802 "}";
803 std::string Expected = "namespace na {\n"
804 "namespace nb {\n"
805 "class A;\n"
806 "}\n"
807 "}\n"
808 "namespace x {\n"
809 "namespace y {\n"
810 "\n"
811 "class B {};\n"
812 "} // namespace y\n"
813 "} // namespace x\n";
814 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
815 }
816
817 TEST_F(ChangeNamespaceTest, CommentsBeforeMovedClass) {
818 std::string Code = "namespace na {\n"
819 "namespace nb {\n"
820 "\n\n"
821 "// Wild comments.\n"
822 "\n"
823 "// Comments.\n"
824 "// More comments.\n"
825 "class B {\n"
826 " // Private comments.\n"
827 " int a;\n"
828 "};\n"
829 "}\n"
830 "}";
831 std::string Expected = "\n"
832 "\n"
833 "namespace x {\n"
834 "namespace y {\n"
835 "\n\n"
836 "// Wild comments.\n"
837 "\n"
838 "// Comments.\n"
839 "// More comments.\n"
840 "class B {\n"
841 " // Private comments.\n"
842 " int a;\n"
843 "};\n"
844 "} // namespace y\n"
845 "} // namespace x\n";
846 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
847 }
848
849 TEST_F(ChangeNamespaceTest, UsingShadowDeclInGlobal) {
850 std::string Code = "namespace glob {\n"
851 "class Glob {};\n"
852 "void GFunc() {}\n"
853 "}\n"
854 "using glob::Glob;\n"
855 "using glob::GFunc;\n"
856 "namespace na {\n"
857 "namespace nb {\n"
858 "void f() { Glob g; GFunc(); }\n"
859 "} // namespace nb\n"
860 "} // namespace na\n";
861
862 std::string Expected = "namespace glob {\n"
863 "class Glob {};\n"
864 "void GFunc() {}\n"
865 "}\n"
866 "using glob::Glob;\n"
867 "using glob::GFunc;\n"
868 "\n"
869 "namespace x {\n"
870 "namespace y {\n"
871 "void f() { Glob g; GFunc(); }\n"
872 "} // namespace y\n"
873 "} // namespace x\n";
874 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
875 }
876
877 TEST_F(ChangeNamespaceTest, UsingShadowDeclsInAnonymousNamespaces) {
878 std::string Code = "namespace util {\n"
879 "class Util {};\n"
880 "void func() {}\n"
881 "}\n"
882 "namespace na {\n"
883 "namespace nb {\n"
884 "namespace {\n"
885 "using ::util::Util;\n"
886 "using ::util::func;\n"
887 "void f() { Util u; func(); }\n"
888 "}\n"
889 "} // namespace nb\n"
890 "} // namespace na\n";
891
892 std::string Expected = "namespace util {\n"
893 "class Util {};\n"
894 "void func() {}\n"
895 "} // namespace util\n"
896 "\n"
897 "namespace x {\n"
898 "namespace y {\n"
899 "namespace {\n"
900 "using ::util::Util;\n"
901 "using ::util::func;\n"
902 "void f() { Util u; func(); }\n"
903 "}\n"
904 "} // namespace y\n"
905 "} // namespace x\n";
906 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
907 }
908
909 TEST_F(ChangeNamespaceTest, UsingNamespaceInGlobal) {
910 std::string Code = "namespace glob {\n"
911 "class Glob {};\n"
912 "}\n"
913 "using namespace glob;\n"
914 "namespace na {\n"
915 "namespace nb {\n"
916 "void f() { Glob g; }\n"
917 "} // namespace nb\n"
918 "} // namespace na\n";
919
920 std::string Expected = "namespace glob {\n"
921 "class Glob {};\n"
922 "}\n"
923 "using namespace glob;\n"
924 "\n"
925 "namespace x {\n"
926 "namespace y {\n"
927 "void f() { Glob g; }\n"
928 "} // namespace y\n"
929 "} // namespace x\n";
930 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
931 }
932
933 TEST_F(ChangeNamespaceTest, NamespaceAliasInGlobal) {
934 std::string Code = "namespace glob {\n"
935 "class Glob {};\n"
936 "}\n"
937 "namespace glob2 { class Glob2 {}; }\n"
938 "namespace gl = glob;\n"
939 "namespace gl2 = glob2;\n"
940 "namespace na {\n"
941 "namespace nb {\n"
942 "void f() { gl::Glob g; gl2::Glob2 g2; }\n"
943 "} // namespace nb\n"
944 "} // namespace na\n";
945
946 std::string Expected =
947 "namespace glob {\n"
948 "class Glob {};\n"
949 "}\n"
950 "namespace glob2 { class Glob2 {}; }\n"
951 "namespace gl = glob;\n"
952 "namespace gl2 = glob2;\n"
953 "\n"
954 "namespace x {\n"
955 "namespace y {\n"
956 "void f() { gl::Glob g; gl2::Glob2 g2; }\n"
957 "} // namespace y\n"
958 "} // namespace x\n";
959 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
960 }
961
962 TEST_F(ChangeNamespaceTest, NamespaceAliasInNamespace) {
963 std::string Code = "namespace glob {\n"
964 "class Glob {};\n"
965 "}\n"
966 "namespace na {\n"
967 "namespace nb {\n"
968 "namespace gl = glob;\n"
969 "void f() { gl::Glob g; }\n"
970 "} // namespace nb\n"
971 "} // namespace na\n";
972
973 std::string Expected = "namespace glob {\n"
974 "class Glob {};\n"
975 "}\n"
976 "\n"
977 "namespace x {\n"
978 "namespace y {\n"
979 "namespace gl = glob;\n"
980 "void f() { gl::Glob g; }\n"
981 "} // namespace y\n"
982 "} // namespace x\n";
983 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
984 }
985
986 TEST_F(ChangeNamespaceTest, NamespaceAliasInAncestorNamespace) {
987 NewNamespace = "na::nx";
988 std::string Code = "namespace glob {\n"
989 "class Glob {};\n"
990 "}\n"
991 "namespace other { namespace gl = glob; }\n"
992 "namespace na {\n"
993 "namespace ga = glob;\n"
994 "namespace nb {\n"
995 "void f() { ga::Glob g; }\n"
996 "} // namespace nb\n"
997 "} // namespace na\n";
998
999 std::string Expected = "namespace glob {\n"
1000 "class Glob {};\n"
1001 "}\n"
1002 "namespace other { namespace gl = glob; }\n"
1003 "namespace na {\n"
1004 "namespace ga = glob;\n"
1005 "\n"
1006 "namespace nx {\n"
1007 "void f() { ga::Glob g; }\n"
1008 "} // namespace nx\n"
1009 "} // namespace na\n";
1010 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1011 }
1012
1013 TEST_F(ChangeNamespaceTest, NamespaceAliasInOtherNamespace) {
1014 std::string Code = "namespace glob {\n"
1015 "class Glob {};\n"
1016 "}\n"
1017 "namespace other { namespace gl = glob; }\n"
1018 "namespace na {\n"
1019 "namespace ga = glob;\n"
1020 "namespace nb {\n"
1021 "void f() { glob::Glob g; }\n"
1022 "} // namespace nb\n"
1023 "} // namespace na\n";
1024
1025 std::string Expected = "namespace glob {\n"
1026 "class Glob {};\n"
1027 "}\n"
1028 "namespace other { namespace gl = glob; }\n"
1029 "namespace na {\n"
1030 "namespace ga = glob;\n"
1031 "\n"
1032 "} // namespace na\n"
1033 "namespace x {\n"
1034 "namespace y {\n"
1035 "void f() { glob::Glob g; }\n"
1036 "} // namespace y\n"
1037 "} // namespace x\n";
1038 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1039 }
1040
1041 TEST_F(ChangeNamespaceTest, UsingDeclAfterReference) {
1042 std::string Code = "namespace glob {\n"
1043 "class Glob {};\n"
1044 "}\n"
1045 "namespace na {\n"
1046 "namespace nb {\n"
1047 "void f() { glob::Glob g; }\n"
1048 "} // namespace nb\n"
1049 "} // namespace na\n"
1050 "using glob::Glob;\n"
1051 "using namespace glob;\n";
1052
1053 std::string Expected = "namespace glob {\n"
1054 "class Glob {};\n"
1055 "}\n"
1056 "\n"
1057 "namespace x {\n"
1058 "namespace y {\n"
1059 "void f() { glob::Glob g; }\n"
1060 "} // namespace y\n"
1061 "} // namespace x\n"
1062 "using glob::Glob;\n"
1063 "using namespace glob;\n";
1064 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1065 }
1066
1067 TEST_F(ChangeNamespaceTest, UsingNamespaceAfterReference) {
1068 NewNamespace = "na::nc";
1069 std::string Code = "namespace glob {\n"
1070 "class Glob {};\n"
1071 "}\n"
1072 "namespace na {\n"
1073 "namespace nb {\n"
1074 "void f() { glob::Glob g; }\n"
1075 "} // namespace nb\n"
1076 "using namespace glob;\n"
1077 "} // namespace na\n";
1078
1079 std::string Expected = "namespace glob {\n"
1080 "class Glob {};\n"
1081 "}\n"
1082 "namespace na {\n"
1083 "\n"
1084 "namespace nc {\n"
1085 "void f() { glob::Glob g; }\n"
1086 "} // namespace nc\n"
1087 "using namespace glob;\n"
1088 "} // namespace na\n";
1089 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1090 }
1091
1092 TEST_F(ChangeNamespaceTest, UsingNamespaceAndUsingShadowInGlobal) {
1093 std::string Code = "namespace glob1 {\n"
1094 "namespace glob2 {\n"
1095 "class Glob {};\n"
1096 "}\n"
1097 "}\n"
1098 "using glob1::glob2::Glob;\n"
1099 "using namespace glob1;\n"
1100 "namespace na {\n"
1101 "namespace nb {\n"
1102 "void f() { Glob g; }\n"
1103 "} // namespace nb\n"
1104 "} // namespace na\n";
1105
1106 std::string Expected = "namespace glob1 {\n"
1107 "namespace glob2 {\n"
1108 "class Glob {};\n"
1109 "}\n"
1110 "}\n"
1111 "using glob1::glob2::Glob;\n"
1112 "using namespace glob1;\n"
1113 "\n"
1114 "namespace x {\n"
1115 "namespace y {\n"
1116 "void f() { Glob g; }\n"
1117 "} // namespace y\n"
1118 "} // namespace x\n";
1119 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1120 }
1121
1122 TEST_F(ChangeNamespaceTest, UsingAliasInGlobal) {
1123 std::string Code = "namespace glob {\n"
1124 "class Glob {};\n"
1125 "}\n"
1126 "using GLB = glob::Glob;\n"
1127 "using BLG = glob::Glob;\n"
1128 "namespace na {\n"
1129 "namespace nb {\n"
1130 "void f() { GLB g; BLG blg; }\n"
1131 "} // namespace nb\n"
1132 "} // namespace na\n";
1133
1134 std::string Expected = "namespace glob {\n"
1135 "class Glob {};\n"
1136 "}\n"
1137 "using GLB = glob::Glob;\n"
1138 "using BLG = glob::Glob;\n"
1139 "\n"
1140 "namespace x {\n"
1141 "namespace y {\n"
1142 "void f() { GLB g; BLG blg; }\n"
1143 "} // namespace y\n"
1144 "} // namespace x\n";
1145 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1146 }
1147
1148 TEST_F(ChangeNamespaceTest, UsingShadowDeclAndMovedNamespace) {
1149 std::string Code = "namespace na { class C_A {};\n }\n"
1150 "using na::C_A;\n"
1151 "namespace na {\n"
1152 "namespace nb {\n"
1153 "class C_X {\n"
1154 "public:\n"
1155 " C_A a;\n"
1156 "};\n"
1157 "} // namespace nb\n"
1158 "} // namespace na\n";
1159 std::string Expected = "namespace na { class C_A {};\n }\n"
1160 "using na::C_A;\n"
1161 "\n"
1162 "namespace x {\n"
1163 "namespace y {\n"
1164 "class C_X {\n"
1165 "public:\n"
1166 " C_A a;\n"
1167 "};\n"
1168 "} // namespace y\n"
1169 "} // namespace x\n";
1170 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1171 }
1172
1173 TEST_F(ChangeNamespaceTest, UsingNamespaceDeclAndMovedNamespace) {
1174 std::string Code = "namespace na { class C_A {};\n }\n"
1175 "using namespace na;\n"
1176 "namespace na {\n"
1177 "namespace nb {\n"
1178 "class C_X {\n"
1179 "public:\n"
1180 " C_A ca;\n"
1181 "};\n"
1182 "} // namespace nb\n"
1183 "} // namespace na\n";
1184 std::string Expected = "namespace na { class C_A {};\n }\n"
1185 "using namespace na;\n"
1186 "\n"
1187 "namespace x {\n"
1188 "namespace y {\n"
1189 "class C_X {\n"
1190 "public:\n"
1191 " C_A ca;\n"
1192 "};\n"
1193 "} // namespace y\n"
1194 "} // namespace x\n";
1195 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1196 }
1197
1198 TEST_F(ChangeNamespaceTest, UsingShadowDeclInFunction) {
1199 std::string Code = "namespace glob {\n"
1200 "class Glob {};\n"
1201 "}\n"
1202 "namespace na {\n"
1203 "namespace nb {\n"
1204 "void f() {\n"
1205 " using glob::Glob;\n"
1206 " Glob g;\n"
1207 "}\n"
1208 "} // namespace nb\n"
1209 "} // namespace na\n";
1210
1211 std::string Expected = "namespace glob {\n"
1212 "class Glob {};\n"
1213 "}\n"
1214 "\n"
1215 "namespace x {\n"
1216 "namespace y {\n"
1217 "void f() {\n"
1218 " using ::glob::Glob;\n"
1219 " Glob g;\n"
1220 "}\n"
1221 "} // namespace y\n"
1222 "} // namespace x\n";
1223 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1224 }
1225
1226 TEST_F(ChangeNamespaceTest, UsingShadowDeclInClass) {
1227 std::string Code = "namespace na { class C_A {}; }\n"
1228 "namespace na {\n"
1229 "namespace nb {\n"
1230 "void f() {\n"
1231 " using ::na::C_A;\n"
1232 " C_A ca;\n"
1233 "}\n"
1234 "} // namespace nb\n"
1235 "} // namespace na\n";
1236 std::string Expected = "namespace na { class C_A {}; }\n"
1237 "\n"
1238 "namespace x {\n"
1239 "namespace y {\n"
1240 "void f() {\n"
1241 " using ::na::C_A;\n"
1242 " C_A ca;\n"
1243 "}\n"
1244 "} // namespace y\n"
1245 "} // namespace x\n";
1246 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1247 }
1248
1249 TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespace) {
1250 std::string Code = "namespace nx { void f(); }\n"
1251 "namespace na {\n"
1252 "using nx::f;\n"
1253 "namespace nb {\n"
1254 "void d() { f(); }\n"
1255 "} // nb\n"
1256 "} // na\n";
1257
1258 std::string Expected = "namespace nx { void f(); }\n"
1259 "namespace na {\n"
1260 "using nx::f;\n"
1261 "\n"
1262 "} // na\n"
1263 "namespace x {\n"
1264 "namespace y {\n"
1265 "void d() { nx::f(); }\n"
1266 "} // namespace y\n"
1267 "} // namespace x\n";
1268 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1269 }
1270
1271 TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespaceNotNested) {
1272 OldNamespace = "na";
1273 std::string Code = "namespace nx { void f(); }\n"
1274 "namespace na {\n"
1275 "using ::nx::f;\n"
1276 "void d() { f(); }\n"
1277 "} // na\n";
1278
1279 std::string Expected = "namespace nx { void f(); }\n"
1280 "\n"
1281 "namespace x {\n"
1282 "namespace y {\n"
1283 "using ::nx::f;\n"
1284 "void d() { f(); }\n"
1285 "} // namespace y\n"
1286 "} // namespace x\n";
1287 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1288 }
1289
1290 TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespaceMultiNested) {
1291 OldNamespace = "a::b::c::d";
1292 NewNamespace = "a::b::x::y";
1293 std::string Code = "namespace nx { void f(); void g(); }\n"
1294 "namespace a {\n"
1295 "namespace b {\n"
1296 "using ::nx::f;\n"
1297 "namespace c {\n"
1298 "using ::nx::g;\n"
1299 "namespace d {\n"
1300 "void d() { f(); g(); }\n"
1301 "} // d\n"
1302 "} // c\n"
1303 "} // b\n"
1304 "} // a\n";
1305
1306 std::string Expected = "namespace nx { void f(); void g(); }\n"
1307 "namespace a {\n"
1308 "namespace b {\n"
1309 "using ::nx::f;\n"
1310 "namespace c {\n"
1311 "using ::nx::g;\n"
1312 "\n"
1313 "} // c\n"
1314 "namespace x {\n"
1315 "namespace y {\n"
1316 "void d() { f(); nx::g(); }\n"
1317 "} // namespace y\n"
1318 "} // namespace x\n"
1319 "} // b\n"
1320 "} // a\n";
1321 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1322 }
1323
1324 TEST_F(ChangeNamespaceTest, UsingShadowDeclInTheParentOfOldNamespace) {
1325 OldNamespace = "nb::nc";
1326 NewNamespace = "nb::nd";
1327 std::string Code = "namespace na { class A {}; }\n"
1328 "namespace nb {\n"
1329 "using na::A;\n"
1330 "namespace nc {\n"
1331 "void d() { A a; }\n"
1332 "} // nc\n"
1333 "} // nb\n";
1334
1335 std::string Expected = "namespace na { class A {}; }\n"
1336 "namespace nb {\n"
1337 "using na::A;\n"
1338 "\n"
1339 "namespace nd {\n"
1340 "void d() { A a; }\n"
1341 "} // namespace nd\n"
1342 "} // nb\n";
1343 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1344 }
1345
1346 TEST_F(ChangeNamespaceTest, UsingShadowDeclInOldNamespace) {
1347 OldNamespace = "nb";
1348 NewNamespace = "nc";
1349 std::string Code = "namespace na { class A {}; }\n"
1350 "namespace nb {\n"
1351 "using na::A;\n"
1352 "void d() { A a; }\n"
1353 "struct X { A a; };\n"
1354 "} // nb\n";
1355
1356 std::string Expected = "namespace na { class A {}; }\n"
1357 "\n"
1358 "namespace nc {\n"
1359 "using ::na::A;\n"
1360 "void d() { A a; }\n"
1361 "struct X { A a; };\n"
1362 "} // namespace nc\n";
1363 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1364 }
1365
1366 TEST_F(ChangeNamespaceTest, UsingShadowDeclOfTemplateClass) {
1367 OldNamespace = "nb";
1368 NewNamespace = "nc";
1369 std::string Code = "namespace na {\n"
1370 "template <typename T>\n"
1371 "class A { T t; };\n"
1372 "} // namespace na\n"
1373 "namespace nb {\n"
1374 "using na::A;\n"
1375 "void d() { A<int> a; }\n"
1376 "} // nb\n";
1377
1378 std::string Expected = "namespace na {\n"
1379 "template <typename T>\n"
1380 "class A { T t; };\n"
1381 "} // namespace na\n"
1382 "\n"
1383 "namespace nc {\n"
1384 "using ::na::A;\n"
1385 "void d() { A<int> a; }\n"
1386 "} // namespace nc\n";
1387 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1388 }
1389
1390 TEST_F(ChangeNamespaceTest, UsingShadowDeclOfTemplateFunction) {
1391 OldNamespace = "nb";
1392 NewNamespace = "nc";
1393 std::string Code = "namespace na {\n"
1394 "template <typename T>\n"
1395 "void f() { T t; };\n"
1396 "} // namespace na\n"
1397 "namespace nb {\n"
1398 "using na::f;\n"
1399 "void d() { f<int>(); }\n"
1400 "} // nb\n";
1401
1402 std::string Expected = "namespace na {\n"
1403 "template <typename T>\n"
1404 "void f() { T t; };\n"
1405 "} // namespace na\n"
1406 "\n"
1407 "namespace nc {\n"
1408 "using ::na::f;\n"
1409 "void d() { f<int>(); }\n"
1410 "} // namespace nc\n";
1411 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1412 }
1413
1414 TEST_F(ChangeNamespaceTest, UsingAliasDecl) {
1415 std::string Code =
1416 "namespace nx { namespace ny { class X {}; } }\n"
1417 "namespace na {\n"
1418 "namespace nb {\n"
1419 "using Y = nx::ny::X;\n"
1420 "void f() { Y y; }\n"
1421 "} // namespace nb\n"
1422 "} // namespace na\n";
1423
1424 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1425 "\n"
1426 "namespace x {\n"
1427 "namespace y {\n"
1428 "using Y = nx::ny::X;\n"
1429 "void f() { Y y; }\n"
1430 "} // namespace y\n"
1431 "} // namespace x\n";
1432 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1433 }
1434
1435 TEST_F(ChangeNamespaceTest, UsingAliasDeclInGlobal) {
1436 std::string Code =
1437 "namespace nx { namespace ny { class X {}; } }\n"
1438 "using Y = nx::ny::X;\n"
1439 "namespace na {\n"
1440 "namespace nb {\n"
1441 "void f() { Y y; }\n"
1442 "} // namespace nb\n"
1443 "} // namespace na\n";
1444
1445 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1446 "using Y = nx::ny::X;\n"
1447 "\n"
1448 "namespace x {\n"
1449 "namespace y {\n"
1450 "void f() { Y y; }\n"
1451 "} // namespace y\n"
1452 "} // namespace x\n";
1453 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1454 }
1455
1456
1457 TEST_F(ChangeNamespaceTest, TypedefAliasDecl) {
1458 std::string Code =
1459 "namespace nx { namespace ny { class X {}; } }\n"
1460 "namespace na {\n"
1461 "namespace nb {\n"
1462 "typedef nx::ny::X Y;\n"
1463 "void f() { Y y; }\n"
1464 "} // namespace nb\n"
1465 "} // namespace na\n";
1466
1467 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1468 "\n"
1469 "namespace x {\n"
1470 "namespace y {\n"
1471 "typedef nx::ny::X Y;\n"
1472 "void f() { Y y; }\n"
1473 "} // namespace y\n"
1474 "} // namespace x\n";
1475 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1476 }
1477
1478 TEST_F(ChangeNamespaceTest, DerivedClassWithConstructors) {
1479 std::string Code =
1480 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1481 "namespace na {\n"
1482 "namespace nb {\n"
1483 "class A : public nx::ny::X {\n"
1484 "public:\n"
1485 " A() : X(0) {}\n"
1486 " A(int i);\n"
1487 "};\n"
1488 "A::A(int i) : X(i) {}\n"
1489 "} // namespace nb\n"
1490 "} // namespace na\n";
1491 std::string Expected =
1492 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1493 "\n\n"
1494 "namespace x {\n"
1495 "namespace y {\n"
1496 "class A : public nx::ny::X {\n"
1497 "public:\n"
1498 " A() : X(0) {}\n"
1499 " A(int i);\n"
1500 "};\n"
1501 "A::A(int i) : X(i) {}\n"
1502 "} // namespace y\n"
1503 "} // namespace x\n";
1504 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1505 }
1506
1507 TEST_F(ChangeNamespaceTest, DerivedClassWithQualifiedConstructors) {
1508 std::string Code =
1509 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1510 "namespace na {\n"
1511 "namespace nb {\n"
1512 "class A : public nx::ny::X {\n"
1513 "public:\n"
1514 " A() : X::X(0) {}\n"
1515 " A(int i);\n"
1516 "};\n"
1517 "A::A(int i) : X::X(i) {}\n"
1518 "} // namespace nb\n"
1519 "} // namespace na\n";
1520 std::string Expected =
1521 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1522 "\n\n"
1523 "namespace x {\n"
1524 "namespace y {\n"
1525 "class A : public nx::ny::X {\n"
1526 "public:\n"
1527 " A() : X::X(0) {}\n"
1528 " A(int i);\n"
1529 "};\n"
1530 "A::A(int i) : X::X(i) {}\n"
1531 "} // namespace y\n"
1532 "} // namespace x\n";
1533 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1534 }
1535
1536 TEST_F(ChangeNamespaceTest, DerivedClassWithConstructorsAndTypeRefs) {
1537 std::string Code =
1538 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1539 "namespace na {\n"
1540 "namespace nb {\n"
1541 "class A : public nx::ny::X {\n"
1542 "public:\n"
1543 " A() : X(0) {}\n"
1544 " A(int i);\n"
1545 "};\n"
1546 "A::A(int i) : X(i) { X x(1);}\n"
1547 "} // namespace nb\n"
1548 "} // namespace na\n";
1549 std::string Expected =
1550 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1551 "\n\n"
1552 "namespace x {\n"
1553 "namespace y {\n"
1554 "class A : public nx::ny::X {\n"
1555 "public:\n"
1556 " A() : X(0) {}\n"
1557 " A(int i);\n"
1558 "};\n"
1559 "A::A(int i) : X(i) { nx::ny::X x(1);}\n"
1560 "} // namespace y\n"
1561 "} // namespace x\n";
1562 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1563 }
1564
1565 TEST_F(ChangeNamespaceTest, MoveToGlobalNamespace) {
1566 NewNamespace = "";
1567 std::string Code = "namespace na {\n"
1568 "class C_A {};\n"
1569 "namespace nc {\n"
1570 "class C_C {};"
1571 "} // namespace nc\n"
1572 "namespace nb {\n"
1573 "class C_X {\n"
1574 "public:\n"
1575 " C_A a;\n"
1576 " nc::C_C c;\n"
1577 "};\n"
1578 "class C_Y {\n"
1579 " C_X x;\n"
1580 "};\n"
1581 "} // namespace nb\n"
1582 "} // namespace na\n";
1583 std::string Expected = "namespace na {\n"
1584 "class C_A {};\n"
1585 "namespace nc {\n"
1586 "class C_C {};"
1587 "} // namespace nc\n"
1588 "\n"
1589 "} // namespace na\n"
1590 "class C_X {\n"
1591 "public:\n"
1592 " na::C_A a;\n"
1593 " na::nc::C_C c;\n"
1594 "};\n"
1595 "class C_Y {\n"
1596 " C_X x;\n"
1597 "};\n";
1598 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1599 }
1600
1601 TEST_F(ChangeNamespaceTest, KeepGlobalSpecifier) {
1602 std::string Code = "class Glob {};\n"
1603 "namespace na {\n"
1604 "class C_A {};\n"
1605 "namespace nc {\n"
1606 "class C_C {};"
1607 "} // namespace nc\n"
1608 "namespace nb {\n"
1609 "class C_X {\n"
1610 "public:\n"
1611 " ::Glob glob_1;\n"
1612 " Glob glob_2;\n"
1613 " C_A a_1;\n"
1614 " ::na::C_A a_2;\n"
1615 " nc::C_C c;\n"
1616 "};\n"
1617 "} // namespace nb\n"
1618 "} // namespace na\n";
1619 std::string Expected = "class Glob {};\n"
1620 "namespace na {\n"
1621 "class C_A {};\n"
1622 "namespace nc {\n"
1623 "class C_C {};"
1624 "} // namespace nc\n"
1625 "\n"
1626 "} // namespace na\n"
1627 "namespace x {\n"
1628 "namespace y {\n"
1629 "class C_X {\n"
1630 "public:\n"
1631 " ::Glob glob_1;\n"
1632 " Glob glob_2;\n"
1633 " na::C_A a_1;\n"
1634 " ::na::C_A a_2;\n"
1635 " na::nc::C_C c;\n"
1636 "};\n"
1637 "} // namespace y\n"
1638 "} // namespace x\n";
1639 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1640 }
1641
1642 TEST_F(ChangeNamespaceTest, UsingAliasInTemplate) {
1643 NewNamespace = "na::nb::nc";
1644 std::string Code = "namespace some_ns {\n"
1645 "template <typename T, typename S>\n"
1646 "class G {};\n"
1647 "} // namespace some_ns\n"
1648 "namespace na {\n"
1649 "template<typename P>\n"
1650 "using GG = some_ns::G<int, P>;\n"
1651 "} // namespace na\n"
1652 "namespace na {\n"
1653 "namespace nb {\n"
1654 "void f() {\n"
1655 " GG<float> g;\n"
1656 "}\n"
1657 "} // namespace nb\n"
1658 "} // namespace na\n";
1659 std::string Expected = "namespace some_ns {\n"
1660 "template <typename T, typename S>\n"
1661 "class G {};\n"
1662 "} // namespace some_ns\n"
1663 "namespace na {\n"
1664 "template<typename P>\n"
1665 "using GG = some_ns::G<int, P>;\n"
1666 "} // namespace na\n"
1667 "namespace na {\n"
1668 "namespace nb {\n"
1669 "namespace nc {\n"
1670 "void f() {\n"
1671 " GG<float> g;\n"
1672 "}\n"
1673 "} // namespace nc\n"
1674 "} // namespace nb\n"
1675 "} // namespace na\n";
1676 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1677 }
1678
1679 TEST_F(ChangeNamespaceTest, TemplateUsingAliasInBaseClass) {
1680 NewNamespace = "na::nb::nc";
1681 std::string Code = "namespace some_ns {\n"
1682 "template <typename T, typename S>\n"
1683 "class G {};\n"
1684 "} // namespace some_ns\n"
1685 "namespace na {\n"
1686 "class Base {\n"
1687 "public:\n"
1688 " template<typename P>\n"
1689 " using GG = some_ns::G<int, P>;\n"
1690 "\n"
1691 " struct Nested {};\n"
1692 "};\n"
1693 "class Derived : public Base {};\n"
1694 "} // namespace na\n"
1695 "namespace na {\n"
1696 "namespace nb {\n"
1697 "void f() {\n"
1698 " Derived::GG<float> g;\n"
1699 " const Derived::GG<int> gg;\n"
1700 " const Derived::GG<int>* gg_ptr;\n"
1701 " struct Derived::Nested nested;\n"
1702 " const struct Derived::Nested *nested_ptr;\n"
1703 "}\n"
1704 "} // namespace nb\n"
1705 "} // namespace na\n";
1706 std::string Expected = "namespace some_ns {\n"
1707 "template <typename T, typename S>\n"
1708 "class G {};\n"
1709 "} // namespace some_ns\n"
1710 "namespace na {\n"
1711 "class Base {\n"
1712 "public:\n"
1713 " template<typename P>\n"
1714 " using GG = some_ns::G<int, P>;\n"
1715 "\n"
1716 " struct Nested {};\n"
1717 "};\n"
1718 "class Derived : public Base {};\n"
1719 "} // namespace na\n"
1720 "namespace na {\n"
1721 "namespace nb {\n"
1722 "namespace nc {\n"
1723 "void f() {\n"
1724 " Derived::GG<float> g;\n"
1725 " const Derived::GG<int> gg;\n"
1726 " const Derived::GG<int>* gg_ptr;\n"
1727 " struct Derived::Nested nested;\n"
1728 " const struct Derived::Nested *nested_ptr;\n"
1729 "}\n"
1730 "} // namespace nc\n"
1731 "} // namespace nb\n"
1732 "} // namespace na\n";
1733 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1734 }
1735
1736 TEST_F(ChangeNamespaceTest, ExistingNamespaceConflictWithNewNamespace) {
1737 OldNamespace = "nx";
1738 NewNamespace = "ny::na::nc";
1739 std::string Code = "namespace na {\n"
1740 "class A {};\n"
1741 "} // namespace na\n"
1742 "namespace nb {\n"
1743 "class B {};\n"
1744 "} // namespace nb\n"
1745 "namespace nx {\n"
1746 "class X {\n"
1747 " na::A a; nb::B b;\n"
1748 "};\n"
1749 "} // namespace nx\n";
1750 std::string Expected = "namespace na {\n"
1751 "class A {};\n"
1752 "} // namespace na\n"
1753 "namespace nb {\n"
1754 "class B {};\n"
1755 "} // namespace nb\n"
1756 "\n"
1757 "namespace ny {\n"
1758 "namespace na {\n"
1759 "namespace nc {\n"
1760 "class X {\n"
1761 " ::na::A a; nb::B b;\n"
1762 "};\n"
1763 "} // namespace nc\n"
1764 "} // namespace na\n"
1765 "} // namespace ny\n";
1766 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1767 }
1768
1769 TEST_F(ChangeNamespaceTest, SymbolConflictWithNewNamespace) {
1770 OldNamespace = "nx";
1771 NewNamespace = "ny::na::nc";
1772 std::string Code = "namespace na {\n"
1773 "class A {};\n"
1774 "namespace nb {\n"
1775 "class B {};\n"
1776 "} // namespace nb\n"
1777 "} // namespace na\n"
1778 "namespace ny {\n"
1779 "class Y {};\n"
1780 "}\n"
1781 "namespace nx {\n"
1782 "class X {\n"
1783 " na::A a; na::nb::B b;\n"
1784 " ny::Y y;"
1785 "};\n"
1786 "} // namespace nx\n";
1787 std::string Expected = "namespace na {\n"
1788 "class A {};\n"
1789 "namespace nb {\n"
1790 "class B {};\n"
1791 "} // namespace nb\n"
1792 "} // namespace na\n"
1793 "namespace ny {\n"
1794 "class Y {};\n"
1795 "}\n"
1796 "\n"
1797 "namespace ny {\n"
1798 "namespace na {\n"
1799 "namespace nc {\n"
1800 "class X {\n"
1801 " ::na::A a; ::na::nb::B b;\n"
1802 " Y y;\n"
1803 "};\n"
1804 "} // namespace nc\n"
1805 "} // namespace na\n"
1806 "} // namespace ny\n";
1807 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1808 }
1809
1810 TEST_F(ChangeNamespaceTest, ShortenNamespaceSpecifier) {
1811 OldNamespace = "nx";
1812 NewNamespace = "ny::na";
1813 std::string Code = "class G {};\n"
1814 "namespace ny {\n"
1815 "class Y {};\n"
1816 "namespace na {\n"
1817 "class A {};\n"
1818 "namespace nc { class C {}; } // namespace nc\n"
1819 "}\n // namespace na\n"
1820 "}\n // namespace ny\n"
1821 "namespace nx {\n"
1822 "class X {\n"
1823 " G g; ny::Y y; ny::na::A a; ny::na::nc::C c;\n"
1824 "};\n"
1825 "} // namespace nx\n";
1826 std::string Expected = "class G {};\n"
1827 "namespace ny {\n"
1828 "class Y {};\n"
1829 "namespace na {\n"
1830 "class A {};\n"
1831 "namespace nc { class C {}; } // namespace nc\n"
1832 "}\n // namespace na\n"
1833 "}\n // namespace ny\n"
1834 "\n"
1835 "namespace ny {\n"
1836 "namespace na {\n"
1837 "class X {\n"
1838 " G g; Y y; A a; nc::C c;\n"
1839 "};\n"
1840 "} // namespace na\n"
1841 "} // namespace ny\n";
1842 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1843 }
1844
1845 TEST_F(ChangeNamespaceTest, ShortenNamespaceSpecifierInAnonymousNamespace) {
1846 OldNamespace = "nx";
1847 NewNamespace = "ny::na";
1848 std::string Code = "class G {};\n"
1849 "namespace ny {\n"
1850 "class Y {};\n"
1851 "namespace na {\n"
1852 "class A {};\n"
1853 "namespace nc { class C {}; } // namespace nc\n"
1854 "}\n // namespace na\n"
1855 "}\n // namespace ny\n"
1856 "namespace nx {\n"
1857 "namespace {\n"
1858 "class X {\n"
1859 " G g; ::ny::Y y; ::ny::na::A a; ::ny::na::nc::C c;\n"
1860 "};\n"
1861 "} // namespace\n"
1862 "} // namespace nx\n";
1863 std::string Expected = "class G {};\n"
1864 "namespace ny {\n"
1865 "class Y {};\n"
1866 "namespace na {\n"
1867 "class A {};\n"
1868 "namespace nc { class C {}; } // namespace nc\n"
1869 "}\n // namespace na\n"
1870 "}\n // namespace ny\n"
1871 "\n"
1872 "namespace ny {\n"
1873 "namespace na {\n"
1874 "namespace {\n"
1875 "class X {\n"
1876 " G g; Y y; A a; nc::C c;\n"
1877 "};\n"
1878 "} // namespace\n"
1879 "} // namespace na\n"
1880 "} // namespace ny\n";
1881 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1882 }
1883
1884 TEST_F(ChangeNamespaceTest, SimpleMoveEnum) {
1885 std::string Code = "namespace na {\n"
1886 "namespace nb {\n"
1887 "enum class X { X1, X2 };\n"
1888 "enum Y { Y1, Y2 };\n"
1889 "} // namespace nb\n"
1890 "} // namespace na\n";
1891 std::string Expected = "\n\nnamespace x {\n"
1892 "namespace y {\n"
1893 "enum class X { X1, X2 };\n"
1894 "enum Y { Y1, Y2 };\n"
1895 "} // namespace y\n"
1896 "} // namespace x\n";
1897
1898 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1899 }
1900
1901 TEST_F(ChangeNamespaceTest, ReferencesToEnums) {
1902 std::string Code = "enum Glob { G1, G2 };\n"
1903 "namespace na {\n"
1904 "enum class X { X1 };\n"
1905 "enum Y { Y1, Y2 };\n"
1906 "namespace nb {\n"
1907 "void f() {\n"
1908 " Glob g1 = Glob::G1;\n"
1909 " Glob g2 = G2;\n"
1910 " X x1 = X::X1;\n"
1911 " Y y1 = Y::Y1;\n"
1912 " Y y2 = Y2;\n"
1913 "}\n"
1914 "} // namespace nb\n"
1915 "} // namespace na\n";
1916 std::string Expected = "enum Glob { G1, G2 };\n"
1917 "namespace na {\n"
1918 "enum class X { X1 };\n"
1919 "enum Y { Y1, Y2 };\n"
1920 "\n"
1921 "} // namespace na\n"
1922 "namespace x {\n"
1923 "namespace y {\n"
1924 "void f() {\n"
1925 " Glob g1 = Glob::G1;\n"
1926 " Glob g2 = G2;\n"
1927 " na::X x1 = na::X::X1;\n"
1928 " na::Y y1 = na::Y::Y1;\n"
1929 " na::Y y2 = na::Y2;\n"
1930 "}\n"
1931 "} // namespace y\n"
1932 "} // namespace x\n";
1933
1934 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1935 }
1936
1937 TEST_F(ChangeNamespaceTest, NoRedundantEnumUpdate) {
1938 std::string Code = "namespace ns {\n"
1939 "enum class X { X1 };\n"
1940 "enum Y { Y1, Y2 };\n"
1941 "} // namespace ns\n"
1942 "namespace na {\n"
1943 "namespace nb {\n"
1944 "void f() {\n"
1945 " ns::X x1 = ns::X::X1;\n"
1946 " ns::Y y1 = ns::Y::Y1;\n"
1947 " ns::Y y2 = ns::Y2;\n"
1948 "}\n"
1949 "} // namespace nb\n"
1950 "} // namespace na\n";
1951 std::string Expected = "namespace ns {\n"
1952 "enum class X { X1 };\n"
1953 "enum Y { Y1, Y2 };\n"
1954 "} // namespace ns\n"
1955 "\n"
1956 "namespace x {\n"
1957 "namespace y {\n"
1958 "void f() {\n"
1959 " ns::X x1 = ns::X::X1;\n"
1960 " ns::Y y1 = ns::Y::Y1;\n"
1961 " ns::Y y2 = ns::Y2;\n"
1962 "}\n"
1963 "} // namespace y\n"
1964 "} // namespace x\n";
1965 ;
1966
1967 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1968 }
1969
1970 TEST_F(ChangeNamespaceTest, EnumsAndUsingShadows) {
1971 std::string Code = "namespace ns {\n"
1972 "enum class X { X1 };\n"
1973 "enum Y { Y1, Y2, Y3 };\n"
1974 "} // namespace ns\n"
1975 "using ns::X;\n"
1976 "using ns::Y;\n"
1977 "using ns::Y::Y2;\n"
1978 "using ns::Y::Y3;\n"
1979 "namespace na {\n"
1980 "namespace nb {\n"
1981 "void f() {\n"
1982 " X x1 = X::X1;\n"
1983 " Y y1 = Y::Y1;\n"
1984 " Y y2 = Y2;\n"
1985 " Y y3 = Y3;\n"
1986 "}\n"
1987 "} // namespace nb\n"
1988 "} // namespace na\n";
1989 std::string Expected = "namespace ns {\n"
1990 "enum class X { X1 };\n"
1991 "enum Y { Y1, Y2, Y3 };\n"
1992 "} // namespace ns\n"
1993 "using ns::X;\n"
1994 "using ns::Y;\n"
1995 "using ns::Y::Y2;\n"
1996 "using ns::Y::Y3;\n"
1997 "\n"
1998 "namespace x {\n"
1999 "namespace y {\n"
2000 "void f() {\n"
2001 " X x1 = X::X1;\n"
2002 " Y y1 = Y::Y1;\n"
2003 " Y y2 = Y2;\n"
2004 " Y y3 = Y3;\n"
2005 "}\n"
2006 "} // namespace y\n"
2007 "} // namespace x\n";
2008
2009 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2010 }
2011
2012 TEST_F(ChangeNamespaceTest, EnumsAndAliases) {
2013 std::string Code = "namespace ns {\n"
2014 "enum class X { X1 };\n"
2015 "enum Y { Y1, Y2, Y3 };\n"
2016 "} // namespace ns\n"
2017 "typedef ns::X TX;\n"
2018 "typedef ns::Y TY;\n"
2019 "using UX = ns::X;\n"
2020 "using UY = ns::Y;\n"
2021 "namespace na {\n"
2022 "namespace nb {\n"
2023 "void f() {\n"
2024 " ns::X x1 = ns::X::X1;\n"
2025 " TX tx1 = TX::X1;\n"
2026 " UX ux1 = UX::X1;\n"
2027 " ns::Y y1 = ns::Y::Y1;\n"
2028 " TY ty1 = TY::Y1;\n"
2029 " UY uy1 = UY::Y1;\n"
2030 "}\n"
2031 "} // namespace nb\n"
2032 "} // namespace na\n";
2033 std::string Expected = "namespace ns {\n"
2034 "enum class X { X1 };\n"
2035 "enum Y { Y1, Y2, Y3 };\n"
2036 "} // namespace ns\n"
2037 "typedef ns::X TX;\n"
2038 "typedef ns::Y TY;\n"
2039 "using UX = ns::X;\n"
2040 "using UY = ns::Y;\n"
2041 "\n"
2042 "namespace x {\n"
2043 "namespace y {\n"
2044 "void f() {\n"
2045 " ns::X x1 = ns::X::X1;\n"
2046 " TX tx1 = TX::X1;\n"
2047 " UX ux1 = UX::X1;\n"
2048 " ns::Y y1 = ns::Y::Y1;\n"
2049 " TY ty1 = TY::Y1;\n"
2050 " UY uy1 = UY::Y1;\n"
2051 "}\n"
2052 "} // namespace y\n"
2053 "} // namespace x\n";
2054
2055 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2056 }
2057
2058 TEST_F(ChangeNamespaceTest, EnumInClass) {
2059 std::string Code = "namespace na {\n"
2060 "struct X { enum E { E1 }; };\n"
2061 "namespace nb {\n"
2062 "void f() {\n"
2063 " X::E e = X::E1;\n"
2064 " X::E ee = X::E::E1;\n"
2065 "}\n"
2066 "} // namespace nb\n"
2067 "} // namespace na\n";
2068 std::string Expected = "namespace na {\n"
2069 "struct X { enum E { E1 }; };\n"
2070 "\n"
2071 "} // namespace na\n"
2072 "namespace x {\n"
2073 "namespace y {\n"
2074 "void f() {\n"
2075 " na::X::E e = na::X::E1;\n"
2076 " na::X::E ee = na::X::E::E1;\n"
2077 "}\n"
2078 "} // namespace y\n"
2079 "} // namespace x\n";
2080
2081 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2082 }
2083
2084 TEST_F(ChangeNamespaceTest, TypeAsTemplateParameter) {
2085 std::string Code = "namespace na {\n"
2086 "struct X {};\n"
2087 "namespace nb {\n"
2088 "template <typename TT>\n"
2089 "void TempTemp(const TT& t) {\n"
2090 " TT tmp;\n"
2091 "}\n"
2092 "template <typename T>\n"
2093 "void Temp(const T& t) {\n"
2094 " T tmp = t;\n"
2095 " TempTemp(tmp);\n"
2096 " TempTemp(t);\n"
2097 "}\n"
2098 "void f() {\n"
2099 " X x;\n"
2100 " Temp(x);\n"
2101 "}\n"
2102 "} // namespace nb\n"
2103 "} // namespace na\n";
2104 std::string Expected = "namespace na {\n"
2105 "struct X {};\n"
2106 "\n"
2107 "} // namespace na\n"
2108 "namespace x {\n"
2109 "namespace y {\n"
2110 "template <typename TT>\n"
2111 "void TempTemp(const TT& t) {\n"
2112 " TT tmp;\n"
2113 "}\n"
2114 "template <typename T>\n"
2115 "void Temp(const T& t) {\n"
2116 " T tmp = t;\n"
2117 " TempTemp(tmp);\n"
2118 " TempTemp(t);\n"
2119 "}\n"
2120 "void f() {\n"
2121 " na::X x;\n"
2122 " Temp(x);\n"
2123 "}\n"
2124 "} // namespace y\n"
2125 "} // namespace x\n";
2126
2127 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2128 }
2129
2130 TEST_F(ChangeNamespaceTest, DefaultMoveConstructors) {
2131 std::string Code = "namespace na {\n"
2132 "class B {\n"
2133 " public:\n"
2134 " B() = default;\n"
2135 " // Allow move only.\n"
2136 " B(B&&) = default;\n"
2137 " B& operator=(B&&) = default;\n"
2138 " B(const B&) = delete;\n"
2139 " B& operator=(const B&) = delete;\n"
2140 " private:\n"
2141 " int ref_;\n"
2142 "};\n"
2143 "} // namespace na\n"
2144 "namespace na {\n"
2145 "namespace nb {\n"
2146 "class A {\n"
2147 "public:\n"
2148 " A() = default;\n"
2149 " A(A&&) = default;\n"
2150 " A& operator=(A&&) = default;\n"
2151 "private:\n"
2152 " B b;\n"
2153 " A(const A&) = delete;\n"
2154 " A& operator=(const A&) = delete;\n"
2155 "};\n"
2156 "void f() { A a; a = A(); A aa = A(); }\n"
2157 "} // namespace nb\n"
2158 "} // namespace na\n";
2159 std::string Expected = "namespace na {\n"
2160 "class B {\n"
2161 " public:\n"
2162 " B() = default;\n"
2163 " // Allow move only.\n"
2164 " B(B&&) = default;\n"
2165 " B& operator=(B&&) = default;\n"
2166 " B(const B&) = delete;\n"
2167 " B& operator=(const B&) = delete;\n"
2168 " private:\n"
2169 " int ref_;\n"
2170 "};\n"
2171 "} // namespace na\n"
2172 "\n"
2173 "namespace x {\n"
2174 "namespace y {\n"
2175 "class A {\n"
2176 "public:\n"
2177 " A() = default;\n"
2178 " A(A&&) = default;\n"
2179 " A& operator=(A&&) = default;\n"
2180 "private:\n"
2181 " na::B b;\n"
2182 " A(const A&) = delete;\n"
2183 " A& operator=(const A&) = delete;\n"
2184 "};\n"
2185 "void f() { A a; a = A(); A aa = A(); }\n"
2186 "} // namespace y\n"
2187 "} // namespace x\n";
2188 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2189 }
2190
2191 TEST_F(ChangeNamespaceTest, InjectedClassNameInFriendDecl) {
2192 OldNamespace = "d";
2193 NewNamespace = "e";
2194 std::string Code = "namespace a{\n"
2195 "template <typename T>\n"
2196 "class Base {\n"
2197 " public:\n"
2198 " void f() {\n"
2199 " T t;\n"
2200 " t.priv();\n"
2201 " }\n"
2202 "};\n"
2203 "} // namespace a\n"
2204 "namespace d {\n"
2205 "class D : public a::Base<D> {\n"
2206 " private:\n"
2207 " friend class Base<D>;\n"
2208 " void priv() {}\n"
2209 " Base b;\n"
2210 "};\n"
2211 "\n"
2212 "void f() {\n"
2213 " D d;\n"
2214 " a:: Base<D> b;\n"
2215 " b.f();\n"
2216 "}\n"
2217 "} // namespace d\n";
2218 std::string Expected = "namespace a{\n"
2219 "template <typename T>\n"
2220 "class Base {\n"
2221 " public:\n"
2222 " void f() {\n"
2223 " T t;\n"
2224 " t.priv();\n"
2225 " }\n"
2226 "};\n"
2227 "} // namespace a\n"
2228 "\n"
2229 "namespace e {\n"
2230 "class D : public a::Base<D> {\n"
2231 " private:\n"
2232 " friend class a::Base<D>;\n"
2233 " void priv() {}\n"
2234 " a::Base b;\n"
2235 "};\n"
2236 "\n"
2237 "void f() {\n"
2238 " D d;\n"
2239 " a::Base<D> b;\n"
2240 " b.f();\n"
2241 "}\n"
2242 "} // namespace e\n";
2243 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2244 }
2245
2246 TEST_F(ChangeNamespaceTest, FullyQualifyConflictNamespace) {
2247 std::string Code =
2248 "namespace x { namespace util { class Some {}; } }\n"
2249 "namespace x { namespace y {namespace base { class Base {}; } } }\n"
2250 "namespace util { class Status {}; }\n"
2251 "namespace base { class Base {}; }\n"
2252 "namespace na {\n"
2253 "namespace nb {\n"
2254 "void f() {\n"
2255 " util::Status s1; x::util::Some s2;\n"
2256 " base::Base b1; x::y::base::Base b2;\n"
2257 "}\n"
2258 "} // namespace nb\n"
2259 "} // namespace na\n";
2260
2261 std::string Expected =
2262 "namespace x { namespace util { class Some {}; } }\n"
2263 "namespace x { namespace y {namespace base { class Base {}; } } }\n"
2264 "namespace util { class Status {}; }\n"
2265 "namespace base { class Base {}; }\n"
2266 "\n"
2267 "namespace x {\n"
2268 "namespace y {\n"
2269 "void f() {\n"
2270 " ::util::Status s1; util::Some s2;\n"
2271 " ::base::Base b1; base::Base b2;\n"
2272 "}\n"
2273 "} // namespace y\n"
2274 "} // namespace x\n";
2275
2276 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
2277 }
2278
2279 } // anonymous namespace
2280 } // namespace change_namespace
2281 } // namespace clang
LLVM monorepo