Bump clang-format from 19.1.7 to 20.1.7

[eramongodb]

Bumps the clang-format version from 19.1.7 to 20.1.7 as followup to mongodb/mongo-c-driver#2046 to improve tooling consistency across both repos.

---

The configuration file has been updated for Clang 20.1. Notable changes include:

• AlignConsecutiveDeclarations.AlignFunctionDeclarations is set to false for consistency with other AlignConsecutiveDeclarations options (defaults to true).
• ReflowComments is set to Always (equivalent to former value of true).

All other options are left unchanged from their prior (existing) or default (new) values.

Aside: it'd be nice if ClangFormat supported a ReflowStrings option...

---

Changes due to this version bump seem to primarily fall into two categories:

• Attribute and typename macros are no longer wrapped even when they exceed the column limit, which I personally consider to be an improvement, although opinions may differ. e.g.:

// Before                                                                                                              v
    template <typename F, typename... Args, typename Fd = remove_cvref_t<F>>
    constexpr auto operator()(F&& fn, Args&&... args) const
        BSONCXX_PRIVATE_RETURNS(impl_invoke::invoker<
                                std::is_member_object_pointer<Fd>::value,
                                std::is_member_function_pointer<
                                    Fd>::value>::apply(static_cast<F&&>(fn), static_cast<Args&&>(args)...));
//                                                                                                                     ^

// After                                                                                                               v
    template <typename F, typename... Args, typename Fd = remove_cvref_t<F>>
    constexpr auto operator()(F&& fn, Args&&... args) const
        BSONCXX_PRIVATE_RETURNS(impl_invoke::invoker<std::is_member_object_pointer<Fd>::value, std::is_member_function_pointer<Fd>::value>::apply(static_cast<F&&>(fn), static_cast<Args&&>(args)...));
//                                                                                                                     ^

// Before                                                                                                              v
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v_noabi::stdx::optional<
                              bsoncxx::v_noabi::types::bson_value::view_or_value> const&)
    comment() const;
//                                                                                                                     ^

// After                                                                                                               v
    MONGOCXX_ABI_EXPORT_CDECL(bsoncxx::v_noabi::stdx::optional<bsoncxx::v_noabi::types::bson_value::view_or_value> const&)
    comment() const;
//                                                                                                                     ^

• Breaking after opening parenthesis of (nested) function calls seems to have been fixed/improved...? The behavior seems to be more consistent than before, although it overall produces deeper indentation levels. e.g.:

// Before
result.append(builder::basic::kvp(
    "result", [matched_count, modified_count, upserted_count, upserted_id](builder::basic::sub_document subdoc) {
        subdoc.append(builder::basic::kvp("matchedCount", matched_count));

        if (modified_count) {
            subdoc.append(builder::basic::kvp("modifiedCount", *modified_count));
        }

        subdoc.append(builder::basic::kvp("upsertedCount", upserted_count));

        if (upserted_id) {
            subdoc.append(builder::basic::kvp("upsertedId", *upserted_id));
        }
    }));

// After
result.append(
    builder::basic::kvp(
        "result",
        [matched_count, modified_count, upserted_count, upserted_id](builder::basic::sub_document subdoc) {
            subdoc.append(builder::basic::kvp("matchedCount", matched_count));

            if (modified_count) {
                subdoc.append(builder::basic::kvp("modifiedCount", *modified_count));
            }

            subdoc.append(builder::basic::kvp("upsertedCount", upserted_count));

            if (upserted_id) {
                subdoc.append(builder::basic::kvp("upsertedId", *upserted_id));
            }
        }));

Although the diff is more than I expected from a ClangFormat 19 -> ClangFormat 20 bump, I am fine with accepting both of these changes as-is without further refinement of the updated configuration file.

[vector-of-bool]

LGTM.

I'm curious what changes might occur if you add our attribute-ish macros to the .clang-format file. It might reflow them better?

[eramongodb]

@vector-of-bool Unless I misunderstood your question, they are already present following #1299 and #1318, e.g. BSONCXX_PRIVATE_RETURNS is currently specified as an AttributeMacros. fwiw specifying BSONCXX_PRIVATE_RETURNS as a StatementMacros instead results in the following (update: fixed the comparison actually fixed the comparison, sorry third time's the charm...):

// As an "attribute macro" (current).
template <typename F, typename... Args, typename Fd = remove_cvref_t<F>>
constexpr auto operator()(F&& fn, Args&&... args) const
    BSONCXX_PRIVATE_RETURNS(impl_invoke::invoker<std::is_member_object_pointer<Fd>::value, std::is_member_function_pointer<Fd>::value>::apply(static_cast<F&&>(fn), static_cast<Args&&>(args)...));

// As a "statement macro".
template <typename F, typename... Args, typename Fd = remove_cvref_t<F>>
constexpr auto operator()(F&& fn, Args&&... args) const BSONCXX_PRIVATE_RETURNS(
    impl_invoke::invoker<
        std::is_member_object_pointer<Fd>::value,
        std::is_member_function_pointer<Fd>::value>::apply(static_cast<F&&>(fn), static_cast<Args&&>(args)...));

Moving it under TypenameMacros appears to make no difference compared to AttributeMacros. I don't think either is particularly better; I believe they are already appropriately specified in the ClangFormat file.