[libc++] Remove `operator!=` from `type_info` in C++20

[avogelsgesang]

Summary

Implements part of:

• P1614R2 The Mothership has Landed

[avogelsgesang]

Note that there are many more classes for which P1614R2 ("The mothership has landed") just removed the operator!= (typeinfo, allocator, memory_resource, polymorphic_allocator, bitset, scoped_allocator_adaptor,function, unordered_map, unordered_set, move_sentinel, common_iterator, unreachable_sentinel_t, ...).

If you prefer, I could go over all of them in a single commit. Afaict, no test cases need changing, as the operator!= will be synthesized by the compiler and all test cases should still pass unchanged.

[Mordante]

Thanks for working on this!

In D130853#3696297, @avogelsgesang wrote:

Note that there are many more classes for which P1614R2 ("The mothership has landed") just removed the operator!= (typeinfo, allocator, memory_resource, polymorphic_allocator, bitset, scoped_allocator_adaptor,function, unordered_map, unordered_set, move_sentinel, common_iterator, unreachable_sentinel_t, ...).

If you prefer, I could go over all of them in a single commit. Afaict, no test cases need changing, as the operator!= will be synthesized by the compiler and all test cases should still pass unchanged.

I think it makes sense to do typeinfo separately since that feels a more "sensetive" class.
We haven't fully implemented to polymorphic_allocator allocators yet so they are in the experimental directory. I prefer to do them separately too.

Feel free to do the others in one go. Can you also remove them from chrono? I haven't started on them yet.

libcxx/include/typeinfo

25

Can you also update the Status page? Just add it to the page and mark it directly as complete.

343

This one should be updated too.

[philnik]

In D130853#3696836, @Mordante wrote:

Thanks for working on this!

In D130853#3696297, @avogelsgesang wrote:

Note that there are many more classes for which P1614R2 ("The mothership has landed") just removed the operator!= (typeinfo, allocator, memory_resource, polymorphic_allocator, bitset, scoped_allocator_adaptor,function, unordered_map, unordered_set, move_sentinel, common_iterator, unreachable_sentinel_t, ...).

If you prefer, I could go over all of them in a single commit. Afaict, no test cases need changing, as the operator!= will be synthesized by the compiler and all test cases should still pass unchanged.

I think it makes sense to do typeinfo separately since that feels a more "sensetive" class.
We haven't fully implemented to polymorphic_allocator allocators yet so they are in the experimental directory. I prefer to do them separately too.

Feel free to do the others in one go. Can you also remove them from chrono? I haven't started on them yet.

I'd actually argue that memory_resource and polymorphic_allocator shouldn't be touched, since they are from LFTSv2 and there the operator!= exists.

[Mordante]

In D130853#3696859, @philnik wrote:

I'd actually argue that memory_resource and polymorphic_allocator shouldn't be touched, since they are from LFTSv2 and there the operator!= exists.

I'm fine with that too, maybe then a separate commit to only add these changes to the status page, when they aren't there yet. That way we don't accidentally forget about them when porting this code to the main library.

[avogelsgesang]

add to status page & remove both operator!= implementations

[avogelsgesang]

I'm fine with that too, maybe then a separate commit to only add these changes to the status page, when they aren't there yet. That way we don't accidentally forget about them when porting this code to the main library.

sounds good. I will do so, probably next week

libcxx/include/typeinfo

343

Thanks for catching this! Somehow I assumed there would be only one typeinfo implementation and stopped my search too early...

Is having multiple implementations of the same class a common pattern in libcxx? I know there is a similar pattern for exception_ptr. Anything else which is similar (so I am aware of it while updating other classes)?

[Mordante]

LGTM modulo one small nit.

libcxx/docs/Status/SpaceshipProjects.csv

15

libcxx/include/typeinfo

343

It's very uncommon. Some classes are very closely tied to the platform they execute on. Most of the platform dependent headers are in the __support directory. You just managed to start with a special case for operator!= ;-)

[avogelsgesang]

Fix link

libcxx/docs/Status/SpaceshipProjects.csv

 Section,Description,Dependencies,Assignee,Complete
 | `[cmp.concept] <https://wg21.link/cmp.concept>`_,"| `three_way_comparable <https://reviews.llvm.org/D103478>`_
 | `three_way_comparable_with <https://reviews.llvm.org/D103478>`_",None,Ruslan Arutyunyan,|Complete|
 | `[cmp.result] <https://wg21.link/cmp.result>`_,| `compare_three_way_result <https://reviews.llvm.org/D103581>`_,None,Arthur O'Dwyer,|Complete|
 | `[expos.only.func] <https://wg21.link/expos.only.func>`_,"| `synth-three-way <https://reviews.llvm.org/D107721>`_
 | `synth-three-way-result <https://reviews.llvm.org/D107721>`_",[cmp.concept],Kent Ross,|Complete|
 | `[comparisons.three.way] <https://wg21.link/comparisons.three.way>`_,| `compare_three_way <https://reviews.llvm.org/D80899>`_,[cmp.concept],Arthur O'Dwyer,|Complete|
 | `[cmp.alg] <https://wg21.link/cmp.alg>`_,"| `strong_order <https://reviews.llvm.org/D110738>`_
 | `weak_order <https://reviews.llvm.org/D110738>`_
 | `partial_order <https://reviews.llvm.org/D110738>`_
 | `strong_order_fallback <https://reviews.llvm.org/D111514>`_
 | `weak_order_fallback <https://reviews.llvm.org/D111514>`_
 | `partial_order_fallback <https://reviews.llvm.org/D111514>`_",None,Arthur O'Dwyer,|Complete| [#note-strongorder]_
 | `[alg.three.way] <https://wg21.link/alg.three.way>`_,| `lexicographical_compare_three_way <https://reviews.llvm.org/D80902>`_,[comparisons.three.way],Christopher Di Bella,|In Progress|
+| `[type.info] <https://wg21.link/type.info>`_,| `typeinfo <https://reviews.llvm.org/D130853>`_,None,Adrian Vogelsgesang,|Complete|
 | `[coroutine.handle.compare] <https://wg21.link/coroutine.handle.compare>`_,| `coroutine_handle <https://reviews.llvm.org/D109433>`_,[comparisons.three.way],Chuanqi Xu,|Complete|
 | `[pairs.spec] <https://wg21.link/pairs.spec>`_,| `pair <https://reviews.llvm.org/D107721>`_,[expos.only.func],Kent Ross,|Complete|
 | `[syserr.errcat.nonvirtuals] <https://wg21.link/syserr.errcat.nonvirtuals>`_,| error_category,[comparisons.three.way],Unassigned,|Not Started|
 | `[syserr.compare] <https://wg21.link/syserr.compare>`_,"| error_code
 | error_condition",None,Unassigned,|Not Started|
 | `[tuple.rel] <https://wg21.link/tuple.rel>`_,| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,|Complete|
 "| `[optional.relops] <https://wg21.link/optional.relops>`_
 | `[optional.nullops] <https://wg21.link/optional.nullops>`_

libcxx/include/typeinfo

 namespace std {
 
 class type_info
 {
 public:
     virtual ~type_info();
 
     bool operator==(const type_info& rhs) const noexcept;
-    bool operator!=(const type_info& rhs) const noexcept;
+    bool operator!=(const type_info& rhs) const noexcept; // removed in C++20
 
     bool before(const type_info& rhs) const noexcept;
     size_t hash_code() const noexcept;
     const char* name() const noexcept;
 
     type_info(const type_info& rhs) = delete;
     type_info& operator=(const type_info& rhs) = delete;
 };
public:
 
     size_t hash_code() const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(const type_info& __arg) const _NOEXCEPT {
       return __compare(__arg) == 0;
     }
 
+#if _LIBCPP_STD_VER <= 17
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const type_info& __arg) const _NOEXCEPT
     { return !operator==(__arg); }
+#endif
 };
 
 #else // !defined(_LIBCPP_ABI_MICROSOFT)
 
 // ========================================================================== //
 //                           Implementations
 // ========================================================================== //
 // ------------------------------------------------------------------------- //
public:
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(const type_info& __arg) const _NOEXCEPT
     {
       return __impl::__eq(__type_name, __arg.__type_name);
     }
 
+#if _LIBCPP_STD_VER <= 17
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const type_info& __arg) const _NOEXCEPT
     { return !operator==(__arg); }
+#endif
 };
 #endif // defined(_LIBCPP_ABI_MICROSOFT)
 
 class _LIBCPP_EXCEPTION_ABI bad_cast
     : public exception
 {
  public:
   bad_cast() _NOEXCEPT;