[Sema] -Wformat: recognize %lb for the printf/scanf family of functions

[MaskRay]

Summary

Fix https://github.com/llvm/llvm-project/issues/62247

D131057 added bArg and BArg in the AsLongLong label in
FormatSpecifier::hasValidLengthModifier, but missed the AsLong label,
therefore %llb is allowed while %lb (e.g. printf("%lb", (long)10)) has a
spurious warning. Add the missing case labels.

[MaskRay]

update test/Sema/format-strings-fixit.c

[enh]

thanks!

[aaron.ballman]

Thanks for the fix! LGTM, but please add a release note for the fix when landing.

[MaskRay]

Change the subject to be clearer.
Add a release note.

clang/docs/ReleaseNotes.rst

- There were some cases in which the diagnostic for the unavailable attribute
   might not be issued, this fixes those cases.
   (`61815 <https://github.com/llvm/llvm-project/issues/61815>`_)
 - Clang now avoids unnecessary diagnostic warnings for obvious expressions in
   the case of binary operators with logical OR operations.
   (`#57906 <https://github.com/llvm/llvm-project/issues/57906>`_)
 - Clang's "static assertion failed" diagnostic now points to the static assertion
   expression instead of pointing to the ``static_assert`` token.
   (`#61951 <https://github.com/llvm/llvm-project/issues/61951>`_)
+- ``-Wformat`` now recognizes ``%lb`` for the ``printf``/``scanf`` family of
+  functions.
+  (`#62247: <https://github.com/llvm/llvm-project/issues/62247>`_).
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.
   (`#60344 <https://github.com/llvm/llvm-project/issues/60344>`_)
 - Fix confusing warning message when ``/clang:-x`` is passed in ``clang-cl``

clang/lib/AST/FormatString.cpp

case LengthModifier::AsLong: // or AsWideChar
       if (CS.isDoubleArg()) {
         // Invalid for OpenCL FP scalars.
         if (LO.OpenCL && VectorNumElts.isInvalid())
           return false;
         return true;
       }
 
       switch (CS.getKind()) {
+        case ConversionSpecifier::bArg:
+        case ConversionSpecifier::BArg:
         case ConversionSpecifier::dArg:
         case ConversionSpecifier::DArg:
         case ConversionSpecifier::iArg:
         case ConversionSpecifier::oArg:
         case ConversionSpecifier::OArg:
         case ConversionSpecifier::uArg:
         case ConversionSpecifier::UArg:
         case ConversionSpecifier::xArg:

clang/test/Sema/format-strings-fixit.c

 typedef __WCHAR_TYPE__ wchar_t;
 
 void test(void) {
   // Basic types
   printf("%s", (int) 123);
   printf("abc%0f", "testing testing 123");
   printf("%u", (long) -12);
   printf("%b", (long) -13);
+  printf("%d", (long) -14);
   printf("%p", 123);
   printf("%c\n", "x");
   printf("%c\n", 1.23);
 
   // Larger types
   printf("%+.2d", (unsigned long long) 123456);
   printf("%1d", (long double) 1.23);
 
void test2(int intSAParm[static 2]) {
   scanf("%f", (my_size_type*)&sizeVar);
   scanf("%f", (my_intmax_type*)&intmaxVar);
   scanf("%f", (my_uintmax_type*)&uIntmaxVar);
   scanf("%f", (my_ptrdiff_type*)&ptrdiffVar);
   scanf("%f", (my_int_type*)&intVar);
 
   // Preserve the original formatting.
   scanf("%b", &longVar);
+  scanf("%d", &longVar);
   scanf("%o", &longVar);
   scanf("%u", &longVar);
   scanf("%x", &longVar);
   scanf("%X", &longVar);
   scanf("%i", &uLongVar);
   scanf("%d", &uLongVar);
   scanf("%F", &longDoubleVar);
   scanf("%e", &longDoubleVar);
   scanf("%E", &longDoubleVar);
   scanf("%g", &longDoubleVar);
   scanf("%G", &longDoubleVar);
   scanf("%a", &longDoubleVar);
   scanf("%A", &longDoubleVar);
 }
 
 // Validate the fixes.
 // CHECK: printf("%d", (int) 123);
 // CHECK: printf("abc%s", "testing testing 123");
 // CHECK: printf("%ld", (long) -12);
-// CHECK: printf("%ld", (long) -13);
+// CHECK: printf("%lb", (long) -13);
+// CHECK: printf("%ld", (long) -14);
 // CHECK: printf("%d", 123);
 // CHECK: printf("%s\n", "x");
 // CHECK: printf("%f\n", 1.23);
 // CHECK: printf("%+.2lld", (unsigned long long) 123456);
 // CHECK: printf("%1Lf", (long double) 1.23);
 // CHECK: printf("%0u", (unsigned) 31337);
 // CHECK: printf("%p", (void *) 0);
 // CHECK: printf("%+f", 1.23);

 // CHECK: scanf("%jd", &intmaxVar);
 // CHECK: scanf("%ju", &uIntmaxVar);
 // CHECK: scanf("%td", &ptrdiffVar);
 // CHECK: scanf("%zu", (my_size_type*)&sizeVar);
 // CHECK: scanf("%jd", (my_intmax_type*)&intmaxVar);
 // CHECK: scanf("%ju", (my_uintmax_type*)&uIntmaxVar);
 // CHECK: scanf("%td", (my_ptrdiff_type*)&ptrdiffVar);
 // CHECK: scanf("%d", (my_int_type*)&intVar);
+// CHECK: scanf("%lb", &longVar);
 // CHECK: scanf("%ld", &longVar);
 // CHECK: scanf("%lo", &longVar);
 // CHECK: scanf("%lu", &longVar);
 // CHECK: scanf("%lx", &longVar);
 // CHECK: scanf("%lX", &longVar);
 // CHECK: scanf("%li", &uLongVar);
 // CHECK: scanf("%ld", &uLongVar);
 // CHECK: scanf("%LF", &longDoubleVar);
 // CHECK: scanf("%Le", &longDoubleVar);
 // CHECK: scanf("%LE", &longDoubleVar);
 // CHECK: scanf("%Lg", &longDoubleVar);
 // CHECK: scanf("%LG", &longDoubleVar);
 // CHECK: scanf("%La", &longDoubleVar);
 // CHECK: scanf("%LA", &longDoubleVar);

clang/test/Sema/format-strings.c

void test10(int x, float f, int i, long long lli) {
   printf("%.d", x); // no-warning
   printf("%.", x);  // expected-warning{{incomplete format specifier}}
   printf("%f", 4); // expected-warning{{format specifies type 'double' but the argument has type 'int'}}
   printf("%qd", lli); // no-warning
   printf("%qd", x); // expected-warning{{format specifies type 'long long' but the argument has type 'int'}}
   printf("%qp", (void *)0); // expected-warning{{length modifier 'q' results in undefined behavior or no effect with 'p' conversion specifier}}
   printf("hhX %hhX", (unsigned char)10); // no-warning
   printf("llX %llX", (long long) 10); // no-warning
+  printf("%lb %lB", (long) 10, (long) 10); // no-warning
   printf("%llb %llB", (long long) 10, (long long) 10); // no-warning
   // This is fine, because there is an implicit conversion to an int.
   printf("%d", (unsigned char) 10); // no-warning
   printf("%d", (long long) 10); // expected-warning{{format specifies type 'int' but the argument has type 'long long'}}
   printf("%Lf\n", (long double) 1.0); // no-warning
   printf("%f\n", (long double) 1.0); // expected-warning{{format specifies type 'double' but the argument has type 'long double'}}
   // The man page says that a zero precision is okay.
   printf("%.0Lf", (long double) 1.0); // no-warning