clang-tools 10.0.0

Move.cpp
Go to the documentation of this file.
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 auto 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(std::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(std::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(std::make_unique<FunctionDeclarationMatch>(this));
633 Finder->addMatcher(functionDecl(InOldFiles, *HasAnySymbolNames, TopLevelDecl)
634 .bind("function"),
635 MatchCallbacks.back().get());
636
637 MatchCallbacks.push_back(std::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(std::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(std::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 auto 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
Loc
SourceLocation Loc
&#39;#&#39; location in the include directive
Definition: IncludeOrderCheck.cpp:37
clang::move::DeclarationReporter::reportDeclaration
void reportDeclaration(llvm::StringRef DeclarationName, llvm::StringRef Type, bool Templated)
Definition: Move.h:34
clang::ast_matchers
Definition: AbseilMatcher.h:14
Code
std::string Code
Definition: FindTargetTests.cpp:67
Decl
const FunctionDecl * Decl
Definition: AvoidBindCheck.cpp:93
clang::move::ClangMoveContext
Definition: Move.h:82
clang::move::ClangMoveTool::onEndOfTranslationUnit
void onEndOfTranslationUnit() override
Definition: Move.cpp:877
clang::move::MoveDefinitionSpec::OldHeader
std::string OldHeader
Definition: Move.h:66
clang::move::ClangMoveContext::OriginalRunningDirectory
std::string OriginalRunningDirectory
Definition: Move.h:91
Parent
const Node * Parent
Definition: ExtractFunction.cpp:148
clang::move::ClangMoveContext::Spec
MoveDefinitionSpec Spec
Definition: Move.h:83
clang::ast_matchers::AST_MATCHER
AST_MATCHER(Expr, isMacroID)
Definition: PreferIsaOrDynCastInConditionalsCheck.cpp:18
clang::clangd::PathRef
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:23
clang::tidy::cppcoreguidelines::toString
static llvm::StringRef toString(SpecialMemberFunctionsCheck::SpecialMemberFunctionKind K)
Definition: SpecialMemberFunctionsCheck.cpp:58
Results
std::vector< CodeCompletionResult > Results
Definition: CodeComplete.cpp:689
run-clang-tidy.make_absolute
def make_absolute(f, directory)
Definition: run-clang-tidy.py:74
clang::move::MoveDefinitionSpec::NewHeader
std::string NewHeader
Definition: Move.h:70
clang::move::MoveDefinitionSpec::Names
SmallVector< std::string, 4 > Names
Definition: Move.h:64
Path
std::vector< HeaderHandle > Path
Definition: PreprocessorTracker.cpp:537
clang::move::ClangMoveTool::registerMatchers
void registerMatchers(ast_matchers::MatchFinder *Finder)
Definition: Move.cpp:499
clang::move::MoveDefinitionSpec::NewCC
std::string NewCC
Definition: Move.h:72
Kind
BindArgumentKind Kind
Definition: AvoidBindCheck.cpp:57
clang::move::HelperDeclRGBuilder::getOutmostClassOrFunDecl
static const Decl * getOutmostClassOrFunDecl(const Decl *D)
Definition: HelperDeclRefGraph.cpp:90
clang::move::ClangMoveContext::FallbackStyle
std::string FallbackStyle
Definition: Move.h:93
IsAngled
bool IsAngled
true if this was an include with angle brackets
Definition: IncludeOrderCheck.cpp:40
clang::move::DeclarationReporter
Definition: Move.h:29
clang::move::ClangMoveContext::DumpDeclarations
bool DumpDeclarations
Definition: Move.h:95
clang::move::HelperDeclRefGraph::dump
void dump() const
Definition: HelperDeclRefGraph.cpp:54
FileName
PathRef FileName
Definition: CodeComplete.cpp:1018
clang::move::HelperDeclRGBuilder::getGraph
const HelperDeclRefGraph * getGraph() const
Definition: HelperDeclRefGraph.h:83
Builder
CodeCompletionBuilder Builder
Definition: CodeCompletionStringsTests.cpp:35
clang::move::ClangMoveContext::FileToReplacements
std::map< std::string, tooling::Replacements > & FileToReplacements
Definition: Move.h:85
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::clangd::isAnonymous
static bool isAnonymous(const DeclarationName &N)
Definition: AST.cpp:184
Line
int Line
Definition: PreprocessorTracker.cpp:526
clang::move::ClangMoveTool::run
void run(const ast_matchers::MatchFinder::MatchResult &Result) override
Definition: Move.cpp:660
Range
CharSourceRange Range
SourceRange for the file name.
Definition: IncludeOrderCheck.cpp:38
IncludeHeader
std::string IncludeHeader
Definition: DiagnosticsTests.cpp:525
Move.h
clang::move::MoveDefinitionSpec::NewDependOnOld
bool NewDependOnOld
Definition: Move.h:78
HelperDeclRefGraph.h
clang::move::ClangMoveTool::addIncludes
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: Move.cpp:687
clang::move::ClangMoveTool::addRemovedDecl
void addRemovedDecl(const NamedDecl *Decl)
Add declarations being removed from old.h/cc.
Definition: Move.cpp:491
clang::move::MoveDefinitionSpec::OldCC
std::string OldCC
Definition: Move.h:68
clang::move::MoveDefinitionSpec::OldDependOnNew
bool OldDependOnNew
Definition: Move.h:75
clang::tidy::readability::AST_MATCHER_P
AST_MATCHER_P(CXXMethodDecl, hasCanonicalDecl, ast_matchers::internal::Matcher< CXXMethodDecl >, InnerMatcher)
Definition: ConvertMemberFunctionsToStatic.cpp:52