clang-tools-extra/clang-move/Move.cpp

   1 //===-- Move.cpp - Implement ClangMove functationalities --------*- 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 #include "Move.h"
  10 #include "HelperDeclRefGraph.h"
  11 #include "clang/ASTMatchers/ASTMatchers.h"
  12 #include "clang/Basic/SourceManager.h"
  13 #include "clang/Format/Format.h"
  14 #include "clang/Frontend/CompilerInstance.h"
  15 #include "clang/Lex/Lexer.h"
  16 #include "clang/Lex/Preprocessor.h"
  17 #include "clang/Rewrite/Core/Rewriter.h"
  18 #include "clang/Tooling/Core/Replacement.h"
  19 #include "llvm/Support/Debug.h"
  20 #include "llvm/Support/Path.h"
  21
  22 #define DEBUG_TYPE "clang-move"
  23
  24 using namespace clang::ast_matchers;
  25
  26 namespace clang {
  27 namespace move {
  28 namespace {
  29
  30 // FIXME: Move to ASTMatchers.
  31 AST_MATCHER(VarDecl, isStaticDataMember) { return Node.isStaticDataMember(); }
  32
  33 AST_MATCHER(NamedDecl, notInMacro) { return !Node.getLocation().isMacroID(); }
  34
  35 AST_MATCHER_P(Decl, hasOutermostEnclosingClass,
  36               ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
  37   const auto *Context = Node.getDeclContext();
  38   if (!Context)
  39     return false;
  40   while (const auto *NextContext = Context->getParent()) {
  41     if (isa<NamespaceDecl>(NextContext) ||
  42         isa<TranslationUnitDecl>(NextContext))
  43       break;
  44     Context = NextContext;
  45   }
  46   return InnerMatcher.matches(*Decl::castFromDeclContext(Context), Finder,
  47                               Builder);
  48 }
  49
  50 AST_MATCHER_P(CXXMethodDecl, ofOutermostEnclosingClass,
  51               ast_matchers::internal::Matcher<CXXRecordDecl>, InnerMatcher) {
  52   const CXXRecordDecl *Parent = Node.getParent();
  53   if (!Parent)
  54     return false;
  55   while (const auto *NextParent =
  56              dyn_cast<CXXRecordDecl>(Parent->getParent())) {
  57     Parent = NextParent;
  58   }
  59
  60   return InnerMatcher.matches(*Parent, Finder, Builder);
  61 }
  62
  63 std::string CleanPath(StringRef PathRef) {
  64   llvm::SmallString<128> Path(PathRef);
  65   llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
  66   // FIXME: figure out why this is necessary.
  67   llvm::sys::path::native(Path);
  68   return std::string(Path);
  69 }
  70
  71 // Make the Path absolute using the CurrentDir if the Path is not an absolute
  72 // path. An empty Path will result in an empty string.
  73 std::string MakeAbsolutePath(StringRef CurrentDir, StringRef Path) {
  74   if (Path.empty())
  75     return "";
  76   llvm::SmallString<128> InitialDirectory(CurrentDir);
  77   llvm::SmallString<128> AbsolutePath(Path);
  78   llvm::sys::fs::make_absolute(InitialDirectory, AbsolutePath);
  79   return CleanPath(std::move(AbsolutePath));
  80 }
  81
  82 // Make the Path absolute using the current working directory of the given
  83 // SourceManager if the Path is not an absolute path.
  84 //
  85 // The Path can be a path relative to the build directory, or retrieved from
  86 // the SourceManager.
  87 std::string MakeAbsolutePath(const SourceManager &SM, StringRef Path) {
  88   llvm::SmallString<128> AbsolutePath(Path);
  89   if (std::error_code EC =
  90           SM.getFileManager().getVirtualFileSystem().makeAbsolute(AbsolutePath))
  91     llvm::errs() << "Warning: could not make absolute file: '" << EC.message()
  92                  << '\n';
  93   // Handle symbolic link path cases.
  94   // We are trying to get the real file path of the symlink.
  95   auto Dir = SM.getFileManager().getOptionalDirectoryRef(
  96       llvm::sys::path::parent_path(AbsolutePath.str()));
  97   if (Dir) {
  98     StringRef DirName = SM.getFileManager().getCanonicalName(*Dir);
  99     // FIXME: getCanonicalName might fail to get real path on VFS.
 100     if (llvm::sys::path::is_absolute(DirName)) {
 101       SmallString<128> AbsoluteFilename;
 102       llvm::sys::path::append(AbsoluteFilename, DirName,
 103                               llvm::sys::path::filename(AbsolutePath.str()));
 104       return CleanPath(AbsoluteFilename);
 105     }
 106   }
 107   return CleanPath(AbsolutePath);
 108 }
 109
 110 // Matches AST nodes that are expanded within the given AbsoluteFilePath.
 111 AST_POLYMORPHIC_MATCHER_P(isExpansionInFile,
 112                           AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc),
 113                           std::string, AbsoluteFilePath) {
 114   auto &SourceManager = Finder->getASTContext().getSourceManager();
 115   auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc());
 116   if (ExpansionLoc.isInvalid())
 117     return false;
 118   auto FileEntry =
 119       SourceManager.getFileEntryRefForID(SourceManager.getFileID(ExpansionLoc));
 120   if (!FileEntry)
 121     return false;
 122   return MakeAbsolutePath(SourceManager, FileEntry->getName()) ==
 123          AbsoluteFilePath;
 124 }
 125
 126 class FindAllIncludes : public PPCallbacks {
 127 public:
 128   explicit FindAllIncludes(SourceManager *SM, ClangMoveTool *const MoveTool)
 129       : SM(*SM), MoveTool(MoveTool) {}
 130
 131   void InclusionDirective(SourceLocation HashLoc, const Token & /*IncludeTok*/,
 132                           StringRef FileName, bool IsAngled,
 133                           CharSourceRange FilenameRange,
 134                           OptionalFileEntryRef /*File*/, StringRef SearchPath,
 135                           StringRef /*RelativePath*/,
 136                           const Module * /*SuggestedModule*/,
 137                           bool /*ModuleImported*/,
 138                           SrcMgr::CharacteristicKind /*FileType*/) override {
 139     if (auto FileEntry = SM.getFileEntryRefForID(SM.getFileID(HashLoc)))
 140       MoveTool->addIncludes(FileName, IsAngled, SearchPath,
 141                             FileEntry->getName(), FilenameRange, SM);
 142   }
 143
 144 private:
 145   const SourceManager &SM;
 146   ClangMoveTool *const MoveTool;
 147 };
 148
 149 /// Add a declaration being moved to new.h/cc. Note that the declaration will
 150 /// also be deleted in old.h/cc.
 151 void MoveDeclFromOldFileToNewFile(ClangMoveTool *MoveTool, const NamedDecl *D) {
 152   MoveTool->getMovedDecls().push_back(D);
 153   MoveTool->addRemovedDecl(D);
 154   MoveTool->getUnremovedDeclsInOldHeader().erase(D);
 155 }
 156
 157 class FunctionDeclarationMatch : public MatchFinder::MatchCallback {
 158 public:
 159   explicit FunctionDeclarationMatch(ClangMoveTool *MoveTool)
 160       : MoveTool(MoveTool) {}
 161
 162   void run(const MatchFinder::MatchResult &Result) override {
 163     const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("function");
 164     assert(FD);
 165     const NamedDecl *D = FD;
 166     if (const auto *FTD = FD->getDescribedFunctionTemplate())
 167       D = FTD;
 168     MoveDeclFromOldFileToNewFile(MoveTool, D);
 169   }
 170
 171 private:
 172   ClangMoveTool *MoveTool;
 173 };
 174
 175 class VarDeclarationMatch : public MatchFinder::MatchCallback {
 176 public:
 177   explicit VarDeclarationMatch(ClangMoveTool *MoveTool)
 178       : MoveTool(MoveTool) {}
 179
 180   void run(const MatchFinder::MatchResult &Result) override {
 181     const auto *VD = Result.Nodes.getNodeAs<VarDecl>("var");
 182     assert(VD);
 183     MoveDeclFromOldFileToNewFile(MoveTool, VD);
 184   }
 185
 186 private:
 187   ClangMoveTool *MoveTool;
 188 };
 189
 190 class TypeAliasMatch : public MatchFinder::MatchCallback {
 191 public:
 192   explicit TypeAliasMatch(ClangMoveTool *MoveTool)
 193       : MoveTool(MoveTool) {}
 194
 195   void run(const MatchFinder::MatchResult &Result) override {
 196     if (const auto *TD = Result.Nodes.getNodeAs<TypedefDecl>("typedef"))
 197       MoveDeclFromOldFileToNewFile(MoveTool, TD);
 198     else if (const auto *TAD =
 199                  Result.Nodes.getNodeAs<TypeAliasDecl>("type_alias")) {
 200       const NamedDecl * D = TAD;
 201       if (const auto * TD = TAD->getDescribedAliasTemplate())
 202         D = TD;
 203       MoveDeclFromOldFileToNewFile(MoveTool, D);
 204     }
 205   }
 206
 207 private:
 208   ClangMoveTool *MoveTool;
 209 };
 210
 211 class EnumDeclarationMatch : public MatchFinder::MatchCallback {
 212 public:
 213   explicit EnumDeclarationMatch(ClangMoveTool *MoveTool)
 214       : MoveTool(MoveTool) {}
 215
 216   void run(const MatchFinder::MatchResult &Result) override {
 217     const auto *ED = Result.Nodes.getNodeAs<EnumDecl>("enum");
 218     assert(ED);
 219     MoveDeclFromOldFileToNewFile(MoveTool, ED);
 220   }
 221
 222 private:
 223   ClangMoveTool *MoveTool;
 224 };
 225
 226 class ClassDeclarationMatch : public MatchFinder::MatchCallback {
 227 public:
 228   explicit ClassDeclarationMatch(ClangMoveTool *MoveTool)
 229       : MoveTool(MoveTool) {}
 230   void run(const MatchFinder::MatchResult &Result) override {
 231     SourceManager *SM = &Result.Context->getSourceManager();
 232     if (const auto *CMD = Result.Nodes.getNodeAs<CXXMethodDecl>("class_method"))
 233       MatchClassMethod(CMD, SM);
 234     else if (const auto *VD =
 235                  Result.Nodes.getNodeAs<VarDecl>("class_static_var_decl"))
 236       MatchClassStaticVariable(VD, SM);
 237     else if (const auto *CD =
 238                  Result.Nodes.getNodeAs<CXXRecordDecl>("moved_class"))
 239       MatchClassDeclaration(CD, SM);
 240   }
 241
 242 private:
 243   void MatchClassMethod(const CXXMethodDecl *CMD, SourceManager *SM) {
 244     // Skip inline class methods. isInline() ast matcher doesn't ignore this
 245     // case.
 246     if (!CMD->isInlined()) {
 247       MoveTool->getMovedDecls().push_back(CMD);
 248       MoveTool->addRemovedDecl(CMD);
 249       // Get template class method from its method declaration as
 250       // UnremovedDecls stores template class method.
 251       if (const auto *FTD = CMD->getDescribedFunctionTemplate())
 252         MoveTool->getUnremovedDeclsInOldHeader().erase(FTD);
 253       else
 254         MoveTool->getUnremovedDeclsInOldHeader().erase(CMD);
 255     }
 256   }
 257
 258   void MatchClassStaticVariable(const NamedDecl *VD, SourceManager *SM) {
 259     MoveDeclFromOldFileToNewFile(MoveTool, VD);
 260   }
 261
 262   void MatchClassDeclaration(const CXXRecordDecl *CD, SourceManager *SM) {
 263     // Get class template from its class declaration as UnremovedDecls stores
 264     // class template.
 265     if (const auto *TC = CD->getDescribedClassTemplate())
 266       MoveTool->getMovedDecls().push_back(TC);
 267     else
 268       MoveTool->getMovedDecls().push_back(CD);
 269     MoveTool->addRemovedDecl(MoveTool->getMovedDecls().back());
 270     MoveTool->getUnremovedDeclsInOldHeader().erase(
 271         MoveTool->getMovedDecls().back());
 272   }
 273
 274   ClangMoveTool *MoveTool;
 275 };
 276
 277 // Expand to get the end location of the line where the EndLoc of the given
 278 // Decl.
 279 SourceLocation getLocForEndOfDecl(const Decl *D,
 280                                   const LangOptions &LangOpts = LangOptions()) {
 281   const auto &SM = D->getASTContext().getSourceManager();
 282   // If the expansion range is a character range, this is the location of
 283   // the first character past the end. Otherwise it's the location of the
 284   // first character in the final token in the range.
 285   auto EndExpansionLoc = SM.getExpansionRange(D->getEndLoc()).getEnd();
 286   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(EndExpansionLoc);
 287   // Try to load the file buffer.
 288   bool InvalidTemp = false;
 289   llvm::StringRef File = SM.getBufferData(LocInfo.first, &InvalidTemp);
 290   if (InvalidTemp)
 291     return SourceLocation();
 292
 293   const char *TokBegin = File.data() + LocInfo.second;
 294   // Lex from the start of the given location.
 295   Lexer Lex(SM.getLocForStartOfFile(LocInfo.first), LangOpts, File.begin(),
 296             TokBegin, File.end());
 297
 298   llvm::SmallVector<char, 16> Line;
 299   // FIXME: this is a bit hacky to get ReadToEndOfLine work.
 300   Lex.setParsingPreprocessorDirective(true);
 301   Lex.ReadToEndOfLine(&Line);
 302   SourceLocation EndLoc = EndExpansionLoc.getLocWithOffset(Line.size());
 303   // If we already reach EOF, just return the EOF SourceLocation;
 304   // otherwise, move 1 offset ahead to include the trailing newline character
 305   // '\n'.
 306   return SM.getLocForEndOfFile(LocInfo.first) == EndLoc
 307              ? EndLoc
 308              : EndLoc.getLocWithOffset(1);
 309 }
 310
 311 // Get full range of a Decl including the comments associated with it.
 312 CharSourceRange getFullRange(const Decl *D,
 313                              const LangOptions &options = LangOptions()) {
 314   const auto &SM = D->getASTContext().getSourceManager();
 315   SourceRange Full(SM.getExpansionLoc(D->getBeginLoc()), getLocForEndOfDecl(D));
 316   // Expand to comments that are associated with the Decl.
 317   if (const auto *Comment = D->getASTContext().getRawCommentForDeclNoCache(D)) {
 318     if (SM.isBeforeInTranslationUnit(Full.getEnd(), Comment->getEndLoc()))
 319       Full.setEnd(Comment->getEndLoc());
 320     // FIXME: Don't delete a preceding comment, if there are no other entities
 321     // it could refer to.
 322     if (SM.isBeforeInTranslationUnit(Comment->getBeginLoc(), Full.getBegin()))
 323       Full.setBegin(Comment->getBeginLoc());
 324   }
 325
 326   return CharSourceRange::getCharRange(Full);
 327 }
 328
 329 std::string getDeclarationSourceText(const Decl *D) {
 330   const auto &SM = D->getASTContext().getSourceManager();
 331   llvm::StringRef SourceText =
 332       Lexer::getSourceText(getFullRange(D), SM, LangOptions());
 333   return SourceText.str();
 334 }
 335
 336 bool isInHeaderFile(const Decl *D, llvm::StringRef OriginalRunningDirectory,
 337                     llvm::StringRef OldHeader) {
 338   const auto &SM = D->getASTContext().getSourceManager();
 339   if (OldHeader.empty())
 340     return false;
 341   auto ExpansionLoc = SM.getExpansionLoc(D->getBeginLoc());
 342   if (ExpansionLoc.isInvalid())
 343     return false;
 344
 345   if (auto FE = SM.getFileEntryRefForID(SM.getFileID(ExpansionLoc))) {
 346     return MakeAbsolutePath(SM, FE->getName()) ==
 347            MakeAbsolutePath(OriginalRunningDirectory, OldHeader);
 348   }
 349
 350   return false;
 351 }
 352
 353 std::vector<std::string> getNamespaces(const Decl *D) {
 354   std::vector<std::string> Namespaces;
 355   for (const auto *Context = D->getDeclContext(); Context;
 356        Context = Context->getParent()) {
 357     if (llvm::isa<TranslationUnitDecl>(Context) ||
 358         llvm::isa<LinkageSpecDecl>(Context))
 359       break;
 360
 361     if (const auto *ND = llvm::dyn_cast<NamespaceDecl>(Context))
 362       Namespaces.push_back(ND->getName().str());
 363   }
 364   std::reverse(Namespaces.begin(), Namespaces.end());
 365   return Namespaces;
 366 }
 367
 368 tooling::Replacements
 369 createInsertedReplacements(const std::vector<std::string> &Includes,
 370                            const std::vector<const NamedDecl *> &Decls,
 371                            llvm::StringRef FileName, bool IsHeader = false,
 372                            StringRef OldHeaderInclude = "") {
 373   std::string NewCode;
 374   std::string GuardName(FileName);
 375   if (IsHeader) {
 376     for (size_t i = 0; i < GuardName.size(); ++i) {
 377       if (!isAlphanumeric(GuardName[i]))
 378         GuardName[i] = '_';
 379     }
 380     GuardName = StringRef(GuardName).upper();
 381     NewCode += "#ifndef " + GuardName + "\n";
 382     NewCode += "#define " + GuardName + "\n\n";
 383   }
 384
 385   NewCode += OldHeaderInclude;
 386   // Add #Includes.
 387   for (const auto &Include : Includes)
 388     NewCode += Include;
 389
 390   if (!Includes.empty())
 391     NewCode += "\n";
 392
 393   // Add moved class definition and its related declarations. All declarations
 394   // in same namespace are grouped together.
 395   //
 396   // Record namespaces where the current position is in.
 397   std::vector<std::string> CurrentNamespaces;
 398   for (const auto *MovedDecl : Decls) {
 399     // The namespaces of the declaration being moved.
 400     std::vector<std::string> DeclNamespaces = getNamespaces(MovedDecl);
 401     auto CurrentIt = CurrentNamespaces.begin();
 402     auto DeclIt = DeclNamespaces.begin();
 403     // Skip the common prefix.
 404     while (CurrentIt != CurrentNamespaces.end() &&
 405            DeclIt != DeclNamespaces.end()) {
 406       if (*CurrentIt != *DeclIt)
 407         break;
 408       ++CurrentIt;
 409       ++DeclIt;
 410     }
 411     // Calculate the new namespaces after adding MovedDecl in CurrentNamespace,
 412     // which is used for next iteration of this loop.
 413     std::vector<std::string> NextNamespaces(CurrentNamespaces.begin(),
 414                                             CurrentIt);
 415     NextNamespaces.insert(NextNamespaces.end(), DeclIt, DeclNamespaces.end());
 416
 417
 418     // End with CurrentNamespace.
 419     bool HasEndCurrentNamespace = false;
 420     auto RemainingSize = CurrentNamespaces.end() - CurrentIt;
 421     for (auto It = CurrentNamespaces.rbegin(); RemainingSize > 0;
 422          --RemainingSize, ++It) {
 423       assert(It < CurrentNamespaces.rend());
 424       NewCode += "} // namespace " + *It + "\n";
 425       HasEndCurrentNamespace = true;
 426     }
 427     // Add trailing '\n' after the nested namespace definition.
 428     if (HasEndCurrentNamespace)
 429       NewCode += "\n";
 430
 431     // If the moved declaration is not in CurrentNamespace, add extra namespace
 432     // definitions.
 433     bool IsInNewNamespace = false;
 434     while (DeclIt != DeclNamespaces.end()) {
 435       NewCode += "namespace " + *DeclIt + " {\n";
 436       IsInNewNamespace = true;
 437       ++DeclIt;
 438     }
 439     // If the moved declaration is in same namespace CurrentNamespace, add
 440     // a preceeding `\n' before the moved declaration.
 441     // FIXME: Don't add empty lines between using declarations.
 442     if (!IsInNewNamespace)
 443       NewCode += "\n";
 444     NewCode += getDeclarationSourceText(MovedDecl);
 445     CurrentNamespaces = std::move(NextNamespaces);
 446   }
 447   std::reverse(CurrentNamespaces.begin(), CurrentNamespaces.end());
 448   for (const auto &NS : CurrentNamespaces)
 449     NewCode += "} // namespace " + NS + "\n";
 450
 451   if (IsHeader)
 452     NewCode += "\n#endif // " + GuardName + "\n";
 453   return tooling::Replacements(tooling::Replacement(FileName, 0, 0, NewCode));
 454 }
 455
 456 // Return a set of all decls which are used/referenced by the given Decls.
 457 // Specifically, given a class member declaration, this method will return all
 458 // decls which are used by the whole class.
 459 llvm::DenseSet<const Decl *>
 460 getUsedDecls(const HelperDeclRefGraph *RG,
 461              const std::vector<const NamedDecl *> &Decls) {
 462   assert(RG);
 463   llvm::DenseSet<const CallGraphNode *> Nodes;
 464   for (const auto *D : Decls) {
 465     auto Result = RG->getReachableNodes(
 466         HelperDeclRGBuilder::getOutmostClassOrFunDecl(D));
 467     Nodes.insert(Result.begin(), Result.end());
 468   }
 469   llvm::DenseSet<const Decl *> Results;
 470   for (const auto *Node : Nodes)
 471     Results.insert(Node->getDecl());
 472   return Results;
 473 }
 474
 475 } // namespace
 476
 477 std::unique_ptr<ASTConsumer>
 478 ClangMoveAction::CreateASTConsumer(CompilerInstance &Compiler,
 479                                    StringRef /*InFile*/) {
 480   Compiler.getPreprocessor().addPPCallbacks(std::make_unique<FindAllIncludes>(
 481       &Compiler.getSourceManager(), &MoveTool));
 482   return MatchFinder.newASTConsumer();
 483 }
 484
 485 ClangMoveTool::ClangMoveTool(ClangMoveContext *const Context,
 486                              DeclarationReporter *const Reporter)
 487     : Context(Context), Reporter(Reporter) {
 488   if (!Context->Spec.NewHeader.empty())
 489     CCIncludes.push_back("#include \"" + Context->Spec.NewHeader + "\"\n");
 490 }
 491
 492 void ClangMoveTool::addRemovedDecl(const NamedDecl *Decl) {
 493   const auto &SM = Decl->getASTContext().getSourceManager();
 494   auto Loc = Decl->getLocation();
 495   StringRef FilePath = SM.getFilename(Loc);
 496   FilePathToFileID[FilePath] = SM.getFileID(Loc);
 497   RemovedDecls.push_back(Decl);
 498 }
 499
 500 void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
 501   auto InOldHeader =
 502       isExpansionInFile(makeAbsolutePath(Context->Spec.OldHeader));
 503   auto InOldCC = isExpansionInFile(makeAbsolutePath(Context->Spec.OldCC));
 504   auto InOldFiles = anyOf(InOldHeader, InOldCC);
 505   auto classTemplateForwardDecls =
 506       classTemplateDecl(unless(has(cxxRecordDecl(isDefinition()))));
 507   auto ForwardClassDecls = namedDecl(
 508       anyOf(cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition()))),
 509             classTemplateForwardDecls));
 510   auto TopLevelDecl =
 511       hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl()));
 512
 513   //============================================================================
 514   // Matchers for old header
 515   //============================================================================
 516   // Match all top-level named declarations (e.g. function, variable, enum) in
 517   // old header, exclude forward class declarations and namespace declarations.
 518   //
 519   // We consider declarations inside a class belongs to the class. So these
 520   // declarations will be ignored.
 521   auto AllDeclsInHeader = namedDecl(
 522       unless(ForwardClassDecls), unless(namespaceDecl()),
 523       unless(usingDirectiveDecl()), // using namespace decl.
 524       notInMacro(),
 525       InOldHeader,
 526       hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))),
 527       hasDeclContext(decl(anyOf(namespaceDecl(), translationUnitDecl()))));
 528   Finder->addMatcher(AllDeclsInHeader.bind("decls_in_header"), this);
 529
 530   // Don't register other matchers when dumping all declarations in header.
 531   if (Context->DumpDeclarations)
 532     return;
 533
 534   // Match forward declarations in old header.
 535   Finder->addMatcher(namedDecl(ForwardClassDecls, InOldHeader).bind("fwd_decl"),
 536                      this);
 537
 538   //============================================================================
 539   // Matchers for old cc
 540   //============================================================================
 541   auto IsOldCCTopLevelDecl = allOf(
 542       hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))), InOldCC);
 543   // Matching using decls/type alias decls which are in named/anonymous/global
 544   // namespace, these decls are always copied to new.h/cc. Those in classes,
 545   // functions are covered in other matchers.
 546   Finder->addMatcher(namedDecl(anyOf(usingDecl(IsOldCCTopLevelDecl),
 547                                      usingDirectiveDecl(unless(isImplicit()),
 548                                                         IsOldCCTopLevelDecl),
 549                                      typeAliasDecl(IsOldCCTopLevelDecl)),
 550                                notInMacro())
 551                          .bind("using_decl"),
 552                      this);
 553
 554   // Match static functions/variable definitions which are defined in named
 555   // namespaces.
 556   SmallVector<std::string, 4> QualNames;
 557   QualNames.reserve(Context->Spec.Names.size());
 558   for (StringRef SymbolName : Context->Spec.Names) {
 559     QualNames.push_back(("::" + SymbolName.trim().ltrim(':')).str());
 560   }
 561
 562   if (QualNames.empty()) {
 563     llvm::errs() << "No symbols being moved.\n";
 564     return;
 565   }
 566
 567   ast_matchers::internal::Matcher<NamedDecl> HasAnySymbolNames =
 568       hasAnyName(SmallVector<StringRef, 4>(QualNames.begin(), QualNames.end()));
 569
 570   auto InMovedClass =
 571       hasOutermostEnclosingClass(cxxRecordDecl(HasAnySymbolNames));
 572
 573   // Matchers for helper declarations in old.cc.
 574   auto InAnonymousNS = hasParent(namespaceDecl(isAnonymous()));
 575   auto NotInMovedClass= allOf(unless(InMovedClass), InOldCC);
 576   auto IsOldCCHelper =
 577       allOf(NotInMovedClass, anyOf(isStaticStorageClass(), InAnonymousNS));
 578   // Match helper classes separately with helper functions/variables since we
 579   // want to reuse these matchers in finding helpers usage below.
 580   //
 581   // There could be forward declarations usage for helpers, especially for
 582   // classes and functions. We need include these forward declarations.
 583   //
 584   // Forward declarations for variable helpers will be excluded as these
 585   // declarations (with "extern") are not supposed in cpp file.
 586    auto HelperFuncOrVar =
 587       namedDecl(notInMacro(), anyOf(functionDecl(IsOldCCHelper),
 588                                     varDecl(isDefinition(), IsOldCCHelper)));
 589   auto HelperClasses =
 590       cxxRecordDecl(notInMacro(), NotInMovedClass, InAnonymousNS);
 591   // Save all helper declarations in old.cc.
 592   Finder->addMatcher(
 593       namedDecl(anyOf(HelperFuncOrVar, HelperClasses)).bind("helper_decls"),
 594       this);
 595
 596   // Construct an AST-based call graph of helper declarations in old.cc.
 597   // In the following matcheres, "dc" is a caller while "helper_decls" and
 598   // "used_class" is a callee, so a new edge starting from caller to callee will
 599   // be add in the graph.
 600   //
 601   // Find helper function/variable usages.
 602   Finder->addMatcher(
 603       declRefExpr(to(HelperFuncOrVar), hasAncestor(decl().bind("dc")))
 604           .bind("func_ref"),
 605       &RGBuilder);
 606   // Find helper class usages.
 607   Finder->addMatcher(
 608       typeLoc(loc(recordType(hasDeclaration(HelperClasses.bind("used_class")))),
 609               hasAncestor(decl().bind("dc"))),
 610       &RGBuilder);
 611
 612   //============================================================================
 613   // Matchers for old files, including old.h/old.cc
 614   //============================================================================
 615   // Create a MatchCallback for class declarations.
 616   MatchCallbacks.push_back(std::make_unique<ClassDeclarationMatch>(this));
 617   // Match moved class declarations.
 618   auto MovedClass =
 619       cxxRecordDecl(InOldFiles, HasAnySymbolNames, isDefinition(), TopLevelDecl)
 620           .bind("moved_class");
 621   Finder->addMatcher(MovedClass, MatchCallbacks.back().get());
 622   // Match moved class methods (static methods included) which are defined
 623   // outside moved class declaration.
 624   Finder->addMatcher(cxxMethodDecl(InOldFiles,
 625                                    ofOutermostEnclosingClass(HasAnySymbolNames),
 626                                    isDefinition())
 627                          .bind("class_method"),
 628                      MatchCallbacks.back().get());
 629   // Match static member variable definition of the moved class.
 630   Finder->addMatcher(
 631       varDecl(InMovedClass, InOldFiles, isDefinition(), isStaticDataMember())
 632           .bind("class_static_var_decl"),
 633       MatchCallbacks.back().get());
 634
 635   MatchCallbacks.push_back(std::make_unique<FunctionDeclarationMatch>(this));
 636   Finder->addMatcher(functionDecl(InOldFiles, HasAnySymbolNames, TopLevelDecl)
 637                          .bind("function"),
 638                      MatchCallbacks.back().get());
 639
 640   MatchCallbacks.push_back(std::make_unique<VarDeclarationMatch>(this));
 641   Finder->addMatcher(
 642       varDecl(InOldFiles, HasAnySymbolNames, TopLevelDecl).bind("var"),
 643       MatchCallbacks.back().get());
 644
 645   // Match enum definition in old.h. Enum helpers (which are defined in old.cc)
 646   // will not be moved for now no matter whether they are used or not.
 647   MatchCallbacks.push_back(std::make_unique<EnumDeclarationMatch>(this));
 648   Finder->addMatcher(
 649       enumDecl(InOldHeader, HasAnySymbolNames, isDefinition(), TopLevelDecl)
 650           .bind("enum"),
 651       MatchCallbacks.back().get());
 652
 653   // Match type alias in old.h, this includes "typedef" and "using" type alias
 654   // declarations. Type alias helpers (which are defined in old.cc) will not be
 655   // moved for now no matter whether they are used or not.
 656   MatchCallbacks.push_back(std::make_unique<TypeAliasMatch>(this));
 657   Finder->addMatcher(namedDecl(anyOf(typedefDecl().bind("typedef"),
 658                                      typeAliasDecl().bind("type_alias")),
 659                                InOldHeader, HasAnySymbolNames, TopLevelDecl),
 660                      MatchCallbacks.back().get());
 661 }
 662
 663 void ClangMoveTool::run(const ast_matchers::MatchFinder::MatchResult &Result) {
 664   if (const auto *D = Result.Nodes.getNodeAs<NamedDecl>("decls_in_header")) {
 665     UnremovedDeclsInOldHeader.insert(D);
 666   } else if (const auto *FWD =
 667                  Result.Nodes.getNodeAs<CXXRecordDecl>("fwd_decl")) {
 668     // Skip all forward declarations which appear after moved class declaration.
 669     if (RemovedDecls.empty()) {
 670       if (const auto *DCT = FWD->getDescribedClassTemplate())
 671         MovedDecls.push_back(DCT);
 672       else
 673         MovedDecls.push_back(FWD);
 674     }
 675   } else if (const auto *ND =
 676                  Result.Nodes.getNodeAs<NamedDecl>("helper_decls")) {
 677     MovedDecls.push_back(ND);
 678     HelperDeclarations.push_back(ND);
 679     LLVM_DEBUG(llvm::dbgs()
 680                << "Add helper : " << ND->getDeclName() << " (" << ND << ")\n");
 681   } else if (const auto *UD = Result.Nodes.getNodeAs<NamedDecl>("using_decl")) {
 682     MovedDecls.push_back(UD);
 683   }
 684 }
 685
 686 std::string ClangMoveTool::makeAbsolutePath(StringRef Path) {
 687   return MakeAbsolutePath(Context->OriginalRunningDirectory, Path);
 688 }
 689
 690 void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
 691                                 llvm::StringRef SearchPath,
 692                                 llvm::StringRef FileName,
 693                                 CharSourceRange IncludeFilenameRange,
 694                                 const SourceManager &SM) {
 695   SmallString<128> HeaderWithSearchPath;
 696   llvm::sys::path::append(HeaderWithSearchPath, SearchPath, IncludeHeader);
 697   std::string AbsoluteIncludeHeader =
 698       MakeAbsolutePath(SM, HeaderWithSearchPath);
 699   std::string IncludeLine =
 700       IsAngled ? ("#include <" + IncludeHeader + ">\n").str()
 701                : ("#include \"" + IncludeHeader + "\"\n").str();
 702
 703   std::string AbsoluteOldHeader = makeAbsolutePath(Context->Spec.OldHeader);
 704   std::string AbsoluteCurrentFile = MakeAbsolutePath(SM, FileName);
 705   if (AbsoluteOldHeader == AbsoluteCurrentFile) {
 706     // Find old.h includes "old.h".
 707     if (AbsoluteOldHeader == AbsoluteIncludeHeader) {
 708       OldHeaderIncludeRangeInHeader = IncludeFilenameRange;
 709       return;
 710     }
 711     HeaderIncludes.push_back(IncludeLine);
 712   } else if (makeAbsolutePath(Context->Spec.OldCC) == AbsoluteCurrentFile) {
 713     // Find old.cc includes "old.h".
 714     if (AbsoluteOldHeader == AbsoluteIncludeHeader) {
 715       OldHeaderIncludeRangeInCC = IncludeFilenameRange;
 716       return;
 717     }
 718     CCIncludes.push_back(IncludeLine);
 719   }
 720 }
 721
 722 void ClangMoveTool::removeDeclsInOldFiles() {
 723   if (RemovedDecls.empty()) return;
 724
 725   // If old_header is not specified (only move declarations from old.cc), remain
 726   // all the helper function declarations in old.cc as UnremovedDeclsInOldHeader
 727   // is empty in this case, there is no way to verify unused/used helpers.
 728   if (!Context->Spec.OldHeader.empty()) {
 729     std::vector<const NamedDecl *> UnremovedDecls;
 730     for (const auto *D : UnremovedDeclsInOldHeader)
 731       UnremovedDecls.push_back(D);
 732
 733     auto UsedDecls = getUsedDecls(RGBuilder.getGraph(), UnremovedDecls);
 734
 735     // We remove the helper declarations which are not used in the old.cc after
 736     // moving the given declarations.
 737     for (const auto *D : HelperDeclarations) {
 738       LLVM_DEBUG(llvm::dbgs() << "Check helper is used: " << D->getDeclName()
 739                               << " (" << D << ")\n");
 740       if (!UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
 741               D->getCanonicalDecl()))) {
 742         LLVM_DEBUG(llvm::dbgs() << "Helper removed in old.cc: "
 743                                 << D->getDeclName() << " (" << D << ")\n");
 744         RemovedDecls.push_back(D);
 745       }
 746     }
 747   }
 748
 749   for (const auto *RemovedDecl : RemovedDecls) {
 750     const auto &SM = RemovedDecl->getASTContext().getSourceManager();
 751     auto Range = getFullRange(RemovedDecl);
 752     tooling::Replacement RemoveReplacement(
 753         SM, CharSourceRange::getCharRange(Range.getBegin(), Range.getEnd()),
 754         "");
 755     std::string FilePath = RemoveReplacement.getFilePath().str();
 756     auto Err = Context->FileToReplacements[FilePath].add(RemoveReplacement);
 757     if (Err)
 758       llvm::errs() << llvm::toString(std::move(Err)) << "\n";
 759   }
 760   const auto &SM = RemovedDecls[0]->getASTContext().getSourceManager();
 761
 762   // Post process of cleanup around all the replacements.
 763   for (auto &FileAndReplacements : Context->FileToReplacements) {
 764     StringRef FilePath = FileAndReplacements.first;
 765     // Add #include of new header to old header.
 766     if (Context->Spec.OldDependOnNew &&
 767         MakeAbsolutePath(SM, FilePath) ==
 768             makeAbsolutePath(Context->Spec.OldHeader)) {
 769       // FIXME: Minimize the include path like clang-include-fixer.
 770       std::string IncludeNewH =
 771           "#include \"" + Context->Spec.NewHeader + "\"\n";
 772       // This replacement for inserting header will be cleaned up at the end.
 773       auto Err = FileAndReplacements.second.add(
 774           tooling::Replacement(FilePath, UINT_MAX, 0, IncludeNewH));
 775       if (Err)
 776         llvm::errs() << llvm::toString(std::move(Err)) << "\n";
 777     }
 778
 779     auto SI = FilePathToFileID.find(FilePath);
 780     // Ignore replacements for new.h/cc.
 781     if (SI == FilePathToFileID.end()) continue;
 782     llvm::StringRef Code = SM.getBufferData(SI->second);
 783     auto Style = format::getStyle(format::DefaultFormatStyle, FilePath,
 784                                   Context->FallbackStyle);
 785     if (!Style) {
 786       llvm::errs() << llvm::toString(Style.takeError()) << "\n";
 787       continue;
 788     }
 789     auto CleanReplacements = format::cleanupAroundReplacements(
 790         Code, Context->FileToReplacements[std::string(FilePath)], *Style);
 791
 792     if (!CleanReplacements) {
 793       llvm::errs() << llvm::toString(CleanReplacements.takeError()) << "\n";
 794       continue;
 795     }
 796     Context->FileToReplacements[std::string(FilePath)] = *CleanReplacements;
 797   }
 798 }
 799
 800 void ClangMoveTool::moveDeclsToNewFiles() {
 801   std::vector<const NamedDecl *> NewHeaderDecls;
 802   std::vector<const NamedDecl *> NewCCDecls;
 803   for (const auto *MovedDecl : MovedDecls) {
 804     if (isInHeaderFile(MovedDecl, Context->OriginalRunningDirectory,
 805                        Context->Spec.OldHeader))
 806       NewHeaderDecls.push_back(MovedDecl);
 807     else
 808       NewCCDecls.push_back(MovedDecl);
 809   }
 810
 811   auto UsedDecls = getUsedDecls(RGBuilder.getGraph(), RemovedDecls);
 812   std::vector<const NamedDecl *> ActualNewCCDecls;
 813
 814   // Filter out all unused helpers in NewCCDecls.
 815   // We only move the used helpers (including transitively used helpers) and the
 816   // given symbols being moved.
 817   for (const auto *D : NewCCDecls) {
 818     if (llvm::is_contained(HelperDeclarations, D) &&
 819         !UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
 820             D->getCanonicalDecl())))
 821       continue;
 822
 823     LLVM_DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getDeclName()
 824                             << " " << D << "\n");
 825     ActualNewCCDecls.push_back(D);
 826   }
 827
 828   if (!Context->Spec.NewHeader.empty()) {
 829     std::string OldHeaderInclude =
 830         Context->Spec.NewDependOnOld
 831             ? "#include \"" + Context->Spec.OldHeader + "\"\n"
 832             : "";
 833     Context->FileToReplacements[Context->Spec.NewHeader] =
 834         createInsertedReplacements(HeaderIncludes, NewHeaderDecls,
 835                                    Context->Spec.NewHeader, /*IsHeader=*/true,
 836                                    OldHeaderInclude);
 837   }
 838   if (!Context->Spec.NewCC.empty())
 839     Context->FileToReplacements[Context->Spec.NewCC] =
 840         createInsertedReplacements(CCIncludes, ActualNewCCDecls,
 841                                    Context->Spec.NewCC);
 842 }
 843
 844 // Move all contents from OldFile to NewFile.
 845 void ClangMoveTool::moveAll(SourceManager &SM, StringRef OldFile,
 846                             StringRef NewFile) {
 847   auto FE = SM.getFileManager().getOptionalFileRef(makeAbsolutePath(OldFile));
 848   if (!FE) {
 849     llvm::errs() << "Failed to get file: " << OldFile << "\n";
 850     return;
 851   }
 852   FileID ID = SM.getOrCreateFileID(*FE, SrcMgr::C_User);
 853   auto Begin = SM.getLocForStartOfFile(ID);
 854   auto End = SM.getLocForEndOfFile(ID);
 855   tooling::Replacement RemoveAll(SM, CharSourceRange::getCharRange(Begin, End),
 856                                  "");
 857   std::string FilePath = RemoveAll.getFilePath().str();
 858   Context->FileToReplacements[FilePath] = tooling::Replacements(RemoveAll);
 859
 860   StringRef Code = SM.getBufferData(ID);
 861   if (!NewFile.empty()) {
 862     auto AllCode =
 863         tooling::Replacements(tooling::Replacement(NewFile, 0, 0, Code));
 864     auto ReplaceOldInclude = [&](CharSourceRange OldHeaderIncludeRange) {
 865       AllCode = AllCode.merge(tooling::Replacements(tooling::Replacement(
 866           SM, OldHeaderIncludeRange, '"' + Context->Spec.NewHeader + '"')));
 867     };
 868     // Fix the case where old.h/old.cc includes "old.h", we replace the
 869     // `#include "old.h"` with `#include "new.h"`.
 870     if (Context->Spec.NewCC == NewFile && OldHeaderIncludeRangeInCC.isValid())
 871       ReplaceOldInclude(OldHeaderIncludeRangeInCC);
 872     else if (Context->Spec.NewHeader == NewFile &&
 873              OldHeaderIncludeRangeInHeader.isValid())
 874       ReplaceOldInclude(OldHeaderIncludeRangeInHeader);
 875     Context->FileToReplacements[std::string(NewFile)] = std::move(AllCode);
 876   }
 877 }
 878
 879 void ClangMoveTool::onEndOfTranslationUnit() {
 880   if (Context->DumpDeclarations) {
 881     assert(Reporter);
 882     for (const auto *Decl : UnremovedDeclsInOldHeader) {
 883       auto Kind = Decl->getKind();
 884       bool Templated = Decl->isTemplated();
 885       const std::string QualifiedName = Decl->getQualifiedNameAsString();
 886       if (Kind == Decl::Kind::Var)
 887         Reporter->reportDeclaration(QualifiedName, "Variable", Templated);
 888       else if (Kind == Decl::Kind::Function ||
 889                Kind == Decl::Kind::FunctionTemplate)
 890         Reporter->reportDeclaration(QualifiedName, "Function", Templated);
 891       else if (Kind == Decl::Kind::ClassTemplate ||
 892                Kind == Decl::Kind::CXXRecord)
 893         Reporter->reportDeclaration(QualifiedName, "Class", Templated);
 894       else if (Kind == Decl::Kind::Enum)
 895         Reporter->reportDeclaration(QualifiedName, "Enum", Templated);
 896       else if (Kind == Decl::Kind::Typedef || Kind == Decl::Kind::TypeAlias ||
 897                Kind == Decl::Kind::TypeAliasTemplate)
 898         Reporter->reportDeclaration(QualifiedName, "TypeAlias", Templated);
 899     }
 900     return;
 901   }
 902
 903   if (RemovedDecls.empty())
 904     return;
 905   // Ignore symbols that are not supported when checking if there is unremoved
 906   // symbol in old header. This makes sure that we always move old files to new
 907   // files when all symbols produced from dump_decls are moved.
 908   auto IsSupportedKind = [](const NamedDecl *Decl) {
 909     switch (Decl->getKind()) {
 910     case Decl::Kind::Function:
 911     case Decl::Kind::FunctionTemplate:
 912     case Decl::Kind::ClassTemplate:
 913     case Decl::Kind::CXXRecord:
 914     case Decl::Kind::Enum:
 915     case Decl::Kind::Typedef:
 916     case Decl::Kind::TypeAlias:
 917     case Decl::Kind::TypeAliasTemplate:
 918     case Decl::Kind::Var:
 919       return true;
 920     default:
 921       return false;
 922     }
 923   };
 924   if (llvm::none_of(UnremovedDeclsInOldHeader, IsSupportedKind) &&
 925       !Context->Spec.OldHeader.empty()) {
 926     auto &SM = RemovedDecls[0]->getASTContext().getSourceManager();
 927     moveAll(SM, Context->Spec.OldHeader, Context->Spec.NewHeader);
 928     moveAll(SM, Context->Spec.OldCC, Context->Spec.NewCC);
 929     return;
 930   }
 931   LLVM_DEBUG(RGBuilder.getGraph()->dump());
 932   moveDeclsToNewFiles();
 933   removeDeclsInOldFiles();
 934 }
 935
 936 } // namespace move
 937 } // namespace clang