Merge branch 'upstream' of github.com:kassane/fmt into zig-pkg

.github/dependabot.yml

@@ -3,6 +3,6 @@ updates:
   - package-ecosystem: "github-actions" # Necessary to update action hashs	
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
     # Allow up to 3 opened pull requests for github-actions versions
     open-pull-requests-limit: 3

.github/workflows/scorecard.yml

@@ -29,7 +29,7 @@ jobs:
 
     steps:
       - name: "Checkout code"
-        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           persist-credentials: false
 
@@ -60,6 +60,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@a09933a12a80f87b87005513f0abb1494c27a716 # v2.21.4
+        uses: github/codeql-action/upload-sarif@00e563ead9f72a8461b24876bee2d0c2e8bd2ee8 # v2.21.5
         with:
           sarif_file: results.sarif

include/fmt/format-inl.h

@@ -1445,8 +1445,7 @@ FMT_FUNC bool write_console(std::FILE* f, string_view text) {
 // Print assuming legacy (non-Unicode) encoding.
 FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
   auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt,
-                     basic_format_args<buffer_context<char>>(args));
+  detail::vformat_to(buffer, fmt, args);
   fwrite_fully(buffer.data(), 1, buffer.size(), f);
 }
 #endif

include/fmt/format.h

@@ -1394,7 +1394,7 @@ FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits,
     return out;
   }
   // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
-  char buffer[num_bits<UInt>() / BASE_BITS + 1];
+  char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
   format_uint<BASE_BITS>(buffer, value, num_digits, upper);
   return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
 }

support/manage.py

@@ -231,7 +231,7 @@ def release(args):
 
     # Convert changelog from RST to GitHub-flavored Markdown and get the
     # version.
-    changelog = 'ChangeLog.rst'
+    changelog = 'ChangeLog.md'
     changelog_path = os.path.join(fmt_repo.dir, changelog)
     import rst2md
     changes, version = rst2md.convert(changelog_path)

test/ranges-test.cc

@@ -79,7 +79,7 @@ TEST(ranges_test, format_set) {
 
 // Models std::flat_set close enough to test if no ambiguous lookup of a
 // formatter happens due to the flat_set type matching is_set and
-// is_container_adaptor_like
+// is_container_adaptor_like.
 template <typename T> class flat_set {
  public:
   using key_type = T;
@@ -91,11 +91,11 @@ template <typename T> class flat_set {
   template <typename... Ts>
   explicit flat_set(Ts&&... args) : c{std::forward<Ts>(args)...} {}
 
-  iterator begin() { return c.begin(); }
-  const_iterator begin() const { return c.begin(); }
+  auto begin() -> iterator { return c.begin(); }
+  auto end() -> iterator { return c.end(); }
 
-  iterator end() { return c.end(); }
-  const_iterator end() const { return c.end(); }
+  auto begin() const -> const_iterator { return c.begin(); }
+  auto end() const -> const_iterator { return c.end(); }
 
  private:
   std::vector<T> c;
@@ -112,7 +112,6 @@ struct box {
 };
 
 auto begin(const box& b) -> const int* { return &b.value; }
-
 auto end(const box& b) -> const int* { return &b.value + 1; }
 }  // namespace adl
 
@@ -169,11 +168,12 @@ struct tuple_like {
   int i;
   std::string str;
 
-  template <size_t N> fmt::enable_if_t<N == 0, int> get() const noexcept {
+  template <size_t N>
+  auto get() const noexcept -> fmt::enable_if_t<N == 0, int> {
     return i;
   }
   template <size_t N>
-  fmt::enable_if_t<N == 1, fmt::string_view> get() const noexcept {
+  auto get() const noexcept -> fmt::enable_if_t<N == 1, fmt::string_view> {
     return str;
   }
 };
@@ -206,8 +206,8 @@ TEST(ranges_test, format_to) {
 }
 
 template <typename Char> struct path_like {
-  const path_like* begin() const;
-  const path_like* end() const;
+  auto begin() const -> const path_like*;
+  auto end() const -> const path_like*;
 
   operator std::basic_string<Char>() const;
 };
@@ -237,8 +237,8 @@ template <typename T> class non_const_only_range {
   explicit non_const_only_range(Args&&... args)
       : vec(std::forward<Args>(args)...) {}
 
-  const_iterator begin() { return vec.begin(); }
-  const_iterator end() { return vec.end(); }
+  auto begin() -> const_iterator{ return vec.begin(); }
+  auto end() -> const_iterator { return vec.end(); }
 };
 
 template <typename T> class noncopyable_range {
@@ -255,16 +255,16 @@ template <typename T> class noncopyable_range {
   noncopyable_range(noncopyable_range const&) = delete;
   noncopyable_range(noncopyable_range&) = delete;
 
-  iterator begin() { return vec.begin(); }
-  iterator end() { return vec.end(); }
+  auto begin() -> iterator { return vec.begin(); }
+  auto end() -> iterator { return vec.end(); }
 };
 
 TEST(ranges_test, range) {
-  noncopyable_range<int> w(3u, 0);
+  auto&& w = noncopyable_range<int>(3u, 0);
   EXPECT_EQ(fmt::format("{}", w), "[0, 0, 0]");
   EXPECT_EQ(fmt::format("{}", noncopyable_range<int>(3u, 0)), "[0, 0, 0]");
 
-  non_const_only_range<int> x(3u, 0);
+  auto x = non_const_only_range<int>(3u, 0);
   EXPECT_EQ(fmt::format("{}", x), "[0, 0, 0]");
   EXPECT_EQ(fmt::format("{}", non_const_only_range<int>(3u, 0)), "[0, 0, 0]");
 
@@ -339,8 +339,8 @@ bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; }
 
 struct zstring {
   const char* p;
-  const char* begin() const { return p; }
-  zstring_sentinel end() const { return {}; }
+  auto begin() const -> const char* { return p; }
+  auto end() const -> zstring_sentinel { return {}; }
 };
 
 #  ifdef __cpp_lib_ranges
@@ -354,20 +354,22 @@ struct cpp20_only_range {
 
     iterator() = default;
     iterator(int i) : val(i) {}
-    int operator*() const { return val; }
-    iterator& operator++() {
+    auto operator*() const -> int { return val; }
+    auto operator++() -> iterator&{
       ++val;
       return *this;
     }
     void operator++(int) { ++*this; }
-    bool operator==(const iterator& rhs) const { return val == rhs.val; }
+    auto operator==(const iterator& rhs) const -> bool {
+      return val == rhs.val;
+    }
   };
 
   int lo;
   int hi;
 
-  iterator begin() const { return iterator(lo); }
-  iterator end() const { return iterator(hi); }
+  auto begin() const -> iterator { return iterator(lo); }
+  auto end() const -> iterator { return iterator(hi); }
 };
 
 static_assert(std::input_iterator<cpp20_only_range::iterator>);
@@ -381,12 +383,12 @@ TEST(ranges_test, join_sentinel) {
 }
 
 TEST(ranges_test, join_range) {
-  noncopyable_range<int> w(3u, 0);
+  auto&& w = noncopyable_range<int>(3u, 0);
   EXPECT_EQ(fmt::format("{}", fmt::join(w, ",")), "0,0,0");
   EXPECT_EQ(fmt::format("{}", fmt::join(noncopyable_range<int>(3u, 0), ",")),
             "0,0,0");
 
-  non_const_only_range<int> x(3u, 0);
+  auto x = non_const_only_range<int>(3u, 0);
   EXPECT_EQ(fmt::format("{}", fmt::join(x, ",")), "0,0,0");
   EXPECT_EQ(fmt::format("{}", fmt::join(non_const_only_range<int>(3u, 0), ",")),
             "0,0,0");
@@ -452,10 +454,10 @@ template <typename R> struct fmt_ref_view {
 };
 
 TEST(ranges_test, range_of_range_of_mixed_const) {
-  std::vector<std::vector<int>> v = {{1, 2, 3}, {4, 5}};
+  auto v = std::vector<std::vector<int>>{{1, 2, 3}, {4, 5}};
   EXPECT_EQ(fmt::format("{}", v), "[[1, 2, 3], [4, 5]]");
 
-  fmt_ref_view<decltype(v)> r{&v};
+  auto r = fmt_ref_view<decltype(v)>{&v};
   EXPECT_EQ(fmt::format("{}", r), "[[1, 2, 3], [4, 5]]");
 }