1 //===--- UseUsingCheck.cpp - clang-tidy------------------------------------===// 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 "UseUsingCheck.h" 10 #include "clang/AST/ASTContext.h" 11 #include "clang/Lex/Lexer.h" 12 13 using namespace clang::ast_matchers; 14 15 namespace clang::tidy::modernize { 16 17 static constexpr llvm::StringLiteral ParentDeclName = "parent-decl"; 18 static constexpr llvm::StringLiteral TagDeclName = "tag-decl"; 19 static constexpr llvm::StringLiteral TypedefName = "typedef"; 20 21 UseUsingCheck::UseUsingCheck(StringRef Name, ClangTidyContext *Context) 22 : ClangTidyCheck(Name, Context), 23 IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {} 24 25 void UseUsingCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { 26 Options.store(Opts, "IgnoreMacros", IgnoreMacros); 27 } 28 29 void UseUsingCheck::registerMatchers(MatchFinder *Finder) { 30 Finder->addMatcher(typedefDecl(unless(isInstantiated()), 31 hasParent(decl().bind(ParentDeclName))) 32 .bind(TypedefName), 33 this); 34 35 // This matcher is used to find tag declarations in source code within 36 // typedefs. They appear in the AST just *prior* to the typedefs. 37 Finder->addMatcher( 38 tagDecl( 39 anyOf(allOf(unless(anyOf(isImplicit(), 40 classTemplateSpecializationDecl())), 41 hasParent(decl().bind(ParentDeclName))), 42 // We want the parent of the ClassTemplateDecl, not the parent 43 // of the specialization. 44 classTemplateSpecializationDecl(hasAncestor(classTemplateDecl( 45 hasParent(decl().bind(ParentDeclName))))))) 46 .bind(TagDeclName), 47 this); 48 } 49 50 void UseUsingCheck::check(const MatchFinder::MatchResult &Result) { 51 const auto *ParentDecl = Result.Nodes.getNodeAs<Decl>(ParentDeclName); 52 if (!ParentDecl) 53 return; 54 55 // Match CXXRecordDecl only to store the range of the last non-implicit full 56 // declaration, to later check whether it's within the typdef itself. 57 const auto *MatchedTagDecl = Result.Nodes.getNodeAs<TagDecl>(TagDeclName); 58 if (MatchedTagDecl) { 59 // It is not sufficient to just track the last TagDecl that we've seen, 60 // because if one struct or union is nested inside another, the last TagDecl 61 // before the typedef will be the nested one (PR#50990). Therefore, we also 62 // keep track of the parent declaration, so that we can look up the last 63 // TagDecl that is a sibling of the typedef in the AST. 64 if (MatchedTagDecl->isThisDeclarationADefinition()) 65 LastTagDeclRanges[ParentDecl] = MatchedTagDecl->getSourceRange(); 66 return; 67 } 68 69 const auto *MatchedDecl = Result.Nodes.getNodeAs<TypedefDecl>(TypedefName); 70 if (MatchedDecl->getLocation().isInvalid()) 71 return; 72 73 SourceLocation StartLoc = MatchedDecl->getBeginLoc(); 74 75 if (StartLoc.isMacroID() && IgnoreMacros) 76 return; 77 78 static const char *UseUsingWarning = "use 'using' instead of 'typedef'"; 79 80 // Warn at StartLoc but do not fix if there is macro or array. 81 if (MatchedDecl->getUnderlyingType()->isArrayType() || StartLoc.isMacroID()) { 82 diag(StartLoc, UseUsingWarning); 83 return; 84 } 85 86 PrintingPolicy PrintPolicy(getLangOpts()); 87 PrintPolicy.SuppressScope = true; 88 PrintPolicy.ConstantArraySizeAsWritten = true; 89 PrintPolicy.UseVoidForZeroParams = false; 90 PrintPolicy.PrintInjectedClassNameWithArguments = false; 91 92 std::string Type = MatchedDecl->getUnderlyingType().getAsString(PrintPolicy); 93 std::string Name = MatchedDecl->getNameAsString(); 94 SourceRange ReplaceRange = MatchedDecl->getSourceRange(); 95 96 // typedefs with multiple comma-separated definitions produce multiple 97 // consecutive TypedefDecl nodes whose SourceRanges overlap. Each range starts 98 // at the "typedef" and then continues *across* previous definitions through 99 // the end of the current TypedefDecl definition. 100 // But also we need to check that the ranges belong to the same file because 101 // different files may contain overlapping ranges. 102 std::string Using = "using "; 103 if (ReplaceRange.getBegin().isMacroID() || 104 (Result.SourceManager->getFileID(ReplaceRange.getBegin()) != 105 Result.SourceManager->getFileID(LastReplacementEnd)) || 106 (ReplaceRange.getBegin() >= LastReplacementEnd)) { 107 // This is the first (and possibly the only) TypedefDecl in a typedef. Save 108 // Type and Name in case we find subsequent TypedefDecl's in this typedef. 109 FirstTypedefType = Type; 110 FirstTypedefName = Name; 111 } else { 112 // This is additional TypedefDecl in a comma-separated typedef declaration. 113 // Start replacement *after* prior replacement and separate with semicolon. 114 ReplaceRange.setBegin(LastReplacementEnd); 115 Using = ";\nusing "; 116 117 // If this additional TypedefDecl's Type starts with the first TypedefDecl's 118 // type, make this using statement refer back to the first type, e.g. make 119 // "typedef int Foo, *Foo_p;" -> "using Foo = int;\nusing Foo_p = Foo*;" 120 if (Type.size() > FirstTypedefType.size() && 121 Type.substr(0, FirstTypedefType.size()) == FirstTypedefType) 122 Type = FirstTypedefName + Type.substr(FirstTypedefType.size() + 1); 123 } 124 if (!ReplaceRange.getEnd().isMacroID()) { 125 const SourceLocation::IntTy Offset = MatchedDecl->getFunctionType() ? 0 : Name.size(); 126 LastReplacementEnd = ReplaceRange.getEnd().getLocWithOffset(Offset); 127 } 128 129 auto Diag = diag(ReplaceRange.getBegin(), UseUsingWarning); 130 131 // If typedef contains a full tag declaration, extract its full text. 132 auto LastTagDeclRange = LastTagDeclRanges.find(ParentDecl); 133 if (LastTagDeclRange != LastTagDeclRanges.end() && 134 LastTagDeclRange->second.isValid() && 135 ReplaceRange.fullyContains(LastTagDeclRange->second)) { 136 Type = std::string(Lexer::getSourceText( 137 CharSourceRange::getTokenRange(LastTagDeclRange->second), 138 *Result.SourceManager, getLangOpts())); 139 if (Type.empty()) 140 return; 141 } 142 143 std::string Replacement = Using + Name + " = " + Type; 144 Diag << FixItHint::CreateReplacement(ReplaceRange, Replacement); 145 } 146 } // namespace clang::tidy::modernize 147