maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang-tools-extra/test/clang-tidy/checkers/readability-uppercase-liter...

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

141 lines
5.8 KiB
C++
Raw Normal View History

[clang-tidy] Re-commit: Add new 'readability-uppercase-literal-suffix' check (CERT DCL16-C, MISRA C:2012, 7.3, MISRA C++:2008, 2-13-4) Summary: Detects when the integral literal or floating point (decimal or hexadecimal) literal has non-uppercase suffix, and suggests to make the suffix uppercase, with fix-it. All valid combinations of suffixes are supported. ``` auto x = 1; // OK, no suffix. auto x = 1u; // warning: integer literal suffix 'u' is not upper-case auto x = 1U; // OK, suffix is uppercase. ... ``` This is a re-commit, the original was reverted by me in rL345305 due to discovered bugs. (implicit code, template instantiation) Tests were added, and the bugs were fixed. I'm unable to find any further bugs, hopefully there aren't any.. References: * [[ https://wiki.sei.cmu.edu/confluence/pages/viewpage.action?pageId=87152241 | CERT DCL16-C ]] * MISRA C:2012, 7.3 - The lowercase character "l" shall not be used in a literal suffix * MISRA C++:2008, 2-13-4 - Literal suffixes shall be upper case Reviewers: JonasToth, aaron.ballman, alexfh, hokein, xazax.hun Reviewed By: aaron.ballman Subscribers: Eugene.Zelenko, mgorny, rnkovacs, cfe-commits Tags: #clang-tools-extra Differential Revision: https://reviews.llvm.org/D52670 llvm-svn: 345381
2018-10-26 21:09:27 +08:00
// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S
// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -target x86_64-pc-linux-gnu -I %S
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %S
#include "readability-uppercase-literal-suffix.h"
void floating_point_suffix() {
static constexpr auto v0 = 0x0p0; // no literal
static_assert(is_same<decltype(v0), const double>::value, "");
static_assert(v0 == 0, "");
// Float
static constexpr auto v1 = 0xfp0f;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v1 = 0xfp0f;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
// CHECK-FIXES: static constexpr auto v1 = 0xfp0F;
static_assert(is_same<decltype(v1), const float>::value, "");
static_assert(v1 == 15, "");
static constexpr auto v2 = 0xfp0F; // OK
static_assert(is_same<decltype(v2), const float>::value, "");
static_assert(v2 == 15, "");
static constexpr auto v3 = 0xfP0f;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v3 = 0xfP0f;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
// CHECK-FIXES: static constexpr auto v3 = 0xfP0F;
static_assert(is_same<decltype(v3), const float>::value, "");
static_assert(v3 == 15, "");
static constexpr auto v4 = 0xfP0F; // OK
static_assert(is_same<decltype(v4), const float>::value, "");
static_assert(v4 == 15, "");
static constexpr auto v5 = 0xFP0f;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v5 = 0xFP0f;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
// CHECK-FIXES: static constexpr auto v5 = 0xFP0F;
static_assert(is_same<decltype(v5), const float>::value, "");
static_assert(v5 == 15, "");
static constexpr auto v6 = 0xFP0F; // OK
static_assert(is_same<decltype(v6), const float>::value, "");
static_assert(v6 == 15, "");
static constexpr auto v7 = 0xFp0f;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v7 = 0xFp0f;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
// CHECK-FIXES: static constexpr auto v7 = 0xFp0F;
static_assert(is_same<decltype(v7), const float>::value, "");
static_assert(v7 == 15, "");
static constexpr auto v8 = 0xFp0F; // OK
static_assert(is_same<decltype(v8), const float>::value, "");
static_assert(v8 == 15, "");
// long double
static constexpr auto v9 = 0xfp0l;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v9 = 0xfp0l;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}L{{$}}
// CHECK-FIXES: static constexpr auto v9 = 0xfp0L;
static_assert(is_same<decltype(v9), const long double>::value, "");
static_assert(v9 == 0xfp0, "");
static constexpr auto v10 = 0xfp0L; // OK.
static_assert(is_same<decltype(v10), const long double>::value, "");
static_assert(v10 == 0xfp0, "");
// __float128
static constexpr auto v11 = 0xfp0q;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v11 = 0xfp0q;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}Q{{$}}
// CHECK-FIXES: static constexpr auto v11 = 0xfp0Q;
static_assert(is_same<decltype(v11), const __float128>::value, "");
static_assert(v11 == 0xfp0, "");
static constexpr auto v12 = 0xfp0Q; // OK.
static_assert(is_same<decltype(v12), const __float128>::value, "");
static_assert(v12 == 0xfp0, "");
}
void floating_point_complex_suffix() {
// _Complex, I
static constexpr auto v14 = 0xfp0i;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v14 = 0xfp0i;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}I{{$}}
// CHECK-FIXES: static constexpr auto v14 = 0xfp0I;
static_assert(is_same<decltype(v14), const _Complex double>::value, "");
static_assert(v14 == 0xfp0I, "");
static constexpr auto v16 = 0xfp0I; // OK.
static_assert(is_same<decltype(v16), const _Complex double>::value, "");
static_assert(v16 == 0xfp0I, "");
// _Complex, J
static constexpr auto v18 = 0xfp0j;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v18 = 0xfp0j;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}J{{$}}
// CHECK-FIXES: static constexpr auto v18 = 0xfp0J;
static_assert(is_same<decltype(v18), const _Complex double>::value, "");
static_assert(v18 == 0xfp0J, "");
static constexpr auto v20 = 0xfp0J; // OK.
static_assert(is_same<decltype(v20), const _Complex double>::value, "");
static_assert(v20 == 0xfp0J, "");
}
void macros() {
#define PASSTHROUGH(X) X
static constexpr auto m0 = PASSTHROUGH(0x0p0f);
// CHECK-MESSAGES: :[[@LINE-1]]:42: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(0x0p0f);
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: {{^ *}}F{{$}}
// CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(0x0p0F);
static_assert(is_same<decltype(m0), const float>::value, "");
static_assert(m0 == 0x0p0F, "");
}