[clang-tidy] Teach readability-uppercase-literal-suffix about C++23 and C23 suffixes
#148275
+506
−58
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
… and C23 suffixes
|
@llvm/pr-subscribers-clang-tools-extra Author: Victor Chernyakin (localspook) ChangesC++23 integer literal suffixes:
C++23 floating-point literal suffixes:
C23 integer literal suffixes:
C23 floating-point literal suffixes:
Clang doesn't actually support any of the new floating point types yet (except for Patch is 26.98 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/148275.diff 6 Files Affected:
diff --git a/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp b/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
index 678aa8dad48a7..dd43ee200f4c0 100644
--- a/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
+++ b/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
@@ -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");
};
constexpr llvm::StringLiteral IntegerLiteralCheck::Name;
constexpr llvm::StringLiteral IntegerLiteralCheck::SkipFirst;
@@ -45,10 +46,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");
};
constexpr llvm::StringLiteral FloatingLiteralCheck::Name;
constexpr llvm::StringLiteral FloatingLiteralCheck::SkipFirst;
diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst
index ad869265a2db5..119c030b43852 100644
--- a/clang-tools-extra/docs/ReleaseNotes.rst
+++ b/clang-tools-extra/docs/ReleaseNotes.rst
@@ -354,6 +354,10 @@ Changes in existing checks
<clang-tidy/checks/readability/redundant-smartptr-get>` check by fixing
some false positives involving smart pointers to arrays.
+- 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
^^^^^^^^^^^^^^
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-c23.c b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-c23.c
new file mode 100644
index 0000000000000..75727fc69e68c
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-c23.c
@@ -0,0 +1,162 @@
+// 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 %s readability-uppercase-literal-suffix %t -- -- -std=c23
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.c
+// RUN: clang-tidy %t.c -checks='-*,readability-uppercase-literal-suffix' -fix -- -std=c23
+// RUN: clang-tidy %t.c -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -std=c23
+
+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-MESSAGES-NEXT: static constexpr auto v1 = 1wb;
+ // CHECK-MESSAGES-NEXT: ^~~
+ // CHECK-MESSAGES-NEXT: WB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v3 = 1wbu;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: WBU{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v4 = 1WBu;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: WBU{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 1wbU;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: WBU{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v7 = 1uwb;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: UWB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v8 = 1uWB;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: UWB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 1Uwb;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: UWB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v1 = 1.df;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DF{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v2 = 1.e0df;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DF{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 1.dd;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DD{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v6 = 1.e0dd;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DD{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 1.dl;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DL{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v10 = 1.e0dl;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DL{{$}}
+ // 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
+}
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-extended-floating-point.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-extended-floating-point.cpp
new file mode 100644
index 0000000000000..abe23e3363766
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-extended-floating-point.cpp
@@ -0,0 +1,248 @@
+// 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 %s readability-uppercase-literal-suffix %t -- -- -target aarch64-linux-gnu -I %clang_tidy_headers
+
+#include "integral_constant.h"
+#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-MESSAGES-NEXT: static constexpr auto v1 = 1.bf16;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: BF16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v2 = 1.e0bf16;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: BF16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 1.f16;
+ // CHECK-MESSAGES-NEXT: ^ ~
+ // CHECK-MESSAGES-NEXT: F16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v6 = 1.e0f16;
+ // CHECK-MESSAGES-NEXT: ^ ~
+ // CHECK-MESSAGES-NEXT: F16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 1.f32;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F32{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v10 = 1.e0f32;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F32{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v13 = 1.f64;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F64{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v14 = 1.e0f64;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F64{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v17 = 1.f128;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F128{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v18 = 1.e0f128;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F128{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v1 = 0xfp0bf16;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: BF16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v3 = 0xfp0f16;
+ // CHECK-MESSAGES-NEXT: ^ ~
+ // CHECK-MESSAGES-NEXT: F16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 0xfp0f32;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F32{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v7 = 0xfp0f64;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F64{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 0xfp0f128;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F128{{$}}
+ // 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 ...
[truncated]
|
|
@llvm/pr-subscribers-clang-tidy Author: Victor Chernyakin (localspook) ChangesC++23 integer literal suffixes:
C++23 floating-point literal suffixes:
C23 integer literal suffixes:
C23 floating-point literal suffixes:
Clang doesn't actually support any of the new floating point types yet (except for Patch is 26.98 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/148275.diff 6 Files Affected:
diff --git a/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp b/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
index 678aa8dad48a7..dd43ee200f4c0 100644
--- a/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
+++ b/clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
@@ -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");
};
constexpr llvm::StringLiteral IntegerLiteralCheck::Name;
constexpr llvm::StringLiteral IntegerLiteralCheck::SkipFirst;
@@ -45,10 +46,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");
};
constexpr llvm::StringLiteral FloatingLiteralCheck::Name;
constexpr llvm::StringLiteral FloatingLiteralCheck::SkipFirst;
diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst
index ad869265a2db5..119c030b43852 100644
--- a/clang-tools-extra/docs/ReleaseNotes.rst
+++ b/clang-tools-extra/docs/ReleaseNotes.rst
@@ -354,6 +354,10 @@ Changes in existing checks
<clang-tidy/checks/readability/redundant-smartptr-get>` check by fixing
some false positives involving smart pointers to arrays.
+- 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
^^^^^^^^^^^^^^
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-c23.c b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-c23.c
new file mode 100644
index 0000000000000..75727fc69e68c
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-c23.c
@@ -0,0 +1,162 @@
+// 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 %s readability-uppercase-literal-suffix %t -- -- -std=c23
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.c
+// RUN: clang-tidy %t.c -checks='-*,readability-uppercase-literal-suffix' -fix -- -std=c23
+// RUN: clang-tidy %t.c -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -std=c23
+
+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-MESSAGES-NEXT: static constexpr auto v1 = 1wb;
+ // CHECK-MESSAGES-NEXT: ^~~
+ // CHECK-MESSAGES-NEXT: WB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v3 = 1wbu;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: WBU{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v4 = 1WBu;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: WBU{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 1wbU;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: WBU{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v7 = 1uwb;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: UWB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v8 = 1uWB;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: UWB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 1Uwb;
+ // CHECK-MESSAGES-NEXT: ^~~~
+ // CHECK-MESSAGES-NEXT: UWB{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v1 = 1.df;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DF{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v2 = 1.e0df;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DF{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 1.dd;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DD{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v6 = 1.e0dd;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DD{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 1.dl;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DL{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v10 = 1.e0dl;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: DL{{$}}
+ // 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
+}
diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-extended-floating-point.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-extended-floating-point.cpp
new file mode 100644
index 0000000000000..abe23e3363766
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-extended-floating-point.cpp
@@ -0,0 +1,248 @@
+// 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 %s readability-uppercase-literal-suffix %t -- -- -target aarch64-linux-gnu -I %clang_tidy_headers
+
+#include "integral_constant.h"
+#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-MESSAGES-NEXT: static constexpr auto v1 = 1.bf16;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: BF16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v2 = 1.e0bf16;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: BF16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 1.f16;
+ // CHECK-MESSAGES-NEXT: ^ ~
+ // CHECK-MESSAGES-NEXT: F16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v6 = 1.e0f16;
+ // CHECK-MESSAGES-NEXT: ^ ~
+ // CHECK-MESSAGES-NEXT: F16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 1.f32;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F32{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v10 = 1.e0f32;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F32{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v13 = 1.f64;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F64{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v14 = 1.e0f64;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F64{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v17 = 1.f128;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F128{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v18 = 1.e0f128;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F128{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v1 = 0xfp0bf16;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: BF16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v3 = 0xfp0f16;
+ // CHECK-MESSAGES-NEXT: ^ ~
+ // CHECK-MESSAGES-NEXT: F16{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v5 = 0xfp0f32;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F32{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v7 = 0xfp0f64;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F64{{$}}
+ // 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-MESSAGES-NEXT: static constexpr auto v9 = 0xfp0f128;
+ // DISABLED-CHECK-MESSAGES-NEXT: ^ ~
+ // DISABLED-CHECK-MESSAGES-NEXT: F128{{$}}
+ // 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 ...
[truncated]
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
C++23 integer literal suffixes:
zstd::make_signed_t<std::size_t>uzstd::size_tC++23 floating-point literal suffixes:
bf16std::bfloat16_tf16std::float16_tf32std::float32_tf64std::float64_tf128std::float128_tC23 integer literal suffixes:
wb_BitInt(N)uwbunsigned _BitInt(N)C23 floating-point literal suffixes:
df_Decimal32dd_Decimal64dl_Decimal128Clang 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.