[libc++] Eliminate <compare>'s dependency on <array>

[• Quuxplusone]

Summary

This refactor is not only a good idea, but is in fact required by the standard, in the sense that <array> is mandated to include <compare>. So <compare> shouldn't have a circular dependency on <array>!

According to "graph_header_deps.py", this also removes <compare>'s dependencies on everything-except-type-traits, and drops its cumulative cost from ~40KLOC to ~8KLOC.

[• Quuxplusone]

libcxx/include/compare

725

Happy to remove the sizeof...(_Ts) here if anyone cares; this was just a very mechanical transformation.

[zoecarver]

This LGTM once the CI is fixed. Thanks!

libcxx/include/compare

703

Looks like the CI wants this to be const.

[• Quuxplusone]

A missing const, and also deal with zero-length arrays. Buildkite should be happier with this revision.

[curdeius]

LGTM!

[grandinj]

According to "graph_header_deps.py", this also removes <compare>'s dependencies on everything-except-type-traits, and drops its cumulative cost from ~40KLOC to ~8KLOC.

Perhaps the output of this should be generated by the build, and committed to git, so it becomes obvious in a given commit when it changes drastically?

[• Quuxplusone]

@grandinj wrote:

Perhaps the output of this should be generated by the build, and committed to git, so it becomes obvious in a given commit when it changes drastically?

Well, we do have a bunch of things that are generated by scripts and it'd be nice to make that happen automatically. However, the thing about this graph is that the cumulative line counts would change with every line added or removed, which means it would be changing all the time and making ugly extra git diffs. (Or we could check in only the graph-without-line-counts, but the graph-without-line-counts is significantly less interesting/useful/satisfying IMO.)
(And this is leaving aside the separate question of how we'd "check in the graph" anyway. git isn't great with binary files. We could check in the .dot file and let people render the graph into an image locally.)

I am planning to PR a family of tests for discrete propositions — such as "<compare> does not pull in std::array" or "<algorithm> does not pull in std::type_info" or "<memory> does not pull in std::ostream" — which I think will be better at the goal of making sure improvements like this are not regressed accidentally in the future.

libcxx/include/compare

public:
     friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
 }
 */
 
 #include <__config>
 #include <type_traits>
-#include <array>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
if (is_same_v<_Tp, weak_ordering>)
     return _WeakOrd;
   if (is_same_v<_Tp, strong_ordering>)
     return _StrongOrd;
   return _None;
 }
 
 template <size_t _Size>
 constexpr _ClassifyCompCategory
-__compute_comp_type(array<_ClassifyCompCategory, _Size> __types) {
-  array<int, _CCC_Size> __seen = {};
+__compute_comp_type(_ClassifyCompCategory (&__types)[_Size]) {
+  int __seen[_CCC_Size] = {};
   for (auto __type : __types)
     ++__seen[__type];
   if (__seen[_None])
     return _None;
   if (__seen[_WeakEq])
     return _WeakEq;
   if (__seen[_StrongEq] && (__seen[_PartialOrd] || __seen[_WeakOrd]))
     return _WeakEq;
   if (__seen[_StrongEq])
     return _StrongEq;
   if (__seen[_PartialOrd])
     return _PartialOrd;
   if (__seen[_WeakOrd])
     return _WeakOrd;
   return _StrongOrd;
 }
 
 template <class ..._Ts>
 constexpr auto __get_comp_type() {
   using _CCC = _ClassifyCompCategory;
-  constexpr array<_CCC, sizeof...(_Ts)> __type_kinds{{__comp_detail::__type_to_enum<_Ts>()...}};
+  constexpr _CCC __type_kinds[sizeof...(_Ts)] = { __comp_detail::__type_to_enum<_Ts>()... };
   constexpr _CCC _Cat = sizeof...(_Ts) == 0 ? _StrongOrd
       : __compute_comp_type(__type_kinds);
   if constexpr (_Cat == _None)
     return void();
   else if constexpr (_Cat == _WeakEq)
     return weak_equality::equivalent;
   else if constexpr (_Cat == _StrongEq)
     return strong_equality::equivalent;