shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

[clang-tidy] Teach readability-uppercase-literal-suffix about C++23 and C23 suffixes (#148275)

Browse Source 
Clang doesn't actually support any of the new floating point types yet
(except for `f16`). I've decided to add disabled tests for them, so that
when the support comes, we can flip the switch and support them with no
delay.
This commit is contained in:
Victor Chernyakin 2025-08-31 16:38:22 -07:00 committed by GitHub
parent 5109361d4a
commit a49030e493
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 414 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
View File

@ -25,10 +25,11 @@ struct IntegerLiteralCheck {
static constexpr llvm::StringLiteral Name = llvm::StringLiteral("integer");
// What should be skipped before looking for the Suffixes? (Nothing here.)
static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral("");
// Suffix can only consist of 'u' and 'l' chars, and can be a complex number
// ('i', 'j'). In MS compatibility mode, suffixes like i32 are supported.
// Suffix can only consist of 'u', 'l', and 'z' chars, can be a bit-precise
// integer (wb), and can be a complex number ('i', 'j'). In MS compatibility
// mode, suffixes like i32 are supported.
static constexpr llvm::StringLiteral Suffixes =
llvm::StringLiteral("uUlLiIjJ");
llvm::StringLiteral("uUlLzZwWbBiIjJ");
};
struct FloatingLiteralCheck {
@ -42,10 +43,10 @@ struct FloatingLiteralCheck {
// Since the exponent ('p'/'P') is mandatory for hexadecimal floating-point
// literals, we first skip everything before the exponent.
static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral("pP");
// Suffix can only consist of 'f', 'l', "f16", 'h', 'q' chars,
// and can be a complex number ('i', 'j').
// Suffix can only consist of 'f', 'l', "f16", "bf16", "df", "dd", "dl",
// 'h', 'q' chars, and can be a complex number ('i', 'j').
static constexpr llvm::StringLiteral Suffixes =
llvm::StringLiteral("fFlLhHqQiIjJ");
llvm::StringLiteral("fFlLbBdDhHqQiIjJ");
};
struct NewSuffix {

4
clang-tools-extra/docs/ReleaseNotes.rst
View File

@ -245,6 +245,10 @@ Changes in existing checks
<clang-tidy/checks/readability/qualified-auto>` check by adding the option
`IgnoreAliasing`, that allows not looking at underlying types of type aliases.
- Improved :doc:`readability-uppercase-literal-suffix
<clang-tidy/checks/readability/uppercase-literal-suffix>` check to recognize
literal suffixes added in C++23 and C23.
Removed checks
^^^^^^^^^^^^^^

18
clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/stdfloat Normal file
View File

@ -0,0 +1,18 @@
//===--- stdfloat - Stub header for tests -----------------------*- 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 _STDFLOAT_
#define _STDFLOAT_
namespace std {
// TODO: define std::float16_t and friends
}
#endif // _STDFLOAT_

29
clang-tools-extra/test/clang-tidy/checkers/cert/uppercase-literal-suffix-integer.cpp
View File

@ -1,14 +1,9 @@
// RUN: %check_clang_tidy %s cert-dcl16-c %t -- -- -I %clang_tidy_headers
// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
// RUN: clang-tidy %t.cpp -checks='-*,cert-dcl16-c' -fix -- -I %clang_tidy_headers
// RUN: clang-tidy %t.cpp -checks='-*,cert-dcl16-c' -warnings-as-errors='-*,cert-dcl16-c' -- -I %clang_tidy_headers
#include "integral_constant.h"
void integer_suffix() {
static constexpr auto v0 = __LINE__; // synthetic
static_assert(v0 == 9 || v0 == 5, "");
static constexpr auto v1 = __cplusplus; // synthetic, long
static constexpr auto v2 = 1; // no literal
@ -29,9 +24,6 @@ void integer_suffix() {
static constexpr auto v5 = 1l;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'l', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1l;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: {{^ *| *}}L{{$}}
// CHECK-FIXES: static constexpr auto v5 = 1L;
static_assert(is_same<decltype(v5), const long>::value, "");
static_assert(v5 == 1, "");
@ -44,9 +36,6 @@ void integer_suffix() {
static constexpr auto v7 = 1ll;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'll', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1ll;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: {{^ *| *}}LL{{$}}
// CHECK-FIXES: static constexpr auto v7 = 1LL;
static_assert(is_same<decltype(v7), const long long>::value, "");
static_assert(v7 == 1, "");
@ -77,27 +66,18 @@ void integer_suffix() {
static constexpr auto v13 = 1lu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v13 = 1lu;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: {{^ *| *}}LU{{$}}
// CHECK-FIXES: static constexpr auto v13 = 1LU;
static_assert(is_same<decltype(v13), const unsigned long>::value, "");
static_assert(v13 == 1, "");
static constexpr auto v14 = 1Lu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Lu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1Lu;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: {{^ *| *}}LU{{$}}
// CHECK-FIXES: static constexpr auto v14 = 1LU;
static_assert(is_same<decltype(v14), const unsigned long>::value, "");
static_assert(v14 == 1, "");
static constexpr auto v15 = 1lU;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lU', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1lU;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: {{^ *| *}}LU{{$}}
// CHECK-FIXES: static constexpr auto v15 = 1LU;
static_assert(is_same<decltype(v15), const unsigned long>::value, "");
static_assert(v15 == 1, "");
@ -128,27 +108,18 @@ void integer_suffix() {
static constexpr auto v21 = 1llu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v21 = 1llu;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: {{^ *| *}}LLU{{$}}
// CHECK-FIXES: static constexpr auto v21 = 1LLU;
static_assert(is_same<decltype(v21), const unsigned long long>::value, "");
static_assert(v21 == 1, "");
static constexpr auto v22 = 1LLu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'LLu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v22 = 1LLu;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: {{^ *| *}}LLU{{$}}
// CHECK-FIXES: static constexpr auto v22 = 1LLU;
static_assert(is_same<decltype(v22), const unsigned long long>::value, "");
static_assert(v22 == 1, "");
static constexpr auto v23 = 1llU;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llU', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v23 = 1llU;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: {{^ *| *}}LLU{{$}}
// CHECK-FIXES: static constexpr auto v23 = 1LLU;
static_assert(is_same<decltype(v23), const unsigned long long>::value, "");
static_assert(v23 == 1, "");

120
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-c23.c Normal file
View File

@ -0,0 +1,120 @@
// TODO: When Clang adds support for decimal floating point types, enable these tests by:
// 1. Removing all the #if 0 + #endif guards.
// 2. Removing all occurrences of the string "DISABLED-" in this file.
// 3. Deleting this message.
// RUN: %check_clang_tidy -std=c23-or-later %s readability-uppercase-literal-suffix %t
void bit_precise_literal_suffix() {
// _BitInt()
static constexpr auto v1 = 1wb;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'wb', which is not uppercase
// CHECK-FIXES: static constexpr auto v1 = 1WB;
static_assert(v1 == 1WB);
static constexpr auto v2 = 1WB; // OK.
static_assert(v2 == 1WB);
// _BitInt() Unsigned
static constexpr auto v3 = 1wbu;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'wbu', which is not uppercase
// CHECK-FIXES: static constexpr auto v3 = 1WBU;
static_assert(v3 == 1WBU);
static constexpr auto v4 = 1WBu;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'WBu', which is not uppercase
// CHECK-FIXES: static constexpr auto v4 = 1WBU;
static_assert(v4 == 1WBU);
static constexpr auto v5 = 1wbU;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'wbU', which is not uppercase
// CHECK-FIXES: static constexpr auto v5 = 1WBU;
static_assert(v5 == 1WBU);
static constexpr auto v6 = 1WBU; // OK.
static_assert(v6 == 1WBU);
// Unsigned _BitInt()
static constexpr auto v7 = 1uwb;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'uwb', which is not uppercase
// CHECK-FIXES: static constexpr auto v7 = 1UWB;
static_assert(v7 == 1UWB);
static constexpr auto v8 = 1uWB;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'uWB', which is not uppercase
// CHECK-FIXES: static constexpr auto v8 = 1UWB;
static_assert(v8 == 1UWB);
static constexpr auto v9 = 1Uwb;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'Uwb', which is not uppercase
// CHECK-FIXES: static constexpr auto v9 = 1UWB;
static_assert(v9 == 1UWB);
static constexpr auto v10 = 1UWB; // OK.
static_assert(v10 == 1UWB);
}
void decimal_floating_point_suffix() {
// _Decimal32
#if 0
static constexpr auto v1 = 1.df;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'df', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v1 = 1.DF;
static_assert(v1 == 1.DF);
static constexpr auto v2 = 1.e0df;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'df', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v2 = 1.e0DF;
static_assert(v2 == 1.DF);
static constexpr auto v3 = 1.DF; // OK.
static_assert(v3 == 1.DF);
static constexpr auto v4 = 1.e0DF; // OK.
static_assert(v4 == 1.DF);
#endif
// _Decimal64
#if 0
static constexpr auto v5 = 1.dd;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'dd', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v5 = 1.DD;
static_assert(v5 == 1.DD);
static constexpr auto v6 = 1.e0dd;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'dd', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v6 = 1.e0DD;
static_assert(v6 == 1.DD);
static constexpr auto v7 = 1.DD; // OK.
static_assert(v7 == 1.DD);
static constexpr auto v8 = 1.e0DD; // OK.
static_assert(v8 == 1.DD);
#endif
// _Decimal128
#if 0
static constexpr auto v9 = 1.dl;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'dl', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v9 = 1.DL;
static_assert(v9 == 1.DL);
static constexpr auto v10 = 1.e0dl;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'dl', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v10 = 1.e0DL;
static_assert(v10 == 1.DL);
static constexpr auto v11 = 1.DL; // OK.
static_assert(v11 == 1.DL);
static constexpr auto v12 = 1.e0DL; // OK.
static_assert(v12 == 1.DL);
#endif
}

264
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-cxx23.cpp Normal file
View File

@ -0,0 +1,264 @@
// TODO: When Clang adds support for C++23 floating-point types, enable these tests by:
// 1. Removing all the #if 0 + #endif guards.
// 2. Removing all occurrences of the string "DISABLED-" in this file.
// 3. Deleting this message.
// These suffixes may be relevant to C too: https://github.com/llvm/llvm-project/issues/97335
// RUN: %check_clang_tidy -std=c++23-or-later %s readability-uppercase-literal-suffix %t -- -- -target aarch64-linux-gnu -I %clang_tidy_headers
#include "integral_constant.h"
#include <cstddef>
#if 0
#include <stdfloat>
#endif
void normal_literals() {
// std::bfloat16_t
#if 0
static constexpr auto v1 = 1.bf16;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'bf16', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v1 = 1.BF16;
static_assert(is_same<decltype(v1), const std::bfloat16_t>::value, "");
static_assert(v1 == 1.BF16, "");
static constexpr auto v2 = 1.e0bf16;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'bf16', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v2 = 1.e0BF16;
static_assert(is_same<decltype(v2), const std::bfloat16_t>::value, "");
static_assert(v2 == 1.BF16, "");
static constexpr auto v3 = 1.BF16; // OK.
static_assert(is_same<decltype(v3), const std::bfloat16_t>::value, "");
static_assert(v3 == 1.BF16, "");
static constexpr auto v4 = 1.e0BF16; // OK.
static_assert(is_same<decltype(v4), const std::bfloat16_t>::value, "");
static_assert(v4 == 1.BF16, "");
#endif
// _Float16/std::float16_t
static constexpr auto v5 = 1.f16;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f16', which is not uppercase
// CHECK-FIXES: static constexpr auto v5 = 1.F16;
static_assert(is_same<decltype(v5), const _Float16>::value, "");
static_assert(v5 == 1.F16, "");
static constexpr auto v6 = 1.e0f16;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f16', which is not uppercase
// CHECK-FIXES: static constexpr auto v6 = 1.e0F16;
static_assert(is_same<decltype(v6), const _Float16>::value, "");
static_assert(v6 == 1.F16, "");
static constexpr auto v7 = 1.F16; // OK.
static_assert(is_same<decltype(v7), const _Float16>::value, "");
static_assert(v7 == 1.F16, "");
static constexpr auto v8 = 1.e0F16; // OK.
static_assert(is_same<decltype(v8), const _Float16>::value, "");
static_assert(v8 == 1.F16, "");
// std::float32_t
#if 0
static constexpr auto v9 = 1.f32;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f32', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v9 = 1.F32;
static_assert(is_same<decltype(v9), const std::float32_t>::value, "");
static_assert(v9 == 1.F32, "");
static constexpr auto v10 = 1.e0f32;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f32', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v10 = 1.e0F32;
static_assert(is_same<decltype(v10), const std::float32_t>::value, "");
static_assert(v10 == 1.F32, "");
static constexpr auto v11 = 1.F32; // OK.
static_assert(is_same<decltype(v11), const std::float32_t>::value, "");
static_assert(v11 == 1.F32, "");
static constexpr auto v12 = 1.e0F32; // OK.
static_assert(is_same<decltype(v12), const std::float32_t>::value, "");
static_assert(v12 == 1.F32, "");
#endif
// std::float64_t
#if 0
static constexpr auto v13 = 1.f64;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f64', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v13 = 1.F64;
static_assert(is_same<decltype(v13), const std::float64_t>::value, "");
static_assert(v13 == 1.F64, "");
static constexpr auto v14 = 1.e0f64;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f64', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v14 = 1.e0F64;
static_assert(is_same<decltype(v14), const std::float64_t>::value, "");
static_assert(v14 == 1.F64, "");
static constexpr auto v15 = 1.F64; // OK.
static_assert(is_same<decltype(v15), const std::float64_t>::value, "");
static_assert(v15 == 1.F64, "");
static constexpr auto v16 = 1.e0F64; // OK.
static_assert(is_same<decltype(v16), const std::float64_t>::value, "");
static_assert(v16 == 1.F64, "");
#endif
// std::float128_t
#if 0
static constexpr auto v17 = 1.f128;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f128', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v17 = 1.F128;
static_assert(is_same<decltype(v17), const std::float128_t>::value, "");
static_assert(v17 == 1.F128, "");
static constexpr auto v18 = 1.e0f128;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f128', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v18 = 1.e0F128;
static_assert(is_same<decltype(v18), const std::float128_t>::value, "");
static_assert(v18 == 1.F128, "");
static constexpr auto v19 = 1.F128; // OK.
static_assert(is_same<decltype(v19), const std::float128_t>::value, "");
static_assert(v19 == 1.F128, "");
static constexpr auto v20 = 1.e0F128; // OK.
static_assert(is_same<decltype(v20), const std::float128_t>::value, "");
static_assert(v20 == 1.F128, "");
#endif
}
void hexadecimal_literals() {
// std::bfloat16_t
#if 0
static constexpr auto v1 = 0xfp0bf16;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'bf16', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v1 = 0xfp0BF16;
static_assert(is_same<decltype(v1), const std::bfloat16_t>::value, "");
static_assert(v1 == 0xfp0BF16, "");
static constexpr auto v2 = 0xfp0BF16; // OK.
static_assert(is_same<decltype(v2), const std::bfloat16_t>::value, "");
static_assert(v2 == 0xfp0BF16, "");
#endif
// _Float16/std::float16_t
static constexpr auto v3 = 0xfp0f16;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f16', which is not uppercase
// CHECK-FIXES: static constexpr auto v3 = 0xfp0F16;
static_assert(is_same<decltype(v3), const _Float16>::value, "");
static_assert(v3 == 0xfp0F16, "");
static constexpr auto v4 = 0xfp0F16; // OK.
static_assert(is_same<decltype(v4), const _Float16>::value, "");
static_assert(v4 == 0xfp0F16, "");
// std::float32_t
#if 0
static constexpr auto v5 = 0xfp0f32;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f32', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v5 = 0xfp0F32;
static_assert(is_same<decltype(v5), const std::float32_t>::value, "");
static_assert(v5 == 0xfp0F32, "");
static constexpr auto v6 = 0xfp0F32; // OK.
static_assert(is_same<decltype(v6), const std::float32_t>::value, "");
static_assert(v6 == 0xfp0F32, "");
#endif
// std::float64_t
#if 0
static constexpr auto v7 = 0xfp0f64;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f64', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v7 = 0xfp0F64;
static_assert(is_same<decltype(v7), const std::float64_t>::value, "");
static_assert(v7 == 0xfp0F64, "");
static constexpr auto v8 = 0xfp0F64; // OK.
static_assert(is_same<decltype(v8), const std::float64_t>::value, "");
static_assert(v8 == 0xfp0F64, "");
#endif
// std::float128_t
#if 0
static constexpr auto v9 = 0xfp0f128;
// DISABLED-CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f128', which is not uppercase
// DISABLED-CHECK-FIXES: static constexpr auto v9 = 0xfp0F128;
static_assert(is_same<decltype(v9), const std::float128_t>::value, "");
static_assert(v9 == 0xfp0F128, "");
static constexpr auto v10 = 0xfp0F128; // OK.
static_assert(is_same<decltype(v10), const std::float128_t>::value, "");
static_assert(v10 == 0xfp0F128, "");
#endif
}
void size_t_suffix() {
// Signed
static constexpr auto v29 = 1z;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'z', which is not uppercase
// CHECK-FIXES: static constexpr auto v29 = 1Z;
static_assert(v29 == 1Z, "");
static constexpr auto v30 = 1Z; // OK.
static_assert(v30 == 1Z, "");
// size_t Unsigned
static constexpr auto v31 = 1zu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'zu', which is not uppercase
// CHECK-FIXES: static constexpr auto v31 = 1ZU;
static_assert(is_same<decltype(v31), const size_t>::value, "");
static_assert(v31 == 1ZU, "");
static constexpr auto v32 = 1Zu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Zu', which is not uppercase
// CHECK-FIXES: static constexpr auto v32 = 1ZU;
static_assert(is_same<decltype(v32), const size_t>::value, "");
static_assert(v32 == 1ZU, "");
static constexpr auto v33 = 1zU;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'zU', which is not uppercase
// CHECK-FIXES: static constexpr auto v33 = 1ZU;
static_assert(is_same<decltype(v33), const size_t>::value, "");
static_assert(v33 == 1ZU, "");
static constexpr auto v34 = 1ZU; // OK.
static_assert(is_same<decltype(v34), const size_t>::value, "");
static_assert(v34 == 1ZU, "");
// Unsigned size_t
static constexpr auto v35 = 1uz;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uz', which is not uppercase
// CHECK-FIXES: static constexpr auto v35 = 1UZ;
static_assert(is_same<decltype(v35), const size_t>::value, "");
static_assert(v35 == 1UZ);
static constexpr auto v36 = 1uZ;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uZ', which is not uppercase
// CHECK-FIXES: static constexpr auto v36 = 1UZ;
static_assert(is_same<decltype(v36), const size_t>::value, "");
static_assert(v36 == 1UZ);
static constexpr auto v37 = 1Uz;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Uz', which is not uppercase
// CHECK-FIXES: static constexpr auto v37 = 1UZ;
static_assert(is_same<decltype(v37), const size_t>::value, "");
static_assert(v37 == 1UZ);
static constexpr auto v38 = 1UZ; // OK.
static_assert(is_same<decltype(v38), const size_t>::value, "");
static_assert(v38 == 1UZ);
}

51
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-float16.cpp
View File

@ -1,51 +0,0 @@
// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target aarch64-linux-gnu -I %clang_tidy_headers
#include "integral_constant.h"
void float16_normal_literals() {
// _Float16
static constexpr auto v14 = 1.f16;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1.f16;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: F16{{$}}
// CHECK-FIXES: static constexpr auto v14 = 1.F16;
static_assert(is_same<decltype(v14), const _Float16>::value, "");
static_assert(v14 == 1.F16, "");
static constexpr auto v15 = 1.e0f16;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1.e0f16;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: F16{{$}}
// CHECK-FIXES: static constexpr auto v15 = 1.e0F16;
static_assert(is_same<decltype(v15), const _Float16>::value, "");
static_assert(v15 == 1.F16, "");
static constexpr auto v16 = 1.F16; // OK.
static_assert(is_same<decltype(v16), const _Float16>::value, "");
static_assert(v16 == 1.F16, "");
static constexpr auto v17 = 1.e0F16; // OK.
static_assert(is_same<decltype(v17), const _Float16>::value, "");
static_assert(v17 == 1.F16, "");
}
void float16_hexadecimal_literals() {
// _Float16
static constexpr auto v13 = 0xfp0f16;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'f16', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v13 = 0xfp0f16;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: F16{{$}}
// CHECK-FIXES: static constexpr auto v13 = 0xfp0F16;
static_assert(is_same<decltype(v13), const _Float16>::value, "");
static_assert(v13 == 0xfp0F16, "");
static constexpr auto v14 = 0xfp0F16; // OK.
static_assert(is_same<decltype(v14), const _Float16>::value, "");
static_assert(v14 == 0xfp0F16, "");
}

9
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-floating-point-opencl-half.cpp
View File

@ -1,7 +1,4 @@
// RUN: %check_clang_tidy -std=cl2.0 %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S -x cl
// 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 -std=cl2.0 -x cl
// 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 -std=cl2.0 -x cl
#pragma OPENCL EXTENSION cl_khr_fp16 : enable
@ -12,16 +9,10 @@ void floating_point_half_suffix() {
static half v2 = 1.h;
// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: floating point literal has suffix 'h', which is not uppercase
// CHECK-MESSAGES-NEXT: static half v2 = 1.h;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: H{{$}}
// CHECK-HIXES: static half v2 = 1.H;
static half v3 = 1.e0h;
// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: floating point literal has suffix 'h', which is not uppercase
// CHECK-MESSAGES-NEXT: static half v3 = 1.e0h;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: H{{$}}
// CHECK-HIXES: static half v3 = 1.e0H;
static half v4 = 1.H; // OK.

36
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-floating-point.cpp
View File

@ -1,7 +1,4 @@
// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %clang_tidy_headers
// 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 %clang_tidy_headers
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %clang_tidy_headers
#include "integral_constant.h"
@ -18,18 +15,12 @@ void floating_point_suffix() {
static constexpr auto v2 = 1.f;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v2 = 1.f;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: F{{$}}
// CHECK-FIXES: static constexpr auto v2 = 1.F;
static_assert(is_same<decltype(v2), const float>::value, "");
static_assert(v2 == 1.0F, "");
static constexpr auto v3 = 1.e0f;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1.e0f;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: F{{$}}
// CHECK-FIXES: static constexpr auto v3 = 1.e0F;
static_assert(is_same<decltype(v3), const float>::value, "");
static_assert(v3 == 1.0F, "");
@ -46,18 +37,12 @@ void floating_point_suffix() {
static constexpr auto v6 = 1.l;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v6 = 1.l;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: L{{$}}
// CHECK-FIXES: static constexpr auto v6 = 1.L;
static_assert(is_same<decltype(v6), const long double>::value, "");
static_assert(v6 == 1., "");
static constexpr auto v7 = 1.e0l;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'l', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1.e0l;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: L{{$}}
// CHECK-FIXES: static constexpr auto v7 = 1.e0L;
static_assert(is_same<decltype(v7), const long double>::value, "");
static_assert(v7 == 1., "");
@ -74,18 +59,12 @@ void floating_point_suffix() {
static constexpr auto v10 = 1.q;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v10 = 1.q;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: Q{{$}}
// CHECK-FIXES: static constexpr auto v10 = 1.Q;
static_assert(is_same<decltype(v10), const __float128>::value, "");
static_assert(v10 == 1., "");
static constexpr auto v11 = 1.e0q;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'q', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1.e0q;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: Q{{$}}
// CHECK-FIXES: static constexpr auto v11 = 1.e0Q;
static_assert(is_same<decltype(v11), const __float128>::value, "");
static_assert(v11 == 1., "");
@ -104,18 +83,12 @@ void floating_point_complex_suffix() {
static constexpr auto v14 = 1.i;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1.i;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: I{{$}}
// CHECK-FIXES: static constexpr auto v14 = 1.I;
static_assert(is_same<decltype(v14), const _Complex double>::value, "");
static_assert(v14 == 1.I, "");
static constexpr auto v15 = 1.e0i;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'i', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1.e0i;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: I{{$}}
// CHECK-FIXES: static constexpr auto v15 = 1.e0I;
static_assert(is_same<decltype(v15), const _Complex double>::value, "");
static_assert(v15 == 1.I, "");
@ -132,18 +105,12 @@ void floating_point_complex_suffix() {
static constexpr auto v18 = 1.j;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v18 = 1.j;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: J{{$}}
// CHECK-FIXES: static constexpr auto v18 = 1.J;
static_assert(is_same<decltype(v18), const _Complex double>::value, "");
static_assert(v18 == 1.J, "");
static constexpr auto v19 = 1.e0j;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: floating point literal has suffix 'j', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v19 = 1.e0j;
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: J{{$}}
// CHECK-FIXES: static constexpr auto v19 = 1.e0J;
static_assert(is_same<decltype(v19), const _Complex double>::value, "");
static_assert(v19 == 1.J, "");
@ -161,9 +128,6 @@ void macros() {
#define PASSTHROUGH(X) X
static constexpr auto m0 = PASSTHROUGH(1.f);
// CHECK-MESSAGES: :[[@LINE-1]]:42: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(1.f);
// CHECK-MESSAGES-NEXT: ^ ~
// CHECK-MESSAGES-NEXT: F{{$}}
// CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(1.F);
static_assert(is_same<decltype(m0), const float>::value, "");
static_assert(m0 == 1.0F, "");

30
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-hexadecimal-floating-point.cpp
View File

@ -1,7 +1,4 @@
// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %clang_tidy_headers
// 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 %clang_tidy_headers
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %clang_tidy_headers
#include "integral_constant.h"
@ -14,9 +11,6 @@ void floating_point_suffix() {
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, "");
@ -27,9 +21,6 @@ void floating_point_suffix() {
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, "");
@ -40,9 +31,6 @@ void floating_point_suffix() {
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, "");
@ -53,9 +41,6 @@ void floating_point_suffix() {
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, "");
@ -68,9 +53,6 @@ void floating_point_suffix() {
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, "");
@ -83,9 +65,6 @@ void floating_point_suffix() {
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, "");
@ -100,9 +79,6 @@ void floating_point_complex_suffix() {
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, "");
@ -115,9 +91,6 @@ void floating_point_complex_suffix() {
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, "");
@ -131,9 +104,6 @@ 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, "");

15
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer-custom-list.cpp
View File

@ -1,7 +1,4 @@
// RUN: %check_clang_tidy --match-partial-fixes %s readability-uppercase-literal-suffix %t -- -config="{CheckOptions: {readability-uppercase-literal-suffix.NewSuffixes: 'L;uL'}}" -- -I %clang_tidy_headers
// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -config="{CheckOptions: {readability-uppercase-literal-suffix.NewSuffixes: 'L;uL'}}" -- -I %clang_tidy_headers
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -config="{CheckOptions: {readability-uppercase-literal-suffix.NewSuffixes: 'L;uL'}}" -- -I %clang_tidy_headers
#include "integral_constant.h"
@ -20,9 +17,6 @@ void integer_suffix() {
static constexpr auto v5 = 1l;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'l', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1l;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: L{{$}}
// CHECK-FIXES: static constexpr auto v5 = 1L;
static_assert(is_same<decltype(v5), const long>::value, "");
static_assert(v5 == 1, "");
@ -45,9 +39,6 @@ void integer_suffix() {
static constexpr auto v9 = 1ul;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'ul', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1ul;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: uL{{$}}
// CHECK-FIXES: static constexpr auto v9 = 1uL;
static_assert(is_same<decltype(v9), const unsigned long>::value, "");
static_assert(v9 == 1, "");
@ -58,18 +49,12 @@ void integer_suffix() {
static constexpr auto v11 = 1Ul;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ul', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1Ul;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: uL{{$}}
// CHECK-FIXES: static constexpr auto v11 = 1uL;
static_assert(is_same<decltype(v11), const unsigned long>::value, "");
static_assert(v11 == 1, "");
static constexpr auto v12 = 1UL; // OK.
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'UL', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v12 = 1UL;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: uL{{$}}
// CHECK-FIXES: static constexpr auto v12 = 1uL;
static_assert(is_same<decltype(v12), const unsigned long>::value, "");
static_assert(v12 == 1, "");

17
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer-ms.cpp
View File

@ -1,14 +1,9 @@
// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %clang_tidy_headers -fms-extensions
// 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 %clang_tidy_headers -fms-extensions
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %clang_tidy_headers -fms-extensions
#include "integral_constant.h"
void integer_suffix() {
static constexpr auto v0 = __LINE__; // synthetic
static_assert(v0 == 9 || v0 == 5, "");
static constexpr auto v1 = __cplusplus; // synthetic, long
static constexpr auto v2 = 1; // no literal
@ -19,9 +14,6 @@ void integer_suffix() {
static constexpr auto v3 = 1i32;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i32', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1i32;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: I32{{$}}
// CHECK-FIXES: static constexpr auto v3 = 1I32;
static_assert(is_same<decltype(v3), const int>::value, "");
static_assert(v3 == 1I32, "");
@ -34,9 +26,6 @@ void integer_suffix() {
static constexpr auto v5 = 1i64;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i64', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1i64;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: I64{{$}}
// CHECK-FIXES: static constexpr auto v5 = 1I64;
static_assert(is_same<decltype(v5), const long int>::value, "");
static_assert(v5 == 1I64, "");
@ -49,9 +38,6 @@ void integer_suffix() {
static constexpr auto v7 = 1i16;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i16', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1i16;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: I16{{$}}
// CHECK-FIXES: static constexpr auto v7 = 1I16;
static_assert(is_same<decltype(v7), const short>::value, "");
static_assert(v7 == 1I16, "");
@ -64,9 +50,6 @@ void integer_suffix() {
static constexpr auto v9 = 1i8;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'i8', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1i8;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: I8{{$}}
// CHECK-FIXES: static constexpr auto v9 = 1I8;
static_assert(is_same<decltype(v9), const char>::value, "");
static_assert(v9 == 1I8, "");

60
clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer.cpp
View File

@ -1,14 +1,10 @@
// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -I %clang_tidy_headers
// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -I %clang_tidy_headers
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -I %clang_tidy_headers
#include "integral_constant.h"
#include <cstddef>
void integer_suffix() {
static constexpr auto v0 = __LINE__; // synthetic
static_assert(v0 == 9 || v0 == 5, "");
static constexpr auto v1 = __cplusplus; // synthetic, long
static constexpr auto v2 = 1; // no literal
@ -19,9 +15,6 @@ void integer_suffix() {
static constexpr auto v3 = 1u;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'u', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v3 = 1u;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: U{{$}}
// CHECK-FIXES: static constexpr auto v3 = 1U;
static_assert(is_same<decltype(v3), const unsigned int>::value, "");
static_assert(v3 == 1, "");
@ -34,9 +27,6 @@ void integer_suffix() {
static constexpr auto v5 = 1l;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'l', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v5 = 1l;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: L{{$}}
// CHECK-FIXES: static constexpr auto v5 = 1L;
static_assert(is_same<decltype(v5), const long>::value, "");
static_assert(v5 == 1, "");
@ -49,9 +39,6 @@ void integer_suffix() {
static constexpr auto v7 = 1ll;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'll', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v7 = 1ll;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: LL{{$}}
// CHECK-FIXES: static constexpr auto v7 = 1LL;
static_assert(is_same<decltype(v7), const long long>::value, "");
static_assert(v7 == 1, "");
@ -64,27 +51,18 @@ void integer_suffix() {
static constexpr auto v9 = 1ul;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: integer literal has suffix 'ul', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v9 = 1ul;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: UL{{$}}
// CHECK-FIXES: static constexpr auto v9 = 1UL;
static_assert(is_same<decltype(v9), const unsigned long>::value, "");
static_assert(v9 == 1, "");
static constexpr auto v10 = 1uL;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uL', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v10 = 1uL;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: UL{{$}}
// CHECK-FIXES: static constexpr auto v10 = 1UL;
static_assert(is_same<decltype(v10), const unsigned long>::value, "");
static_assert(v10 == 1, "");
static constexpr auto v11 = 1Ul;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ul', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v11 = 1Ul;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: UL{{$}}
// CHECK-FIXES: static constexpr auto v11 = 1UL;
static_assert(is_same<decltype(v11), const unsigned long>::value, "");
static_assert(v11 == 1, "");
@ -97,27 +75,18 @@ void integer_suffix() {
static constexpr auto v13 = 1lu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v13 = 1lu;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: LU{{$}}
// CHECK-FIXES: static constexpr auto v13 = 1LU;
static_assert(is_same<decltype(v13), const unsigned long>::value, "");
static_assert(v13 == 1, "");
static constexpr auto v14 = 1Lu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Lu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v14 = 1Lu;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: LU{{$}}
// CHECK-FIXES: static constexpr auto v14 = 1LU;
static_assert(is_same<decltype(v14), const unsigned long>::value, "");
static_assert(v14 == 1, "");
static constexpr auto v15 = 1lU;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'lU', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v15 = 1lU;
// CHECK-MESSAGES-NEXT: ^~~
// CHECK-MESSAGES-NEXT: LU{{$}}
// CHECK-FIXES: static constexpr auto v15 = 1LU;
static_assert(is_same<decltype(v15), const unsigned long>::value, "");
static_assert(v15 == 1, "");
@ -130,27 +99,18 @@ void integer_suffix() {
static constexpr auto v17 = 1ull;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'ull', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v17 = 1ull;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: ULL{{$}}
// CHECK-FIXES: static constexpr auto v17 = 1ULL;
static_assert(is_same<decltype(v17), const unsigned long long>::value, "");
static_assert(v17 == 1, "");
static constexpr auto v18 = 1uLL;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'uLL', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v18 = 1uLL;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: ULL{{$}}
// CHECK-FIXES: static constexpr auto v18 = 1ULL;
static_assert(is_same<decltype(v18), const unsigned long long>::value, "");
static_assert(v18 == 1, "");
static constexpr auto v19 = 1Ull;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'Ull', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v19 = 1Ull;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: ULL{{$}}
// CHECK-FIXES: static constexpr auto v19 = 1ULL;
static_assert(is_same<decltype(v19), const unsigned long long>::value, "");
static_assert(v19 == 1, "");
@ -163,27 +123,18 @@ void integer_suffix() {
static constexpr auto v21 = 1llu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v21 = 1llu;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: LLU{{$}}
// CHECK-FIXES: static constexpr auto v21 = 1LLU;
static_assert(is_same<decltype(v21), const unsigned long long>::value, "");
static_assert(v21 == 1, "");
static constexpr auto v22 = 1LLu;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'LLu', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v22 = 1LLu;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: LLU{{$}}
// CHECK-FIXES: static constexpr auto v22 = 1LLU;
static_assert(is_same<decltype(v22), const unsigned long long>::value, "");
static_assert(v22 == 1, "");
static constexpr auto v23 = 1llU;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'llU', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v23 = 1llU;
// CHECK-MESSAGES-NEXT: ^~~~
// CHECK-MESSAGES-NEXT: LLU{{$}}
// CHECK-FIXES: static constexpr auto v23 = 1LLU;
static_assert(is_same<decltype(v23), const unsigned long long>::value, "");
static_assert(v23 == 1, "");
@ -198,9 +149,6 @@ void integer_complex_suffix() {
static constexpr auto v25 = 1i;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'i', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v25 = 1i;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: I{{$}}
// CHECK-FIXES: static constexpr auto v25 = 1I;
static_assert(is_same<decltype(v25), const _Complex int>::value, "");
static_assert(v25 == 1I, "");
@ -213,9 +161,6 @@ void integer_complex_suffix() {
static constexpr auto v27 = 1j;
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: integer literal has suffix 'j', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto v27 = 1j;
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: J{{$}}
// CHECK-FIXES: static constexpr auto v27 = 1J;
static_assert(is_same<decltype(v27), const _Complex int>::value, "");
static_assert(v27 == 1J, "");
@ -229,9 +174,6 @@ void macros() {
#define PASSTHROUGH(X) X
static constexpr auto m0 = PASSTHROUGH(1u);
// CHECK-MESSAGES: :[[@LINE-1]]:42: warning: integer literal has suffix 'u', which is not uppercase
// CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(1u);
// CHECK-MESSAGES-NEXT: ^~
// CHECK-MESSAGES-NEXT: U{{$}}
// CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(1U);
static_assert(is_same<decltype(m0), const unsigned int>::value, "");
static_assert(m0 == 1, "");