clang-tools  8.0.0
ClangMove.cpp
Go to the documentation of this file.
1 //===-- ClangMove.cpp - Implement ClangMove functationalities ---*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "ClangMove.h"
11 #include "HelperDeclRefGraph.h"
12 #include "clang/ASTMatchers/ASTMatchers.h"
13 #include "clang/Basic/SourceManager.h"
14 #include "clang/Format/Format.h"
15 #include "clang/Frontend/CompilerInstance.h"
16 #include "clang/Lex/Lexer.h"
17 #include "clang/Lex/Preprocessor.h"
18 #include "clang/Rewrite/Core/Rewriter.h"
19 #include "clang/Tooling/Core/Replacement.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/Path.h"
22 
23 #define DEBUG_TYPE "clang-move"
24 
25 using namespace clang::ast_matchers;
26 
27 namespace clang {
28 namespace move {
29 namespace {
30 
31 // FIXME: Move to ASTMatchers.
32 AST_MATCHER(VarDecl, isStaticDataMember) { return Node.isStaticDataMember(); }
33 
34 AST_MATCHER(NamedDecl, notInMacro) { return !Node.getLocation().isMacroID(); }
35 
36 AST_MATCHER_P(Decl, hasOutermostEnclosingClass,
37  ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
38  const auto *Context = Node.getDeclContext();
39  if (!Context)
40  return false;
41  while (const auto *NextContext = Context->getParent()) {
42  if (isa<NamespaceDecl>(NextContext) ||
43  isa<TranslationUnitDecl>(NextContext))
44  break;
45  Context = NextContext;
46  }
47  return InnerMatcher.matches(*Decl::castFromDeclContext(Context), Finder,
48  Builder);
49 }
50 
51 AST_MATCHER_P(CXXMethodDecl, ofOutermostEnclosingClass,
52  ast_matchers::internal::Matcher<CXXRecordDecl>, InnerMatcher) {
53  const CXXRecordDecl *Parent = Node.getParent();
54  if (!Parent)
55  return false;
56  while (const auto *NextParent =
57  dyn_cast<CXXRecordDecl>(Parent->getParent())) {
58  Parent = NextParent;
59  }
60 
61  return InnerMatcher.matches(*Parent, Finder, Builder);
62 }
63 
64 std::string CleanPath(StringRef PathRef) {
65  llvm::SmallString<128> Path(PathRef);
66  llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
67  // FIXME: figure out why this is necessary.
68  llvm::sys::path::native(Path);
69  return Path.str();
70 }
71 
72 // Make the Path absolute using the CurrentDir if the Path is not an absolute
73 // path. An empty Path will result in an empty string.
74 std::string MakeAbsolutePath(StringRef CurrentDir, StringRef Path) {
75  if (Path.empty())
76  return "";
77  llvm::SmallString<128> InitialDirectory(CurrentDir);
78  llvm::SmallString<128> AbsolutePath(Path);
79  llvm::sys::fs::make_absolute(InitialDirectory, AbsolutePath);
80  return CleanPath(std::move(AbsolutePath));
81 }
82 
83 // Make the Path absolute using the current working directory of the given
84 // SourceManager if the Path is not an absolute path.
85 //
86 // The Path can be a path relative to the build directory, or retrieved from
87 // the SourceManager.
88 std::string MakeAbsolutePath(const SourceManager &SM, StringRef Path) {
89  llvm::SmallString<128> AbsolutePath(Path);
90  if (std::error_code EC =
91  SM.getFileManager().getVirtualFileSystem()->makeAbsolute(
92  AbsolutePath))
93  llvm::errs() << "Warning: could not make absolute file: '" << EC.message()
94  << '\n';
95  // Handle symbolic link path cases.
96  // We are trying to get the real file path of the symlink.
97  const DirectoryEntry *Dir = SM.getFileManager().getDirectory(
98  llvm::sys::path::parent_path(AbsolutePath.str()));
99  if (Dir) {
100  StringRef DirName = SM.getFileManager().getCanonicalName(Dir);
101  // FIXME: getCanonicalName might fail to get real path on VFS.
102  if (llvm::sys::path::is_absolute(DirName)) {
103  SmallString<128> AbsoluteFilename;
104  llvm::sys::path::append(AbsoluteFilename, DirName,
105  llvm::sys::path::filename(AbsolutePath.str()));
106  return CleanPath(AbsoluteFilename);
107  }
108  }
109  return CleanPath(AbsolutePath);
110 }
111 
112 // Matches AST nodes that are expanded within the given AbsoluteFilePath.
113 AST_POLYMORPHIC_MATCHER_P(isExpansionInFile,
114  AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc),
115  std::string, AbsoluteFilePath) {
116  auto &SourceManager = Finder->getASTContext().getSourceManager();
117  auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getBeginLoc());
118  if (ExpansionLoc.isInvalid())
119  return false;
120  auto FileEntry =
121  SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc));
122  if (!FileEntry)
123  return false;
124  return MakeAbsolutePath(SourceManager, FileEntry->getName()) ==
125  AbsoluteFilePath;
126 }
127 
128 class FindAllIncludes : public PPCallbacks {
129 public:
130  explicit FindAllIncludes(SourceManager *SM, ClangMoveTool *const MoveTool)
131  : SM(*SM), MoveTool(MoveTool) {}
132 
133  void InclusionDirective(SourceLocation HashLoc, const Token & /*IncludeTok*/,
134  StringRef FileName, bool IsAngled,
135  CharSourceRange FilenameRange,
136  const FileEntry * /*File*/, StringRef SearchPath,
137  StringRef /*RelativePath*/,
138  const Module * /*Imported*/,
139  SrcMgr::CharacteristicKind /*FileType*/) override {
140  if (const auto *FileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc)))
141  MoveTool->addIncludes(FileName, IsAngled, SearchPath,
142  FileEntry->getName(), FilenameRange, SM);
143  }
144 
145 private:
146  const SourceManager &SM;
147  ClangMoveTool *const MoveTool;
148 };
149 
150 /// Add a declatration being moved to new.h/cc. Note that the declaration will
151 /// also be deleted in old.h/cc.
152 void MoveDeclFromOldFileToNewFile(ClangMoveTool *MoveTool, const NamedDecl *D) {
153  MoveTool->getMovedDecls().push_back(D);
154  MoveTool->addRemovedDecl(D);
155  MoveTool->getUnremovedDeclsInOldHeader().erase(D);
156 }
157 
158 class FunctionDeclarationMatch : public MatchFinder::MatchCallback {
159 public:
160  explicit FunctionDeclarationMatch(ClangMoveTool *MoveTool)
161  : MoveTool(MoveTool) {}
162 
163  void run(const MatchFinder::MatchResult &Result) override {
164  const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("function");
165  assert(FD);
166  const NamedDecl *D = FD;
167  if (const auto *FTD = FD->getDescribedFunctionTemplate())
168  D = FTD;
169  MoveDeclFromOldFileToNewFile(MoveTool, D);
170  }
171 
172 private:
173  ClangMoveTool *MoveTool;
174 };
175 
176 class VarDeclarationMatch : public MatchFinder::MatchCallback {
177 public:
178  explicit VarDeclarationMatch(ClangMoveTool *MoveTool)
179  : MoveTool(MoveTool) {}
180 
181  void run(const MatchFinder::MatchResult &Result) override {
182  const auto *VD = Result.Nodes.getNodeAs<VarDecl>("var");
183  assert(VD);
184  MoveDeclFromOldFileToNewFile(MoveTool, VD);
185  }
186 
187 private:
188  ClangMoveTool *MoveTool;
189 };
190 
191 class TypeAliasMatch : public MatchFinder::MatchCallback {
192 public:
193  explicit TypeAliasMatch(ClangMoveTool *MoveTool)
194  : MoveTool(MoveTool) {}
195 
196  void run(const MatchFinder::MatchResult &Result) override {
197  if (const auto *TD = Result.Nodes.getNodeAs<TypedefDecl>("typedef"))
198  MoveDeclFromOldFileToNewFile(MoveTool, TD);
199  else if (const auto *TAD =
200  Result.Nodes.getNodeAs<TypeAliasDecl>("type_alias")) {
201  const NamedDecl * D = TAD;
202  if (const auto * TD = TAD->getDescribedAliasTemplate())
203  D = TD;
204  MoveDeclFromOldFileToNewFile(MoveTool, D);
205  }
206  }
207 
208 private:
209  ClangMoveTool *MoveTool;
210 };
211 
212 class EnumDeclarationMatch : public MatchFinder::MatchCallback {
213 public:
214  explicit EnumDeclarationMatch(ClangMoveTool *MoveTool)
215  : MoveTool(MoveTool) {}
216 
217  void run(const MatchFinder::MatchResult &Result) override {
218  const auto *ED = Result.Nodes.getNodeAs<EnumDecl>("enum");
219  assert(ED);
220  MoveDeclFromOldFileToNewFile(MoveTool, ED);
221  }
222 
223 private:
224  ClangMoveTool *MoveTool;
225 };
226 
227 class ClassDeclarationMatch : public MatchFinder::MatchCallback {
228 public:
229  explicit ClassDeclarationMatch(ClangMoveTool *MoveTool)
230  : MoveTool(MoveTool) {}
231  void run(const MatchFinder::MatchResult &Result) override {
232  SourceManager *SM = &Result.Context->getSourceManager();
233  if (const auto *CMD = Result.Nodes.getNodeAs<CXXMethodDecl>("class_method"))
234  MatchClassMethod(CMD, SM);
235  else if (const auto *VD =
236  Result.Nodes.getNodeAs<VarDecl>("class_static_var_decl"))
237  MatchClassStaticVariable(VD, SM);
238  else if (const auto *CD =
239  Result.Nodes.getNodeAs<CXXRecordDecl>("moved_class"))
240  MatchClassDeclaration(CD, SM);
241  }
242 
243 private:
244  void MatchClassMethod(const CXXMethodDecl *CMD, SourceManager *SM) {
245  // Skip inline class methods. isInline() ast matcher doesn't ignore this
246  // case.
247  if (!CMD->isInlined()) {
248  MoveTool->getMovedDecls().push_back(CMD);
249  MoveTool->addRemovedDecl(CMD);
250  // Get template class method from its method declaration as
251  // UnremovedDecls stores template class method.
252  if (const auto *FTD = CMD->getDescribedFunctionTemplate())
253  MoveTool->getUnremovedDeclsInOldHeader().erase(FTD);
254  else
255  MoveTool->getUnremovedDeclsInOldHeader().erase(CMD);
256  }
257  }
258 
259  void MatchClassStaticVariable(const NamedDecl *VD, SourceManager *SM) {
260  MoveDeclFromOldFileToNewFile(MoveTool, VD);
261  }
262 
263  void MatchClassDeclaration(const CXXRecordDecl *CD, SourceManager *SM) {
264  // Get class template from its class declaration as UnremovedDecls stores
265  // class template.
266  if (const auto *TC = CD->getDescribedClassTemplate())
267  MoveTool->getMovedDecls().push_back(TC);
268  else
269  MoveTool->getMovedDecls().push_back(CD);
270  MoveTool->addRemovedDecl(MoveTool->getMovedDecls().back());
271  MoveTool->getUnremovedDeclsInOldHeader().erase(
272  MoveTool->getMovedDecls().back());
273  }
274 
275  ClangMoveTool *MoveTool;
276 };
277 
278 // Expand to get the end location of the line where the EndLoc of the given
279 // Decl.
280 SourceLocation getLocForEndOfDecl(const Decl *D,
281  const LangOptions &LangOpts = LangOptions()) {
282  const auto &SM = D->getASTContext().getSourceManager();
283  // If the expansion range is a character range, this is the location of
284  // the first character past the end. Otherwise it's the location of the
285  // first character in the final token in the range.
286  auto EndExpansionLoc = SM.getExpansionRange(D->getEndLoc()).getEnd();
287  std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(EndExpansionLoc);
288  // Try to load the file buffer.
289  bool InvalidTemp = false;
290  llvm::StringRef File = SM.getBufferData(LocInfo.first, &InvalidTemp);
291  if (InvalidTemp)
292  return SourceLocation();
293 
294  const char *TokBegin = File.data() + LocInfo.second;
295  // Lex from the start of the given location.
296  Lexer Lex(SM.getLocForStartOfFile(LocInfo.first), LangOpts, File.begin(),
297  TokBegin, File.end());
298 
299  llvm::SmallVector<char, 16> Line;
300  // FIXME: this is a bit hacky to get ReadToEndOfLine work.
301  Lex.setParsingPreprocessorDirective(true);
302  Lex.ReadToEndOfLine(&Line);
303  SourceLocation EndLoc = EndExpansionLoc.getLocWithOffset(Line.size());
304  // If we already reach EOF, just return the EOF SourceLocation;
305  // otherwise, move 1 offset ahead to include the trailing newline character
306  // '\n'.
307  return SM.getLocForEndOfFile(LocInfo.first) == EndLoc
308  ? EndLoc
309  : EndLoc.getLocWithOffset(1);
310 }
311 
312 // Get full range of a Decl including the comments associated with it.
313 CharSourceRange getFullRange(const Decl *D,
314  const LangOptions &options = LangOptions()) {
315  const auto &SM = D->getASTContext().getSourceManager();
316  SourceRange Full(SM.getExpansionLoc(D->getBeginLoc()), getLocForEndOfDecl(D));
317  // Expand to comments that are associated with the Decl.
318  if (const auto *Comment = D->getASTContext().getRawCommentForDeclNoCache(D)) {
319  if (SM.isBeforeInTranslationUnit(Full.getEnd(), Comment->getEndLoc()))
320  Full.setEnd(Comment->getEndLoc());
321  // FIXME: Don't delete a preceding comment, if there are no other entities
322  // it could refer to.
323  if (SM.isBeforeInTranslationUnit(Comment->getBeginLoc(), Full.getBegin()))
324  Full.setBegin(Comment->getBeginLoc());
325  }
326 
327  return CharSourceRange::getCharRange(Full);
328 }
329 
330 std::string getDeclarationSourceText(const Decl *D) {
331  const auto &SM = D->getASTContext().getSourceManager();
332  llvm::StringRef SourceText =
333  Lexer::getSourceText(getFullRange(D), SM, LangOptions());
334  return SourceText.str();
335 }
336 
337 bool isInHeaderFile(const Decl *D, llvm::StringRef OriginalRunningDirectory,
338  llvm::StringRef OldHeader) {
339  const auto &SM = D->getASTContext().getSourceManager();
340  if (OldHeader.empty())
341  return false;
342  auto ExpansionLoc = SM.getExpansionLoc(D->getBeginLoc());
343  if (ExpansionLoc.isInvalid())
344  return false;
345 
346  if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc))) {
347  return MakeAbsolutePath(SM, FE->getName()) ==
348  MakeAbsolutePath(OriginalRunningDirectory, OldHeader);
349  }
350 
351  return false;
352 }
353 
354 std::vector<std::string> getNamespaces(const Decl *D) {
355  std::vector<std::string> Namespaces;
356  for (const auto *Context = D->getDeclContext(); Context;
357  Context = Context->getParent()) {
358  if (llvm::isa<TranslationUnitDecl>(Context) ||
359  llvm::isa<LinkageSpecDecl>(Context))
360  break;
361 
362  if (const auto *ND = llvm::dyn_cast<NamespaceDecl>(Context))
363  Namespaces.push_back(ND->getName().str());
364  }
365  std::reverse(Namespaces.begin(), Namespaces.end());
366  return Namespaces;
367 }
368 
369 tooling::Replacements
370 createInsertedReplacements(const std::vector<std::string> &Includes,
371  const std::vector<const NamedDecl *> &Decls,
372  llvm::StringRef FileName, bool IsHeader = false,
373  StringRef OldHeaderInclude = "") {
374  std::string NewCode;
375  std::string GuardName(FileName);
376  if (IsHeader) {
377  for (size_t i = 0; i < GuardName.size(); ++i) {
378  if (!isAlphanumeric(GuardName[i]))
379  GuardName[i] = '_';
380  }
381  GuardName = StringRef(GuardName).upper();
382  NewCode += "#ifndef " + GuardName + "\n";
383  NewCode += "#define " + GuardName + "\n\n";
384  }
385 
386  NewCode += OldHeaderInclude;
387  // Add #Includes.
388  for (const auto &Include : Includes)
389  NewCode += Include;
390 
391  if (!Includes.empty())
392  NewCode += "\n";
393 
394  // Add moved class definition and its related declarations. All declarations
395  // in same namespace are grouped together.
396  //
397  // Record namespaces where the current position is in.
398  std::vector<std::string> CurrentNamespaces;
399  for (const auto *MovedDecl : Decls) {
400  // The namespaces of the declaration being moved.
401  std::vector<std::string> DeclNamespaces = getNamespaces(MovedDecl);
402  auto CurrentIt = CurrentNamespaces.begin();
403  auto DeclIt = DeclNamespaces.begin();
404  // Skip the common prefix.
405  while (CurrentIt != CurrentNamespaces.end() &&
406  DeclIt != DeclNamespaces.end()) {
407  if (*CurrentIt != *DeclIt)
408  break;
409  ++CurrentIt;
410  ++DeclIt;
411  }
412  // Calculate the new namespaces after adding MovedDecl in CurrentNamespace,
413  // which is used for next iteration of this loop.
414  std::vector<std::string> NextNamespaces(CurrentNamespaces.begin(),
415  CurrentIt);
416  NextNamespaces.insert(NextNamespaces.end(), DeclIt, DeclNamespaces.end());
417 
418 
419  // End with CurrentNamespace.
420  bool HasEndCurrentNamespace = false;
421  auto RemainingSize = CurrentNamespaces.end() - CurrentIt;
422  for (auto It = CurrentNamespaces.rbegin(); RemainingSize > 0;
423  --RemainingSize, ++It) {
424  assert(It < CurrentNamespaces.rend());
425  NewCode += "} // namespace " + *It + "\n";
426  HasEndCurrentNamespace = true;
427  }
428  // Add trailing '\n' after the nested namespace definition.
429  if (HasEndCurrentNamespace)
430  NewCode += "\n";
431 
432  // If the moved declaration is not in CurrentNamespace, add extra namespace
433  // definitions.
434  bool IsInNewNamespace = false;
435  while (DeclIt != DeclNamespaces.end()) {
436  NewCode += "namespace " + *DeclIt + " {\n";
437  IsInNewNamespace = true;
438  ++DeclIt;
439  }
440  // If the moved declaration is in same namespace CurrentNamespace, add
441  // a preceeding `\n' before the moved declaration.
442  // FIXME: Don't add empty lines between using declarations.
443  if (!IsInNewNamespace)
444  NewCode += "\n";
445  NewCode += getDeclarationSourceText(MovedDecl);
446  CurrentNamespaces = std::move(NextNamespaces);
447  }
448  std::reverse(CurrentNamespaces.begin(), CurrentNamespaces.end());
449  for (const auto &NS : CurrentNamespaces)
450  NewCode += "} // namespace " + NS + "\n";
451 
452  if (IsHeader)
453  NewCode += "\n#endif // " + GuardName + "\n";
454  return tooling::Replacements(tooling::Replacement(FileName, 0, 0, NewCode));
455 }
456 
457 // Return a set of all decls which are used/referenced by the given Decls.
458 // Specically, given a class member declaration, this method will return all
459 // decls which are used by the whole class.
460 llvm::DenseSet<const Decl *>
461 getUsedDecls(const HelperDeclRefGraph *RG,
462  const std::vector<const NamedDecl *> &Decls) {
463  assert(RG);
464  llvm::DenseSet<const CallGraphNode *> Nodes;
465  for (const auto *D : Decls) {
466  auto Result = RG->getReachableNodes(
467  HelperDeclRGBuilder::getOutmostClassOrFunDecl(D));
468  Nodes.insert(Result.begin(), Result.end());
469  }
470  llvm::DenseSet<const Decl *> Results;
471  for (const auto *Node : Nodes)
472  Results.insert(Node->getDecl());
473  return Results;
474 }
475 
476 } // namespace
477 
478 std::unique_ptr<ASTConsumer>
479 ClangMoveAction::CreateASTConsumer(CompilerInstance &Compiler,
480  StringRef /*InFile*/) {
481  Compiler.getPreprocessor().addPPCallbacks(llvm::make_unique<FindAllIncludes>(
482  &Compiler.getSourceManager(), &MoveTool));
483  return MatchFinder.newASTConsumer();
484 }
485 
486 ClangMoveTool::ClangMoveTool(ClangMoveContext *const Context,
487  DeclarationReporter *const Reporter)
488  : Context(Context), Reporter(Reporter) {
489  if (!Context->Spec.NewHeader.empty())
490  CCIncludes.push_back("#include \"" + Context->Spec.NewHeader + "\"\n");
491 }
492 
493 void ClangMoveTool::addRemovedDecl(const NamedDecl *Decl) {
494  const auto &SM = Decl->getASTContext().getSourceManager();
495  auto Loc = Decl->getLocation();
496  StringRef FilePath = SM.getFilename(Loc);
497  FilePathToFileID[FilePath] = SM.getFileID(Loc);
498  RemovedDecls.push_back(Decl);
499 }
500 
501 void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
502  auto InOldHeader =
503  isExpansionInFile(makeAbsolutePath(Context->Spec.OldHeader));
504  auto InOldCC = isExpansionInFile(makeAbsolutePath(Context->Spec.OldCC));
505  auto InOldFiles = anyOf(InOldHeader, InOldCC);
506  auto classTemplateForwardDecls =
507  classTemplateDecl(unless(has(cxxRecordDecl(isDefinition()))));
508  auto ForwardClassDecls = namedDecl(
509  anyOf(cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition()))),
510  classTemplateForwardDecls));
511  auto TopLevelDecl =
512  hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl()));
513 
514  //============================================================================
515  // Matchers for old header
516  //============================================================================
517  // Match all top-level named declarations (e.g. function, variable, enum) in
518  // old header, exclude forward class declarations and namespace declarations.
519  //
520  // We consider declarations inside a class belongs to the class. So these
521  // declarations will be ignored.
522  auto AllDeclsInHeader = namedDecl(
523  unless(ForwardClassDecls), unless(namespaceDecl()),
524  unless(usingDirectiveDecl()), // using namespace decl.
525  notInMacro(),
526  InOldHeader,
527  hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))),
528  hasDeclContext(decl(anyOf(namespaceDecl(), translationUnitDecl()))));
529  Finder->addMatcher(AllDeclsInHeader.bind("decls_in_header"), this);
530 
531  // Don't register other matchers when dumping all declarations in header.
532  if (Context->DumpDeclarations)
533  return;
534 
535  // Match forward declarations in old header.
536  Finder->addMatcher(namedDecl(ForwardClassDecls, InOldHeader).bind("fwd_decl"),
537  this);
538 
539  //============================================================================
540  // Matchers for old cc
541  //============================================================================
542  auto IsOldCCTopLevelDecl = allOf(
543  hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))), InOldCC);
544  // Matching using decls/type alias decls which are in named/anonymous/global
545  // namespace, these decls are always copied to new.h/cc. Those in classes,
546  // functions are covered in other matchers.
547  Finder->addMatcher(namedDecl(anyOf(usingDecl(IsOldCCTopLevelDecl),
548  usingDirectiveDecl(unless(isImplicit()),
549  IsOldCCTopLevelDecl),
550  typeAliasDecl(IsOldCCTopLevelDecl)),
551  notInMacro())
552  .bind("using_decl"),
553  this);
554 
555  // Match static functions/variable definitions which are defined in named
556  // namespaces.
557  Optional<ast_matchers::internal::Matcher<NamedDecl>> HasAnySymbolNames;
558  for (StringRef SymbolName : Context->Spec.Names) {
559  llvm::StringRef GlobalSymbolName = SymbolName.trim().ltrim(':');
560  const auto HasName = hasName(("::" + GlobalSymbolName).str());
561  HasAnySymbolNames =
562  HasAnySymbolNames ? anyOf(*HasAnySymbolNames, HasName) : HasName;
563  }
564 
565  if (!HasAnySymbolNames) {
566  llvm::errs() << "No symbols being moved.\n";
567  return;
568  }
569  auto InMovedClass =
570  hasOutermostEnclosingClass(cxxRecordDecl(*HasAnySymbolNames));
571 
572  // Matchers for helper declarations in old.cc.
573  auto InAnonymousNS = hasParent(namespaceDecl(isAnonymous()));
574  auto NotInMovedClass= allOf(unless(InMovedClass), InOldCC);
575  auto IsOldCCHelper =
576  allOf(NotInMovedClass, anyOf(isStaticStorageClass(), InAnonymousNS));
577  // Match helper classes separately with helper functions/variables since we
578  // want to reuse these matchers in finding helpers usage below.
579  //
580  // There could be forward declarations usage for helpers, especially for
581  // classes and functions. We need include these forward declarations.
582  //
583  // Forward declarations for variable helpers will be excluded as these
584  // declarations (with "extern") are not supposed in cpp file.
585  auto HelperFuncOrVar =
586  namedDecl(notInMacro(), anyOf(functionDecl(IsOldCCHelper),
587  varDecl(isDefinition(), IsOldCCHelper)));
588  auto HelperClasses =
589  cxxRecordDecl(notInMacro(), NotInMovedClass, InAnonymousNS);
590  // Save all helper declarations in old.cc.
591  Finder->addMatcher(
592  namedDecl(anyOf(HelperFuncOrVar, HelperClasses)).bind("helper_decls"),
593  this);
594 
595  // Construct an AST-based call graph of helper declarations in old.cc.
596  // In the following matcheres, "dc" is a caller while "helper_decls" and
597  // "used_class" is a callee, so a new edge starting from caller to callee will
598  // be add in the graph.
599  //
600  // Find helper function/variable usages.
601  Finder->addMatcher(
602  declRefExpr(to(HelperFuncOrVar), hasAncestor(decl().bind("dc")))
603  .bind("func_ref"),
604  &RGBuilder);
605  // Find helper class usages.
606  Finder->addMatcher(
607  typeLoc(loc(recordType(hasDeclaration(HelperClasses.bind("used_class")))),
608  hasAncestor(decl().bind("dc"))),
609  &RGBuilder);
610 
611  //============================================================================
612  // Matchers for old files, including old.h/old.cc
613  //============================================================================
614  // Create a MatchCallback for class declarations.
615  MatchCallbacks.push_back(llvm::make_unique<ClassDeclarationMatch>(this));
616  // Match moved class declarations.
617  auto MovedClass = cxxRecordDecl(InOldFiles, *HasAnySymbolNames,
618  isDefinition(), TopLevelDecl)
619  .bind("moved_class");
620  Finder->addMatcher(MovedClass, MatchCallbacks.back().get());
621  // Match moved class methods (static methods included) which are defined
622  // outside moved class declaration.
623  Finder->addMatcher(
624  cxxMethodDecl(InOldFiles, ofOutermostEnclosingClass(*HasAnySymbolNames),
625  isDefinition())
626  .bind("class_method"),
627  MatchCallbacks.back().get());
628  // Match static member variable definition of the moved class.
629  Finder->addMatcher(
630  varDecl(InMovedClass, InOldFiles, isDefinition(), isStaticDataMember())
631  .bind("class_static_var_decl"),
632  MatchCallbacks.back().get());
633 
634  MatchCallbacks.push_back(llvm::make_unique<FunctionDeclarationMatch>(this));
635  Finder->addMatcher(functionDecl(InOldFiles, *HasAnySymbolNames, TopLevelDecl)
636  .bind("function"),
637  MatchCallbacks.back().get());
638 
639  MatchCallbacks.push_back(llvm::make_unique<VarDeclarationMatch>(this));
640  Finder->addMatcher(
641  varDecl(InOldFiles, *HasAnySymbolNames, TopLevelDecl).bind("var"),
642  MatchCallbacks.back().get());
643 
644  // Match enum definition in old.h. Enum helpers (which are defined in old.cc)
645  // will not be moved for now no matter whether they are used or not.
646  MatchCallbacks.push_back(llvm::make_unique<EnumDeclarationMatch>(this));
647  Finder->addMatcher(
648  enumDecl(InOldHeader, *HasAnySymbolNames, isDefinition(), TopLevelDecl)
649  .bind("enum"),
650  MatchCallbacks.back().get());
651 
652  // Match type alias in old.h, this includes "typedef" and "using" type alias
653  // declarations. Type alias helpers (which are defined in old.cc) will not be
654  // moved for now no matter whether they are used or not.
655  MatchCallbacks.push_back(llvm::make_unique<TypeAliasMatch>(this));
656  Finder->addMatcher(namedDecl(anyOf(typedefDecl().bind("typedef"),
657  typeAliasDecl().bind("type_alias")),
658  InOldHeader, *HasAnySymbolNames, TopLevelDecl),
659  MatchCallbacks.back().get());
660 }
661 
662 void ClangMoveTool::run(const ast_matchers::MatchFinder::MatchResult &Result) {
663  if (const auto *D = Result.Nodes.getNodeAs<NamedDecl>("decls_in_header")) {
664  UnremovedDeclsInOldHeader.insert(D);
665  } else if (const auto *FWD =
666  Result.Nodes.getNodeAs<CXXRecordDecl>("fwd_decl")) {
667  // Skip all forward declarations which appear after moved class declaration.
668  if (RemovedDecls.empty()) {
669  if (const auto *DCT = FWD->getDescribedClassTemplate())
670  MovedDecls.push_back(DCT);
671  else
672  MovedDecls.push_back(FWD);
673  }
674  } else if (const auto *ND =
675  Result.Nodes.getNodeAs<NamedDecl>("helper_decls")) {
676  MovedDecls.push_back(ND);
677  HelperDeclarations.push_back(ND);
678  LLVM_DEBUG(llvm::dbgs() << "Add helper : " << ND->getNameAsString() << " ("
679  << ND << ")\n");
680  } else if (const auto *UD = Result.Nodes.getNodeAs<NamedDecl>("using_decl")) {
681  MovedDecls.push_back(UD);
682  }
683 }
684 
685 std::string ClangMoveTool::makeAbsolutePath(StringRef Path) {
686  return MakeAbsolutePath(Context->OriginalRunningDirectory, Path);
687 }
688 
689 void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
690  llvm::StringRef SearchPath,
691  llvm::StringRef FileName,
692  CharSourceRange IncludeFilenameRange,
693  const SourceManager &SM) {
694  SmallVector<char, 128> HeaderWithSearchPath;
695  llvm::sys::path::append(HeaderWithSearchPath, SearchPath, IncludeHeader);
696  std::string AbsoluteIncludeHeader =
697  MakeAbsolutePath(SM, llvm::StringRef(HeaderWithSearchPath.data(),
698  HeaderWithSearchPath.size()));
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: "
739  << D->getNameAsString() << " (" << D << ")\n");
741  D->getCanonicalDecl()))) {
742  LLVM_DEBUG(llvm::dbgs() << "Helper removed in old.cc: "
743  << D->getNameAsString() << " (" << 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 include-fixer.
770  std::string IncludeNewH =
771  "#include \"" + Context->Spec.NewHeader + "\"\n";
772  // This replacment 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[FilePath], *Style);
791 
792  if (!CleanReplacements) {
793  llvm::errs() << llvm::toString(CleanReplacements.takeError()) << "\n";
794  continue;
795  }
796  Context->FileToReplacements[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 transively used helpers) and the
816  // given symbols being moved.
817  for (const auto *D : NewCCDecls) {
818  if (llvm::is_contained(HelperDeclarations, D) &&
820  D->getCanonicalDecl())))
821  continue;
822 
823  LLVM_DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getNameAsString()
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  const FileEntry *FE = SM.getFileManager().getFile(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[NewFile] = std::move(AllCode);
876  }
877 }
878 
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 (std::none_of(UnremovedDeclsInOldHeader.begin(),
925  UnremovedDeclsInOldHeader.end(), IsSupportedKind) &&
926  !Context->Spec.OldHeader.empty()) {
927  auto &SM = RemovedDecls[0]->getASTContext().getSourceManager();
928  moveAll(SM, Context->Spec.OldHeader, Context->Spec.NewHeader);
929  moveAll(SM, Context->Spec.OldCC, Context->Spec.NewCC);
930  return;
931  }
932  LLVM_DEBUG(RGBuilder.getGraph()->dump());
933  moveDeclsToNewFiles();
934  removeDeclsInOldFiles();
935 }
936 
937 } // namespace move
938 } // namespace clang
SourceLocation Loc
&#39;#&#39; location in the include directive
void reportDeclaration(llvm::StringRef DeclarationName, llvm::StringRef Type, bool Templated)
Definition: ClangMove.h:35
AST_MATCHER(BinaryOperator, isAssignmentOperator)
Definition: Matchers.h:20
void onEndOfTranslationUnit() override
Definition: ClangMove.cpp:879
std::string OriginalRunningDirectory
Definition: ClangMove.h:92
MoveDefinitionSpec Spec
Definition: ClangMove.h:84
llvm::DenseSet< const CallGraphNode * > getReachableNodes(const Decl *D) const
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:24
static llvm::StringRef toString(SpecialMemberFunctionsCheck::SpecialMemberFunctionKind K)
std::vector< CodeCompletionResult > Results
def make_absolute(f, directory)
SmallVector< std::string, 4 > Names
Definition: ClangMove.h:65
std::vector< HeaderHandle > Path
void registerMatchers(ast_matchers::MatchFinder *Finder)
Definition: ClangMove.cpp:501
BindArgumentKind Kind
llvm::SmallPtrSet< const NamedDecl *, 8 > & getUnremovedDeclsInOldHeader()
Definition: ClangMove.h:151
static const Decl * getOutmostClassOrFunDecl(const Decl *D)
bool IsAngled
true if this was an include with angle brackets
const Decl * D
Definition: XRefs.cpp:79
llvm::Optional< llvm::Expected< tooling::AtomicChanges > > Result
PathRef FileName
const HelperDeclRefGraph * getGraph() const
std::map< std::string, tooling::Replacements > & FileToReplacements
Definition: ClangMove.h:86
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
AST_MATCHER_P(FunctionDecl, throws, internal::Matcher< Type >, InnerMatcher)
void run(const ast_matchers::MatchFinder::MatchResult &Result) override
Definition: ClangMove.cpp:662
CharSourceRange Range
SourceRange for the file name.
void addIncludes(llvm::StringRef IncludeHeader, bool IsAngled, llvm::StringRef SearchPath, llvm::StringRef FileName, clang::CharSourceRange IncludeFilenameRange, const SourceManager &SM)
Add #includes from old.h/cc files.
Definition: ClangMove.cpp:689
void addRemovedDecl(const NamedDecl *Decl)
Add declarations being removed from old.h/cc.
Definition: ClangMove.cpp:493
std::vector< const NamedDecl * > & getMovedDecls()
Definition: ClangMove.h:144