1//===-- ChangeNamespace.cpp - Change namespace implementation -------------===//
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#include "ChangeNamespace.h"
9#include "clang/AST/ASTContext.h"
10#include "clang/Format/Format.h"
11#include "clang/Lex/Lexer.h"
12#include "llvm/Support/Casting.h"
13#include "llvm/Support/ErrorHandling.h"
14
15using namespace clang::ast_matchers;
16
17namespace clang {
18namespace change_namespace {
19
20namespace {
21
22inline std::string joinNamespaces(ArrayRef<StringRef> Namespaces) {
23 return llvm::join(R&: Namespaces, Separator: "::");
24}
25
26// Given "a::b::c", returns {"a", "b", "c"}.
27llvm::SmallVector<llvm::StringRef, 4> splitSymbolName(llvm::StringRef Name) {
28 llvm::SmallVector<llvm::StringRef, 4> Splitted;
29 Name.split(A&: Splitted, Separator: "::", /*MaxSplit=*/-1,
30 /*KeepEmpty=*/false);
31 return Splitted;
32}
33
34SourceLocation startLocationForType(TypeLoc TLoc) {
35 // For elaborated types (e.g. `struct a::A`) we want the portion after the
36 // `struct` but including the namespace qualifier, `a::`.
37 if (TLoc.getTypeLocClass() == TypeLoc::Elaborated) {
38 NestedNameSpecifierLoc NestedNameSpecifier =
39 TLoc.castAs<ElaboratedTypeLoc>().getQualifierLoc();
40 if (NestedNameSpecifier.getNestedNameSpecifier())
41 return NestedNameSpecifier.getBeginLoc();
42 TLoc = TLoc.getNextTypeLoc();
43 }
44 return TLoc.getBeginLoc();
45}
46
47SourceLocation endLocationForType(TypeLoc TLoc) {
48 // Dig past any namespace or keyword qualifications.
49 while (TLoc.getTypeLocClass() == TypeLoc::Elaborated ||
50 TLoc.getTypeLocClass() == TypeLoc::Qualified)
51 TLoc = TLoc.getNextTypeLoc();
52
53 // The location for template specializations (e.g. Foo<int>) includes the
54 // templated types in its location range. We want to restrict this to just
55 // before the `<` character.
56 if (TLoc.getTypeLocClass() == TypeLoc::TemplateSpecialization)
57 return TLoc.castAs<TemplateSpecializationTypeLoc>()
58 .getLAngleLoc()
59 .getLocWithOffset(Offset: -1);
60 return TLoc.getEndLoc();
61}
62
63// Returns the containing namespace of `InnerNs` by skipping `PartialNsName`.
64// If the `InnerNs` does not have `PartialNsName` as suffix, or `PartialNsName`
65// is empty, nullptr is returned.
66// For example, if `InnerNs` is "a::b::c" and `PartialNsName` is "b::c", then
67// the NamespaceDecl of namespace "a" will be returned.
68const NamespaceDecl *getOuterNamespace(const NamespaceDecl *InnerNs,
69 llvm::StringRef PartialNsName) {
70 if (!InnerNs || PartialNsName.empty())
71 return nullptr;
72 const auto *CurrentContext = llvm::cast<DeclContext>(Val: InnerNs);
73 const auto *CurrentNs = InnerNs;
74 auto PartialNsNameSplitted = splitSymbolName(Name: PartialNsName);
75 while (!PartialNsNameSplitted.empty()) {
76 // Get the inner-most namespace in CurrentContext.
77 while (CurrentContext && !llvm::isa<NamespaceDecl>(Val: CurrentContext))
78 CurrentContext = CurrentContext->getParent();
79 if (!CurrentContext)
80 return nullptr;
81 CurrentNs = llvm::cast<NamespaceDecl>(Val: CurrentContext);
82 if (PartialNsNameSplitted.back() != CurrentNs->getNameAsString())
83 return nullptr;
84 PartialNsNameSplitted.pop_back();
85 CurrentContext = CurrentContext->getParent();
86 }
87 return CurrentNs;
88}
89
90static std::unique_ptr<Lexer>
91getLexerStartingFromLoc(SourceLocation Loc, const SourceManager &SM,
92 const LangOptions &LangOpts) {
93 if (Loc.isMacroID() &&
94 !Lexer::isAtEndOfMacroExpansion(loc: Loc, SM, LangOpts, MacroEnd: &Loc))
95 return nullptr;
96 // Break down the source location.
97 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc);
98 // Try to load the file buffer.
99 bool InvalidTemp = false;
100 llvm::StringRef File = SM.getBufferData(FID: LocInfo.first, Invalid: &InvalidTemp);
101 if (InvalidTemp)
102 return nullptr;
103
104 const char *TokBegin = File.data() + LocInfo.second;
105 // Lex from the start of the given location.
106 return std::make_unique<Lexer>(args: SM.getLocForStartOfFile(FID: LocInfo.first),
107 args: LangOpts, args: File.begin(), args&: TokBegin, args: File.end());
108}
109
110// FIXME: get rid of this helper function if this is supported in clang-refactor
111// library.
112static SourceLocation getStartOfNextLine(SourceLocation Loc,
113 const SourceManager &SM,
114 const LangOptions &LangOpts) {
115 std::unique_ptr<Lexer> Lex = getLexerStartingFromLoc(Loc, SM, LangOpts);
116 if (!Lex.get())
117 return SourceLocation();
118 llvm::SmallVector<char, 16> Line;
119 // FIXME: this is a bit hacky to get ReadToEndOfLine work.
120 Lex->setParsingPreprocessorDirective(true);
121 Lex->ReadToEndOfLine(Result: &Line);
122 auto End = Loc.getLocWithOffset(Offset: Line.size());
123 return SM.getLocForEndOfFile(FID: SM.getDecomposedLoc(Loc).first) == End
124 ? End
125 : End.getLocWithOffset(Offset: 1);
126}
127
128// Returns `R` with new range that refers to code after `Replaces` being
129// applied.
130tooling::Replacement
131getReplacementInChangedCode(const tooling::Replacements &Replaces,
132 const tooling::Replacement &R) {
133 unsigned NewStart = Replaces.getShiftedCodePosition(Position: R.getOffset());
134 unsigned NewEnd =
135 Replaces.getShiftedCodePosition(Position: R.getOffset() + R.getLength());
136 return tooling::Replacement(R.getFilePath(), NewStart, NewEnd - NewStart,
137 R.getReplacementText());
138}
139
140// Adds a replacement `R` into `Replaces` or merges it into `Replaces` by
141// applying all existing Replaces first if there is conflict.
142void addOrMergeReplacement(const tooling::Replacement &R,
143 tooling::Replacements *Replaces) {
144 auto Err = Replaces->add(R);
145 if (Err) {
146 llvm::consumeError(Err: std::move(Err));
147 auto Replace = getReplacementInChangedCode(Replaces: *Replaces, R);
148 *Replaces = Replaces->merge(Replaces: tooling::Replacements(Replace));
149 }
150}
151
152tooling::Replacement createReplacement(SourceLocation Start, SourceLocation End,
153 llvm::StringRef ReplacementText,
154 const SourceManager &SM) {
155 if (!Start.isValid() || !End.isValid()) {
156 llvm::errs() << "start or end location were invalid\n";
157 return tooling::Replacement();
158 }
159 if (SM.getDecomposedLoc(Loc: Start).first != SM.getDecomposedLoc(Loc: End).first) {
160 llvm::errs()
161 << "start or end location were in different macro expansions\n";
162 return tooling::Replacement();
163 }
164 Start = SM.getSpellingLoc(Loc: Start);
165 End = SM.getSpellingLoc(Loc: End);
166 if (SM.getFileID(SpellingLoc: Start) != SM.getFileID(SpellingLoc: End)) {
167 llvm::errs() << "start or end location were in different files\n";
168 return tooling::Replacement();
169 }
170 return tooling::Replacement(
171 SM, CharSourceRange::getTokenRange(B: SM.getSpellingLoc(Loc: Start),
172 E: SM.getSpellingLoc(Loc: End)),
173 ReplacementText);
174}
175
176void addReplacementOrDie(
177 SourceLocation Start, SourceLocation End, llvm::StringRef ReplacementText,
178 const SourceManager &SM,
179 std::map<std::string, tooling::Replacements> *FileToReplacements) {
180 const auto R = createReplacement(Start, End, ReplacementText, SM);
181 auto Err = (*FileToReplacements)[std::string(R.getFilePath())].add(R);
182 if (Err)
183 llvm_unreachable(llvm::toString(std::move(Err)).c_str());
184}
185
186tooling::Replacement createInsertion(SourceLocation Loc,
187 llvm::StringRef InsertText,
188 const SourceManager &SM) {
189 if (Loc.isInvalid()) {
190 llvm::errs() << "insert Location is invalid.\n";
191 return tooling::Replacement();
192 }
193 Loc = SM.getSpellingLoc(Loc);
194 return tooling::Replacement(SM, Loc, 0, InsertText);
195}
196
197// Returns the shortest qualified name for declaration `DeclName` in the
198// namespace `NsName`. For example, if `DeclName` is "a::b::X" and `NsName`
199// is "a::c::d", then "b::X" will be returned.
200// Note that if `DeclName` is `::b::X` and `NsName` is `::a::b`, this returns
201// "::b::X" instead of "b::X" since there will be a name conflict otherwise.
202// \param DeclName A fully qualified name, "::a::b::X" or "a::b::X".
203// \param NsName A fully qualified name, "::a::b" or "a::b". Global namespace
204// will have empty name.
205std::string getShortestQualifiedNameInNamespace(llvm::StringRef DeclName,
206 llvm::StringRef NsName) {
207 DeclName = DeclName.ltrim(Char: ':');
208 NsName = NsName.ltrim(Char: ':');
209 if (!DeclName.contains(C: ':'))
210 return std::string(DeclName);
211
212 auto NsNameSplitted = splitSymbolName(Name: NsName);
213 auto DeclNsSplitted = splitSymbolName(Name: DeclName);
214 llvm::StringRef UnqualifiedDeclName = DeclNsSplitted.pop_back_val();
215 // If the Decl is in global namespace, there is no need to shorten it.
216 if (DeclNsSplitted.empty())
217 return std::string(UnqualifiedDeclName);
218 // If NsName is the global namespace, we can simply use the DeclName sans
219 // leading "::".
220 if (NsNameSplitted.empty())
221 return std::string(DeclName);
222
223 if (NsNameSplitted.front() != DeclNsSplitted.front()) {
224 // The DeclName must be fully-qualified, but we still need to decide if a
225 // leading "::" is necessary. For example, if `NsName` is "a::b::c" and the
226 // `DeclName` is "b::X", then the reference must be qualified as "::b::X"
227 // to avoid conflict.
228 if (llvm::is_contained(Range&: NsNameSplitted, Element: DeclNsSplitted.front()))
229 return ("::" + DeclName).str();
230 return std::string(DeclName);
231 }
232 // Since there is already an overlap namespace, we know that `DeclName` can be
233 // shortened, so we reduce the longest common prefix.
234 auto DeclI = DeclNsSplitted.begin();
235 auto DeclE = DeclNsSplitted.end();
236 auto NsI = NsNameSplitted.begin();
237 auto NsE = NsNameSplitted.end();
238 for (; DeclI != DeclE && NsI != NsE && *DeclI == *NsI; ++DeclI, ++NsI) {
239 }
240 return (DeclI == DeclE)
241 ? UnqualifiedDeclName.str()
242 : (llvm::join(Begin: DeclI, End: DeclE, Separator: "::") + "::" + UnqualifiedDeclName)
243 .str();
244}
245
246std::string wrapCodeInNamespace(StringRef NestedNs, std::string Code) {
247 if (Code.back() != '\n')
248 Code += "\n";
249 auto NsSplitted = splitSymbolName(Name: NestedNs);
250 while (!NsSplitted.empty()) {
251 // FIXME: consider code style for comments.
252 Code = ("namespace " + NsSplitted.back() + " {\n" + Code +
253 "} // namespace " + NsSplitted.back() + "\n")
254 .str();
255 NsSplitted.pop_back();
256 }
257 return Code;
258}
259
260// Returns true if \p D is a nested DeclContext in \p Context
261bool isNestedDeclContext(const DeclContext *D, const DeclContext *Context) {
262 while (D) {
263 if (D == Context)
264 return true;
265 D = D->getParent();
266 }
267 return false;
268}
269
270// Returns true if \p D is visible at \p Loc with DeclContext \p DeclCtx.
271bool isDeclVisibleAtLocation(const SourceManager &SM, const Decl *D,
272 const DeclContext *DeclCtx, SourceLocation Loc) {
273 SourceLocation DeclLoc = SM.getSpellingLoc(Loc: D->getBeginLoc());
274 Loc = SM.getSpellingLoc(Loc);
275 return SM.isBeforeInTranslationUnit(LHS: DeclLoc, RHS: Loc) &&
276 (SM.getFileID(SpellingLoc: DeclLoc) == SM.getFileID(SpellingLoc: Loc) &&
277 isNestedDeclContext(D: DeclCtx, Context: D->getDeclContext()));
278}
279
280// Given a qualified symbol name, returns true if the symbol will be
281// incorrectly qualified without leading "::". For example, a symbol
282// "nx::ny::Foo" in namespace "na::nx::ny" without leading "::"; a symbol
283// "util::X" in namespace "na" can potentially conflict with "na::util" (if this
284// exists).
285bool conflictInNamespace(const ASTContext &AST, llvm::StringRef QualifiedSymbol,
286 llvm::StringRef Namespace) {
287 auto SymbolSplitted = splitSymbolName(Name: QualifiedSymbol.trim(Chars: ":"));
288 assert(!SymbolSplitted.empty());
289 SymbolSplitted.pop_back(); // We are only interested in namespaces.
290
291 if (SymbolSplitted.size() >= 1 && !Namespace.empty()) {
292 auto SymbolTopNs = SymbolSplitted.front();
293 auto NsSplitted = splitSymbolName(Name: Namespace.trim(Chars: ":"));
294 assert(!NsSplitted.empty());
295
296 auto LookupDecl = [&AST](const Decl &Scope,
297 llvm::StringRef Name) -> const NamedDecl * {
298 const auto *DC = llvm::dyn_cast<DeclContext>(Val: &Scope);
299 if (!DC)
300 return nullptr;
301 auto LookupRes = DC->lookup(Name: DeclarationName(&AST.Idents.get(Name)));
302 if (LookupRes.empty())
303 return nullptr;
304 return LookupRes.front();
305 };
306 // We do not check the outermost namespace since it would not be a
307 // conflict if it equals to the symbol's outermost namespace and the
308 // symbol name would have been shortened.
309 const NamedDecl *Scope =
310 LookupDecl(*AST.getTranslationUnitDecl(), NsSplitted.front());
311 for (const auto &I : llvm::drop_begin(RangeOrContainer&: NsSplitted)) {
312 if (I == SymbolTopNs) // Handles "::ny" in "::nx::ny" case.
313 return true;
314 // Handles "::util" and "::nx::util" conflicts.
315 if (Scope) {
316 if (LookupDecl(*Scope, SymbolTopNs))
317 return true;
318 Scope = LookupDecl(*Scope, I);
319 }
320 }
321 if (Scope && LookupDecl(*Scope, SymbolTopNs))
322 return true;
323 }
324 return false;
325}
326
327bool isTemplateParameter(TypeLoc Type) {
328 while (!Type.isNull()) {
329 if (Type.getTypeLocClass() == TypeLoc::SubstTemplateTypeParm)
330 return true;
331 Type = Type.getNextTypeLoc();
332 }
333 return false;
334}
335
336} // anonymous namespace
337
338ChangeNamespaceTool::ChangeNamespaceTool(
339 llvm::StringRef OldNs, llvm::StringRef NewNs, llvm::StringRef FilePattern,
340 llvm::ArrayRef<std::string> AllowedSymbolPatterns,
341 std::map<std::string, tooling::Replacements> *FileToReplacements,
342 llvm::StringRef FallbackStyle)
343 : FallbackStyle(FallbackStyle), FileToReplacements(*FileToReplacements),
344 OldNamespace(OldNs.ltrim(Char: ':')), NewNamespace(NewNs.ltrim(Char: ':')),
345 FilePattern(FilePattern), FilePatternRE(FilePattern) {
346 FileToReplacements->clear();
347 auto OldNsSplitted = splitSymbolName(Name: OldNamespace);
348 auto NewNsSplitted = splitSymbolName(Name: NewNamespace);
349 // Calculates `DiffOldNamespace` and `DiffNewNamespace`.
350 while (!OldNsSplitted.empty() && !NewNsSplitted.empty() &&
351 OldNsSplitted.front() == NewNsSplitted.front()) {
352 OldNsSplitted.erase(CI: OldNsSplitted.begin());
353 NewNsSplitted.erase(CI: NewNsSplitted.begin());
354 }
355 DiffOldNamespace = joinNamespaces(Namespaces: OldNsSplitted);
356 DiffNewNamespace = joinNamespaces(Namespaces: NewNsSplitted);
357
358 for (const auto &Pattern : AllowedSymbolPatterns)
359 AllowedSymbolRegexes.emplace_back(args: Pattern);
360}
361
362void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
363 std::string FullOldNs = "::" + OldNamespace;
364 // Prefix is the outer-most namespace in DiffOldNamespace. For example, if the
365 // OldNamespace is "a::b::c" and DiffOldNamespace is "b::c", then Prefix will
366 // be "a::b". Declarations in this namespace will not be visible in the new
367 // namespace. If DiffOldNamespace is empty, Prefix will be a invalid name "-".
368 llvm::SmallVector<llvm::StringRef, 4> DiffOldNsSplitted;
369 llvm::StringRef(DiffOldNamespace)
370 .split(A&: DiffOldNsSplitted, Separator: "::", /*MaxSplit=*/-1,
371 /*KeepEmpty=*/false);
372 std::string Prefix = "-";
373 if (!DiffOldNsSplitted.empty())
374 Prefix = (StringRef(FullOldNs).drop_back(N: DiffOldNamespace.size()) +
375 DiffOldNsSplitted.front())
376 .str();
377 auto IsInMovedNs =
378 allOf(hasAncestor(namespaceDecl(hasName(Name: FullOldNs)).bind(ID: "ns_decl")),
379 isExpansionInFileMatching(RegExp: FilePattern));
380 auto IsVisibleInNewNs = anyOf(
381 IsInMovedNs, unless(hasAncestor(namespaceDecl(hasName(Name: Prefix)))));
382 // Match using declarations.
383 Finder->addMatcher(
384 NodeMatch: usingDecl(isExpansionInFileMatching(RegExp: FilePattern), IsVisibleInNewNs)
385 .bind(ID: "using"),
386 Action: this);
387 // Match using namespace declarations.
388 Finder->addMatcher(NodeMatch: usingDirectiveDecl(isExpansionInFileMatching(RegExp: FilePattern),
389 IsVisibleInNewNs)
390 .bind(ID: "using_namespace"),
391 Action: this);
392 // Match namespace alias declarations.
393 Finder->addMatcher(NodeMatch: namespaceAliasDecl(isExpansionInFileMatching(RegExp: FilePattern),
394 IsVisibleInNewNs)
395 .bind(ID: "namespace_alias"),
396 Action: this);
397
398 // Match old namespace blocks.
399 Finder->addMatcher(
400 NodeMatch: namespaceDecl(hasName(Name: FullOldNs), isExpansionInFileMatching(RegExp: FilePattern))
401 .bind(ID: "old_ns"),
402 Action: this);
403
404 // Match class forward-declarations in the old namespace.
405 // Note that forward-declarations in classes are not matched.
406 Finder->addMatcher(NodeMatch: cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition())),
407 IsInMovedNs, hasParent(namespaceDecl()))
408 .bind(ID: "class_fwd_decl"),
409 Action: this);
410
411 // Match template class forward-declarations in the old namespace.
412 Finder->addMatcher(
413 NodeMatch: classTemplateDecl(unless(hasDescendant(cxxRecordDecl(isDefinition()))),
414 IsInMovedNs, hasParent(namespaceDecl()))
415 .bind(ID: "template_class_fwd_decl"),
416 Action: this);
417
418 // Match references to types that are not defined in the old namespace.
419 // Forward-declarations in the old namespace are also matched since they will
420 // be moved back to the old namespace.
421 auto DeclMatcher = namedDecl(
422 hasAncestor(namespaceDecl()),
423 unless(anyOf(
424 isImplicit(), hasAncestor(namespaceDecl(isAnonymous())),
425 hasAncestor(cxxRecordDecl()),
426 allOf(IsInMovedNs, unless(cxxRecordDecl(unless(isDefinition())))))));
427
428 // Using shadow declarations in classes always refers to base class, which
429 // does not need to be qualified since it can be inferred from inheritance.
430 // Note that this does not match using alias declarations.
431 auto UsingShadowDeclInClass =
432 usingDecl(hasAnyUsingShadowDecl(InnerMatcher: decl()), hasParent(cxxRecordDecl()));
433
434 // Match TypeLocs on the declaration. Carefully match only the outermost
435 // TypeLoc and template specialization arguments (which are not outermost)
436 // that are directly linked to types matching `DeclMatcher`. Nested name
437 // specifier locs are handled separately below.
438 Finder->addMatcher(
439 NodeMatch: typeLoc(IsInMovedNs,
440 loc(InnerMatcher: qualType(hasDeclaration(InnerMatcher: DeclMatcher.bind(ID: "from_decl")))),
441 unless(anyOf(hasParent(typeLoc(loc(InnerMatcher: qualType(
442 hasDeclaration(InnerMatcher: DeclMatcher),
443 unless(templateSpecializationType()))))),
444 hasParent(nestedNameSpecifierLoc()),
445 hasAncestor(decl(isImplicit())),
446 hasAncestor(UsingShadowDeclInClass),
447 hasAncestor(functionDecl(isDefaulted())))),
448 hasAncestor(decl().bind(ID: "dc")))
449 .bind(ID: "type"),
450 Action: this);
451
452 // Types in `UsingShadowDecl` is not matched by `typeLoc` above, so we need to
453 // special case it.
454 // Since using declarations inside classes must have the base class in the
455 // nested name specifier, we leave it to the nested name specifier matcher.
456 Finder->addMatcher(NodeMatch: usingDecl(IsInMovedNs, hasAnyUsingShadowDecl(InnerMatcher: decl()),
457 unless(UsingShadowDeclInClass))
458 .bind(ID: "using_with_shadow"),
459 Action: this);
460
461 // Handle types in nested name specifier. Specifiers that are in a TypeLoc
462 // matched above are not matched, e.g. "A::" in "A::A" is not matched since
463 // "A::A" would have already been fixed.
464 Finder->addMatcher(
465 NodeMatch: nestedNameSpecifierLoc(
466 hasAncestor(decl(IsInMovedNs).bind(ID: "dc")),
467 loc(InnerMatcher: nestedNameSpecifier(
468 specifiesType(InnerMatcher: hasDeclaration(InnerMatcher: DeclMatcher.bind(ID: "from_decl"))))),
469 unless(anyOf(hasAncestor(decl(isImplicit())),
470 hasAncestor(UsingShadowDeclInClass),
471 hasAncestor(functionDecl(isDefaulted())),
472 hasAncestor(typeLoc(loc(InnerMatcher: qualType(hasDeclaration(
473 InnerMatcher: decl(equalsBoundNode(ID: "from_decl"))))))))))
474 .bind(ID: "nested_specifier_loc"),
475 Action: this);
476
477 // Matches base class initializers in constructors. TypeLocs of base class
478 // initializers do not need to be fixed. For example,
479 // class X : public a::b::Y {
480 // public:
481 // X() : Y::Y() {} // Y::Y do not need namespace specifier.
482 // };
483 Finder->addMatcher(
484 NodeMatch: cxxCtorInitializer(isBaseInitializer()).bind(ID: "base_initializer"), Action: this);
485
486 // Handle function.
487 // Only handle functions that are defined in a namespace excluding member
488 // function, static methods (qualified by nested specifier), and functions
489 // defined in the global namespace.
490 // Note that the matcher does not exclude calls to out-of-line static method
491 // definitions, so we need to exclude them in the callback handler.
492 auto FuncMatcher =
493 functionDecl(unless(anyOf(cxxMethodDecl(), IsInMovedNs,
494 hasAncestor(namespaceDecl(isAnonymous())),
495 hasAncestor(cxxRecordDecl()))),
496 hasParent(namespaceDecl()));
497 Finder->addMatcher(NodeMatch: expr(hasAncestor(decl().bind(ID: "dc")), IsInMovedNs,
498 unless(hasAncestor(decl(isImplicit()))),
499 anyOf(callExpr(callee(InnerMatcher: FuncMatcher)).bind(ID: "call"),
500 declRefExpr(to(InnerMatcher: FuncMatcher.bind(ID: "func_decl")))
501 .bind(ID: "func_ref"))),
502 Action: this);
503
504 auto GlobalVarMatcher = varDecl(
505 hasGlobalStorage(), hasParent(namespaceDecl()),
506 unless(anyOf(IsInMovedNs, hasAncestor(namespaceDecl(isAnonymous())))));
507 Finder->addMatcher(NodeMatch: declRefExpr(IsInMovedNs, hasAncestor(decl().bind(ID: "dc")),
508 to(InnerMatcher: GlobalVarMatcher.bind(ID: "var_decl")))
509 .bind(ID: "var_ref"),
510 Action: this);
511
512 // Handle unscoped enum constant.
513 auto UnscopedEnumMatcher = enumConstantDecl(hasParent(enumDecl(
514 hasParent(namespaceDecl()),
515 unless(anyOf(isScoped(), IsInMovedNs, hasAncestor(cxxRecordDecl()),
516 hasAncestor(namespaceDecl(isAnonymous())))))));
517 Finder->addMatcher(
518 NodeMatch: declRefExpr(IsInMovedNs, hasAncestor(decl().bind(ID: "dc")),
519 to(InnerMatcher: UnscopedEnumMatcher.bind(ID: "enum_const_decl")))
520 .bind(ID: "enum_const_ref"),
521 Action: this);
522}
523
524void ChangeNamespaceTool::run(
525 const ast_matchers::MatchFinder::MatchResult &Result) {
526 if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>(ID: "using")) {
527 UsingDecls.insert(Ptr: Using);
528 } else if (const auto *UsingNamespace =
529 Result.Nodes.getNodeAs<UsingDirectiveDecl>(
530 ID: "using_namespace")) {
531 UsingNamespaceDecls.insert(Ptr: UsingNamespace);
532 } else if (const auto *NamespaceAlias =
533 Result.Nodes.getNodeAs<NamespaceAliasDecl>(
534 ID: "namespace_alias")) {
535 NamespaceAliasDecls.insert(Ptr: NamespaceAlias);
536 } else if (const auto *NsDecl =
537 Result.Nodes.getNodeAs<NamespaceDecl>(ID: "old_ns")) {
538 moveOldNamespace(Result, NsDecl);
539 } else if (const auto *FwdDecl =
540 Result.Nodes.getNodeAs<CXXRecordDecl>(ID: "class_fwd_decl")) {
541 moveClassForwardDeclaration(Result, FwdDecl: cast<NamedDecl>(Val: FwdDecl));
542 } else if (const auto *TemplateFwdDecl =
543 Result.Nodes.getNodeAs<ClassTemplateDecl>(
544 ID: "template_class_fwd_decl")) {
545 moveClassForwardDeclaration(Result, FwdDecl: cast<NamedDecl>(Val: TemplateFwdDecl));
546 } else if (const auto *UsingWithShadow =
547 Result.Nodes.getNodeAs<UsingDecl>(ID: "using_with_shadow")) {
548 fixUsingShadowDecl(Result, UsingDeclaration: UsingWithShadow);
549 } else if (const auto *Specifier =
550 Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
551 ID: "nested_specifier_loc")) {
552 SourceLocation Start = Specifier->getBeginLoc();
553 SourceLocation End = endLocationForType(TLoc: Specifier->getTypeLoc());
554 fixTypeLoc(Result, Start, End, Type: Specifier->getTypeLoc());
555 } else if (const auto *BaseInitializer =
556 Result.Nodes.getNodeAs<CXXCtorInitializer>(
557 ID: "base_initializer")) {
558 BaseCtorInitializerTypeLocs.push_back(
559 Elt: BaseInitializer->getTypeSourceInfo()->getTypeLoc());
560 } else if (const auto *TLoc = Result.Nodes.getNodeAs<TypeLoc>(ID: "type")) {
561 // This avoids fixing types with record types as qualifier, which is not
562 // filtered by matchers in some cases, e.g. the type is templated. We should
563 // handle the record type qualifier instead.
564 TypeLoc Loc = *TLoc;
565 while (Loc.getTypeLocClass() == TypeLoc::Qualified)
566 Loc = Loc.getNextTypeLoc();
567 if (Loc.getTypeLocClass() == TypeLoc::Elaborated) {
568 NestedNameSpecifierLoc NestedNameSpecifier =
569 Loc.castAs<ElaboratedTypeLoc>().getQualifierLoc();
570 // FIXME: avoid changing injected class names.
571 if (auto *NNS = NestedNameSpecifier.getNestedNameSpecifier()) {
572 const Type *SpecifierType = NNS->getAsType();
573 if (SpecifierType && SpecifierType->isRecordType())
574 return;
575 }
576 }
577 fixTypeLoc(Result, Start: startLocationForType(TLoc: Loc), End: endLocationForType(TLoc: Loc), Type: Loc);
578 } else if (const auto *VarRef =
579 Result.Nodes.getNodeAs<DeclRefExpr>(ID: "var_ref")) {
580 const auto *Var = Result.Nodes.getNodeAs<VarDecl>(ID: "var_decl");
581 assert(Var);
582 if (Var->getCanonicalDecl()->isStaticDataMember())
583 return;
584 const auto *Context = Result.Nodes.getNodeAs<Decl>(ID: "dc");
585 assert(Context && "Empty decl context.");
586 fixDeclRefExpr(Result, UseContext: Context->getDeclContext(),
587 From: llvm::cast<NamedDecl>(Val: Var), Ref: VarRef);
588 } else if (const auto *EnumConstRef =
589 Result.Nodes.getNodeAs<DeclRefExpr>(ID: "enum_const_ref")) {
590 // Do not rename the reference if it is already scoped by the EnumDecl name.
591 if (EnumConstRef->hasQualifier() &&
592 EnumConstRef->getQualifier()->getKind() ==
593 NestedNameSpecifier::SpecifierKind::TypeSpec &&
594 EnumConstRef->getQualifier()->getAsType()->isEnumeralType())
595 return;
596 const auto *EnumConstDecl =
597 Result.Nodes.getNodeAs<EnumConstantDecl>(ID: "enum_const_decl");
598 assert(EnumConstDecl);
599 const auto *Context = Result.Nodes.getNodeAs<Decl>(ID: "dc");
600 assert(Context && "Empty decl context.");
601 // FIXME: this would qualify "ns::VALUE" as "ns::EnumValue::VALUE". Fix it
602 // if it turns out to be an issue.
603 fixDeclRefExpr(Result, UseContext: Context->getDeclContext(),
604 From: llvm::cast<NamedDecl>(Val: EnumConstDecl), Ref: EnumConstRef);
605 } else if (const auto *FuncRef =
606 Result.Nodes.getNodeAs<DeclRefExpr>(ID: "func_ref")) {
607 // If this reference has been processed as a function call, we do not
608 // process it again.
609 if (ProcessedFuncRefs.count(Ptr: FuncRef))
610 return;
611 ProcessedFuncRefs.insert(Ptr: FuncRef);
612 const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>(ID: "func_decl");
613 assert(Func);
614 const auto *Context = Result.Nodes.getNodeAs<Decl>(ID: "dc");
615 assert(Context && "Empty decl context.");
616 fixDeclRefExpr(Result, UseContext: Context->getDeclContext(),
617 From: llvm::cast<NamedDecl>(Val: Func), Ref: FuncRef);
618 } else {
619 const auto *Call = Result.Nodes.getNodeAs<CallExpr>(ID: "call");
620 assert(Call != nullptr && "Expecting callback for CallExpr.");
621 const auto *CalleeFuncRef =
622 llvm::cast<DeclRefExpr>(Val: Call->getCallee()->IgnoreImplicit());
623 ProcessedFuncRefs.insert(Ptr: CalleeFuncRef);
624 const FunctionDecl *Func = Call->getDirectCallee();
625 assert(Func != nullptr);
626 // FIXME: ignore overloaded operators. This would miss cases where operators
627 // are called by qualified names (i.e. "ns::operator <"). Ignore such
628 // cases for now.
629 if (Func->isOverloadedOperator())
630 return;
631 // Ignore out-of-line static methods since they will be handled by nested
632 // name specifiers.
633 if (Func->getCanonicalDecl()->getStorageClass() ==
634 StorageClass::SC_Static &&
635 Func->isOutOfLine())
636 return;
637 const auto *Context = Result.Nodes.getNodeAs<Decl>(ID: "dc");
638 assert(Context && "Empty decl context.");
639 SourceRange CalleeRange = Call->getCallee()->getSourceRange();
640 replaceQualifiedSymbolInDeclContext(
641 Result, DeclContext: Context->getDeclContext(), Start: CalleeRange.getBegin(),
642 End: CalleeRange.getEnd(), FromDecl: llvm::cast<NamedDecl>(Val: Func));
643 }
644}
645
646static SourceLocation getLocAfterNamespaceLBrace(const NamespaceDecl *NsDecl,
647 const SourceManager &SM,
648 const LangOptions &LangOpts) {
649 std::unique_ptr<Lexer> Lex =
650 getLexerStartingFromLoc(Loc: NsDecl->getBeginLoc(), SM, LangOpts);
651 assert(Lex.get() &&
652 "Failed to create lexer from the beginning of namespace.");
653 if (!Lex.get())
654 return SourceLocation();
655 Token Tok;
656 while (!Lex->LexFromRawLexer(Result&: Tok) && Tok.isNot(K: tok::TokenKind::l_brace)) {
657 }
658 return Tok.isNot(K: tok::TokenKind::l_brace)
659 ? SourceLocation()
660 : Tok.getEndLoc().getLocWithOffset(Offset: 1);
661}
662
663// Stores information about a moved namespace in `MoveNamespaces` and leaves
664// the actual movement to `onEndOfTranslationUnit()`.
665void ChangeNamespaceTool::moveOldNamespace(
666 const ast_matchers::MatchFinder::MatchResult &Result,
667 const NamespaceDecl *NsDecl) {
668 // If the namespace is empty, do nothing.
669 if (Decl::castToDeclContext(NsDecl)->decls_empty())
670 return;
671
672 const SourceManager &SM = *Result.SourceManager;
673 // Get the range of the code in the old namespace.
674 SourceLocation Start =
675 getLocAfterNamespaceLBrace(NsDecl, SM, LangOpts: Result.Context->getLangOpts());
676 assert(Start.isValid() && "Can't find l_brace for namespace.");
677 MoveNamespace MoveNs;
678 MoveNs.Offset = SM.getFileOffset(SpellingLoc: Start);
679 // The range of the moved namespace is from the location just past the left
680 // brace to the location right before the right brace.
681 MoveNs.Length = SM.getFileOffset(SpellingLoc: NsDecl->getRBraceLoc()) - MoveNs.Offset;
682
683 // Insert the new namespace after `DiffOldNamespace`. For example, if
684 // `OldNamespace` is "a::b::c" and `NewNamespace` is `a::x::y`, then
685 // "x::y" will be inserted inside the existing namespace "a" and after "a::b".
686 // `OuterNs` is the first namespace in `DiffOldNamespace`, e.g. "namespace b"
687 // in the above example.
688 // If there is no outer namespace (i.e. DiffOldNamespace is empty), the new
689 // namespace will be a nested namespace in the old namespace.
690 const NamespaceDecl *OuterNs = getOuterNamespace(InnerNs: NsDecl, PartialNsName: DiffOldNamespace);
691 SourceLocation InsertionLoc = Start;
692 if (OuterNs) {
693 SourceLocation LocAfterNs = getStartOfNextLine(
694 Loc: OuterNs->getRBraceLoc(), SM, LangOpts: Result.Context->getLangOpts());
695 assert(LocAfterNs.isValid() &&
696 "Failed to get location after DiffOldNamespace");
697 InsertionLoc = LocAfterNs;
698 }
699 MoveNs.InsertionOffset = SM.getFileOffset(SpellingLoc: SM.getSpellingLoc(Loc: InsertionLoc));
700 MoveNs.FID = SM.getFileID(SpellingLoc: Start);
701 MoveNs.SourceMgr = Result.SourceManager;
702 MoveNamespaces[std::string(SM.getFilename(SpellingLoc: Start))].push_back(x: MoveNs);
703}
704
705// Removes a class forward declaration from the code in the moved namespace and
706// creates an `InsertForwardDeclaration` to insert the forward declaration back
707// into the old namespace after moving code from the old namespace to the new
708// namespace.
709// For example, changing "a" to "x":
710// Old code:
711// namespace a {
712// class FWD;
713// class A { FWD *fwd; }
714// } // a
715// New code:
716// namespace a {
717// class FWD;
718// } // a
719// namespace x {
720// class A { a::FWD *fwd; }
721// } // x
722void ChangeNamespaceTool::moveClassForwardDeclaration(
723 const ast_matchers::MatchFinder::MatchResult &Result,
724 const NamedDecl *FwdDecl) {
725 SourceLocation Start = FwdDecl->getBeginLoc();
726 SourceLocation End = FwdDecl->getEndLoc();
727 const SourceManager &SM = *Result.SourceManager;
728 SourceLocation AfterSemi = Lexer::findLocationAfterToken(
729 loc: End, TKind: tok::semi, SM, LangOpts: Result.Context->getLangOpts(),
730 /*SkipTrailingWhitespaceAndNewLine=*/true);
731 if (AfterSemi.isValid())
732 End = AfterSemi.getLocWithOffset(Offset: -1);
733 // Delete the forward declaration from the code to be moved.
734 addReplacementOrDie(Start, End, ReplacementText: "", SM, FileToReplacements: &FileToReplacements);
735 llvm::StringRef Code = Lexer::getSourceText(
736 Range: CharSourceRange::getTokenRange(B: SM.getSpellingLoc(Loc: Start),
737 E: SM.getSpellingLoc(Loc: End)),
738 SM, LangOpts: Result.Context->getLangOpts());
739 // Insert the forward declaration back into the old namespace after moving the
740 // code from old namespace to new namespace.
741 // Insertion information is stored in `InsertFwdDecls` and actual
742 // insertion will be performed in `onEndOfTranslationUnit`.
743 // Get the (old) namespace that contains the forward declaration.
744 const auto *NsDecl = Result.Nodes.getNodeAs<NamespaceDecl>(ID: "ns_decl");
745 // The namespace contains the forward declaration, so it must not be empty.
746 assert(!NsDecl->decls_empty());
747 const auto Insertion = createInsertion(
748 Loc: getLocAfterNamespaceLBrace(NsDecl, SM, LangOpts: Result.Context->getLangOpts()),
749 InsertText: Code, SM);
750 InsertForwardDeclaration InsertFwd;
751 InsertFwd.InsertionOffset = Insertion.getOffset();
752 InsertFwd.ForwardDeclText = Insertion.getReplacementText().str();
753 InsertFwdDecls[std::string(Insertion.getFilePath())].push_back(x: InsertFwd);
754}
755
756// Replaces a qualified symbol (in \p DeclCtx) that refers to a declaration \p
757// FromDecl with the shortest qualified name possible when the reference is in
758// `NewNamespace`.
759void ChangeNamespaceTool::replaceQualifiedSymbolInDeclContext(
760 const ast_matchers::MatchFinder::MatchResult &Result,
761 const DeclContext *DeclCtx, SourceLocation Start, SourceLocation End,
762 const NamedDecl *FromDecl) {
763 const auto *NsDeclContext = DeclCtx->getEnclosingNamespaceContext();
764 if (llvm::isa<TranslationUnitDecl>(Val: NsDeclContext)) {
765 // This should not happen in usual unless the TypeLoc is in function type
766 // parameters, e.g `std::function<void(T)>`. In this case, DeclContext of
767 // `T` will be the translation unit. We simply use fully-qualified name
768 // here.
769 // Note that `FromDecl` must not be defined in the old namespace (according
770 // to `DeclMatcher`), so its fully-qualified name will not change after
771 // changing the namespace.
772 addReplacementOrDie(Start, End, ReplacementText: FromDecl->getQualifiedNameAsString(),
773 SM: *Result.SourceManager, FileToReplacements: &FileToReplacements);
774 return;
775 }
776 const auto *NsDecl = llvm::cast<NamespaceDecl>(Val: NsDeclContext);
777 // Calculate the name of the `NsDecl` after it is moved to new namespace.
778 std::string OldNs = NsDecl->getQualifiedNameAsString();
779 llvm::StringRef Postfix = OldNs;
780 bool Consumed = Postfix.consume_front(Prefix: OldNamespace);
781 assert(Consumed && "Expect OldNS to start with OldNamespace.");
782 (void)Consumed;
783 const std::string NewNs = (NewNamespace + Postfix).str();
784
785 llvm::StringRef NestedName = Lexer::getSourceText(
786 Range: CharSourceRange::getTokenRange(
787 B: Result.SourceManager->getSpellingLoc(Loc: Start),
788 E: Result.SourceManager->getSpellingLoc(Loc: End)),
789 SM: *Result.SourceManager, LangOpts: Result.Context->getLangOpts());
790 std::string FromDeclName = FromDecl->getQualifiedNameAsString();
791 for (llvm::Regex &RE : AllowedSymbolRegexes)
792 if (RE.match(String: FromDeclName))
793 return;
794 std::string ReplaceName =
795 getShortestQualifiedNameInNamespace(DeclName: FromDeclName, NsName: NewNs);
796 // Checks if there is any using namespace declarations that can shorten the
797 // qualified name.
798 for (const auto *UsingNamespace : UsingNamespaceDecls) {
799 if (!isDeclVisibleAtLocation(*Result.SourceManager, UsingNamespace, DeclCtx,
800 Start))
801 continue;
802 StringRef FromDeclNameRef = FromDeclName;
803 if (FromDeclNameRef.consume_front(Prefix: UsingNamespace->getNominatedNamespace()
804 ->getQualifiedNameAsString())) {
805 FromDeclNameRef = FromDeclNameRef.drop_front(N: 2);
806 if (FromDeclNameRef.size() < ReplaceName.size())
807 ReplaceName = std::string(FromDeclNameRef);
808 }
809 }
810 // Checks if there is any namespace alias declarations that can shorten the
811 // qualified name.
812 for (const auto *NamespaceAlias : NamespaceAliasDecls) {
813 if (!isDeclVisibleAtLocation(*Result.SourceManager, NamespaceAlias, DeclCtx,
814 Start))
815 continue;
816 StringRef FromDeclNameRef = FromDeclName;
817 if (FromDeclNameRef.consume_front(
818 Prefix: NamespaceAlias->getNamespace()->getQualifiedNameAsString() +
819 "::")) {
820 std::string AliasName = NamespaceAlias->getNameAsString();
821 std::string AliasQualifiedName =
822 NamespaceAlias->getQualifiedNameAsString();
823 // We only consider namespace aliases define in the global namespace or
824 // in namespaces that are directly visible from the reference, i.e.
825 // ancestor of the `OldNs`. Note that declarations in ancestor namespaces
826 // but not visible in the new namespace is filtered out by
827 // "IsVisibleInNewNs" matcher.
828 if (AliasQualifiedName != AliasName) {
829 // The alias is defined in some namespace.
830 assert(StringRef(AliasQualifiedName).ends_with("::" + AliasName));
831 llvm::StringRef AliasNs =
832 StringRef(AliasQualifiedName).drop_back(N: AliasName.size() + 2);
833 if (!llvm::StringRef(OldNs).starts_with(Prefix: AliasNs))
834 continue;
835 }
836 std::string NameWithAliasNamespace =
837 (AliasName + "::" + FromDeclNameRef).str();
838 if (NameWithAliasNamespace.size() < ReplaceName.size())
839 ReplaceName = NameWithAliasNamespace;
840 }
841 }
842 // Checks if there is any using shadow declarations that can shorten the
843 // qualified name.
844 bool Matched = false;
845 for (const UsingDecl *Using : UsingDecls) {
846 if (Matched)
847 break;
848 if (isDeclVisibleAtLocation(*Result.SourceManager, Using, DeclCtx, Start)) {
849 for (const auto *UsingShadow : Using->shadows()) {
850 const auto *TargetDecl = UsingShadow->getTargetDecl();
851 if (TargetDecl->getQualifiedNameAsString() ==
852 FromDecl->getQualifiedNameAsString()) {
853 ReplaceName = FromDecl->getNameAsString();
854 Matched = true;
855 break;
856 }
857 }
858 }
859 }
860 bool Conflict = conflictInNamespace(AST: DeclCtx->getParentASTContext(),
861 QualifiedSymbol: ReplaceName, Namespace: NewNamespace);
862 // If the new nested name in the new namespace is the same as it was in the
863 // old namespace, we don't create replacement unless there can be ambiguity.
864 if ((NestedName == ReplaceName && !Conflict) ||
865 (NestedName.starts_with(Prefix: "::") && NestedName.drop_front(N: 2) == ReplaceName))
866 return;
867 // If the reference need to be fully-qualified, add a leading "::" unless
868 // NewNamespace is the global namespace.
869 if (ReplaceName == FromDeclName && !NewNamespace.empty() && Conflict)
870 ReplaceName = "::" + ReplaceName;
871 addReplacementOrDie(Start, End, ReplacementText: ReplaceName, SM: *Result.SourceManager,
872 FileToReplacements: &FileToReplacements);
873}
874
875// Replace the [Start, End] of `Type` with the shortest qualified name when the
876// `Type` is in `NewNamespace`.
877void ChangeNamespaceTool::fixTypeLoc(
878 const ast_matchers::MatchFinder::MatchResult &Result, SourceLocation Start,
879 SourceLocation End, TypeLoc Type) {
880 // FIXME: do not rename template parameter.
881 if (Start.isInvalid() || End.isInvalid())
882 return;
883 // Types of CXXCtorInitializers do not need to be fixed.
884 if (llvm::is_contained(Range&: BaseCtorInitializerTypeLocs, Element: Type))
885 return;
886 if (isTemplateParameter(Type))
887 return;
888 // The declaration which this TypeLoc refers to.
889 const auto *FromDecl = Result.Nodes.getNodeAs<NamedDecl>(ID: "from_decl");
890 // `hasDeclaration` gives underlying declaration, but if the type is
891 // a typedef type, we need to use the typedef type instead.
892 auto IsInMovedNs = [&](const NamedDecl *D) {
893 if (!llvm::StringRef(D->getQualifiedNameAsString())
894 .starts_with(Prefix: OldNamespace + "::"))
895 return false;
896 auto ExpansionLoc = Result.SourceManager->getExpansionLoc(Loc: D->getBeginLoc());
897 if (ExpansionLoc.isInvalid())
898 return false;
899 llvm::StringRef Filename = Result.SourceManager->getFilename(SpellingLoc: ExpansionLoc);
900 return FilePatternRE.match(Filename);
901 };
902 // Make `FromDecl` the immediate declaration that `Type` refers to, i.e. if
903 // `Type` is an alias type, we make `FromDecl` the type alias declaration.
904 // Also, don't fix the \p Type if it refers to a type alias decl in the moved
905 // namespace since the alias decl will be moved along with the type reference.
906 if (auto *Typedef = Type.getType()->getAs<TypedefType>()) {
907 FromDecl = Typedef->getDecl();
908 if (IsInMovedNs(FromDecl))
909 return;
910 } else if (auto *TemplateType =
911 Type.getType()->getAs<TemplateSpecializationType>()) {
912 if (TemplateType->isTypeAlias()) {
913 FromDecl = TemplateType->getTemplateName().getAsTemplateDecl();
914 if (IsInMovedNs(FromDecl))
915 return;
916 }
917 }
918 const auto *DeclCtx = Result.Nodes.getNodeAs<Decl>(ID: "dc");
919 assert(DeclCtx && "Empty decl context.");
920 replaceQualifiedSymbolInDeclContext(Result, DeclCtx: DeclCtx->getDeclContext(), Start,
921 End, FromDecl);
922}
923
924void ChangeNamespaceTool::fixUsingShadowDecl(
925 const ast_matchers::MatchFinder::MatchResult &Result,
926 const UsingDecl *UsingDeclaration) {
927 SourceLocation Start = UsingDeclaration->getBeginLoc();
928 SourceLocation End = UsingDeclaration->getEndLoc();
929 if (Start.isInvalid() || End.isInvalid())
930 return;
931
932 assert(UsingDeclaration->shadow_size() > 0);
933 // FIXME: it might not be always accurate to use the first using-decl.
934 const NamedDecl *TargetDecl =
935 UsingDeclaration->shadow_begin()->getTargetDecl();
936 std::string TargetDeclName = TargetDecl->getQualifiedNameAsString();
937 // FIXME: check if target_decl_name is in moved ns, which doesn't make much
938 // sense. If this happens, we need to use name with the new namespace.
939 // Use fully qualified name in UsingDecl for now.
940 addReplacementOrDie(Start, End, ReplacementText: "using ::" + TargetDeclName,
941 SM: *Result.SourceManager, FileToReplacements: &FileToReplacements);
942}
943
944void ChangeNamespaceTool::fixDeclRefExpr(
945 const ast_matchers::MatchFinder::MatchResult &Result,
946 const DeclContext *UseContext, const NamedDecl *From,
947 const DeclRefExpr *Ref) {
948 SourceRange RefRange = Ref->getSourceRange();
949 replaceQualifiedSymbolInDeclContext(Result, DeclCtx: UseContext, Start: RefRange.getBegin(),
950 End: RefRange.getEnd(), FromDecl: From);
951}
952
953void ChangeNamespaceTool::onEndOfTranslationUnit() {
954 // Move namespace blocks and insert forward declaration to old namespace.
955 for (const auto &FileAndNsMoves : MoveNamespaces) {
956 auto &NsMoves = FileAndNsMoves.second;
957 if (NsMoves.empty())
958 continue;
959 const std::string &FilePath = FileAndNsMoves.first;
960 auto &Replaces = FileToReplacements[FilePath];
961 auto &SM = *NsMoves.begin()->SourceMgr;
962 llvm::StringRef Code = SM.getBufferData(FID: NsMoves.begin()->FID);
963 auto ChangedCode = tooling::applyAllReplacements(Code, Replaces);
964 if (!ChangedCode) {
965 llvm::errs() << llvm::toString(E: ChangedCode.takeError()) << "\n";
966 continue;
967 }
968 // Replacements on the changed code for moving namespaces and inserting
969 // forward declarations to old namespaces.
970 tooling::Replacements NewReplacements;
971 // Cut the changed code from the old namespace and paste the code in the new
972 // namespace.
973 for (const auto &NsMove : NsMoves) {
974 // Calculate the range of the old namespace block in the changed
975 // code.
976 const unsigned NewOffset = Replaces.getShiftedCodePosition(Position: NsMove.Offset);
977 const unsigned NewLength =
978 Replaces.getShiftedCodePosition(Position: NsMove.Offset + NsMove.Length) -
979 NewOffset;
980 tooling::Replacement Deletion(FilePath, NewOffset, NewLength, "");
981 std::string MovedCode = ChangedCode->substr(pos: NewOffset, n: NewLength);
982 std::string MovedCodeWrappedInNewNs =
983 wrapCodeInNamespace(NestedNs: DiffNewNamespace, Code: MovedCode);
984 // Calculate the new offset at which the code will be inserted in the
985 // changed code.
986 unsigned NewInsertionOffset =
987 Replaces.getShiftedCodePosition(Position: NsMove.InsertionOffset);
988 tooling::Replacement Insertion(FilePath, NewInsertionOffset, 0,
989 MovedCodeWrappedInNewNs);
990 addOrMergeReplacement(R: Deletion, Replaces: &NewReplacements);
991 addOrMergeReplacement(R: Insertion, Replaces: &NewReplacements);
992 }
993 // After moving namespaces, insert forward declarations back to old
994 // namespaces.
995 const auto &FwdDeclInsertions = InsertFwdDecls[FilePath];
996 for (const auto &FwdDeclInsertion : FwdDeclInsertions) {
997 unsigned NewInsertionOffset =
998 Replaces.getShiftedCodePosition(Position: FwdDeclInsertion.InsertionOffset);
999 tooling::Replacement Insertion(FilePath, NewInsertionOffset, 0,
1000 FwdDeclInsertion.ForwardDeclText);
1001 addOrMergeReplacement(R: Insertion, Replaces: &NewReplacements);
1002 }
1003 // Add replacements referring to the changed code to existing replacements,
1004 // which refers to the original code.
1005 Replaces = Replaces.merge(Replaces: NewReplacements);
1006 auto Style =
1007 format::getStyle(StyleName: format::DefaultFormatStyle, FileName: FilePath, FallbackStyle);
1008 if (!Style) {
1009 llvm::errs() << llvm::toString(E: Style.takeError()) << "\n";
1010 continue;
1011 }
1012 // Clean up old namespaces if there is nothing in it after moving.
1013 auto CleanReplacements =
1014 format::cleanupAroundReplacements(Code, Replaces, Style: *Style);
1015 if (!CleanReplacements) {
1016 llvm::errs() << llvm::toString(E: CleanReplacements.takeError()) << "\n";
1017 continue;
1018 }
1019 FileToReplacements[FilePath] = *CleanReplacements;
1020 }
1021
1022 // Make sure we don't generate replacements for files that do not match
1023 // FilePattern.
1024 for (auto &Entry : FileToReplacements)
1025 if (!FilePatternRE.match(String: Entry.first))
1026 Entry.second.clear();
1027}
1028
1029} // namespace change_namespace
1030} // namespace clang
1031

source code of clang-tools-extra/clang-change-namespace/ChangeNamespace.cpp