Implement compile-time checks by default

vitaut · vitaut · commit bcc20b29df13 · 2020-11-15T17:24:36.000-08:00
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
@@ -17,6 +17,9 @@ jobs:
             std: 14
           - cxx: g++-10
             std: 17
+          - cxx: g++-10
+            std: 20
+            cxxflags: -DFMT_COMPILE_TIME_CHECKS=1
           - cxx: clang++-9
             std: 11
           - cxx: clang++-9
@@ -36,6 +39,7 @@ jobs:
       working-directory: ${{runner.workspace}}/build
       env:
         CXX: ${{matrix.cxx}}
+        CXXFLAGS: ${{matrix.cxxflags}}
       run: |
         cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.fuzz}} \
               -DCMAKE_CXX_STANDARD=${{matrix.std}} -DFMT_DOC=OFF \
diff --git a/include/fmt/chrono.h b/include/fmt/chrono.h
@@ -404,20 +404,20 @@ struct formatter<std::chrono::time_point<std::chrono::system_clock>, Char>
 };
 
 template <typename Char> struct formatter<std::tm, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
     auto it = ctx.begin();
     if (it != ctx.end() && *it == ':') ++it;
     auto end = it;
     while (end != ctx.end() && *end != '}') ++end;
-    tm_format.reserve(detail::to_unsigned(end - it + 1));
-    tm_format.append(it, end);
-    tm_format.push_back('\0');
+    specs = {it, detail::to_unsigned(end - it)};
     return end;
   }
 
   template <typename FormatContext>
   auto format(const std::tm& tm, FormatContext& ctx) -> decltype(ctx.out()) {
+    basic_memory_buffer<Char> tm_format;
+    tm_format.append(specs.begin(), specs.end());
+    tm_format.push_back('\0');
     basic_memory_buffer<Char> buf;
     size_t start = buf.size();
     for (;;) {
@@ -440,7 +440,7 @@ template <typename Char> struct formatter<std::tm, Char> {
     return std::copy(buf.begin(), buf.end(), ctx.out());
   }
 
-  basic_memory_buffer<Char> tm_format;
+  basic_string_view<Char> specs;
 };
 
 namespace detail {
@@ -638,28 +638,29 @@ FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,
 struct chrono_format_checker {
   FMT_NORETURN void report_no_date() { FMT_THROW(format_error("no date")); }
 
-  template <typename Char> void on_text(const Char*, const Char*) {}
+  template <typename Char>
+  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
   FMT_NORETURN void on_abbr_weekday() { report_no_date(); }
   FMT_NORETURN void on_full_weekday() { report_no_date(); }
   FMT_NORETURN void on_dec0_weekday(numeric_system) { report_no_date(); }
   FMT_NORETURN void on_dec1_weekday(numeric_system) { report_no_date(); }
   FMT_NORETURN void on_abbr_month() { report_no_date(); }
   FMT_NORETURN void on_full_month() { report_no_date(); }
-  void on_24_hour(numeric_system) {}
-  void on_12_hour(numeric_system) {}
-  void on_minute(numeric_system) {}
-  void on_second(numeric_system) {}
+  FMT_CONSTEXPR void on_24_hour(numeric_system) {}
+  FMT_CONSTEXPR void on_12_hour(numeric_system) {}
+  FMT_CONSTEXPR void on_minute(numeric_system) {}
+  FMT_CONSTEXPR void on_second(numeric_system) {}
   FMT_NORETURN void on_datetime(numeric_system) { report_no_date(); }
   FMT_NORETURN void on_loc_date(numeric_system) { report_no_date(); }
   FMT_NORETURN void on_loc_time(numeric_system) { report_no_date(); }
   FMT_NORETURN void on_us_date() { report_no_date(); }
   FMT_NORETURN void on_iso_date() { report_no_date(); }
-  void on_12_hour_time() {}
-  void on_24_hour_time() {}
-  void on_iso_time() {}
-  void on_am_pm() {}
-  void on_duration_value() {}
-  void on_duration_unit() {}
+  FMT_CONSTEXPR void on_12_hour_time() {}
+  FMT_CONSTEXPR void on_24_hour_time() {}
+  FMT_CONSTEXPR void on_iso_time() {}
+  FMT_CONSTEXPR void on_am_pm() {}
+  FMT_CONSTEXPR void on_duration_value() {}
+  FMT_CONSTEXPR void on_duration_unit() {}
   FMT_NORETURN void on_utc_offset() { report_no_date(); }
   FMT_NORETURN void on_tz_name() { report_no_date(); }
 };
@@ -1033,11 +1034,11 @@ template <typename Rep, typename Period, typename Char>
 struct formatter<std::chrono::duration<Rep, Period>, Char> {
  private:
   basic_format_specs<Char> specs;
-  int precision;
+  int precision = -1;
   using arg_ref_type = detail::arg_ref<Char>;
   arg_ref_type width_ref;
   arg_ref_type precision_ref;
-  mutable basic_string_view<Char> format_str;
+  basic_string_view<Char> format_str;
   using duration = std::chrono::duration<Rep, Period>;
 
   struct spec_handler {
@@ -1060,17 +1061,21 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
     }
 
     void on_error(const char* msg) { FMT_THROW(format_error(msg)); }
-    void on_fill(basic_string_view<Char> fill) { f.specs.fill = fill; }
-    void on_align(align_t align) { f.specs.align = align; }
-    void on_width(int width) { f.specs.width = width; }
-    void on_precision(int _precision) { f.precision = _precision; }
-    void end_precision() {}
+    FMT_CONSTEXPR void on_fill(basic_string_view<Char> fill) {
+      f.specs.fill = fill;
+    }
+    FMT_CONSTEXPR void on_align(align_t align) { f.specs.align = align; }
+    FMT_CONSTEXPR void on_width(int width) { f.specs.width = width; }
+    FMT_CONSTEXPR void on_precision(int _precision) {
+      f.precision = _precision;
+    }
+    FMT_CONSTEXPR void end_precision() {}
 
-    template <typename Id> void on_dynamic_width(Id arg_id) {
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
       f.width_ref = make_arg_ref(arg_id);
     }
 
-    template <typename Id> void on_dynamic_precision(Id arg_id) {
+    template <typename Id> FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
       f.precision_ref = make_arg_ref(arg_id);
     }
   };
@@ -1100,8 +1105,6 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
   }
 
  public:
-  formatter() : precision(-1) {}
-
   FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
       -> decltype(ctx.begin()) {
     auto range = do_parse(ctx);
diff --git a/include/fmt/core.h b/include/fmt/core.h
@@ -249,6 +249,10 @@
 #  pragma execution_character_set("utf-8")
 #endif
 
+#ifndef FMT_COMPILE_TIME_CHECKS
+#  define FMT_COMPILE_TIME_CHECKS 0
+#endif
+
 FMT_BEGIN_NAMESPACE
 
 // Implementations of enable_if_t and other metafunctions for older systems.
@@ -1864,7 +1868,9 @@ FMT_INLINE std::basic_string<Char> vformat(
 */
 // Pass char_t as a default template parameter instead of using
 // std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... Args, typename Char = char_t<S>>
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(!FMT_COMPILE_TIME_CHECKS ||
+                        !std::is_same<Char, char>::value)>
 FMT_INLINE std::basic_string<Char> format(const S& format_str, Args&&... args) {
   const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
   return detail::vformat(to_string_view(format_str), vargs);
diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h
@@ -2652,7 +2652,8 @@ struct stringifier {
 }  // namespace detail
 
 template <> struct formatter<detail::bigint> {
-  format_parse_context::iterator parse(format_parse_context& ctx) {
+  FMT_CONSTEXPR format_parse_context::iterator parse(
+      format_parse_context& ctx) {
     return ctx.begin();
   }
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
@@ -3065,7 +3065,7 @@ FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
   using mapped_type =
       conditional_t<detail::mapped_type_constant<T, context>::value !=
                         type::custom_type,
-                    decltype(arg_mapper<context>().map(std::declval<T>())), T>;
+                    decltype(arg_mapper<context>().map(std::declval<const T&>())), T>;
   auto f = conditional_t<has_formatter<mapped_type, context>::value,
                          formatter<mapped_type, char_type>,
                          detail::fallback_formatter<T, char_type>>();
@@ -3561,7 +3561,7 @@ template <typename Char = char> class dynamic_formatter {
 
  public:
   template <typename ParseContext>
-  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     format_str_ = ctx.begin();
     // Checks are deferred to formatting time when the argument type is known.
     detail::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
@@ -3864,6 +3864,30 @@ make_format_to_n_args(const Args&... args) {
   return format_arg_store<buffer_context<Char>, Args...>(args...);
 }
 
+#if FMT_COMPILE_TIME_CHECKS
+template <typename... Args> struct format_string {
+  string_view str;
+
+  template <size_t N> consteval format_string(const char (&s)[N]) : str(s) {
+    if constexpr (detail::count_named_args<Args...>() == 0) {
+      using checker = detail::format_string_checker<char, detail::error_handler,
+                                                    remove_cvref_t<Args>...>;
+      detail::parse_format_string<true>(string_view(s, N), checker(s, {}));
+    }
+  }
+
+  template <typename T,
+            FMT_ENABLE_IF(std::is_constructible_v<string_view, const T&>)>
+  format_string(const T& s) : str(s) {}
+};
+
+template <typename... Args>
+FMT_INLINE std::string format(
+    format_string<std::type_identity_t<Args>...> format_str, Args&&... args) {
+  return detail::vformat(format_str.str, make_format_args(args...));
+}
+#endif
+
 template <typename Char, enable_if_t<(!std::is_same<Char, char>::value), int>>
 std::basic_string<Char> detail::vformat(
     basic_string_view<Char> format_str,
diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
@@ -36,20 +36,18 @@ struct formatting_range : formatting_base<Char> {
   static FMT_CONSTEXPR_DECL const size_t range_length_limit =
       FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
                                       // range.
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
+  Char prefix = '{';
+  Char delimiter = ',';
+  Char postfix = '}';
   static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
   static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
 template <typename Char, typename Enable = void>
 struct formatting_tuple : formatting_base<Char> {
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
+  Char prefix = '(';
+  Char delimiter = ',';
+  Char postfix = ')';
   static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
   static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -148,7 +148,7 @@ endif ()
 
 message(STATUS "FMT_PEDANTIC: ${FMT_PEDANTIC}")
 
-if (FMT_PEDANTIC)
+if (FMT_PEDANTIC AND CXX_STANDARD LESS 20)
   # MSVC fails to compile GMock when C++17 is enabled.
   if (FMT_HAS_VARIANT AND NOT MSVC)
     add_fmt_test(std-format-test)
diff --git a/test/chrono-test.cc b/test/chrono-test.cc
@@ -96,12 +96,14 @@ TEST(TimeTest, GMTime) {
 }
 
 TEST(TimeTest, TimePoint) {
-  std::chrono::system_clock::time_point point = std::chrono::system_clock::now();
+  std::chrono::system_clock::time_point point =
+      std::chrono::system_clock::now();
 
   std::time_t t = std::chrono::system_clock::to_time_t(point);
   std::tm tm = *std::localtime(&t);
   char strftime_output[256];
-  std::strftime(strftime_output, sizeof(strftime_output), "It is %Y-%m-%d %H:%M:%S", &tm);
+  std::strftime(strftime_output, sizeof(strftime_output),
+                "It is %Y-%m-%d %H:%M:%S", &tm);
 
   EXPECT_EQ(strftime_output, fmt::format("It is {:%Y-%m-%d %H:%M:%S}", point));
 }
@@ -246,25 +248,25 @@ TEST(ChronoTest, FormatSpecs) {
 
 TEST(ChronoTest, InvalidSpecs) {
   auto sec = std::chrono::seconds(0);
-  EXPECT_THROW_MSG(fmt::format("{:%a}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%A}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%c}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%x}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%Ex}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%X}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%EX}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%D}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%F}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%Ec}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%w}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%u}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%b}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%B}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%z}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%Z}", sec), fmt::format_error, "no date");
-  EXPECT_THROW_MSG(fmt::format("{:%Eq}", sec), fmt::format_error,
+  EXPECT_THROW_MSG(fmt::format(+"{:%a}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%A}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%c}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%x}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%Ex}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%X}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%EX}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%D}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%F}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%Ec}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%w}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%u}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%b}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%B}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%z}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%Z}", sec), fmt::format_error, "no date");
+  EXPECT_THROW_MSG(fmt::format(+"{:%Eq}", sec), fmt::format_error,
                    "invalid format");
-  EXPECT_THROW_MSG(fmt::format("{:%Oq}", sec), fmt::format_error,
+  EXPECT_THROW_MSG(fmt::format(+"{:%Oq}", sec), fmt::format_error,
                    "invalid format");
 }
 
@@ -307,7 +309,7 @@ TEST(ChronoTest, FormatDefaultFP) {
 }
 
 TEST(ChronoTest, FormatPrecision) {
-  EXPECT_THROW_MSG(fmt::format("{:.2}", std::chrono::seconds(42)),
+  EXPECT_THROW_MSG(fmt::format(+"{:.2}", std::chrono::seconds(42)),
                    fmt::format_error,
                    "precision not allowed for this argument type");
   EXPECT_EQ("1.2ms", fmt::format("{:.1}", dms(1.234)));
@@ -334,7 +336,7 @@ TEST(ChronoTest, FormatSimpleQq) {
 }
 
 TEST(ChronoTest, FormatPrecisionQq) {
-  EXPECT_THROW_MSG(fmt::format("{:.2%Q %q}", std::chrono::seconds(42)),
+  EXPECT_THROW_MSG(fmt::format(+"{:.2%Q %q}", std::chrono::seconds(42)),
                    fmt::format_error,
                    "precision not allowed for this argument type");
   EXPECT_EQ("1.2 ms", fmt::format("{:.1%Q %q}", dms(1.234)));
@@ -351,12 +353,12 @@ TEST(ChronoTest, FormatFullSpecsQq) {
 }
 
 TEST(ChronoTest, InvalidWidthId) {
-  EXPECT_THROW(fmt::format("{:{o}", std::chrono::seconds(0)),
+  EXPECT_THROW(fmt::format(+"{:{o}", std::chrono::seconds(0)),
                fmt::format_error);
 }
 
 TEST(ChronoTest, InvalidColons) {
-  EXPECT_THROW(fmt::format("{0}=:{0::", std::chrono::seconds(0)),
+  EXPECT_THROW(fmt::format(+"{0}=:{0::", std::chrono::seconds(0)),
                fmt::format_error);
 }
 
diff --git a/test/core-test.cc b/test/core-test.cc
@@ -24,6 +24,9 @@
 #endif
 
 #include "fmt/args.h"
+#if defined(FMT_COMPILE_TIME_CHECKS) && FMT_COMPILE_TIME_CHECKS
+#  include "fmt/format.h"
+#endif
 
 #undef min
 #undef max
@@ -633,7 +636,7 @@ template <> struct formatter<convertible_to_int> {
 };
 
 template <> struct formatter<convertible_to_c_string> {
-  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
   }
   auto format(convertible_to_c_string, format_context& ctx)
@@ -696,18 +699,10 @@ TYPED_TEST(IsStringTest, IsString) {
 }
 
 TEST(CoreTest, Format) {
-  // This should work without including fmt/format.h.
-#ifdef FMT_FORMAT_H_
-#  error fmt/format.h must not be included in the core test
-#endif
   EXPECT_EQ(fmt::format("{}", 42), "42");
 }
 
 TEST(CoreTest, FormatTo) {
-  // This should work without including fmt/format.h.
-#ifdef FMT_FORMAT_H_
-#  error fmt/format.h must not be included in the core test
-#endif
   std::string s;
   fmt::format_to(std::back_inserter(s), "{}", 42);
   EXPECT_EQ(s, "42");
diff --git a/test/format-test.cc b/test/format-test.cc
diff --git a/test/locale-test.cc b/test/locale-test.cc
diff --git a/test/ostream-test.cc b/test/ostream-test.cc

Original file line number	Diff line number	Diff line change
`@@ -2652,7 +2652,8 @@ struct stringifier {`
`2652`	`2652`	`} // namespace detail`
`2653`	`2653`
`2654`	`2654`	`template <> struct formatter<detail::bigint> {`
`2655`		`- format_parse_context::iterator parse(format_parse_context& ctx) {`
	`2655`	`+ FMT_CONSTEXPR format_parse_context::iterator parse(`
	`2656`	`+ format_parse_context& ctx) {`
`2656`	`2657`	`return ctx.begin();`
`2657`	`2658`	`}`
`2658`	`2659`