| 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. |
| 29 |
class DeclarationReporter { |
| 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. |
| 62 |
struct MoveDefinitionSpec { |
| 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. |
| 82 |
struct ClangMoveContext { |
| 83 |
MoveDefinitionSpec Spec; |
| 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. |
| 91 |
std::string OriginalRunningDirectory; |
| 92 |
// The name of a predefined code style. |
| 93 |
std::string FallbackStyle; |
| 94 |
// Whether dump all declarations in old header. |
| 95 |
bool DumpDeclarations; |
| 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: |
| 204 |
ClangMoveAction(ClangMoveContext *const Context, |
| 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: |
| 223 |
ClangMoveActionFactory(ClangMoveContext *const Context, |
| 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 |