[libc++][format] Fix precision parser conformance.

[Mordante]

Summary

@CaseyCarter reported that the tests for the std-format-spec rejects leading
zeroes for precision, which the Standard does not require. The Standard allows
them. Only for precision, not for the width or an arg-id.

Fixes the precision parser and adds some test for the arg-id since they
were missing.

[• Quuxplusone]

LGTM FWIW

libcxx/test/std/utilities/format/format.functions/format_tests.h

180

It would be friendlier to make this message "A format-spec arg-id shouldn't have leading zeros".
Also (definitely unrelated to this PR) I think it's superfluous to keep repeating the word format-spec in all these messages. The exception type is already format_error and it's thrown during format-string parsing, right? I think "An arg-id shouldn't... would be perfectly unambiguous to the catcher.

199

I'd like to see another test case for {:.010} to conclusively prove it's parsed as decimal 10, not octal 8.

[CaseyCarter]

@CaseyCarter reported the std-format-spec parser prohibits leading zeros

Technically, I reported that the _test_ expects the std-format-spec parser to reject leading zeroes for precision, which the Working Draft does not require. I wouldn't write this silly format-spec even if it is allowed, but I did notice that MSVC STL fails this test.

libcxx/test/std/utilities/format/format.functions/format_tests.h

180

+1 for "... shouldn't have leading zeroes". A user who mistakenly believes that 01 is a valid _arg-id_ will read this message, see all the }s in the format string, and spend an hour investigating the wrong thing / filing a bug report when we could have pointed them directly at the problem.

[Mordante]

Thanks for the reviews!

In D116381#3213091, @CaseyCarter wrote:

@CaseyCarter reported the std-format-spec parser prohibits leading zeros

Technically, I reported that the _test_ expects the std-format-spec parser to reject leading zeroes for precision, which the Working Draft does not require. I wouldn't write this silly format-spec even if it is allowed, but I did notice that MSVC STL fails this test.

True, I can reword the message. But without your report this bug wouldn't be fixed ;-) And I agree these tests are probably the only time I'll write the leading zeros for precision; unless I want to do a C++ Pub quiz.

libcxx/test/std/utilities/format/format.functions/format_tests.h

180

@vitaut suggested here https://reviews.llvm.org/D115988#inline-1110797 to simplify all messages. So for now I keep this message as is. If we keep multiple errors it should indeed be a better message, but if we're going to simplify them I rather keep this one as is.

[Mordante]

libcxx/test/std/utilities/format/format.functions/format_tests.h

180

Changing the message requires updating some tests, so I prefer to do it in a separate PR D116495.

[Mordante]

Rebased to check CI, addresses the last review comment.

libcxx/include/__format/parser_std_format_spec.h

protected:
   __parse(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
     if (*__begin != _CharT('.'))
       return __begin;
 
     ++__begin;
     if (__begin == __end)
       __throw_format_error("End of input while parsing format-spec precision");
 
-    if (*__begin == _CharT('0')) {
-      ++__begin;
-      if (__begin != __end && *__begin >= '0' && *__begin <= '9')
-        __throw_format_error(
-            "A format-spec precision field shouldn't have a leading zero");
-
-      __precision = 0;
-      __precision_as_arg = 0;
-      return __begin;
-    }
-
     if (*__begin == _CharT('{')) {
       __format::__parse_number_result __arg_id =
           __parse_arg_id(++__begin, __end, __parse_ctx);
       _LIBCPP_ASSERT(__arg_id.__value != __format::__number_max,
                      "Unsupported number of arguments, since this number of "
                      "arguments is used a special value");
       __precision = __arg_id.__value;
       return __arg_id.__ptr;

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string.pass.cpp

constexpr void test() {
   test({.precision = 1000, .precision_as_arg = false}, 5, CSTR(".1000}"));
   test({.precision = 1000000, .precision_as_arg = false}, 8, CSTR(".1000000}"));
 
   test({.precision = 0, .precision_as_arg = true}, 3, CSTR(".{}}"));
   test({.precision = 0, .precision_as_arg = true}, 4, CSTR(".{0}}"));
   test({.precision = 1, .precision_as_arg = true}, 4, CSTR(".{1}}"));
 
   test_exception<Parser<CharT>>(
-      "A format-spec precision field shouldn't have a leading zero",
-      CSTR(".00"));
-  test_exception<Parser<CharT>>(
-      "A format-spec precision field shouldn't have a leading zero",
-      CSTR(".01"));
-  test_exception<Parser<CharT>>(
       "The format-spec precision field doesn't contain a value or arg-id",
       CSTR(".a"));
   test_exception<Parser<CharT>>(
       "The format-spec precision field doesn't contain a value or arg-id",
       CSTR(".:"));
 
   static_assert(std::__format::__number_max == 2'147'483'647,
                 "Update the assert and the test.");

libcxx/test/std/utilities/format/format.functions/format_tests.h

check_exception(
       "A format-spec arg-id replacement argument isn't an integral type",
       STR("hello {:{}}"), world, universe);
   check_exception(
       "Using manual argument numbering in automatic argument numbering mode",
       STR("hello {:{0}}"), world, 1);
   check_exception(
       "Using automatic argument numbering in manual argument numbering mode",
       STR("hello {0:{}}"), world, 1);
+  // Arg-id may not have leading zeros.
+  check_exception(
+      "A format-spec arg-id should terminate at a '}'",
+      STR("hello {0:{01}}"), world, 1);
 
   // *** precision ***
-  check_exception("A format-spec precision field shouldn't have a leading zero",
-                  STR("hello {:.01}"), world);
-
 #if _LIBCPP_VERSION
   // This limit isn't specified in the Standard.
   static_assert(std::__format::__number_max == 2'147'483'647,
                 "Update the assert and the test.");
   check_exception("The numeric value of the format-spec is too large",
                   STR("{:.2147483648}"), world);
   check_exception("The numeric value of the format-spec is too large",
                   STR("{:.5000000000}"), world);
   check_exception("The numeric value of the format-spec is too large",
                   STR("{:.10000000000}"), world);
 #endif
 
   // Precision 0 allowed, but not useful for string arguments.
   check(STR("hello "), STR("hello {:.{}}"), world, 0);
+  // Precision may have leading zeros. Secondly tests the value is still base 10.
+  check(STR("hello 0123456789"), STR("hello {:.000010}"), STR("0123456789abcdef"));
   check_exception(
       "A format-spec arg-id replacement shouldn't have a negative value",
       STR("hello {:.{}}"), world, -1);
   check_exception(
       "A format-spec arg-id replacement exceeds the maximum supported value",
       STR("hello {:.{}}"), world, -1u);
   check_exception("Argument index out of bounds", STR("hello {:.{}}"), world);
   check_exception(
       "A format-spec arg-id replacement argument isn't an integral type",
       STR("hello {:.{}}"), world, universe);
   check_exception(
       "Using manual argument numbering in automatic argument numbering mode",
       STR("hello {:.{0}}"), world, 1);
   check_exception(
       "Using automatic argument numbering in manual argument numbering mode",
       STR("hello {0:.{}}"), world, 1);
+  // Arg-id may not have leading zeros.
+  check_exception(
+      "A format-spec arg-id should terminate at a '}'",
+      STR("hello {0:.{01}}"), world, 1);
 
   // *** locale-specific form ***
   check_exception("The format-spec should consume the input or end with a '}'",
                   STR("hello {:L}"), world);
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("s"))
     check_exception(