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
|
//===--- MagicNumbersCheck.h - clang-tidy-----------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAGICNUMBERSCHECK_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAGICNUMBERSCHECK_H
#include "../ClangTidyCheck.h"
#include "clang/Lex/Lexer.h"
#include <llvm/ADT/APFloat.h>
#include <llvm/ADT/SmallVector.h>
namespace clang::tidy::readability {
/// Detects magic numbers, integer and floating point literals embedded in code.
///
/// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/readability/magic-numbers.html
class MagicNumbersCheck : public ClangTidyCheck {
public:
MagicNumbersCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private:
bool isConstant(const clang::ast_matchers::MatchFinder::MatchResult &Result,
const clang::Expr &ExprResult) const;
bool isIgnoredValue(const IntegerLiteral *Literal) const;
bool isIgnoredValue(const FloatingLiteral *Literal) const;
bool isSyntheticValue(const clang::SourceManager *,
const FloatingLiteral *) const {
return false;
}
bool isSyntheticValue(const clang::SourceManager *SourceManager,
const IntegerLiteral *Literal) const;
bool isBitFieldWidth(const clang::ast_matchers::MatchFinder::MatchResult &,
const FloatingLiteral &) const {
return false;
}
bool isBitFieldWidth(const clang::ast_matchers::MatchFinder::MatchResult &Result,
const IntegerLiteral &Literal) const;
template <typename L>
void checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result,
const char *BoundName) {
const L *MatchedLiteral = Result.Nodes.getNodeAs<L>(BoundName);
if (!MatchedLiteral)
return;
if (Result.SourceManager->isMacroBodyExpansion(
MatchedLiteral->getLocation()))
return;
if (isIgnoredValue(MatchedLiteral))
return;
if (isConstant(Result, *MatchedLiteral))
return;
if (isSyntheticValue(Result.SourceManager, MatchedLiteral))
return;
if (isBitFieldWidth(Result, *MatchedLiteral))
return;
const StringRef LiteralSourceText = Lexer::getSourceText(
CharSourceRange::getTokenRange(MatchedLiteral->getSourceRange()),
*Result.SourceManager, getLangOpts());
diag(MatchedLiteral->getLocation(),
"%0 is a magic number; consider replacing it with a named constant")
<< LiteralSourceText;
}
const bool IgnoreAllFloatingPointValues;
const bool IgnoreBitFieldsWidths;
const bool IgnorePowersOf2IntegerValues;
const StringRef RawIgnoredIntegerValues;
const StringRef RawIgnoredFloatingPointValues;
constexpr static unsigned SensibleNumberOfMagicValueExceptions = 16;
constexpr static llvm::APFloat::roundingMode DefaultRoundingMode =
llvm::APFloat::rmNearestTiesToEven;
llvm::SmallVector<int64_t, SensibleNumberOfMagicValueExceptions>
IgnoredIntegerValues;
llvm::SmallVector<float, SensibleNumberOfMagicValueExceptions>
IgnoredFloatingPointValues;
llvm::SmallVector<double, SensibleNumberOfMagicValueExceptions>
IgnoredDoublePointValues;
};
} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAGICNUMBERSCHECK_H
|
