[Clang-tidy] readability check to convert numerical constants to std::numeric_limits

[IdrissRio]

Summary

Hello, i want to propose this check suggested by @EugeneZelenko.
I have found it in the beginner tag of llvm-bugzilla repository.

This check looks for numerical unsigned constants that are equal to -1 or ~0
and substitutes them with std::numeric_limits<type>::max().

It includes the library <limits> if is not found.

Example:

unsigned const int x = -1;

becomes

unsigned const int x = std::numeric_limits<unsigned int>::max();

If the library <limits> is not include in the TU the check will add it with this criteria:

• If a #include is found it will add #include <limits> before this include.
• if no #include directive is found it will add it at the begin of the TU.

[lebedev.ri]

The check itself isn't in the diff.

[IdrissRio]

Sorry i have forgot to add the source code.

[JonasToth]

Hi IdrissRio,

thanks for working on this! I have one question: Why are variables _not_ considered in the check but only constants? IMHO it would make sense to transform these as well.

I dont have time for long review today anymore, I will continue tomorrow.

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

23

Unfortunatly this is duplicated effort.
Please take a look at cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp and
utils/IncludeInserter.{h,cpp} to add new includes from clang-tidy

91

Is failure here expected? The matcher should match both nodes simultanously, if so please use an assert instead to detect unexpected failures

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

17

please indent that code, otherwise its is rendered incorrect

[Eugene.Zelenko]

I think modernize is better module for this check.

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

59

Semicolon at end is not necessary. Please also run Clang-format.

88

Unnecessary empty line.

docs/ReleaseNotes.rst

60

Please use alphabetical order for new checks.

63

Please enclose -1 and ~0 in `.

64

Please enclose std::numeric_limits<type>::max() in ``.

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

8

Please synchronize with Release Notes.

[Eugene.Zelenko]

It'll be good idea to handle climits constants too.

[jfb]

Can you also catch casts such as (unsigned)-1 ?

[Eugene.Zelenko]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

45

Unnecessary empty line.

[JonasToth]

@aaron.ballman I have a question for an expert: How would bitfields relate to this check? Can there be a similar pattern for them and do they need to be handled here?

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

63

you dont need this-> and please use the same return early pattern as in the other registering call

65

its uncommong to specify the global namespace (first ::), you can remove these

78

Please use the full name for the bind, Literal or IntLiteral (please consistent with VarDecl, so CamelCase). I feel that this is more readable (no strong opinion though if you want to leave it as is)

94

Please declar this variable later, directly before usage (locality), and add const SourceManager* SM as you don't seem to manipulate SM

96

You can use llvm::Twine here which is very efficient for concatenation.

std::string Replacement = (Twine("std::numeric_limits<") + Decl->getType().getAtomicUnqualifiedType().getAsString() + ">::max()").str();

108

I think its better to create the source-range before to deal with exceptional cases (invalid ranges, macros)

docs/clang-tidy/checks/list.rst

12

spurious change, does it still happen on master? i thought this was ordered at some point already

220

this does not follow the naming convention (hyphens and not CamelCase)

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

5

please make === full length.

11

This line is slightly inaccurate. The library is the standard library, s/library/header-file

45

Please remove the empty lines at the end

test/clang-tidy/readability-numerical-costants-to-max-int.cpp

10

Please add testcases for macros (literal in macro, variable declaration in macro, other possibilities you might find) and for templates.

template <typename Foo>
void f() {
    Foo f = -1;
}

template <int NonType>
void f2() {
    decltype(NonType) new_var = -1;
}

and variations. Please try to cover as many possible constructs as you can.

Another interesting case are enums, example:

enum FooEnum : unsigned {
   bar = 0,
   foobar = 1,
   maximum = -1
}

You don't need to handle this case yet, but please add a testcase to demonstrate the behaviour of the check for it. Adding a TODO: would be perfect to signal future extendability.

[Eugene.Zelenko]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

63

By the word, see PR32774 for such check suggestion.

[IdrissRio]

Update with the suggestion proposed by @Eugene.Zelenko and @JonasToth

[lebedev.ri]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.h

25

I feel like the name is overly vague.
This *only* handles the cases of -1 and ~0.
It does not handle cases like 255 -> std::numeric_limits<uint_8>::max().
(It might be nice to do that, but it is more complex i suspect.)

[Eugene.Zelenko]

docs/ReleaseNotes.rst

118

Wrong kind of quotes were used. Should be . std::numeric_limits<type>::max() Should be enclosed in `.

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

7

Please re-synchronize.

[JonasToth]

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

63

please assert Lit as well and add an error message in the assert, like assert(Decl && Lit && "Expect both matchers to match");

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

45

Please remove the empty line at the end

test/clang-tidy/readability-numerical-costants-to-max-int.cpp

72

Please add tests that use typedefs (and using = ...) to mask the underlying type. If they dont work, use hasCanonicalType in the matcher, as the canonical type looks through the typedefs.

Common typedefs are uint32_t and the like to control the bitwidth of the integer.

[aaron.ballman]

I like the thrust of this check, but we already have the readability-magic-numbers check and I think that this functionality would fit naturally there. That check finds numerical constants and recommends turning them into named constants, but for special values it seems reasonable to recommend using numeric_limits instead. What do others think of that, from an organizational perspective?

[JonasToth]

In D52892#1263324, @aaron.ballman wrote:

I like the thrust of this check, but we already have the readability-magic-numbers check and I think that this functionality would fit naturally there. That check finds numerical constants and recommends turning them into named constants, but for special values it seems reasonable to recommend using numeric_limits instead. What do others think of that, from an organizational perspective?

+1, totally forgot that one. I feel that the bugprone is more strict though, so adding an readability-mode for it that only warns for the numeric_limits constants seems desirable.

clang-tidy/readability/CMakeLists.txt

add_clang_library(clangTidyReadabilityModule
   ImplicitBoolConversionCheck.cpp
   InconsistentDeclarationParameterNameCheck.cpp
   MagicNumbersCheck.cpp
   MisleadingIndentationCheck.cpp
   MisplacedArrayIndexCheck.cpp
   NamedParameterCheck.cpp
   NamespaceCommentCheck.cpp
   NonConstParameterCheck.cpp
+  NumericalCostantsToMaxIntCheck.cpp
   ReadabilityTidyModule.cpp
   RedundantControlFlowCheck.cpp
   RedundantDeclarationCheck.cpp
   RedundantFunctionPtrDereferenceCheck.cpp
   RedundantMemberInitCheck.cpp
   RedundantSmartptrGetCheck.cpp
   RedundantStringCStrCheck.cpp
   RedundantStringInitCheck.cpp

clang-tidy/readability/NumericalCostantsToMaxIntCheck.h

+//===--- NumericalCostantsToMaxIntCheck.h - clang-tidy ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NUMERICALCOSTANTSTOMAXINTCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NUMERICALCOSTANTSTOMAXINTCHECK_H
+
+#include "../ClangTidy.h"
+#include "../utils/IncludeInserter.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// \brief This check looks for numerical unsigned constants that are equal to
+/// -1 or ~0 and substitutes them with std::numeric_limits<type>::max().
+///
+/// If necessary adds the header file 'limits' of the standard library.
+///
+class NumericalCostantsToMaxIntCheck : public ClangTidyCheck {
+public:
+  NumericalCostantsToMaxIntCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void registerPPCallbacks(CompilerInstance &Compiler) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  const utils::IncludeSorter::IncludeStyle IncludeStyle;
+  std::unique_ptr<utils::IncludeInserter> Inserter;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NUMERICALCOSTANTSTOMAXINTCHECK_H

clang-tidy/readability/NumericalCostantsToMaxIntCheck.cpp

+//===--- NumericalcostantstomaxintCheck.cpp - clang-tidy ------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "NumericalCostantsToMaxIntCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Frontend/CompilerInstance.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+void NumericalCostantsToMaxIntCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "IncludeStyle", IncludeStyle);
+}
+
+NumericalCostantsToMaxIntCheck::NumericalCostantsToMaxIntCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
+          Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
+
+void NumericalCostantsToMaxIntCheck::registerPPCallbacks(
+    CompilerInstance &Compiler) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+
+  Inserter.reset(new utils::IncludeInserter(
+      Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
+  Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
+}
+
+void NumericalCostantsToMaxIntCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+  Finder->addMatcher(
+      varDecl(hasType(qualType(allOf(isUnsignedInteger(), isConstQualified()))),
+              anyOf(hasInitializer(ignoringImpCasts(unaryOperator(
+                        hasOperatorName("-"),
+                        hasUnaryOperand(
+                            integerLiteral(equals(1)).bind("Literal"))))),
+                    hasInitializer(ignoringImpCasts(unaryOperator(
+                        hasOperatorName("~"),
+                        hasUnaryOperand(
+                            integerLiteral(equals(0)).bind("Literal")))))))
+          .bind("VarDecl"),
+      this);
+}
+
+void NumericalCostantsToMaxIntCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *Decl = Result.Nodes.getNodeAs<VarDecl>("VarDecl");
+  const auto *Lit = Result.Nodes.getNodeAs<IntegerLiteral>("Literal");
+  assert(Decl != nullptr);
+  std::string InsteadOf = "-1";
+  std::string Replacement =
+      (Twine("std::numeric_limits<") +
+       Decl->getType().getAtomicUnqualifiedType().getAsString() + ">::max()")
+          .str();
+  if (Lit->getValue() == 0)
+    InsteadOf = "~0";
+  const SourceManager *SM = Result.SourceManager;
+  SourceRange LitSR =
+      SourceRange(SM->getSpellingLoc(Lit->getBeginLoc().getLocWithOffset(-1)),
+                  SM->getSpellingLoc(Lit->getEndLoc()));
+  auto Diag = diag(Lit->getLocation(),
+                   "use '%0' instead of '%1' for unsigned constant int")
+              << Replacement << InsteadOf
+              << FixItHint::CreateReplacement(LitSR, Replacement);
+
+  Optional<FixItHint> Insertion = Inserter->CreateIncludeInsertion(
+      Result.SourceManager->getMainFileID(), "limits", true);
+  if (Insertion)
+    Diag << Insertion.getValue();
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "IdentifierNamingCheck.h"
 #include "ImplicitBoolConversionCheck.h"
 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "MagicNumbersCheck.h"
 #include "MisleadingIndentationCheck.h"
 #include "MisplacedArrayIndexCheck.h"
 #include "NamedParameterCheck.h"
 #include "NonConstParameterCheck.h"
+#include "NumericalCostantsToMaxIntCheck.h"
 #include "RedundantControlFlowCheck.h"
 #include "RedundantDeclarationCheck.h"
 #include "RedundantFunctionPtrDereferenceCheck.h"
 #include "RedundantMemberInitCheck.h"
 #include "RedundantSmartptrGetCheck.h"
 #include "RedundantStringCStrCheck.h"
 #include "RedundantStringInitCheck.h"
 #include "SimplifyBooleanExprCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<InconsistentDeclarationParameterNameCheck>(
         "readability-inconsistent-declaration-parameter-name");
     CheckFactories.registerCheck<MagicNumbersCheck>(
         "readability-magic-numbers");
     CheckFactories.registerCheck<MisleadingIndentationCheck>(
         "readability-misleading-indentation");
     CheckFactories.registerCheck<MisplacedArrayIndexCheck>(
         "readability-misplaced-array-index");
+    CheckFactories.registerCheck<NumericalCostantsToMaxIntCheck>(
+        "readability-numerical-costants-to-max-int");
     CheckFactories.registerCheck<RedundantFunctionPtrDereferenceCheck>(
         "readability-redundant-function-ptr-dereference");
     CheckFactories.registerCheck<RedundantMemberInitCheck>(
         "readability-redundant-member-init");
     CheckFactories.registerCheck<SimplifySubscriptExprCheck>(
         "readability-simplify-subscript-expr");
     CheckFactories.registerCheck<StaticAccessedThroughInstanceCheck>(
         "readability-static-accessed-through-instance");

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
 - New :doc:`abseil-duration-division
   <clang-tidy/checks/abseil-duration-division>` check.
 
   Checks for uses of ``absl::Duration`` division that is done in a
   floating-point context, and recommends the use of a function that
   returns a floating-point value.
 
 - New :doc:`abseil-faster-strsplit-delimiter
   <clang-tidy/checks/abseil-faster-strsplit-delimiter>` check.
 
   Finds instances of ``absl::StrSplit()`` or ``absl::MaxSplits()`` where the
   delimiter is a single character string literal and replaces with a character.
 
- New :doc:`modernize-deprecated-ios-base-aliases
   This check warns the uses of the deprecated member types of ``std::ios_base``
   and replaces those that have a non-deprecated equivalent.
 
 - New :doc:`readability-magic-numbers
   <clang-tidy/checks/readability-magic-numbers>` check.
 
   Detects usage of magic numbers, numbers that are used as literals instead of
   introduced via constants or symbols.
   
+- New :doc:`readability-numerical-costants-to-max-int
+  <clang-tidy/checks/readability-numerical-costants-to-max-int>` check.
+
+  Checks for numerical unsigned constants that are equal to '-1' or '~0'
+  and substitutes them with 'std::numeric_limits<type>::max()'.
+
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

docs/clang-tidy/checks/list.rst

 .. title:: clang-tidy - Clang-Tidy Checks
 
 Clang-Tidy Checks
 =================
 
 .. toctree::
    abseil-duration-division
    abseil-faster-strsplit-delimiter
    abseil-no-internal-dependencies
    abseil-no-namespace
    abseil-redundant-strcat-calls
    abseil-string-find-startswith
    abseil-str-cat-append
    android-cloexec-accept
    android-cloexec-accept4
    android-cloexec-creat
    android-cloexec-dup
    android-cloexec-epoll-create
    android-cloexec-epoll-create1
    android-cloexec-fopen
.. toctree::
    performance-inefficient-vector-operation
    performance-move-const-arg
    performance-move-constructor-init
    performance-noexcept-move-constructor
    performance-type-promotion-in-math-fn
    performance-unnecessary-copy-initialization
    performance-unnecessary-value-param
    portability-simd-intrinsics
    readability-avoid-const-params-in-decls
    readability-braces-around-statements
    readability-container-size-empty
    readability-delete-null-pointer
    readability-deleted-default
    readability-else-after-return
    readability-function-size
    readability-identifier-naming
    readability-implicit-bool-conversion
    readability-inconsistent-declaration-parameter-name
    readability-magic-numbers
    readability-misleading-indentation
    readability-misplaced-array-index
    readability-named-parameter
    readability-non-const-parameter
+   readability-numerical-costants-to-max-int
    readability-redundant-control-flow
    readability-redundant-declaration
    readability-redundant-function-ptr-dereference
    readability-redundant-member-init
    readability-redundant-smartptr-get
    readability-redundant-string-cstr
    readability-redundant-string-init
    readability-simplify-boolean-expr
    readability-simplify-subscript-expr
    readability-static-accessed-through-instance
    readability-static-definition-in-anonymous-namespace
    readability-string-compare
    readability-uniqueptr-delete-release
    zircon-temporary-objects

docs/clang-tidy/checks/readability-numerical-costants-to-max-int.rst

+.. title:: clang-tidy - readability-numerical-costants-to-max-int
+
+readability-numerical-costants-to-max-int
+=========================================
+
+
+Checks for numerical unsigned constants that are equal to '-1' or '~0'
+and substitutes them with 'std::numeric_limits<type>::max()'.
+
+If necessary adds the header file 'limits' of the standard library.
+
+Examples:
+
+.. code-block:: c++
+
+  unsigned const long int x = -1;
+
+becomes
+
+.. code-block:: c++
+
+  unsigned const long int x = std::numeric_limits<unsigned long>::max();
+
+or
+
+.. code-block:: c++
+
+  unsigned const short x = ~0;
+
+
+becomes
+
+.. code-block:: c++
+
+  unsigned const short x = std::numeric_limits<short>::max();
+
+  
+Options
+-------
+
+.. option:: IncludeStyle
+
+   A string specifying which include-style is used, `llvm` or `google`. Default
+   is `llvm`.
 No newline at end of file

test/clang-tidy/readability-numerical-costants-to-max-int.cpp

+// RUN: %check_clang_tidy %s readability-numerical-costants-to-max-int %t
+unsigned const int Uval1 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: #include <limits>
+// CHECK-FIXES: unsigned const int Uval1 = std::numeric_limits<unsigned int>::max();
+
+unsigned const long Uval2 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long Uval2 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long int Uval3 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long int Uval3 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long long int Uval4 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:39: warning: use 'std::numeric_limits<unsigned long long>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long long int Uval4 = std::numeric_limits<unsigned long long>::max();
+
+unsigned const short int Uval5 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: use 'std::numeric_limits<unsigned short>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const short int Uval5 = std::numeric_limits<unsigned short>::max();
+
+unsigned const Uval6 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const Uval6 = std::numeric_limits<unsigned int>::max();
+
+unsigned const char Uval7 = -1;
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: use 'std::numeric_limits<unsigned char>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const char Uval7 = std::numeric_limits<unsigned char>::max();
+
+//if not constants do nothing
+unsigned int Uval8 = -1;
+unsigned long Uval9 = -1;
+unsigned long int Uval10 = -1;
+unsigned long long int Uval11 = -1;
+unsigned short int Uval12 = -1;
+unsigned Uval13 = -1;
+unsigned char Uval14 = -1;
+
+unsigned const long Uval15 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long Uval15 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long int Uval16 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: use 'std::numeric_limits<unsigned long>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long int Uval16 = std::numeric_limits<unsigned long>::max();
+
+unsigned const long long int Uval17 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:40: warning: use 'std::numeric_limits<unsigned long long>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const long long int Uval17 = std::numeric_limits<unsigned long long>::max();
+
+unsigned const short int Uval18 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: use 'std::numeric_limits<unsigned short>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const short int Uval18 = std::numeric_limits<unsigned short>::max();
+
+unsigned const Uval19 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const Uval19 = std::numeric_limits<unsigned int>::max();
+
+unsigned const char Uval20 = ~0;
+// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use 'std::numeric_limits<unsigned char>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+// CHECK-FIXES: unsigned const char Uval20 = std::numeric_limits<unsigned char>::max();
+
+//if not constants do nothing
+unsigned int Uval21 = ~0;
+unsigned long Uva22 = ~0;
+unsigned long int Uval23 = ~0;
+unsigned long long int Uval24 = ~0;
+unsigned short int Uval25 = ~0;
+unsigned Uval26 = ~0;
+unsigned char Uval27 = ~0;
+
+#define UNSIGNED unsigned
+#define CONST const
+#define UNSIGNEDCONST unsigned const
+#define UNSIGNEDCONSTDECLMINUS unsigned const x1 = -1;
+// CHECK-FIXES: #define UNSIGNEDCONSTDECLMINUS unsigned const x1 = std::numeric_limits<unsigned int>::max();
+
+#define UNSIGNEDCONSTDECLBITWISE unsigned const x2 = ~0;
+// CHECK-FIXES: #define UNSIGNEDCONSTDECLBITWISE unsigned const x2 = std::numeric_limits<unsigned int>::max();
+
+#define MINUSONE -1;
+// CHECK-FIXES: #define MINUSONE std::numeric_limits<unsigned int>::max();
+
+#define BITWISEZERO ~0;
+// CHECK-FIXES: #define BITWISEZERO std::numeric_limits<unsigned int>::max();
+template <typename Foo>
+void f() {
+  Foo f = -1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+  // CHECK-FIXES: Foo f = std::numeric_limits<unsigned int>::max();
+}
+
+void testFunction() {
+  f<const unsigned>();
+
+  const UNSIGNED int y = -1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+  // CHECK-FIXES: const UNSIGNED int y = std::numeric_limits<unsigned int>::max();
+
+  UNSIGNED CONST z = -1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+  // CHECK-FIXES: UNSIGNED CONST z = std::numeric_limits<unsigned int>::max();
+
+  UNSIGNEDCONST w = -1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+  // CHECK-FIXES: UNSIGNEDCONST w = std::numeric_limits<unsigned int>::max();
+
+  UNSIGNEDCONSTDECLMINUS
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+
+  UNSIGNEDCONSTDECLBITWISE
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+
+  UNSIGNEDCONST int a = MINUSONE;
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '-1' for unsigned constant int [readability-numerical-costants-to-max-int]
+
+  UNSIGNEDCONST int b = BITWISEZERO;
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use 'std::numeric_limits<unsigned int>::max()' instead of '~0' for unsigned constant int [readability-numerical-costants-to-max-int]
+}