clang-tools  14.0.0git
Move.h
Go to the documentation of this file.
1 //===-- Move.h - Clang move ----------------------------------------------===//
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_CLANG_MOVE_CLANGMOVE_H
10 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H
11 
12 #include "HelperDeclRefGraph.h"
13 #include "clang/ASTMatchers/ASTMatchFinder.h"
14 #include "clang/Frontend/FrontendAction.h"
15 #include "clang/Tooling/Core/Replacement.h"
16 #include "clang/Tooling/Tooling.h"
17 #include "llvm/ADT/SmallPtrSet.h"
18 #include "llvm/ADT/StringMap.h"
19 #include "llvm/ADT/StringRef.h"
20 #include <map>
21 #include <memory>
22 #include <string>
23 #include <vector>
24 
25 namespace clang {
26 namespace move {
27 
28 // A reporter which collects and reports declarations in old header.
30 public:
31  DeclarationReporter() = default;
32  ~DeclarationReporter() = default;
33 
34  void reportDeclaration(llvm::StringRef DeclarationName, llvm::StringRef Type,
35  bool Templated) {
36  DeclarationList.emplace_back(DeclarationName, Type, Templated);
37  };
38 
39  struct Declaration {
40  Declaration(llvm::StringRef QName, llvm::StringRef Kind, bool Templated)
41  : QualifiedName(QName), Kind(Kind), Templated(Templated) {}
42 
43  friend bool operator==(const Declaration &LHS, const Declaration &RHS) {
44  return std::tie(LHS.QualifiedName, LHS.Kind, LHS.Templated) ==
45  std::tie(RHS.QualifiedName, RHS.Kind, RHS.Templated);
46  }
47  std::string QualifiedName; // E.g. A::B::Foo.
48  std::string Kind; // E.g. Function, Class
49  bool Templated = false; // Whether the declaration is templated.
50  };
51 
52  const std::vector<Declaration> getDeclarationList() const {
53  return DeclarationList;
54  }
55 
56 private:
57  std::vector<Declaration> DeclarationList;
58 };
59 
60 // Specify declarations being moved. It contains all information of the moved
61 // declarations.
63  // The list of fully qualified names, e.g. Foo, a::Foo, b::Foo.
64  SmallVector<std::string, 4> Names;
65  // The file path of old header, can be relative path and absolute path.
66  std::string OldHeader;
67  // The file path of old cc, can be relative path and absolute path.
68  std::string OldCC;
69  // The file path of new header, can be relative path and absolute path.
70  std::string NewHeader;
71  // The file path of new cc, can be relative path and absolute path.
72  std::string NewCC;
73  // Whether old.h depends on new.h. If true, #include "new.h" will be added
74  // in old.h.
75  bool OldDependOnNew = false;
76  // Whether new.h depends on old.h. If true, #include "old.h" will be added
77  // in new.h.
78  bool NewDependOnOld = false;
79 };
80 
81 // A Context which contains extra options which are used in ClangMoveTool.
84  // The Key is file path, value is the replacements being applied to the file.
85  std::map<std::string, tooling::Replacements> &FileToReplacements;
86  // The original working directory where the local clang-move binary runs.
87  //
88  // clang-move will change its current working directory to the build
89  // directory when analyzing the source file. We save the original working
90  // directory in order to get the absolute file path for the fields in Spec.
92  // The name of a predefined code style.
93  std::string FallbackStyle;
94  // Whether dump all declarations in old header.
96 };
97 
98 // This tool is used to move class/function definitions from the given source
99 // files (old.h/cc) to new files (new.h/cc).
100 // The goal of this tool is to make the new/old files as compilable as possible.
101 //
102 // When moving a symbol,all used helper declarations (e.g. static
103 // functions/variables definitions in global/named namespace,
104 // functions/variables/classes definitions in anonymous namespace) used by the
105 // moved symbol in old.cc are moved to the new.cc. In addition, all
106 // using-declarations in old.cc are also moved to new.cc; forward class
107 // declarations in old.h are also moved to new.h.
108 //
109 // The remaining helper declarations which are unused by non-moved symbols in
110 // old.cc will be removed.
111 //
112 // Note: When all declarations in old header are being moved, all code in
113 // old.h/cc will be moved, which means old.h/cc are empty. This ignores symbols
114 // that are not supported (e.g. typedef and enum) so that we always move old
115 // files to new files when all symbols produced from dump_decls are moved.
116 class ClangMoveTool : public ast_matchers::MatchFinder::MatchCallback {
117 public:
118  ClangMoveTool(ClangMoveContext *const Context,
119  DeclarationReporter *const Reporter);
120 
121  void registerMatchers(ast_matchers::MatchFinder *Finder);
122 
123  void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
124 
125  void onEndOfTranslationUnit() override;
126 
127  /// Add #includes from old.h/cc files.
128  ///
129  /// \param IncludeHeader The name of the file being included, as written in
130  /// the source code.
131  /// \param IsAngled Whether the file name was enclosed in angle brackets.
132  /// \param SearchPath The search path which was used to find the IncludeHeader
133  /// in the file system. It can be a relative path or an absolute path.
134  /// \param FileName The name of file where the IncludeHeader comes from.
135  /// \param IncludeFilenameRange The source range for the written file name in
136  /// #include (i.e. "old.h" for #include "old.h") in old.cc.
137  /// \param SM The SourceManager.
138  void addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
139  llvm::StringRef SearchPath, llvm::StringRef FileName,
140  clang::CharSourceRange IncludeFilenameRange,
141  const SourceManager &SM);
142 
143  std::vector<const NamedDecl *> &getMovedDecls() { return MovedDecls; }
144 
145  /// Add declarations being removed from old.h/cc. For each declarations, the
146  /// method also records the mapping relationship between the corresponding
147  /// FilePath and its FileID.
148  void addRemovedDecl(const NamedDecl *Decl);
149 
150  llvm::SmallPtrSet<const NamedDecl *, 8> &getUnremovedDeclsInOldHeader() {
151  return UnremovedDeclsInOldHeader;
152  }
153 
154 private:
155  // Make the Path absolute using the OrignalRunningDirectory if the Path is not
156  // an absolute path. An empty Path will result in an empty string.
157  std::string makeAbsolutePath(StringRef Path);
158 
159  void removeDeclsInOldFiles();
160  void moveDeclsToNewFiles();
161  void moveAll(SourceManager& SM, StringRef OldFile, StringRef NewFile);
162 
163  // Stores all MatchCallbacks created by this tool.
164  std::vector<std::unique_ptr<ast_matchers::MatchFinder::MatchCallback>>
165  MatchCallbacks;
166  // Store all potential declarations (decls being moved, forward decls) that
167  // might need to move to new.h/cc. It includes all helper declarations
168  // (include unused ones) by default. The unused ones will be filtered out in
169  // the last stage. Saving in an AST-visited order.
170  std::vector<const NamedDecl *> MovedDecls;
171  // The declarations that needs to be removed in old.cc/h.
172  std::vector<const NamedDecl *> RemovedDecls;
173  // The #includes in old_header.h.
174  std::vector<std::string> HeaderIncludes;
175  // The #includes in old_cc.cc.
176  std::vector<std::string> CCIncludes;
177  // Records all helper declarations (function/variable/class definitions in
178  // anonymous namespaces, static function/variable definitions in global/named
179  // namespaces) in old.cc. saving in an AST-visited order.
180  std::vector<const NamedDecl *> HelperDeclarations;
181  // The unmoved named declarations in old header.
182  llvm::SmallPtrSet<const NamedDecl*, 8> UnremovedDeclsInOldHeader;
183  /// The source range for the written file name in #include (i.e. "old.h" for
184  /// #include "old.h") in old.cc, including the enclosing quotes or angle
185  /// brackets.
186  clang::CharSourceRange OldHeaderIncludeRangeInCC;
187  /// The source range for the written file name in #include (i.e. "old.h" for
188  /// #include "old.h") in old.h, including the enclosing quotes or angle
189  /// brackets.
190  clang::CharSourceRange OldHeaderIncludeRangeInHeader;
191  /// Mapping from FilePath to FileID, which can be used in post processes like
192  /// cleanup around replacements.
193  llvm::StringMap<FileID> FilePathToFileID;
194  /// A context contains all running options. It is not owned.
195  ClangMoveContext *const Context;
196  /// A reporter to report all declarations from old header. It is not owned.
197  DeclarationReporter *const Reporter;
198  /// Builder for helper declarations reference graph.
199  HelperDeclRGBuilder RGBuilder;
200 };
201 
202 class ClangMoveAction : public clang::ASTFrontendAction {
203 public:
205  DeclarationReporter *const Reporter)
206  : MoveTool(Context, Reporter) {
207  MoveTool.registerMatchers(&MatchFinder);
208  }
209 
210  ~ClangMoveAction() override = default;
211 
212  std::unique_ptr<clang::ASTConsumer>
213  CreateASTConsumer(clang::CompilerInstance &Compiler,
214  llvm::StringRef InFile) override;
215 
216 private:
217  ast_matchers::MatchFinder MatchFinder;
218  ClangMoveTool MoveTool;
219 };
220 
221 class ClangMoveActionFactory : public tooling::FrontendActionFactory {
222 public:
224  DeclarationReporter *const Reporter = nullptr)
225  : Context(Context), Reporter(Reporter) {}
226 
227  std::unique_ptr<clang::FrontendAction> create() override {
228  return std::make_unique<ClangMoveAction>(Context, Reporter);
229  }
230 
231 private:
232  // Not owned.
233  ClangMoveContext *const Context;
234  DeclarationReporter *const Reporter;
235 };
236 
237 } // namespace move
238 } // namespace clang
239 
240 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H
clang::move::ClangMoveTool::registerMatchers
void registerMatchers(ast_matchers::MatchFinder *Finder)
Definition: Move.cpp:499
clang::move::DeclarationReporter::Declaration::operator==
friend bool operator==(const Declaration &LHS, const Declaration &RHS)
Definition: Move.h:43
Type
NodeType Type
Definition: HTMLGenerator.cpp:73
clang::move::DeclarationReporter::Declaration::Kind
std::string Kind
Definition: Move.h:48
clang::move::DeclarationReporter::reportDeclaration
void reportDeclaration(llvm::StringRef DeclarationName, llvm::StringRef Type, bool Templated)
Definition: Move.h:34
clang::move::ClangMoveTool::getUnremovedDeclsInOldHeader
llvm::SmallPtrSet< const NamedDecl *, 8 > & getUnremovedDeclsInOldHeader()
Definition: Move.h:150
clang::move::ClangMoveContext
Definition: Move.h:82
clang::move::DeclarationReporter::Declaration::QualifiedName
std::string QualifiedName
Definition: Move.h:47
clang::move::DeclarationReporter::Declaration::Declaration
Declaration(llvm::StringRef QName, llvm::StringRef Kind, bool Templated)
Definition: Move.h:40
clang::move::ClangMoveTool::run
void run(const ast_matchers::MatchFinder::MatchResult &Result) override
Definition: Move.cpp:662
clang::move::ClangMoveActionFactory::ClangMoveActionFactory
ClangMoveActionFactory(ClangMoveContext *const Context, DeclarationReporter *const Reporter=nullptr)
Definition: Move.h:223
clang::move::MoveDefinitionSpec::OldDependOnNew
bool OldDependOnNew
Definition: Move.h:75
clang::move::ClangMoveContext::DumpDeclarations
bool DumpDeclarations
Definition: Move.h:95
clang::move::MoveDefinitionSpec::NewDependOnOld
bool NewDependOnOld
Definition: Move.h:78
clang::move::ClangMoveTool::ClangMoveTool
ClangMoveTool(ClangMoveContext *const Context, DeclarationReporter *const Reporter)
Definition: Move.cpp:484
Decl
const FunctionDecl * Decl
Definition: AvoidBindCheck.cpp:100
clang::move::MoveDefinitionSpec::OldHeader
std::string OldHeader
Definition: Move.h:66
clang::move::DeclarationReporter::Declaration::Templated
bool Templated
Definition: Move.h:49
clang::move::DeclarationReporter
Definition: Move.h:29
clang::move::ClangMoveTool::onEndOfTranslationUnit
void onEndOfTranslationUnit() override
Definition: Move.cpp:878
clang::move::ClangMoveAction::CreateASTConsumer
std::unique_ptr< clang::ASTConsumer > CreateASTConsumer(clang::CompilerInstance &Compiler, llvm::StringRef InFile) override
Definition: Move.cpp:477
clang::move::MoveDefinitionSpec::OldCC
std::string OldCC
Definition: Move.h:68
clang::move::ClangMoveActionFactory
Definition: Move.h:221
clang::move::ClangMoveAction::ClangMoveAction
ClangMoveAction(ClangMoveContext *const Context, DeclarationReporter *const Reporter)
Definition: Move.h:204
FileName
StringRef FileName
Definition: KernelNameRestrictionCheck.cpp:46
clang::move::ClangMoveAction::~ClangMoveAction
~ClangMoveAction() override=default
clang::move::ClangMoveTool
Definition: Move.h:116
IsAngled
bool IsAngled
true if this was an include with angle brackets
Definition: IncludeOrderCheck.cpp:40
clang::move::DeclarationReporter::getDeclarationList
const std::vector< Declaration > getDeclarationList() const
Definition: Move.h:52
clang::move::MoveDefinitionSpec
Definition: Move.h:62
clang::move::ClangMoveAction
Definition: Move.h:202
clang::move::DeclarationReporter::~DeclarationReporter
~DeclarationReporter()=default
clang::move::MoveDefinitionSpec::NewHeader
std::string NewHeader
Definition: Move.h:70
clang::move::MoveDefinitionSpec::NewCC
std::string NewCC
Definition: Move.h:72
clang::move::ClangMoveContext::FileToReplacements
std::map< std::string, tooling::Replacements > & FileToReplacements
Definition: Move.h:85
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::move::ClangMoveContext::FallbackStyle
std::string FallbackStyle
Definition: Move.h:93
clang::move::MoveDefinitionSpec::Names
SmallVector< std::string, 4 > Names
Definition: Move.h:64
clang::move::ClangMoveContext::OriginalRunningDirectory
std::string OriginalRunningDirectory
Definition: Move.h:91
clang::move::ClangMoveActionFactory::create
std::unique_ptr< clang::FrontendAction > create() override
Definition: Move.h:227
clang::move::ClangMoveTool::addIncludes
void addIncludes(llvm::StringRef IncludeHeader, bool IsAngled, llvm::StringRef SearchPath, llvm::StringRef FileName, clang::CharSourceRange IncludeFilenameRange, const SourceManager &SM)
Add #includes from old.h/cc files.
Definition: Move.cpp:689
clang::move::HelperDeclRGBuilder
Definition: HelperDeclRefGraph.h:79
HelperDeclRefGraph.h
clang::move::DeclarationReporter::DeclarationReporter
DeclarationReporter()=default
clang::move::ClangMoveTool::getMovedDecls
std::vector< const NamedDecl * > & getMovedDecls()
Definition: Move.h:143
clang::move::DeclarationReporter::Declaration
Definition: Move.h:39
Path
std::vector< HeaderHandle > Path
Definition: PreprocessorTracker.cpp:525
clang::move::ClangMoveContext::Spec
MoveDefinitionSpec Spec
Definition: Move.h:83
clang::move::ClangMoveTool::addRemovedDecl
void addRemovedDecl(const NamedDecl *Decl)
Add declarations being removed from old.h/cc.
Definition: Move.cpp:491