1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
//===---------- ASTUtils.cpp - clang-tidy ---------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "ASTUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h"
namespace clang::tidy::utils {
using namespace ast_matchers;
const FunctionDecl *getSurroundingFunction(ASTContext &Context,
const Stmt &Statement) {
return selectFirst<const FunctionDecl>(
"function", match(stmt(hasAncestor(functionDecl().bind("function"))),
Statement, Context));
}
bool isBinaryOrTernary(const Expr *E) {
const Expr *EBase = E->IgnoreImpCasts();
if (isa<BinaryOperator>(EBase) || isa<ConditionalOperator>(EBase)) {
return true;
}
if (const auto *Operator = dyn_cast<CXXOperatorCallExpr>(EBase)) {
return Operator->isInfixBinaryOp();
}
return false;
}
bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
const LangOptions &LangOpts,
StringRef FlagName) {
// If the Flag is an integer constant, check it.
if (isa<IntegerLiteral>(Flags)) {
if (!SM.isMacroBodyExpansion(Flags->getBeginLoc()) &&
!SM.isMacroArgExpansion(Flags->getBeginLoc()))
return false;
// Get the macro name.
auto MacroName = Lexer::getSourceText(
CharSourceRange::getTokenRange(Flags->getSourceRange()), SM, LangOpts);
return MacroName == FlagName;
}
// If it's a binary OR operation.
if (const auto *BO = dyn_cast<BinaryOperator>(Flags))
if (BO->getOpcode() == BinaryOperatorKind::BO_Or)
return exprHasBitFlagWithSpelling(BO->getLHS()->IgnoreParenCasts(), SM,
LangOpts, FlagName) ||
exprHasBitFlagWithSpelling(BO->getRHS()->IgnoreParenCasts(), SM,
LangOpts, FlagName);
// Otherwise, assume it has the flag.
return true;
}
bool rangeIsEntirelyWithinMacroArgument(SourceRange Range,
const SourceManager *SM) {
// Check if the range is entirely contained within a macro argument.
SourceLocation MacroArgExpansionStartForRangeBegin;
SourceLocation MacroArgExpansionStartForRangeEnd;
bool RangeIsEntirelyWithinMacroArgument =
SM &&
SM->isMacroArgExpansion(Range.getBegin(),
&MacroArgExpansionStartForRangeBegin) &&
SM->isMacroArgExpansion(Range.getEnd(),
&MacroArgExpansionStartForRangeEnd) &&
MacroArgExpansionStartForRangeBegin == MacroArgExpansionStartForRangeEnd;
return RangeIsEntirelyWithinMacroArgument;
}
bool rangeContainsMacroExpansion(SourceRange Range, const SourceManager *SM) {
return rangeIsEntirelyWithinMacroArgument(Range, SM) ||
Range.getBegin().isMacroID() || Range.getEnd().isMacroID();
}
bool rangeCanBeFixed(SourceRange Range, const SourceManager *SM) {
return utils::rangeIsEntirelyWithinMacroArgument(Range, SM) ||
!utils::rangeContainsMacroExpansion(Range, SM);
}
bool areStatementsIdentical(const Stmt *FirstStmt, const Stmt *SecondStmt,
const ASTContext &Context, bool Canonical) {
if (!FirstStmt || !SecondStmt)
return false;
if (FirstStmt == SecondStmt)
return true;
if (FirstStmt->getStmtClass() != SecondStmt->getStmtClass())
return false;
if (isa<Expr>(FirstStmt) && isa<Expr>(SecondStmt)) {
// If we have errors in expressions, we will be unable
// to accurately profile and compute hashes for each statements.
if (llvm::cast<Expr>(FirstStmt)->containsErrors() ||
llvm::cast<Expr>(SecondStmt)->containsErrors())
return false;
}
llvm::FoldingSetNodeID DataFirst, DataSecond;
FirstStmt->Profile(DataFirst, Context, Canonical);
SecondStmt->Profile(DataSecond, Context, Canonical);
return DataFirst == DataSecond;
}
const IndirectFieldDecl *
findOutermostIndirectFieldDeclForField(const FieldDecl *FD) {
const RecordDecl *Record = FD->getParent();
assert(Record->isAnonymousStructOrUnion() &&
"FD must be a field in an anonymous record");
const DeclContext *Context = Record;
while (isa<RecordDecl>(Context) &&
cast<RecordDecl>(Context)->isAnonymousStructOrUnion()) {
Context = Context->getParent();
}
// Search for the target IndirectFieldDecl within the located context.
for (const auto *D : Context->decls()) {
const auto *IFD = dyn_cast<IndirectFieldDecl>(D);
if (!IFD)
continue;
if (IFD->getAnonField() == FD)
return IFD;
}
return nullptr;
}
} // namespace clang::tidy::utils
|
