| 1 |
//===--- TimeSubtractionCheck.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 "TimeSubtractionCheck.h" |
| 10 |
#include "DurationRewriter.h" |
| 11 |
#include "clang/AST/ASTContext.h" |
| 12 |
#include "clang/ASTMatchers/ASTMatchFinder.h" |
| 13 |
#include "clang/Lex/Lexer.h" |
| 14 |
#include "clang/Tooling/FixIt.h" |
| 15 |
#include <optional> |
| 16 |
|
| 17 |
using namespace clang::ast_matchers; |
| 18 |
|
| 19 |
namespace clang::tidy::abseil { |
| 20 |
|
| 21 |
// Returns `true` if `Range` is inside a macro definition. |
| 22 |
static bool insideMacroDefinition(const MatchFinder::MatchResult &Result, |
| 23 |
SourceRange Range) { |
| 24 |
return !clang::Lexer::makeFileCharRange( |
| 25 |
clang::CharSourceRange::getCharRange(Range), |
| 26 |
*Result.SourceManager, Result.Context->getLangOpts()) |
| 27 |
.isValid(); |
| 28 |
} |
| 29 |
|
| 30 |
static bool isConstructorAssignment(const MatchFinder::MatchResult &Result, |
| 31 |
const Expr *Node) { |
| 32 |
// For C++14 and earlier there are elidable constructors that must be matched |
| 33 |
// in hasParent. The elidable constructors do not exist in C++17 and later and |
| 34 |
// therefore an additional check that does not match against the elidable |
| 35 |
// constructors are needed for this case. |
| 36 |
return selectFirst<const Expr>( |
| 37 |
"e", |
| 38 |
match(expr(anyOf( |
| 39 |
callExpr(hasParent(materializeTemporaryExpr(hasParent( |
| 40 |
cxxConstructExpr(hasParent(exprWithCleanups( |
| 41 |
hasParent(varDecl())))))))) |
| 42 |
.bind("e"), |
| 43 |
callExpr(hasParent(varDecl())).bind("e"))), |
| 44 |
*Node, *Result.Context)) != nullptr; |
| 45 |
} |
| 46 |
|
| 47 |
static bool isArgument(const MatchFinder::MatchResult &Result, |
| 48 |
const Expr *Node) { |
| 49 |
// For the same reason as in isConstructorAssignment two AST shapes need to be |
| 50 |
// matched here. |
| 51 |
return selectFirst<const Expr>( |
| 52 |
"e", |
| 53 |
match( |
| 54 |
expr(anyOf( |
| 55 |
expr(hasParent(materializeTemporaryExpr( |
| 56 |
hasParent(cxxConstructExpr( |
| 57 |
hasParent(callExpr()), |
| 58 |
unless(hasParent(cxxOperatorCallExpr()))))))) |
| 59 |
.bind("e"), |
| 60 |
expr(hasParent(callExpr()), |
| 61 |
unless(hasParent(cxxOperatorCallExpr()))) |
| 62 |
.bind("e"))), |
| 63 |
*Node, *Result.Context)) != nullptr; |
| 64 |
} |
| 65 |
|
| 66 |
static bool isReturn(const MatchFinder::MatchResult &Result, const Expr *Node) { |
| 67 |
// For the same reason as in isConstructorAssignment two AST shapes need to be |
| 68 |
// matched here. |
| 69 |
return selectFirst<const Expr>( |
| 70 |
"e", |
| 71 |
match(expr(anyOf( |
| 72 |
expr(hasParent(materializeTemporaryExpr(hasParent( |
| 73 |
cxxConstructExpr(hasParent(exprWithCleanups( |
| 74 |
hasParent(returnStmt())))))))) |
| 75 |
.bind("e"), |
| 76 |
expr(hasParent(returnStmt())).bind("e"))), |
| 77 |
*Node, *Result.Context)) != nullptr; |
| 78 |
} |
| 79 |
|
| 80 |
static bool parensRequired(const MatchFinder::MatchResult &Result, |
| 81 |
const Expr *Node) { |
| 82 |
// TODO: Figure out any more contexts in which we can omit the surrounding |
| 83 |
// parentheses. |
| 84 |
return !(isConstructorAssignment(Result, Node) || isArgument(Result, Node) || |
| 85 |
isReturn(Result, Node)); |
| 86 |
} |
| 87 |
|
| 88 |
void TimeSubtractionCheck::emitDiagnostic(const Expr *Node, |
| 89 |
llvm::StringRef Replacement) { |
| 90 |
diag(Node->getBeginLoc(), "perform subtraction in the time domain") |
| 91 |
<< FixItHint::CreateReplacement(Node->getSourceRange(), Replacement); |
| 92 |
} |
| 93 |
|
| 94 |
void TimeSubtractionCheck::registerMatchers(MatchFinder *Finder) { |
| 95 |
for (const char *ScaleName : |
| 96 |
{"Hours", "Minutes", "Seconds", "Millis", "Micros", "Nanos"}) { |
| 97 |
std::string TimeInverse = (llvm::Twine("ToUnix") + ScaleName).str(); |
| 98 |
std::optional<DurationScale> Scale = getScaleForTimeInverse(TimeInverse); |
| 99 |
assert(Scale && "Unknown scale encountered"); |
| 100 |
|
| 101 |
auto TimeInverseMatcher = callExpr(callee( |
| 102 |
functionDecl(hasName((llvm::Twine("::absl::") + TimeInverse).str())) |
| 103 |
.bind("func_decl"))); |
| 104 |
|
| 105 |
// Match the cases where we know that the result is a 'Duration' and the |
| 106 |
// first argument is a 'Time'. Just knowing the type of the first operand |
| 107 |
// is not sufficient, since the second operand could be either a 'Time' or |
| 108 |
// a 'Duration'. If we know the result is a 'Duration', we can then infer |
| 109 |
// that the second operand must be a 'Time'. |
| 110 |
auto CallMatcher = |
| 111 |
callExpr( |
| 112 |
callee(functionDecl(hasName(getDurationFactoryForScale(*Scale)))), |
| 113 |
hasArgument(0, binaryOperator(hasOperatorName("-"), |
| 114 |
hasLHS(TimeInverseMatcher)) |
| 115 |
.bind("binop"))) |
| 116 |
.bind("outer_call"); |
| 117 |
Finder->addMatcher(CallMatcher, this); |
| 118 |
|
| 119 |
// Match cases where we know the second operand is a 'Time'. Since |
| 120 |
// subtracting a 'Time' from a 'Duration' is not defined, in these cases, |
| 121 |
// we always know the first operand is a 'Time' if the second is a 'Time'. |
| 122 |
auto OperandMatcher = |
| 123 |
binaryOperator(hasOperatorName("-"), hasRHS(TimeInverseMatcher)) |
| 124 |
.bind("binop"); |
| 125 |
Finder->addMatcher(OperandMatcher, this); |
| 126 |
} |
| 127 |
} |
| 128 |
|
| 129 |
void TimeSubtractionCheck::check(const MatchFinder::MatchResult &Result) { |
| 130 |
const auto *BinOp = Result.Nodes.getNodeAs<BinaryOperator>("binop"); |
| 131 |
std::string InverseName = |
| 132 |
Result.Nodes.getNodeAs<FunctionDecl>("func_decl")->getNameAsString(); |
| 133 |
if (insideMacroDefinition(Result, BinOp->getSourceRange())) |
| 134 |
return; |
| 135 |
|
| 136 |
std::optional<DurationScale> Scale = getScaleForTimeInverse(InverseName); |
| 137 |
if (!Scale) |
| 138 |
return; |
| 139 |
|
| 140 |
const auto *OuterCall = Result.Nodes.getNodeAs<CallExpr>("outer_call"); |
| 141 |
if (OuterCall) { |
| 142 |
if (insideMacroDefinition(Result, OuterCall->getSourceRange())) |
| 143 |
return; |
| 144 |
|
| 145 |
// We're working with the first case of matcher, and need to replace the |
| 146 |
// entire 'Duration' factory call. (Which also means being careful about |
| 147 |
// our order-of-operations and optionally putting in some parenthesis. |
| 148 |
bool NeedParens = parensRequired(Result, OuterCall); |
| 149 |
|
| 150 |
emitDiagnostic( |
| 151 |
OuterCall, |
| 152 |
(llvm::Twine(NeedParens ? "(" : "") + |
| 153 |
rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) + " - " + |
| 154 |
rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) + |
| 155 |
(NeedParens ? ")" : "")) |
| 156 |
.str()); |
| 157 |
} else { |
| 158 |
// We're working with the second case of matcher, and either just need to |
| 159 |
// change the arguments, or perhaps remove an outer function call. In the |
| 160 |
// latter case (addressed first), we also need to worry about parenthesis. |
| 161 |
const auto *MaybeCallArg = selectFirst<const CallExpr>( |
| 162 |
"arg", match(expr(hasAncestor( |
| 163 |
callExpr(callee(functionDecl(hasName( |
| 164 |
getDurationFactoryForScale(*Scale))))) |
| 165 |
.bind("arg"))), |
| 166 |
*BinOp, *Result.Context)); |
| 167 |
if (MaybeCallArg && MaybeCallArg->getArg(0)->IgnoreImpCasts() == BinOp && |
| 168 |
!insideMacroDefinition(Result, MaybeCallArg->getSourceRange())) { |
| 169 |
// Handle the case where the matched expression is inside a call which |
| 170 |
// converts it from the inverse to a Duration. In this case, we replace |
| 171 |
// the outer with just the subtraction expression, which gives the right |
| 172 |
// type and scale, taking care again about parenthesis. |
| 173 |
bool NeedParens = parensRequired(Result, MaybeCallArg); |
| 174 |
|
| 175 |
emitDiagnostic( |
| 176 |
MaybeCallArg, |
| 177 |
(llvm::Twine(NeedParens ? "(" : "") + |
| 178 |
rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) + |
| 179 |
" - " + |
| 180 |
rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) + |
| 181 |
(NeedParens ? ")" : "")) |
| 182 |
.str()); |
| 183 |
} else { |
| 184 |
// In the last case, just convert the arguments and wrap the result in |
| 185 |
// the correct inverse function. |
| 186 |
emitDiagnostic( |
| 187 |
BinOp, |
| 188 |
(llvm::Twine( |
| 189 |
getDurationInverseForScale(*Scale).second.str().substr(2)) + |
| 190 |
"(" + rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) + |
| 191 |
" - " + |
| 192 |
rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) + ")") |
| 193 |
.str()); |
| 194 |
} |
| 195 |
} |
| 196 |
} |
| 197 |
|
| 198 |
} // namespace clang::tidy::abseil |