1 | //===--- MagicNumbersCheck.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 | // A checker for magic numbers: integer or floating point literals embedded |
10 | // in the code, outside the definition of a constant or an enumeration. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #include "MagicNumbersCheck.h" |
15 | #include "../utils/OptionsUtils.h" |
16 | #include "clang/AST/ASTContext.h" |
17 | #include "clang/AST/ASTTypeTraits.h" |
18 | #include "clang/AST/Type.h" |
19 | #include "clang/ASTMatchers/ASTMatchFinder.h" |
20 | #include "llvm/ADT/STLExtras.h" |
21 | |
22 | using namespace clang::ast_matchers; |
23 | |
24 | namespace clang { |
25 | |
26 | static bool isUsedToInitializeAConstant(const MatchFinder::MatchResult &Result, |
27 | const DynTypedNode &Node) { |
28 | |
29 | const auto *AsDecl = Node.get<DeclaratorDecl>(); |
30 | if (AsDecl) { |
31 | if (AsDecl->getType().isConstQualified()) |
32 | return true; |
33 | |
34 | return AsDecl->isImplicit(); |
35 | } |
36 | |
37 | if (Node.get<EnumConstantDecl>()) |
38 | return true; |
39 | |
40 | return llvm::any_of(Range: Result.Context->getParents(Node), |
41 | P: [&Result](const DynTypedNode &Parent) { |
42 | return isUsedToInitializeAConstant(Result, Node: Parent); |
43 | }); |
44 | } |
45 | |
46 | static bool isUsedToDefineATypeAlias(const MatchFinder::MatchResult &Result, |
47 | const DynTypedNode &Node) { |
48 | |
49 | if (Node.get<TypeAliasDecl>() || Node.get<TypedefNameDecl>()) |
50 | return true; |
51 | |
52 | return llvm::any_of(Range: Result.Context->getParents(Node), |
53 | P: [&Result](const DynTypedNode &Parent) { |
54 | return isUsedToDefineATypeAlias(Result, Node: Parent); |
55 | }); |
56 | } |
57 | |
58 | static bool isUsedToDefineABitField(const MatchFinder::MatchResult &Result, |
59 | const DynTypedNode &Node) { |
60 | const auto *AsFieldDecl = Node.get<FieldDecl>(); |
61 | if (AsFieldDecl && AsFieldDecl->isBitField()) |
62 | return true; |
63 | |
64 | return llvm::any_of(Range: Result.Context->getParents(Node), |
65 | P: [&Result](const DynTypedNode &Parent) { |
66 | return isUsedToDefineABitField(Result, Node: Parent); |
67 | }); |
68 | } |
69 | |
70 | namespace tidy::readability { |
71 | |
72 | const char DefaultIgnoredIntegerValues[] = "1;2;3;4;" ; |
73 | const char DefaultIgnoredFloatingPointValues[] = "1.0;100.0;" ; |
74 | |
75 | MagicNumbersCheck::MagicNumbersCheck(StringRef Name, ClangTidyContext *Context) |
76 | : ClangTidyCheck(Name, Context), |
77 | IgnoreAllFloatingPointValues( |
78 | Options.get(LocalName: "IgnoreAllFloatingPointValues" , Default: false)), |
79 | IgnoreBitFieldsWidths(Options.get(LocalName: "IgnoreBitFieldsWidths" , Default: true)), |
80 | IgnorePowersOf2IntegerValues( |
81 | Options.get(LocalName: "IgnorePowersOf2IntegerValues" , Default: false)), |
82 | IgnoreTypeAliases(Options.get(LocalName: "IgnoreTypeAliases" , Default: false)), |
83 | IgnoreUserDefinedLiterals( |
84 | Options.get(LocalName: "IgnoreUserDefinedLiterals" , Default: false)), |
85 | RawIgnoredIntegerValues( |
86 | Options.get(LocalName: "IgnoredIntegerValues" , Default: DefaultIgnoredIntegerValues)), |
87 | RawIgnoredFloatingPointValues(Options.get( |
88 | LocalName: "IgnoredFloatingPointValues" , Default: DefaultIgnoredFloatingPointValues)) { |
89 | // Process the set of ignored integer values. |
90 | const std::vector<StringRef> IgnoredIntegerValuesInput = |
91 | utils::options::parseStringList(Option: RawIgnoredIntegerValues); |
92 | IgnoredIntegerValues.resize(N: IgnoredIntegerValuesInput.size()); |
93 | llvm::transform(Range: IgnoredIntegerValuesInput, d_first: IgnoredIntegerValues.begin(), |
94 | F: [](StringRef Value) { |
95 | int64_t Res = 0; |
96 | Value.getAsInteger(Radix: 10, Result&: Res); |
97 | return Res; |
98 | }); |
99 | llvm::sort(C&: IgnoredIntegerValues); |
100 | |
101 | if (!IgnoreAllFloatingPointValues) { |
102 | // Process the set of ignored floating point values. |
103 | const std::vector<StringRef> IgnoredFloatingPointValuesInput = |
104 | utils::options::parseStringList(Option: RawIgnoredFloatingPointValues); |
105 | IgnoredFloatingPointValues.reserve(N: IgnoredFloatingPointValuesInput.size()); |
106 | IgnoredDoublePointValues.reserve(N: IgnoredFloatingPointValuesInput.size()); |
107 | for (const auto &InputValue : IgnoredFloatingPointValuesInput) { |
108 | llvm::APFloat FloatValue(llvm::APFloat::IEEEsingle()); |
109 | auto StatusOrErr = |
110 | FloatValue.convertFromString(InputValue, DefaultRoundingMode); |
111 | assert(StatusOrErr && "Invalid floating point representation" ); |
112 | consumeError(Err: StatusOrErr.takeError()); |
113 | IgnoredFloatingPointValues.push_back(Elt: FloatValue.convertToFloat()); |
114 | |
115 | llvm::APFloat DoubleValue(llvm::APFloat::IEEEdouble()); |
116 | StatusOrErr = |
117 | DoubleValue.convertFromString(InputValue, DefaultRoundingMode); |
118 | assert(StatusOrErr && "Invalid floating point representation" ); |
119 | consumeError(Err: StatusOrErr.takeError()); |
120 | IgnoredDoublePointValues.push_back(Elt: DoubleValue.convertToDouble()); |
121 | } |
122 | llvm::sort(C&: IgnoredFloatingPointValues); |
123 | llvm::sort(C&: IgnoredDoublePointValues); |
124 | } |
125 | } |
126 | |
127 | void MagicNumbersCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { |
128 | Options.store(Options&: Opts, LocalName: "IgnoreAllFloatingPointValues" , |
129 | Value: IgnoreAllFloatingPointValues); |
130 | Options.store(Options&: Opts, LocalName: "IgnoreBitFieldsWidths" , Value: IgnoreBitFieldsWidths); |
131 | Options.store(Options&: Opts, LocalName: "IgnorePowersOf2IntegerValues" , |
132 | Value: IgnorePowersOf2IntegerValues); |
133 | Options.store(Options&: Opts, LocalName: "IgnoreTypeAliases" , Value: IgnoreTypeAliases); |
134 | Options.store(Options&: Opts, LocalName: "IgnoreUserDefinedLiterals" , Value: IgnoreUserDefinedLiterals); |
135 | Options.store(Options&: Opts, LocalName: "IgnoredIntegerValues" , Value: RawIgnoredIntegerValues); |
136 | Options.store(Options&: Opts, LocalName: "IgnoredFloatingPointValues" , |
137 | Value: RawIgnoredFloatingPointValues); |
138 | } |
139 | |
140 | void MagicNumbersCheck::registerMatchers(MatchFinder *Finder) { |
141 | Finder->addMatcher(NodeMatch: integerLiteral().bind(ID: "integer" ), Action: this); |
142 | if (!IgnoreAllFloatingPointValues) |
143 | Finder->addMatcher(NodeMatch: floatLiteral().bind(ID: "float" ), Action: this); |
144 | } |
145 | |
146 | void MagicNumbersCheck::check(const MatchFinder::MatchResult &Result) { |
147 | |
148 | TraversalKindScope RAII(*Result.Context, TK_AsIs); |
149 | |
150 | checkBoundMatch<IntegerLiteral>(Result, BoundName: "integer" ); |
151 | checkBoundMatch<FloatingLiteral>(Result, BoundName: "float" ); |
152 | } |
153 | |
154 | bool MagicNumbersCheck::isConstant(const MatchFinder::MatchResult &Result, |
155 | const Expr &ExprResult) const { |
156 | return llvm::any_of( |
157 | Range: Result.Context->getParents(Node: ExprResult), |
158 | P: [this, &Result](const DynTypedNode &Parent) { |
159 | if (isUsedToInitializeAConstant(Result, Node: Parent)) |
160 | return true; |
161 | |
162 | if (IgnoreTypeAliases && isUsedToDefineATypeAlias(Result, Node: Parent)) |
163 | return true; |
164 | |
165 | // Ignore this instance, because this matches an |
166 | // expanded class enumeration value. |
167 | if (Parent.get<CStyleCastExpr>() && |
168 | llvm::any_of( |
169 | Range: Result.Context->getParents(Node: Parent), |
170 | P: [](const DynTypedNode &GrandParent) { |
171 | return GrandParent.get<SubstNonTypeTemplateParmExpr>() != |
172 | nullptr; |
173 | })) |
174 | return true; |
175 | |
176 | // Ignore this instance, because this match reports the |
177 | // location where the template is defined, not where it |
178 | // is instantiated. |
179 | if (Parent.get<SubstNonTypeTemplateParmExpr>()) |
180 | return true; |
181 | |
182 | // Don't warn on string user defined literals: |
183 | // std::string s = "Hello World"s; |
184 | if (const auto *UDL = Parent.get<UserDefinedLiteral>()) |
185 | if (UDL->getLiteralOperatorKind() == UserDefinedLiteral::LOK_String) |
186 | return true; |
187 | |
188 | return false; |
189 | }); |
190 | } |
191 | |
192 | bool MagicNumbersCheck::isIgnoredValue(const IntegerLiteral *Literal) const { |
193 | if (Literal->getType()->isBitIntType()) { |
194 | return true; |
195 | } |
196 | const llvm::APInt IntValue = Literal->getValue(); |
197 | const int64_t Value = IntValue.getZExtValue(); |
198 | if (Value == 0) |
199 | return true; |
200 | |
201 | if (IgnorePowersOf2IntegerValues && IntValue.isPowerOf2()) |
202 | return true; |
203 | |
204 | return llvm::binary_search(Range: IgnoredIntegerValues, Value); |
205 | } |
206 | |
207 | bool MagicNumbersCheck::isIgnoredValue(const FloatingLiteral *Literal) const { |
208 | const llvm::APFloat FloatValue = Literal->getValue(); |
209 | if (FloatValue.isZero()) |
210 | return true; |
211 | |
212 | if (&FloatValue.getSemantics() == &llvm::APFloat::IEEEsingle()) { |
213 | const float Value = FloatValue.convertToFloat(); |
214 | return llvm::binary_search(Range: IgnoredFloatingPointValues, Value); |
215 | } |
216 | |
217 | if (&FloatValue.getSemantics() == &llvm::APFloat::IEEEdouble()) { |
218 | const double Value = FloatValue.convertToDouble(); |
219 | return llvm::binary_search(Range: IgnoredDoublePointValues, Value); |
220 | } |
221 | |
222 | return false; |
223 | } |
224 | |
225 | bool MagicNumbersCheck::isSyntheticValue(const SourceManager *SourceManager, |
226 | const IntegerLiteral *Literal) const { |
227 | const std::pair<FileID, unsigned> FileOffset = |
228 | SourceManager->getDecomposedLoc(Loc: Literal->getLocation()); |
229 | if (FileOffset.first.isInvalid()) |
230 | return false; |
231 | |
232 | const StringRef BufferIdentifier = |
233 | SourceManager->getBufferOrFake(FID: FileOffset.first).getBufferIdentifier(); |
234 | |
235 | return BufferIdentifier.empty(); |
236 | } |
237 | |
238 | bool MagicNumbersCheck::isBitFieldWidth( |
239 | const clang::ast_matchers::MatchFinder::MatchResult &Result, |
240 | const IntegerLiteral &Literal) const { |
241 | return IgnoreBitFieldsWidths && |
242 | llvm::any_of(Range: Result.Context->getParents(Node: Literal), |
243 | P: [&Result](const DynTypedNode &Parent) { |
244 | return isUsedToDefineABitField(Result, Node: Parent); |
245 | }); |
246 | } |
247 | |
248 | bool MagicNumbersCheck::isUserDefinedLiteral( |
249 | const clang::ast_matchers::MatchFinder::MatchResult &Result, |
250 | const clang::Expr &Literal) const { |
251 | DynTypedNodeList Parents = Result.Context->getParents(Node: Literal); |
252 | if (Parents.empty()) |
253 | return false; |
254 | return Parents[0].get<UserDefinedLiteral>() != nullptr; |
255 | } |
256 | |
257 | } // namespace tidy::readability |
258 | } // namespace clang |
259 | |