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