| //===--- 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 { |
| namespace tidy { |
| namespace 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 std::string RawIgnoredIntegerValues; |
| const std::string 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 readability |
| } // namespace tidy |
| } // namespace clang |
| |
| #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAGICNUMBERSCHECK_H |