| 1 |
//===--- IsolateDeclarationCheck.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 "IsolateDeclarationCheck.h" |
| 10 |
#include "../utils/LexerUtils.h" |
| 11 |
#include "clang/ASTMatchers/ASTMatchFinder.h" |
| 12 |
#include <optional> |
| 13 |
|
| 14 |
using namespace clang::ast_matchers; |
| 15 |
using namespace clang::tidy::utils::lexer; |
| 16 |
|
| 17 |
namespace clang::tidy::readability { |
| 18 |
|
| 19 |
namespace { |
| 20 |
AST_MATCHER(DeclStmt, isSingleDecl) { return Node.isSingleDecl(); } |
| 21 |
AST_MATCHER(DeclStmt, onlyDeclaresVariables) { |
| 22 |
return llvm::all_of(Node.decls(), [](Decl *D) { return isa<VarDecl>(D); }); |
| 23 |
} |
| 24 |
} // namespace |
| 25 |
|
| 26 |
void IsolateDeclarationCheck::registerMatchers(MatchFinder *Finder) { |
| 27 |
Finder->addMatcher(declStmt(onlyDeclaresVariables(), unless(isSingleDecl()), |
| 28 |
hasParent(compoundStmt())) |
| 29 |
.bind("decl_stmt"), |
| 30 |
this); |
| 31 |
} |
| 32 |
|
| 33 |
static SourceLocation findStartOfIndirection(SourceLocation Start, |
| 34 |
int Indirections, |
| 35 |
const SourceManager &SM, |
| 36 |
const LangOptions &LangOpts) { |
| 37 |
assert(Indirections >= 0 && "Indirections must be non-negative"); |
| 38 |
if (Indirections == 0) |
| 39 |
return Start; |
| 40 |
|
| 41 |
// Note that the post-fix decrement is necessary to perform the correct |
| 42 |
// number of transformations. |
| 43 |
while (Indirections-- != 0) { |
| 44 |
Start = findPreviousAnyTokenKind(Start, SM, LangOpts, tok::star, tok::amp); |
| 45 |
if (Start.isInvalid() || Start.isMacroID()) |
| 46 |
return SourceLocation(); |
| 47 |
} |
| 48 |
return Start; |
| 49 |
} |
| 50 |
|
| 51 |
static bool isMacroID(SourceRange R) { |
| 52 |
return R.getBegin().isMacroID() || R.getEnd().isMacroID(); |
| 53 |
} |
| 54 |
|
| 55 |
/// This function counts the number of written indirections for the given |
| 56 |
/// Type \p T. It does \b NOT resolve typedefs as it's a helper for lexing |
| 57 |
/// the source code. |
| 58 |
/// \see declRanges |
| 59 |
static int countIndirections(const Type *T, int Indirections = 0) { |
| 60 |
if (T->isFunctionPointerType()) { |
| 61 |
const auto *Pointee = T->getPointeeType()->castAs<FunctionType>(); |
| 62 |
return countIndirections( |
| 63 |
Pointee->getReturnType().IgnoreParens().getTypePtr(), ++Indirections); |
| 64 |
} |
| 65 |
|
| 66 |
// Note: Do not increment the 'Indirections' because it is not yet clear |
| 67 |
// if there is an indirection added in the source code of the array |
| 68 |
// declaration. |
| 69 |
if (const auto *AT = dyn_cast<ArrayType>(T)) |
| 70 |
return countIndirections(AT->getElementType().IgnoreParens().getTypePtr(), |
| 71 |
Indirections); |
| 72 |
|
| 73 |
if (isa<PointerType>(T) || isa<ReferenceType>(T)) |
| 74 |
return countIndirections(T->getPointeeType().IgnoreParens().getTypePtr(), |
| 75 |
++Indirections); |
| 76 |
|
| 77 |
return Indirections; |
| 78 |
} |
| 79 |
|
| 80 |
static bool typeIsMemberPointer(const Type *T) { |
| 81 |
if (isa<ArrayType>(T)) |
| 82 |
return typeIsMemberPointer(T->getArrayElementTypeNoTypeQual()); |
| 83 |
|
| 84 |
if ((isa<PointerType>(T) || isa<ReferenceType>(T)) && |
| 85 |
isa<PointerType>(T->getPointeeType())) |
| 86 |
return typeIsMemberPointer(T->getPointeeType().getTypePtr()); |
| 87 |
|
| 88 |
return isa<MemberPointerType>(T); |
| 89 |
} |
| 90 |
|
| 91 |
/// This function tries to extract the SourceRanges that make up all |
| 92 |
/// declarations in this \c DeclStmt. |
| 93 |
/// |
| 94 |
/// The resulting vector has the structure {UnderlyingType, Decl1, Decl2, ...}. |
| 95 |
/// Each \c SourceRange is of the form [Begin, End). |
| 96 |
/// If any of the create ranges is invalid or in a macro the result will be |
| 97 |
/// \c None. |
| 98 |
/// If the \c DeclStmt contains only one declaration, the result is \c None. |
| 99 |
/// If the \c DeclStmt contains declarations other than \c VarDecl the result |
| 100 |
/// is \c None. |
| 101 |
/// |
| 102 |
/// \code |
| 103 |
/// int * ptr1 = nullptr, value = 42; |
| 104 |
/// // [ ][ ] [ ] - The ranges here are inclusive |
| 105 |
/// \endcode |
| 106 |
/// \todo Generalize this function to take other declarations than \c VarDecl. |
| 107 |
static std::optional<std::vector<SourceRange>> |
| 108 |
declRanges(const DeclStmt *DS, const SourceManager &SM, |
| 109 |
const LangOptions &LangOpts) { |
| 110 |
std::size_t DeclCount = std::distance(DS->decl_begin(), DS->decl_end()); |
| 111 |
if (DeclCount < 2) |
| 112 |
return std::nullopt; |
| 113 |
|
| 114 |
if (rangeContainsExpansionsOrDirectives(DS->getSourceRange(), SM, LangOpts)) |
| 115 |
return std::nullopt; |
| 116 |
|
| 117 |
// The initial type of the declaration and each declaration has it's own |
| 118 |
// slice. This is necessary, because pointers and references bind only |
| 119 |
// to the local variable and not to all variables in the declaration. |
| 120 |
// Example: 'int *pointer, value = 42;' |
| 121 |
std::vector<SourceRange> Slices; |
| 122 |
Slices.reserve(DeclCount + 1); |
| 123 |
|
| 124 |
// Calculate the first slice, for now only variables are handled but in the |
| 125 |
// future this should be relaxed and support various kinds of declarations. |
| 126 |
const auto *FirstDecl = dyn_cast<VarDecl>(*DS->decl_begin()); |
| 127 |
|
| 128 |
if (FirstDecl == nullptr) |
| 129 |
return std::nullopt; |
| 130 |
|
| 131 |
// FIXME: Member pointers are not transformed correctly right now, that's |
| 132 |
// why they are treated as problematic here. |
| 133 |
if (typeIsMemberPointer(FirstDecl->getType().IgnoreParens().getTypePtr())) |
| 134 |
return std::nullopt; |
| 135 |
|
| 136 |
// Consider the following case: 'int * pointer, value = 42;' |
| 137 |
// Created slices (inclusive) [ ][ ] [ ] |
| 138 |
// Because 'getBeginLoc' points to the start of the variable *name*, the |
| 139 |
// location of the pointer must be determined separately. |
| 140 |
SourceLocation Start = findStartOfIndirection( |
| 141 |
FirstDecl->getLocation(), |
| 142 |
countIndirections(FirstDecl->getType().IgnoreParens().getTypePtr()), SM, |
| 143 |
LangOpts); |
| 144 |
|
| 145 |
// Fix function-pointer declarations that have a '(' in front of the |
| 146 |
// pointer. |
| 147 |
// Example: 'void (*f2)(int), (*g2)(int, float) = gg;' |
| 148 |
// Slices: [ ][ ] [ ] |
| 149 |
if (FirstDecl->getType()->isFunctionPointerType()) |
| 150 |
Start = findPreviousTokenKind(Start, SM, LangOpts, tok::l_paren); |
| 151 |
|
| 152 |
// It is possible that a declarator is wrapped with parens. |
| 153 |
// Example: 'float (((*f_ptr2)))[42], *f_ptr3, ((f_value2)) = 42.f;' |
| 154 |
// The slice for the type-part must not contain these parens. Consequently |
| 155 |
// 'Start' is moved to the most left paren if there are parens. |
| 156 |
while (true) { |
| 157 |
if (Start.isInvalid() || Start.isMacroID()) |
| 158 |
break; |
| 159 |
|
| 160 |
Token T = getPreviousToken(Start, SM, LangOpts); |
| 161 |
if (T.is(tok::l_paren)) { |
| 162 |
Start = findPreviousTokenStart(Start, SM, LangOpts); |
| 163 |
continue; |
| 164 |
} |
| 165 |
break; |
| 166 |
} |
| 167 |
|
| 168 |
SourceRange DeclRange(DS->getBeginLoc(), Start); |
| 169 |
if (DeclRange.isInvalid() || isMacroID(DeclRange)) |
| 170 |
return std::nullopt; |
| 171 |
|
| 172 |
// The first slice, that is prepended to every isolated declaration, is |
| 173 |
// created. |
| 174 |
Slices.emplace_back(DeclRange); |
| 175 |
|
| 176 |
// Create all following slices that each declare a variable. |
| 177 |
SourceLocation DeclBegin = Start; |
| 178 |
for (const auto &Decl : DS->decls()) { |
| 179 |
const auto *CurrentDecl = cast<VarDecl>(Decl); |
| 180 |
|
| 181 |
// FIXME: Member pointers are not transformed correctly right now, that's |
| 182 |
// why they are treated as problematic here. |
| 183 |
if (typeIsMemberPointer(CurrentDecl->getType().IgnoreParens().getTypePtr())) |
| 184 |
return std::nullopt; |
| 185 |
|
| 186 |
SourceLocation DeclEnd = |
| 187 |
CurrentDecl->hasInit() |
| 188 |
? findNextTerminator(CurrentDecl->getInit()->getEndLoc(), SM, |
| 189 |
LangOpts) |
| 190 |
: findNextTerminator(CurrentDecl->getEndLoc(), SM, LangOpts); |
| 191 |
|
| 192 |
SourceRange VarNameRange(DeclBegin, DeclEnd); |
| 193 |
if (VarNameRange.isInvalid() || isMacroID(VarNameRange)) |
| 194 |
return std::nullopt; |
| 195 |
|
| 196 |
Slices.emplace_back(VarNameRange); |
| 197 |
DeclBegin = DeclEnd.getLocWithOffset(1); |
| 198 |
} |
| 199 |
return Slices; |
| 200 |
} |
| 201 |
|
| 202 |
static std::optional<std::vector<StringRef>> |
| 203 |
collectSourceRanges(llvm::ArrayRef<SourceRange> Ranges, const SourceManager &SM, |
| 204 |
const LangOptions &LangOpts) { |
| 205 |
std::vector<StringRef> Snippets; |
| 206 |
Snippets.reserve(Ranges.size()); |
| 207 |
|
| 208 |
for (const auto &Range : Ranges) { |
| 209 |
CharSourceRange CharRange = Lexer::getAsCharRange( |
| 210 |
CharSourceRange::getCharRange(Range.getBegin(), Range.getEnd()), SM, |
| 211 |
LangOpts); |
| 212 |
|
| 213 |
if (CharRange.isInvalid()) |
| 214 |
return std::nullopt; |
| 215 |
|
| 216 |
bool InvalidText = false; |
| 217 |
StringRef Snippet = |
| 218 |
Lexer::getSourceText(CharRange, SM, LangOpts, &InvalidText); |
| 219 |
|
| 220 |
if (InvalidText) |
| 221 |
return std::nullopt; |
| 222 |
|
| 223 |
Snippets.emplace_back(Snippet); |
| 224 |
} |
| 225 |
|
| 226 |
return Snippets; |
| 227 |
} |
| 228 |
|
| 229 |
/// Expects a vector {TypeSnippet, Firstdecl, SecondDecl, ...}. |
| 230 |
static std::vector<std::string> |
| 231 |
createIsolatedDecls(llvm::ArrayRef<StringRef> Snippets) { |
| 232 |
// The first section is the type snippet, which does not make a decl itself. |
| 233 |
assert(Snippets.size() > 2 && "Not enough snippets to create isolated decls"); |
| 234 |
std::vector<std::string> Decls(Snippets.size() - 1); |
| 235 |
|
| 236 |
for (std::size_t I = 1; I < Snippets.size(); ++I) |
| 237 |
Decls[I - 1] = Twine(Snippets[0]) |
| 238 |
.concat(Snippets[0].endswith(" ") ? "" : " ") |
| 239 |
.concat(Snippets[I].ltrim()) |
| 240 |
.concat(";") |
| 241 |
.str(); |
| 242 |
|
| 243 |
return Decls; |
| 244 |
} |
| 245 |
|
| 246 |
void IsolateDeclarationCheck::check(const MatchFinder::MatchResult &Result) { |
| 247 |
const auto *WholeDecl = Result.Nodes.getNodeAs<DeclStmt>("decl_stmt"); |
| 248 |
|
| 249 |
auto Diag = |
| 250 |
diag(WholeDecl->getBeginLoc(), |
| 251 |
"multiple declarations in a single statement reduces readability"); |
| 252 |
|
| 253 |
std::optional<std::vector<SourceRange>> PotentialRanges = |
| 254 |
declRanges(WholeDecl, *Result.SourceManager, getLangOpts()); |
| 255 |
if (!PotentialRanges) |
| 256 |
return; |
| 257 |
|
| 258 |
std::optional<std::vector<StringRef>> PotentialSnippets = collectSourceRanges( |
| 259 |
*PotentialRanges, *Result.SourceManager, getLangOpts()); |
| 260 |
|
| 261 |
if (!PotentialSnippets) |
| 262 |
return; |
| 263 |
|
| 264 |
std::vector<std::string> NewDecls = createIsolatedDecls(*PotentialSnippets); |
| 265 |
std::string Replacement = llvm::join( |
| 266 |
NewDecls, |
| 267 |
(Twine("\n") + Lexer::getIndentationForLine(WholeDecl->getBeginLoc(), |
| 268 |
*Result.SourceManager)) |
| 269 |
.str()); |
| 270 |
|
| 271 |
Diag << FixItHint::CreateReplacement(WholeDecl->getSourceRange(), |
| 272 |
Replacement); |
| 273 |
} |
| 274 |
} // namespace clang::tidy::readability |