|
150
|
1 //===-- ChangeNamespace.h -- Change namespace ------------------*- 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 #ifndef LLVM_CLANG_TOOLS_EXTRA_CHANGE_NAMESPACE_CHANGENAMESPACE_H
|
|
|
10 #define LLVM_CLANG_TOOLS_EXTRA_CHANGE_NAMESPACE_CHANGENAMESPACE_H
|
|
|
11
|
|
|
12 #include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
|
13 #include "clang/Format/Format.h"
|
|
|
14 #include "clang/Tooling/Core/Replacement.h"
|
|
|
15 #include "llvm/Support/Regex.h"
|
|
|
16 #include <string>
|
|
|
17
|
|
|
18 namespace clang {
|
|
|
19 namespace change_namespace {
|
|
|
20
|
|
|
21 // This tool can be used to change the surrounding namespaces of class/function
|
|
|
22 // definitions. Classes/functions in the moved namespace will have new
|
|
|
23 // namespaces while references to symbols (e.g. types, functions) which are not
|
|
|
24 // defined in the changed namespace will be correctly qualified by prepending
|
|
|
25 // namespace specifiers before them.
|
|
|
26 // This will try to add shortest namespace specifiers possible. When a symbol
|
|
|
27 // reference needs to be fully-qualified, this adds a "::" prefix to the
|
|
|
28 // namespace specifiers unless the new namespace is the global namespace.
|
|
|
29 // For classes, only classes that are declared/defined in the given namespace in
|
|
173
|
30 // specified files will be moved: forward declarations will remain in the old
|
|
150
|
31 // namespace.
|
|
|
32 // For example, changing "a" to "x":
|
|
|
33 // Old code:
|
|
|
34 // namespace a {
|
|
|
35 // class FWD;
|
|
|
36 // class A { FWD *fwd; }
|
|
|
37 // } // a
|
|
|
38 // New code:
|
|
|
39 // namespace a {
|
|
|
40 // class FWD;
|
|
|
41 // } // a
|
|
|
42 // namespace x {
|
|
|
43 // class A { ::a::FWD *fwd; }
|
|
|
44 // } // x
|
|
|
45 // FIXME: support moving typedef, enums across namespaces.
|
|
|
46 class ChangeNamespaceTool : public ast_matchers::MatchFinder::MatchCallback {
|
|
|
47 public:
|
|
|
48 // Moves code in the old namespace `OldNs` to the new namespace `NewNs` in
|
|
|
49 // files matching `FilePattern`.
|
|
|
50 ChangeNamespaceTool(
|
|
|
51 llvm::StringRef OldNs, llvm::StringRef NewNs, llvm::StringRef FilePattern,
|
|
207
|
52 llvm::ArrayRef<std::string> AllowedSymbolPatterns,
|
|
150
|
53 std::map<std::string, tooling::Replacements> *FileToReplacements,
|
|
|
54 llvm::StringRef FallbackStyle = "LLVM");
|
|
|
55
|
|
|
56 void registerMatchers(ast_matchers::MatchFinder *Finder);
|
|
|
57
|
|
|
58 void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
|
|
|
59
|
|
|
60 // Moves the changed code in old namespaces but leaves class forward
|
|
|
61 // declarations behind.
|
|
|
62 void onEndOfTranslationUnit() override;
|
|
|
63
|
|
|
64 private:
|
|
|
65 void moveOldNamespace(const ast_matchers::MatchFinder::MatchResult &Result,
|
|
|
66 const NamespaceDecl *NsDecl);
|
|
|
67
|
|
|
68 void moveClassForwardDeclaration(
|
|
|
69 const ast_matchers::MatchFinder::MatchResult &Result,
|
|
|
70 const NamedDecl *FwdDecl);
|
|
|
71
|
|
|
72 void replaceQualifiedSymbolInDeclContext(
|
|
|
73 const ast_matchers::MatchFinder::MatchResult &Result,
|
|
|
74 const DeclContext *DeclContext, SourceLocation Start, SourceLocation End,
|
|
|
75 const NamedDecl *FromDecl);
|
|
|
76
|
|
|
77 void fixTypeLoc(const ast_matchers::MatchFinder::MatchResult &Result,
|
|
|
78 SourceLocation Start, SourceLocation End, TypeLoc Type);
|
|
|
79
|
|
|
80 void fixUsingShadowDecl(const ast_matchers::MatchFinder::MatchResult &Result,
|
|
|
81 const UsingDecl *UsingDeclaration);
|
|
|
82
|
|
|
83 void fixDeclRefExpr(const ast_matchers::MatchFinder::MatchResult &Result,
|
|
|
84 const DeclContext *UseContext, const NamedDecl *From,
|
|
|
85 const DeclRefExpr *Ref);
|
|
|
86
|
|
|
87 // Information about moving an old namespace.
|
|
|
88 struct MoveNamespace {
|
|
|
89 // The start offset of the namespace block being moved in the original
|
|
|
90 // code.
|
|
|
91 unsigned Offset;
|
|
|
92 // The length of the namespace block in the original code.
|
|
|
93 unsigned Length;
|
|
|
94 // The offset at which the new namespace block will be inserted in the
|
|
|
95 // original code.
|
|
|
96 unsigned InsertionOffset;
|
|
|
97 // The file in which the namespace is declared.
|
|
|
98 FileID FID;
|
|
|
99 SourceManager *SourceMgr;
|
|
|
100 };
|
|
|
101
|
|
|
102 // Information about inserting a class forward declaration.
|
|
|
103 struct InsertForwardDeclaration {
|
|
|
104 // The offset at while the forward declaration will be inserted in the
|
|
|
105 // original code.
|
|
|
106 unsigned InsertionOffset;
|
|
|
107 // The code to be inserted.
|
|
|
108 std::string ForwardDeclText;
|
|
|
109 };
|
|
|
110
|
|
|
111 std::string FallbackStyle;
|
|
|
112 // In match callbacks, this contains replacements for replacing `typeLoc`s in
|
|
|
113 // and deleting forward declarations in the moved namespace blocks.
|
|
|
114 // In `onEndOfTranslationUnit` callback, the previous added replacements are
|
|
|
115 // applied (on the moved namespace blocks), and then changed code in old
|
|
|
116 // namespaces re moved to new namespaces, and previously deleted forward
|
|
|
117 // declarations are inserted back to old namespaces, from which they are
|
|
|
118 // deleted.
|
|
|
119 std::map<std::string, tooling::Replacements> &FileToReplacements;
|
|
|
120 // A fully qualified name of the old namespace without "::" prefix, e.g.
|
|
|
121 // "a::b::c".
|
|
|
122 std::string OldNamespace;
|
|
|
123 // A fully qualified name of the new namespace without "::" prefix, e.g.
|
|
|
124 // "x::y::z".
|
|
|
125 std::string NewNamespace;
|
|
|
126 // The longest suffix in the old namespace that does not overlap the new
|
|
|
127 // namespace.
|
|
|
128 // For example, if `OldNamespace` is "a::b::c" and `NewNamespace` is
|
|
|
129 // "a::x::y", then `DiffOldNamespace` will be "b::c".
|
|
|
130 std::string DiffOldNamespace;
|
|
|
131 // The longest suffix in the new namespace that does not overlap the old
|
|
|
132 // namespace.
|
|
|
133 // For example, if `OldNamespace` is "a::b::c" and `NewNamespace` is
|
|
|
134 // "a::x::y", then `DiffNewNamespace` will be "x::y".
|
|
|
135 std::string DiffNewNamespace;
|
|
|
136 // A regex pattern that matches files to be processed.
|
|
|
137 std::string FilePattern;
|
|
|
138 llvm::Regex FilePatternRE;
|
|
|
139 // Information about moved namespaces grouped by file.
|
|
|
140 // Since we are modifying code in old namespaces (e.g. add namespace
|
|
173
|
141 // specifiers) as well as moving them, we store information about namespaces
|
|
150
|
142 // to be moved and only move them after all modifications are finished (i.e.
|
|
|
143 // in `onEndOfTranslationUnit`).
|
|
|
144 std::map<std::string, std::vector<MoveNamespace>> MoveNamespaces;
|
|
|
145 // Information about forward declaration insertions grouped by files.
|
|
|
146 // A class forward declaration is not moved, so it will be deleted from the
|
|
|
147 // moved code block and inserted back into the old namespace. The insertion
|
|
|
148 // will be done after removing the code from the old namespace and before
|
|
|
149 // inserting it to the new namespace.
|
|
|
150 std::map<std::string, std::vector<InsertForwardDeclaration>> InsertFwdDecls;
|
|
|
151 // Records all using declarations, which can be used to shorten namespace
|
|
|
152 // specifiers.
|
|
|
153 llvm::SmallPtrSet<const UsingDecl *, 8> UsingDecls;
|
|
|
154 // Records all using namespace declarations, which can be used to shorten
|
|
|
155 // namespace specifiers.
|
|
|
156 llvm::SmallPtrSet<const UsingDirectiveDecl *, 8> UsingNamespaceDecls;
|
|
|
157 // Records all namespace alias declarations, which can be used to shorten
|
|
|
158 // namespace specifiers.
|
|
|
159 llvm::SmallPtrSet<const NamespaceAliasDecl *, 8> NamespaceAliasDecls;
|
|
|
160 // TypeLocs of CXXCtorInitializer. Types of CXXCtorInitializers do not need to
|
|
|
161 // be fixed.
|
|
|
162 llvm::SmallVector<TypeLoc, 8> BaseCtorInitializerTypeLocs;
|
|
|
163 // Since a DeclRefExpr for a function call can be matched twice (one as
|
|
|
164 // CallExpr and one as DeclRefExpr), we record all DeclRefExpr's that have
|
|
|
165 // been processed so that we don't handle them twice.
|
|
|
166 llvm::SmallPtrSet<const clang::DeclRefExpr*, 16> ProcessedFuncRefs;
|
|
|
167 // Patterns of symbol names whose references are not expected to be updated
|
|
|
168 // when changing namespaces around them.
|
|
207
|
169 std::vector<llvm::Regex> AllowedSymbolRegexes;
|
|
150
|
170 };
|
|
|
171
|
|
|
172 } // namespace change_namespace
|
|
|
173 } // namespace clang
|
|
|
174
|
|
|
175 #endif // LLVM_CLANG_TOOLS_EXTRA_CHANGE_NAMESPACE_CHANGENAMESPACE_H
|
