[C++2b] Support size_t literals

[AntonBikineev]

Summary

This adds support for C++2b z/uz suffixes for size_t literals (P0330).

[AntonBikineev]

Fix failing tests

[AntonBikineev]

Fix formatting

[aaron.ballman]

Thanks for working on this! I think the direction is good in general, but I think we should also add tests for use in the preprocessor (#if 1z == 1, etc) as well as tests for the behavior in C.

clang/include/clang/Basic/DiagnosticCommonKinds.td

191

clang/include/clang/Lex/LiteralSupport.h

66

clang/lib/Frontend/InitPreprocessor.cpp

593–595

clang/lib/Lex/LiteralSupport.cpp

680

clang/lib/Lex/PPExpressions.cpp

325–327

326

This feature is specific to C++ and needs some sort of diagnostic in C. There is not currently a WG14 proposal for this literal suffix, so I think this should be an error in that case rather than a warning.

clang/lib/Sema/SemaExpr.cpp

3871–3873

3872

Same diagnostic needs for C here as above.

3911

The assert message doesn't seem to match the predicate -- why does a null qualtype imply it's a microsoft literal?

clang/test/SemaCXX/size_t-literal.cpp

15–17

Rather than check __cplusplus like this, I think the RUN lines should specify a verify prefix. e.g., -verify=cxx2b and then use cxx2b-no-diagnostics and -verify=cxx20 and then use cxx20-warning {{}}.

[AntonBikineev]

Thanks Aaron for taking a look! Addressed the comments. I also hope it's okay to test preprocessor in the same test (test/Lexer/size_t-literal.cpp).

clang/lib/Sema/SemaExpr.cpp

3911

Hm, agree, that's probably misleading. I've tried to check that the previous branch couldn't be taken if this one has been. I think "assert(!Literal.MicrosoftInteger && ...);" would make more sense.

clang/test/SemaCXX/size_t-literal.cpp

15–17

Good idea, thanks! That has made the test much cleaner.

[AntonBikineev]

Address comments

[rsmith]

clang/include/clang/Basic/DiagnosticCommonKinds.td

190

Should this be an ExtWarn? I think we should warn on this by default.

clang/lib/Lex/LiteralSupport.cpp

594–595

General comment: I think the checks here have become too complex and error-prone. I suggest we add another flag, hasSize, that's set when we parse any size modifier (F, L, LL, H, F128, I64, and now Z), and when parsing any size modifier, replace the existing ad-hoc set of checks with a check for hasSize.

clang/lib/Lex/PPExpressions.cpp

325

We should issue a compat warning when these literals are used in C++2b or later. (That is, always issue a diagnostic for a size_t literal: in C, it's an error, in C++20 and before, it's an extension warning, and in C++2b and later, it's a backwards-compatibility warning.) There are a bunch of examples of this elsewhere in the codebase -- look for the emission of warn_cxx.*_compat.

clang/lib/Sema/SemaExpr.cpp

3871

Also need the C++20-and-before compat warning here for C++2b-onwards mode.

3926

This should exclude the isSizeT case in addition to isLong and isLongLong. (It probably doesn't matter, because int is not larger than size_t on any platform we support, but nonetheless we should check.)

3942

Likewise here.

3973

Likewise here -- and this one actually does matter, because we have targets with a 32-bit size_t but a 64-bit long long.

clang/test/Lexer/size_t-literal.cpp

7–9

Please also check -1z < 0 and -1zu < 0 to ensure that the preprocessor gets the signedness correct.

[AntonBikineev]

Thanks Richard for taking a look!

clang/include/clang/Basic/DiagnosticCommonKinds.td

190

I tried to follow the strategy used for 'long long' (only warn with -Wlong-long), but I agree that warn-by-default would probably be better.

clang/lib/Lex/LiteralSupport.cpp

594–595

Good idea! It actually helped to flush out the issue when Q and H are mixed together: https://godbolt.org/z/8hj39P93a

[AntonBikineev]

Address comments

[rsmith]

clang/lib/Lex/LiteralSupport.cpp

636

Looks like this might fix incorrect acceptance of 1.0f16f and 1.0f16L in CUDA mode too :)

clang/lib/Sema/SemaExpr.cpp

3934–3941

I'd like to see some test coverage for this, particularly the testing of the high bit to determine if we're forming a signed or unsigned literal.

3973

Can we get a test for this case? (Eg, 5'000'000'000z with -triple i686-linux.)

[AntonBikineev]

clang/lib/Lex/LiteralSupport.cpp

636

Nice!

clang/lib/Sema/SemaExpr.cpp

3892

I now begin to think that we should probably also prohibit things like 0x1234z to be implicitly interpreted as unsigned. Wdyt?

3992

I think this branch should also be covered, since we probably don't want promotion from size_t to ULL but instead have a separate diagnostic that size_t is out-of-range. I've added another diagnostic and branch here.

[AntonBikineev]

Address comments. Also:

• always issue a new diagnostic if size_t/ssize_t is out of range;
• prohibit numbers with 'z' suffix and non-10-radix to be interpreted as unsigned.

[rsmith]

clang/include/clang/Basic/DiagnosticCommonKinds.td

198–200

I wonder if it'd be better to say 'ssize_t' instead of signed 'size_t' here? The latter sounds self-contradictory since size_t is an unsigned type.

clang/lib/Sema/SemaExpr.cpp

3892

Table 8 says that a z-suffixed literal has type ssize_t (if the value fits) or size_t (otherwise), so I think taking AllowUnsigned into account is correct (although perhaps surprising).

3992

Thanks, that makes sense to me. I agree that a z-suffixed literal should never have any type other than size_t or ssize_t; we don't want to fall back to unsigned long long as an extension.

clang/test/SemaCXX/size_t-literal.cpp

79

This case looks valid to me.

[AntonBikineev]

clang/include/clang/Basic/DiagnosticCommonKinds.td

198–200

I thought about it (and actually had it first as ssize_t). The problem with ssize_t is that it's not defined by C or C++ Standards, AFAIK, but by POSIX. The proposal calls it "the signed integer type corresponding to std::size_t", so I decided to shorten it to "signed 'size_t'". However, I don't have strong opinion on this.

clang/lib/Sema/SemaExpr.cpp

3892

Thanks for pointing this out! Changed it back and fixed the tests.

[AntonBikineev]

Address comments

[rsmith]

Thanks! Looks good to me. Please wait a day or so in case Aaron has more comments before going ahead.

clang/include/clang/Basic/DiagnosticCommonKinds.td

198–200

That makes sense. OK, I don't have a strong opinion either, so let's go with what you have.

clang/lib/Sema/SemaExpr.cpp

3992–3993

(Mostly to make it clear that this can happen for size_t regardless of the u suffix.)

clang/www/cxx_status.html

1273 ↗

(On Diff #334263)

[aaron.ballman]

Generally LGTM but I did have a question about the feature testing macro.

clang/lib/Frontend/InitPreprocessor.cpp

593–594

Because we allow this as an extension in all C++ modes, should this be enabled always rather than gated on C++2b?

clang/lib/Lex/LiteralSupport.cpp

673

[AntonBikineev]

clang/lib/Frontend/InitPreprocessor.cpp

593–594

I was also wondering about this. I've checked that we also do the same for other feature macros, such as __cpp_binary_literals, which is defined for -std>=c++14 while at the same time is allowed as an extension before C++14. Therefore I decided to mimic the behaviour.

[AntonBikineev]

Fix comment

[aaron.ballman]

LGTM, thank you for the patch!

clang/lib/Frontend/InitPreprocessor.cpp

593–594

Thanks for checking on that! I think that seems defensible enough. :-)

[AntonBikineev]

Aaron, Richard, thanks a lot for reviewing this!

Sorry, forgot to add amend the commit with 'Differential revision', closing this manually..

[• Quuxplusone]

clang/lib/Frontend/InitPreprocessor.cpp

593–594

Btw, thus far libc++ has tended to make the opposite choice: for example, libc++ defines __cpp_lib_variant == 202102 in all modes, because the programmer conceivably might be depending on that macro to make some decision, so we want to make sure it reflects the specific semantics that we implement. (For __cpp_binary_literals specifically, I agree it doesn't really matter because nobody's going to be making decisions based on the value of this macro.)

See https://reviews.llvm.org/D99290#inline-934563 (D96385, D97394) for previous discussions on the libc++ side.

[AntonBikineev]

clang/lib/Frontend/InitPreprocessor.cpp

593–594

Thanks for pointing this out, Arthur.

I wish there was some consistency, however, I'm not sure if this is easily feasible. I guess the strategy of defining __cpp_size_t_literals on all modes would be problematic, since if the user code depends on __cpp_size_t_literals, it could suddenly receive the extension warning (when compiled with -std<2++2b), which is enabled by default.

593–594

Btw, thus far libc++ has tended to make the opposite choice: for example, libc++ defines __cpp_lib_variant == 202102 in all modes, because the programmer conceivably might be depending on that macro to make some decision, so we want to make sure it reflects the specific semantics that we implement. (For __cpp_binary_literals specifically, I agree it doesn't really matter because nobody's going to be making decisions based on the value of this macro.)

See https://reviews.llvm.org/D99290#inline-934563 (D96385, D97394) for previous discussions on the libc++ side.

[• Quuxplusone]

clang/lib/Frontend/InitPreprocessor.cpp

593–594

I guess the strategy of defining __cpp_size_t_literals in all modes would be problematic, since if the [pre-C++2b] user code depends on __cpp_size_t_literals, it could suddenly receive the extension warning...

Ah, yes. Orthogonally to everything I said above, I think it's fair to say that

• in modes where 42uz produces a fatal error, it's definitely "not supported"
• in modes where it's accepted without complaint, it's definitely "supported" (*)
• in modes where it produces a non-fatal warning, you can plausibly argue it either way

(*) - with a bonus exception that if the user passes -Wno-blah or -w, that doesn't magically make things be supported
libc++'s situation seems more black-and-white; e.g. variant behaves one way or the other. There's no libc++ equivalent of "you get the new behavior but with a warning." :)

[rsmith]

clang/lib/Frontend/InitPreprocessor.cpp

593–594

We have some prior art to draw on here: our __has_extension(X) behavior is that under -pedantic-errors, we don't advertise any extensions beyond the __has_feature(X) set, and otherwise we advertise features even if they will lead to warnings (or errors via -Werror or -Werror=pedantic or similar warning flags).

I'm not sure that's necessarily the best thing, since it's only loosely connected to whether the construct in question would lead to (warnings or) errors, but it's consistent with the principle that warning flags shouldn't change behavior (beyond which warnings or errors are emitted) and probably more useful than never advertising extensions in earlier language modes.

clang/include/clang/Basic/DiagnosticCommonKinds.td

def ext_c99_longlong : Extension<
   "'long long' is an extension when C99 mode is not enabled">,
   InGroup<LongLong>;
 def ext_cxx11_longlong : Extension<
   "'long long' is a C++11 extension">,
   InGroup<CXX11LongLong>;
 def warn_cxx98_compat_longlong : Warning<
   "'long long' is incompatible with C++98">,
   InGroup<CXX98CompatPedantic>, DefaultIgnore;
+def ext_cxx2b_size_t_suffix : Extension<
+  "size_t suffix for literals is a C++2b extension">,
+  InGroup<CXX2b>;
 def err_integer_literal_too_large : Error<
   "integer literal is too large to be represented in any %select{signed |}0"
   "integer type">;
 def ext_integer_literal_too_large_for_signed : ExtWarn<
   "integer literal is too large to be represented in a signed integer type, "
   "interpreting as unsigned">,
   InGroup<ImplicitlyUnsignedLiteral>;
 def warn_old_implicitly_unsigned_long : Warning<
   "integer literal is too large to be represented in type 'long', "
   "interpreting as 'unsigned long' per C89; this literal will "
   "%select{have type 'long long'|be ill-formed}0 in C99 onwards">,
   InGroup<C99Compat>;
 def warn_old_implicitly_unsigned_long_cxx : Warning<
   "integer literal is too large to be represented in type 'long', "
   "interpreting as 'unsigned long' per C++98; this literal will "
   "%select{have type 'long long'|be ill-formed}0 in C++11 onwards">,

clang/include/clang/Lex/LiteralSupport.h

 public:
   NumericLiteralParser(StringRef TokSpelling, SourceLocation TokLoc,
                        const SourceManager &SM, const LangOptions &LangOpts,
                        const TargetInfo &Target, DiagnosticsEngine &Diags);
   bool hadError : 1;
   bool isUnsigned : 1;
   bool isLong : 1;          // This is *not* set for long long.
   bool isLongLong : 1;
+  bool isSizeT : 1;         // C++2b's z/uz size_t literals
   bool isHalf : 1;          // 1.0h
   bool isFloat : 1;         // 1.0f
   bool isImaginary : 1;     // 1.0i
   bool isFloat16 : 1;       // 1.0f16
   bool isFloat128 : 1;      // 1.0q
   uint8_t MicrosoftInteger; // Microsoft suffix extension i8, i16, i32, or i64.
 
   bool isFract : 1;         // 1.0hr/r/lr/uhr/ur/ulr

clang/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus20) {
     Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
     Builder.defineMacro("__cpp_constinit", "201907L");
     //Builder.defineMacro("__cpp_coroutines", "201902L");
     Builder.defineMacro("__cpp_designated_initializers", "201707L");
     Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
     //Builder.defineMacro("__cpp_modules", "201907L");
     //Builder.defineMacro("__cpp_using_enum", "201907L");
   }
+  // C++2b features.
+  if (LangOpts.CPlusPlus2b) {
+    Builder.defineMacro("__cpp_size_t_suffix", "202011L");
+  }
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "201811L");
   Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
 
   // TS features.
   if (LangOpts.Coroutines)
     Builder.defineMacro("__cpp_coroutines", "201703L");
 }

clang/lib/Lex/LiteralSupport.cpp

NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
   s = DigitsBegin = ThisTokBegin;
   saw_exponent = false;
   saw_period = false;
   saw_ud_suffix = false;
   saw_fixed_point_suffix = false;
   isLong = false;
   isUnsigned = false;
   isLongLong = false;
+  isSizeT = false;
   isHalf = false;
   isFloat = false;
   isImaginary = false;
   isFloat16 = false;
   isFloat128 = false;
   MicrosoftInteger = 0;
   isFract = false;
   isAccum = false;
if (LangOpts.FixedPoint) {
     }
   }
 
   // Parse the suffix.  At this point we can classify whether we have an FP or
   // integer constant.
   bool isFixedPointConstant = isFixedPointLiteral();
   bool isFPConstant = isFloatingLiteral();
 
   // Loop over all of the characters of the suffix.  If we see something bad,
   // we break out of the loop.
   for (; s != ThisTokEnd; ++s) {
     switch (*s) {
     case 'R':
     case 'r':
       if (!LangOpts.FixedPoint)
         break;
       if (isFract || isAccum) break;
       if (!(saw_period || saw_exponent)) break;
       isFract = true;
       continue;
     case 'K':
     case 'k':
       if (!LangOpts.FixedPoint)
         break;
       if (isFract || isAccum) break;
       if (!(saw_period || saw_exponent)) break;
       isAccum = true;
       continue;
     case 'h':      // FP Suffix for "half".
     case 'H':
       // OpenCL Extension v1.2 s9.5 - h or H suffix for half type.
       if (!(LangOpts.Half || LangOpts.FixedPoint))
         break;
       if (isIntegerLiteral()) break;  // Error for integer constant.
-      if (isHalf || isFloat || isLong) break; // HH, FH, LH invalid.
+      if (isHalf || isFloat || isLong || isSizeT) break; // HH, FH, LH invalid.
       isHalf = true;
       continue;  // Success.
     case 'f':      // FP Suffix for "float"
     case 'F':
       if (!isFPConstant) break;  // Error for integer constant.
-      if (isHalf || isFloat || isLong || isFloat128)
+      if (isHalf || isFloat || isLong || isSizeT || isFloat128)
         break; // HF, FF, LF, QF invalid.
 
       // CUDA host and device may have different _Float16 support, therefore
       // allows f16 literals to avoid false alarm.
       // ToDo: more precise check for CUDA.
       if ((Target.hasFloat16Type() || LangOpts.CUDA) && s + 2 < ThisTokEnd &&
           s[1] == '1' && s[2] == '6') {
         s += 2; // success, eat up 2 characters.
         isFloat16 = true;
         continue;
       }
 
       isFloat = true;
       continue;  // Success.
     case 'q':    // FP Suffix for "__float128"
     case 'Q':
       if (!isFPConstant) break;  // Error for integer constant.
-      if (isHalf || isFloat || isLong || isFloat128)
+      if (isHalf || isFloat || isLong || isSizeT || isFloat128)
         break; // HQ, FQ, LQ, QQ invalid.
       isFloat128 = true;
       continue;  // Success.
     case 'u':
     case 'U':
       if (isFPConstant) break;  // Error for floating constant.
       if (isUnsigned) break;    // Cannot be repeated.
       isUnsigned = true;
       continue;  // Success.
     case 'l':
     case 'L':
       if (isLong || isLongLong) break;  // Cannot be repeated.
       if (isHalf || isFloat || isFloat128) break;     // LH, LF, LQ invalid.
+      if (isSizeT) break; // LZ is invalid.
 
       // Check for long long.  The L's need to be adjacent and the same case.
       if (s[1] == s[0]) {
         assert(s + 1 < ThisTokEnd && "didn't maximally munch?");
         if (isFPConstant) break;        // long long invalid for floats.
         isLongLong = true;
         ++s;  // Eat both of them.
       } else {
         isLong = true;
       }
       continue; // Success.
+    case 'z':
+    case 'Z':
+      if (isSizeT) break; // Cannot be repeated.
+      if (isLong || isLongLong) break;  // ZL and ZLL are invalid.
+      if (isHalf || isFloat || isFloat128) break;     // ZH, ZF, ZQ are invalid.
+      if (isFPConstant) break; // invalid for floats.
+      if (MicrosoftInteger) break; // invalid for Microsoft integers.
+      isSizeT = true;
+      continue;
     case 'i':
     case 'I':
       if (LangOpts.MicrosoftExt) {
-        if (isLong || isLongLong || MicrosoftInteger)
+        if (isLong || isLongLong || isSizeT || MicrosoftInteger)
           break;
 
         if (!isFPConstant) {
           // Allow i8, i16, i32, and i64.
           switch (s[1]) {
           case '8':
             s += 2; // i8 suffix
             MicrosoftInteger = 8;
if (s != ThisTokEnd || isImaginary) {
     expandUCNs(UDSuffixBuf, StringRef(SuffixBegin, ThisTokEnd - SuffixBegin));
     if (isValidUDSuffix(LangOpts, UDSuffixBuf)) {
       if (!isImaginary) {
         // Any suffix pieces we might have parsed are actually part of the
         // ud-suffix.
         isLong = false;
         isUnsigned = false;
         isLongLong = false;
+        isSizeT = false;
         isFloat = false;
         isFloat16 = false;
         isHalf = false;
         isImaginary = false;
         MicrosoftInteger = 0;
         saw_fixed_point_suffix = false;
         isFract = false;
         isAccum = false;

clang/lib/Lex/PPExpressions.cpp

if (!PP.getLangOpts().C99 && Literal.isLongLong) {
       if (PP.getLangOpts().CPlusPlus)
         PP.Diag(PeekTok,
              PP.getLangOpts().CPlusPlus11 ?
              diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
       else
         PP.Diag(PeekTok, diag::ext_c99_longlong);
     }
 
+    // 'z/uz' literals are a C++2b feature.
+    if (!PP.getLangOpts().CPlusPlus2b && Literal.isSizeT) {
+      PP.Diag(PeekTok, diag::ext_cxx2b_size_t_suffix);
+    }
+
     // Parse the integer literal into Result.
     if (Literal.GetIntegerValue(Result.Val)) {
       // Overflow parsing integer literal.
       if (ValueLive)
         PP.Diag(PeekTok, diag::err_integer_literal_too_large)
             << /* Unsigned */ 1;
       Result.Val.setIsUnsigned(true);
     } else {

clang/lib/Sema/SemaExpr.cpp

if (!getLangOpts().C99 && Literal.isLongLong) {
       if (getLangOpts().CPlusPlus)
         Diag(Tok.getLocation(),
              getLangOpts().CPlusPlus11 ?
              diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
       else
         Diag(Tok.getLocation(), diag::ext_c99_longlong);
     }
 
+    // 'z/uz' literals are a C++2b feature.
+    if (!getLangOpts().CPlusPlus2b && Literal.isSizeT) {
+      Diag(Tok.getLocation(), diag::ext_cxx2b_size_t_suffix);
+    }
+
     // Get the value in the widest-possible width.
     unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth();
     llvm::APInt ResultVal(MaxWidth, 0);
 
     if (Literal.GetIntegerValue(ResultVal)) {
       // If this value didn't fit into uintmax_t, error and force to ull.
       Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
           << /* Unsigned */ 1;
       Ty = Context.UnsignedLongLongTy;
       assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
              "long long is not intmax_t?");
     } else {
       // If this value fits into a ULL, try to figure out what else it fits into
       // according to the rules of C99 6.4.4.1p5.
 
       // Octal, Hexadecimal, and integers with a U suffix are allowed to
       // be an unsigned int.
       bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
 
       // Check from smallest to largest, picking the smallest type we can.
       unsigned Width = 0;
 
       // Microsoft specific integer suffixes are explicitly sized.
       if (Literal.MicrosoftInteger) {
         if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
           Width = 8;
           Ty = Context.CharTy;
         } else {
           Width = Literal.MicrosoftInteger;
           Ty = Context.getIntTypeForBitwidth(Width,
                                              /*Signed=*/!Literal.isUnsigned);
         }
       }
 
+      // Check C++2b size_t literals.
+      if (Literal.isSizeT) {
+        assert(Ty.isNull() && "size_t literals can't be Microsoft literals");
+        unsigned SizeTSize = Context.getTargetInfo().getTypeWidth(
+            Context.getTargetInfo().getSizeType());
+
+        // Does it fit in size_t?
+        if (ResultVal.isIntN(SizeTSize)) {
+          // Does it fit in a ssize_t?
+          if (!Literal.isUnsigned && ResultVal[SizeTSize - 1] == 0)
+            Ty = Context.getSignedSizeType();
+          else if (AllowUnsigned)
+            Ty = Context.getSizeType();
+          Width = SizeTSize;
+        }
+      }
+
       if (Ty.isNull() && !Literal.isLong && !Literal.isLongLong) {
         // Are int/unsigned possibilities?
         unsigned IntSize = Context.getTargetInfo().getIntWidth();
 
         // Does it fit in a unsigned int?
         if (ResultVal.isIntN(IntSize)) {
           // Does it fit in a signed int?
           if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
             Ty = Context.IntTy;
           else if (AllowUnsigned)
             Ty = Context.UnsignedIntTy;
           Width = IntSize;
         }
       }
 
       // Are long/unsigned long possibilities?
       if (Ty.isNull() && !Literal.isLongLong) {
         unsigned LongSize = Context.getTargetInfo().getLongWidth();
 
         // Does it fit in a unsigned long?
         if (ResultVal.isIntN(LongSize)) {
           // Does it fit in a signed long?
           if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
             Ty = Context.LongTy;
           else if (AllowUnsigned)
if (Literal.GetIntegerValue(ResultVal)) {
                                             : /*will be ill-formed*/ 1);
             Ty = Context.UnsignedLongTy;
           }
           Width = LongSize;
         }
       }
 
       // Check long long if needed.
       if (Ty.isNull()) {
         unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth();
 
         // Does it fit in a unsigned long long?
         if (ResultVal.isIntN(LongLongSize)) {
           // Does it fit in a signed long long?
           // To be compatible with MSVC, hex integer literals ending with the
           // LL or i64 suffix are always signed in Microsoft mode.
           if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
               (getLangOpts().MSVCCompat && Literal.isLongLong)))
             Ty = Context.LongLongTy;
           else if (AllowUnsigned)
             Ty = Context.UnsignedLongLongTy;
           Width = LongLongSize;
         }
       }
 
       // If we still couldn't decide a type, we probably have something that
       // does not fit in a signed long long, but has no U suffix.
       if (Ty.isNull()) {
         Diag(Tok.getLocation(), diag::ext_integer_literal_too_large_for_signed);
         Ty = Context.UnsignedLongLongTy;
         Width = Context.getTargetInfo().getLongLongWidth();
       }
 
       if (ResultVal.getBitWidth() != Width)
         ResultVal = ResultVal.trunc(Width);
     }
     Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation());

clang/test/Lexer/cxx-features.cpp

 #elif __cplusplus < 202002L
 #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx17 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx17)
 #elif __cplusplus == 202002L
 #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx20 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx20)
 #else
 #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx23 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx23)
 #endif
 
+// --- C++2b features ---
+
+#if check(size_t_suffix, 0, 0, 0, 0, 0, 202011)
+#error "wrong value for __cpp_size_t_suffix"
+#endif
+
 // --- C++20 features ---
 
 #if check(aggregate_paren_init, 0, 0, 0, 0, 0, 0)
 // FIXME: 201902 in C++20
 #error "wrong value for __cpp_aggregate_paren_init"
 #endif
 
 #if defined(CHAR8_T) ? check(char8_t, 201811, 201811, 201811, 201811, 201811, 201811) : \

clang/test/Lexer/size_t-literal.cpp

+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify -ferror-limit=0 %s
+
+void ValidSuffix() {
+  // Decimal literals.
+  {
+    auto a1 = 1z;
+    auto a2 = 1Z;
+
+    auto a3 = 1uz;
+    auto a4 = 1uZ;
+    auto a5 = 1Uz;
+    auto a6 = 1UZ;
+
+    auto a7 = 1zu;
+    auto a8 = 1Zu;
+    auto a9 = 1zU;
+    auto a10 = 1ZU;
+
+    auto a11 = 1'2z;
+    auto a12 = 1'2Z;
+  }
+  // Hexadecimal literals.
+  {
+    auto a1 = 0x1z;
+    auto a2 = 0x1Z;
+
+    auto a3 = 0x1uz;
+    auto a4 = 0x1uZ;
+    auto a5 = 0x1Uz;
+    auto a6 = 0x1UZ;
+
+    auto a7 = 0x1zu;
+    auto a8 = 0x1Zu;
+    auto a9 = 0x1zU;
+    auto a10 = 0x1ZU;
+
+    auto a11 = 0x1'2z;
+    auto a12 = 0x1'2Z;
+  }
+  // Binary literals.
+  {
+    auto a1 = 0b1z;
+    auto a2 = 0b1Z;
+
+    auto a3 = 0b1uz;
+    auto a4 = 0b1uZ;
+    auto a5 = 0b1Uz;
+    auto a6 = 0b1UZ;
+
+    auto a7 = 0b1zu;
+    auto a8 = 0b1Zu;
+    auto a9 = 0b1zU;
+    auto a10 = 0b1ZU;
+
+    auto a11 = 0b1'1z;
+    auto a12 = 0b1'1Z;
+  }
+  // Octal literals.
+  {
+    auto a1 = 01z;
+    auto a2 = 01Z;
+
+    auto a3 = 01uz;
+    auto a4 = 01uZ;
+    auto a5 = 01Uz;
+    auto a6 = 01UZ;
+
+    auto a7 = 01zu;
+    auto a8 = 01Zu;
+    auto a9 = 01zU;
+    auto a10 = 01ZU;
+
+    auto a11 = 0'1z;
+    auto a12 = 0'1Z;
+  }
+}
+
+void InvalidSuffix() {
+  // Long.
+  {
+    auto a1 = 1lz; // expected-error {{invalid suffix}}
+    auto a2 = 1lZ; // expected-error {{invalid suffix}}
+    auto a3 = 1Lz; // expected-error {{invalid suffix}}
+    auto a4 = 1LZ; // expected-error {{invalid suffix}}
+
+    auto a5 = 1zl; // expected-error {{invalid suffix}}
+    auto a6 = 1Zl; // expected-error {{invalid suffix}}
+    auto a7 = 1zL; // expected-error {{invalid suffix}}
+    auto a8 = 1ZL; // expected-error {{invalid suffix}}
+
+    auto a9 = 1ulz; // expected-error {{invalid suffix}}
+    auto a10 = 1ulZ; // expected-error {{invalid suffix}}
+    auto a11 = 1uLz; // expected-error {{invalid suffix}}
+    auto a12 = 1uLZ; // expected-error {{invalid suffix}}
+
+    auto a13 = 1uzl; // expected-error {{invalid suffix}}
+    auto a14 = 1uZl; // expected-error {{invalid suffix}}
+    auto a15 = 1uzL; // expected-error {{invalid suffix}}
+    auto a16 = 1uZL; // expected-error {{invalid suffix}}
+  }
+  // Long long.
+  {
+    auto a1 = 1llz; // expected-error {{invalid suffix}}
+    auto a2 = 1llZ; // expected-error {{invalid suffix}}
+    auto a3 = 1LLz; // expected-error {{invalid suffix}}
+    auto a4 = 1LLZ; // expected-error {{invalid suffix}}
+
+    auto a5 = 1zll; // expected-error {{invalid suffix}}
+    auto a6 = 1Zll; // expected-error {{invalid suffix}}
+    auto a7 = 1zLL; // expected-error {{invalid suffix}}
+    auto a8 = 1ZLL; // expected-error {{invalid suffix}}
+
+    auto a9 = 1ullz; // expected-error {{invalid suffix}}
+    auto a10 = 1ullZ; // expected-error {{invalid suffix}}
+    auto a11 = 1uLLz; // expected-error {{invalid suffix}}
+    auto a12 = 1uLLZ; // expected-error {{invalid suffix}}
+
+    auto a13 = 1uzll; // expected-error {{invalid suffix}}
+    auto a14 = 1uZll; // expected-error {{invalid suffix}}
+    auto a15 = 1uzLL; // expected-error {{invalid suffix}}
+    auto a16 = 1uZLL; // expected-error {{invalid suffix}}
+  }
+  // Floating point.
+  {
+    auto a1 = 0.1z; // expected-error {{invalid suffix}}
+    auto a2 = 0.1Z; // expected-error {{invalid suffix}}
+    auto a3 = 0.1uz; // expected-error {{invalid suffix}}
+    auto a4 = 0.1uZ; // expected-error {{invalid suffix}}
+    auto a5 = 0.1Uz; // expected-error {{invalid suffix}}
+    auto a6 = 0.1UZ; // expected-error {{invalid suffix}}
+    auto a7 = 0.1zu; // expected-error {{invalid suffix}}
+    auto a8 = 0.1Zu; // expected-error {{invalid suffix}}
+    auto a9 = 0.1zU; // expected-error {{invalid suffix}}
+    auto a10 = 0.1ZU; // expected-error {{invalid suffix}}
+
+    auto a11 = 0.1fz; // expected-error {{invalid suffix}}
+    auto a12 = 0.1fZ; // expected-error {{invalid suffix}}
+    auto a13 = 0.1fuz; // expected-error {{invalid suffix}}
+    auto a14 = 0.1fuZ; // expected-error {{invalid suffix}}
+    auto a15 = 0.1fUz; // expected-error {{invalid suffix}}
+    auto a16 = 0.1fUZ; // expected-error {{invalid suffix}}
+    auto a17 = 0.1fzu; // expected-error {{invalid suffix}}
+    auto a18 = 0.1fZu; // expected-error {{invalid suffix}}
+    auto a19 = 0.1fzU; // expected-error {{invalid suffix}}
+    auto a110 = 0.1fZU; // expected-error {{invalid suffix}}
+  }
+  // Repetitive suffix.
+  {
+    auto a1 = 1zz; // expected-error {{invalid suffix}}
+    auto a2 = 1zZ; // expected-error {{invalid suffix}}
+    auto a3 = 1Zz; // expected-error {{invalid suffix}}
+    auto a4 = 1ZZ; // expected-error {{invalid suffix}}
+  }
+}

clang/test/SemaCXX/size_t-literal.cpp

+// RUN: %clang_cc1 -std=c++2b -Werror=c++2b-extensions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++20 -Werror=c++2b-extensions -fsyntax-only -verify %s
+
+typedef __SIZE_TYPE__ size_t;
+// Assume ptrdiff_t is the signed integer type corresponding to size_t.
+typedef __PTRDIFF_TYPE__ ssize_t;
+
+template <typename, typename>
+struct is_same { static constexpr bool value = false; };
+
+template <typename T>
+struct is_same<T, T> { static constexpr bool value = true; };
+
+#if __cplusplus >= 202101L
+//  expected-no-diagnostics
+#endif
+
+void SSizeT() {
+  auto a1 = 1z;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a1), ssize_t>::value);
+
+  auto a2 = 1Z;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a2), ssize_t>::value);
+}
+
+void SizeT() {
+  auto a1 = 1uz;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a1), size_t>::value);
+
+  auto a2 = 1uZ;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a2), size_t>::value);
+
+  auto a3 = 1Uz;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a3), size_t>::value);
+
+  auto a4 = 1UZ;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a4), size_t>::value);
+
+  auto a5 = 1zu;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a5), size_t>::value);
+
+  auto a6 = 1Zu;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a6), size_t>::value);
+
+  auto a7 = 1zU;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a7), size_t>::value);
+
+  auto a8 = 1ZU;
+#if __cplusplus < 202101L
+  // expected-error@-2 {{size_t suffix for literals is a C++2b extension}}
+#endif
+  static_assert(is_same<decltype(a8), size_t>::value);
+}