239 lines · c
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-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H10#define LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H11 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 25namespace clang {26namespace move {27 28// A reporter which collects and reports declarations in old header.29class DeclarationReporter {30public: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, Class49 bool Templated = false; // Whether the declaration is templated.50 };51 52 ArrayRef<Declaration> getDeclarationList() const { return DeclarationList; }53 54private:55 std::vector<Declaration> DeclarationList;56};57 58// Specify declarations being moved. It contains all information of the moved59// declarations.60struct MoveDefinitionSpec {61 // The list of fully qualified names, e.g. Foo, a::Foo, b::Foo.62 SmallVector<std::string, 4> Names;63 // The file path of old header, can be relative path and absolute path.64 std::string OldHeader;65 // The file path of old cc, can be relative path and absolute path.66 std::string OldCC;67 // The file path of new header, can be relative path and absolute path.68 std::string NewHeader;69 // The file path of new cc, can be relative path and absolute path.70 std::string NewCC;71 // Whether old.h depends on new.h. If true, #include "new.h" will be added72 // in old.h.73 bool OldDependOnNew = false;74 // Whether new.h depends on old.h. If true, #include "old.h" will be added75 // in new.h.76 bool NewDependOnOld = false;77};78 79// A Context which contains extra options which are used in ClangMoveTool.80struct ClangMoveContext {81 MoveDefinitionSpec Spec;82 // The Key is file path, value is the replacements being applied to the file.83 std::map<std::string, tooling::Replacements> &FileToReplacements;84 // The original working directory where the local clang-move binary runs.85 //86 // clang-move will change its current working directory to the build87 // directory when analyzing the source file. We save the original working88 // directory in order to get the absolute file path for the fields in Spec.89 std::string OriginalRunningDirectory;90 // The name of a predefined code style.91 std::string FallbackStyle;92 // Whether dump all declarations in old header.93 bool DumpDeclarations;94};95 96// This tool is used to move class/function definitions from the given source97// files (old.h/cc) to new files (new.h/cc).98// The goal of this tool is to make the new/old files as compilable as possible.99//100// When moving a symbol,all used helper declarations (e.g. static101// functions/variables definitions in global/named namespace,102// functions/variables/classes definitions in anonymous namespace) used by the103// moved symbol in old.cc are moved to the new.cc. In addition, all104// using-declarations in old.cc are also moved to new.cc; forward class105// declarations in old.h are also moved to new.h.106//107// The remaining helper declarations which are unused by non-moved symbols in108// old.cc will be removed.109//110// Note: When all declarations in old header are being moved, all code in111// old.h/cc will be moved, which means old.h/cc are empty. This ignores symbols112// that are not supported (e.g. typedef and enum) so that we always move old113// files to new files when all symbols produced from dump_decls are moved.114class ClangMoveTool : public ast_matchers::MatchFinder::MatchCallback {115public:116 ClangMoveTool(ClangMoveContext *const Context,117 DeclarationReporter *const Reporter);118 119 void registerMatchers(ast_matchers::MatchFinder *Finder);120 121 void run(const ast_matchers::MatchFinder::MatchResult &Result) override;122 123 void onEndOfTranslationUnit() override;124 125 /// Add #includes from old.h/cc files.126 ///127 /// \param IncludeHeader The name of the file being included, as written in128 /// the source code.129 /// \param IsAngled Whether the file name was enclosed in angle brackets.130 /// \param SearchPath The search path which was used to find the IncludeHeader131 /// in the file system. It can be a relative path or an absolute path.132 /// \param FileName The name of file where the IncludeHeader comes from.133 /// \param IncludeFilenameRange The source range for the written file name in134 /// #include (i.e. "old.h" for #include "old.h") in old.cc.135 /// \param SM The SourceManager.136 void addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,137 llvm::StringRef SearchPath, llvm::StringRef FileName,138 clang::CharSourceRange IncludeFilenameRange,139 const SourceManager &SM);140 141 std::vector<const NamedDecl *> &getMovedDecls() { return MovedDecls; }142 143 /// Add declarations being removed from old.h/cc. For each declarations, the144 /// method also records the mapping relationship between the corresponding145 /// FilePath and its FileID.146 void addRemovedDecl(const NamedDecl *Decl);147 148 llvm::SmallPtrSet<const NamedDecl *, 8> &getUnremovedDeclsInOldHeader() {149 return UnremovedDeclsInOldHeader;150 }151 152private:153 // Make the Path absolute using the OrignalRunningDirectory if the Path is not154 // an absolute path. An empty Path will result in an empty string.155 std::string makeAbsolutePath(StringRef Path);156 157 void removeDeclsInOldFiles();158 void moveDeclsToNewFiles();159 void moveAll(SourceManager& SM, StringRef OldFile, StringRef NewFile);160 161 // Stores all MatchCallbacks created by this tool.162 std::vector<std::unique_ptr<ast_matchers::MatchFinder::MatchCallback>>163 MatchCallbacks;164 // Store all potential declarations (decls being moved, forward decls) that165 // might need to move to new.h/cc. It includes all helper declarations166 // (include unused ones) by default. The unused ones will be filtered out in167 // the last stage. Saving in an AST-visited order.168 std::vector<const NamedDecl *> MovedDecls;169 // The declarations that needs to be removed in old.cc/h.170 std::vector<const NamedDecl *> RemovedDecls;171 // The #includes in old_header.h.172 std::vector<std::string> HeaderIncludes;173 // The #includes in old_cc.cc.174 std::vector<std::string> CCIncludes;175 // Records all helper declarations (function/variable/class definitions in176 // anonymous namespaces, static function/variable definitions in global/named177 // namespaces) in old.cc. saving in an AST-visited order.178 std::vector<const NamedDecl *> HelperDeclarations;179 // The unmoved named declarations in old header.180 llvm::SmallPtrSet<const NamedDecl*, 8> UnremovedDeclsInOldHeader;181 /// The source range for the written file name in #include (i.e. "old.h" for182 /// #include "old.h") in old.cc, including the enclosing quotes or angle183 /// brackets.184 clang::CharSourceRange OldHeaderIncludeRangeInCC;185 /// The source range for the written file name in #include (i.e. "old.h" for186 /// #include "old.h") in old.h, including the enclosing quotes or angle187 /// brackets.188 clang::CharSourceRange OldHeaderIncludeRangeInHeader;189 /// Mapping from FilePath to FileID, which can be used in post processes like190 /// cleanup around replacements.191 llvm::StringMap<FileID> FilePathToFileID;192 /// A context contains all running options. It is not owned.193 ClangMoveContext *const Context;194 /// A reporter to report all declarations from old header. It is not owned.195 DeclarationReporter *const Reporter;196 /// Builder for helper declarations reference graph.197 HelperDeclRGBuilder RGBuilder;198};199 200class ClangMoveAction : public clang::ASTFrontendAction {201public:202 ClangMoveAction(ClangMoveContext *const Context,203 DeclarationReporter *const Reporter)204 : MoveTool(Context, Reporter) {205 MoveTool.registerMatchers(&MatchFinder);206 }207 208 ~ClangMoveAction() override = default;209 210 std::unique_ptr<clang::ASTConsumer>211 CreateASTConsumer(clang::CompilerInstance &Compiler,212 llvm::StringRef InFile) override;213 214private:215 ast_matchers::MatchFinder MatchFinder;216 ClangMoveTool MoveTool;217};218 219class ClangMoveActionFactory : public tooling::FrontendActionFactory {220public:221 ClangMoveActionFactory(ClangMoveContext *const Context,222 DeclarationReporter *const Reporter = nullptr)223 : Context(Context), Reporter(Reporter) {}224 225 std::unique_ptr<clang::FrontendAction> create() override {226 return std::make_unique<ClangMoveAction>(Context, Reporter);227 }228 229private:230 // Not owned.231 ClangMoveContext *const Context;232 DeclarationReporter *const Reporter;233};234 235} // namespace move236} // namespace clang237 238#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H239