Unbreak build on windows.

Interestingly, (only) MSVC fails to compile a template function with an rvalue reference to an array, followed by a parameter with a default initializer of {} (e.g., void f(T (&&a)[N], T x = {})).

See https://godbolt.org/z/cv3dhhro7 for details and a minimal, reproducible example.

This patch uses a simple, equivalent alternative code that successfully compiles, found in the snippet above.

PiperOrigin-RevId: 731333419

Author: tomokinat

src/base/container/flat_internal.h

@@ -46,7 +46,7 @@ namespace mozc::internal {
 // Sorts the given span in place.
 // C++17 backport of constexpr `std::sort` from C++20.
 template <class T, class Compare = std::less<>>
-constexpr void Sort(absl::Span<T> span, const Compare &cmp = {}) {
+constexpr void Sort(absl::Span<T> span, const Compare &cmp = Compare()) {
   // Since we're dealing with compile-time constants, expected to be small,
   // we use insertion sort. It's faster for small inputs, and easier to
   // implement :)
@@ -114,7 +114,7 @@ inline void DuplicateEntryFound() { LOG(FATAL) << "Duplicate entry found"; }
 // according to `cmp`.
 template <class T, class Compare = std::less<>>
 constexpr void SortAndVerifyUnique(absl::Span<T> span,
-                                   const Compare &cmp = {}) {
+                                   const Compare &cmp = Compare()) {
   Sort(span, cmp);
   for (int i = 0; i + i < span.size(); ++i) {
     if (!cmp(span[i], span[i + 1]) && !cmp(span[i + 1], span[i])) {

src/base/container/flat_map.h

@@ -88,7 +88,7 @@ class FlatMap {
 // complex and explicitly declaring it would leak the number of entries, `N`.
 template <class K, class V, class CompareKey = std::less<>, size_t N>
 constexpr auto CreateFlatMap(Entry<K, V> (&&entries)[N],
-                             const CompareKey &cmp_key = {}) {
+                             const CompareKey &cmp_key = CompareKey()) {
   return FlatMap<K, V, CompareKey, N>(internal::ToArray(std::move(entries)),
                                       cmp_key);
 }

src/base/container/flat_multimap.h

@@ -97,7 +97,7 @@ class FlatMultimap {
 // complex and explicitly declaring it would leak the number of entries, `N`.
 template <class K, class V, class CompareKey = std::less<>, size_t N>
 constexpr auto CreateFlatMultimap(Entry<K, V> (&&entries)[N],
-                                  const CompareKey &cmp_key = {}) {
+                                  const CompareKey &cmp_key = CompareKey()) {
   return FlatMultimap<K, V, CompareKey, N>(
       internal::ToArray(std::move(entries)), cmp_key);
 }

src/base/container/flat_set.h

@@ -77,7 +77,8 @@ class FlatSet {
 // Declare the variable as auto and use `CreateFlatSet`. The actual type is
 // complex and explicitly declaring it would leak the number of elements, `N`.
 template <class T, class Compare = std::less<>, size_t N>
-constexpr auto CreateFlatSet(T (&&elements)[N], const Compare &cmp = {}) {
+constexpr auto CreateFlatSet(T (&&elements)[N],
+                             const Compare &cmp = Compare()) {
   return FlatSet<T, Compare, N>(internal::ToArray(std::move(elements)), cmp);
 }