libc++: reverse_iterator operator== won't compile.

[huihzhang]

Failure triggered by https://reviews.llvm.org/D149543

Reduced test case

#include <vector>

std::vector<bool> vec(3, true);

#define RI  std::reverse_iterator<std::vector<bool>::iterator>
class D : public RI {
public:
        RI::iterator_type getCurrent() { return current; }
        D(bool a=true) {
                if (a)
                    current = vec.begin();
                else
                    current = vec.end();
        }
};

int test() {
    D x(true);
    D y(false);
    return std::operator==<std::vector<bool>::iterator>(x, y);
}

Compiler explorer: https://godbolt.org/z/ahM1PnTYr

[huihzhang]

Failing with:

In file included from /opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__iterator/concepts.h:34:
/opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__memory/pointer_traits.h:118:22: error: implicit instantiation of undefined template 'std::__pointer_traits_element_type<std::__bit_iterator<std::vector, false>>'
118 | typedef typename __pointer_traits_element_type::type element_type;
| ^

In file included from /opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__iterator/concepts.h:34:
/opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__memory/pointer_traits.h:92:52: error: no member named 'rebind' in 'std::__bit_iterator<std::vector, false>'
92 | typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type;
| ~~~~~ ^

In file included from :1:
In file included from /opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/vector:321:
In file included from /opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__format/formatter_bool.h:20:
In file included from /opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__format/formatter_integral.h:21:
In file included from /opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__format/formatter_output.h:22:
In file included from /opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/__format/parser_std_format_spec.h:39:
/opt/compiler-explorer/clang-trunk-20230824/bin/../include/c++/v1/string:725:21: error: static assertion failed due to requirement 'is_same<bool, char>::value': Allocator::value_type must be same type as value_type
725 | static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

:20:57: note: in instantiation of template class 'std::basic_string, std::__bit_iterator, false>>' requested here 20 | return std::operator==::iterator>(x, y); | ^ :20:12: note: while substituting deduced template arguments into function template 'operator==' [with _Allocator = std::vector::iterator] 20 | return std::operator==::iterator>(x, y); | ^

[huihzhang]

same failure with -std=c++23

[philnik777]

Works fine if you don't explicitly specify the template arguments: https://godbolt.org/z/r6Eqz1e8s. I'm pretty sure you aren't allowed to do that in general.

[huihzhang]

Thanks @philnik777 !

I have a few more questions. I see that gcc trunk is able to compile test with "std::operator==<std::vector::iterator>(x, y)"
see https://godbolt.org/z/ehnY4WsKc

when running -E to check the preprocessed file, both version are defined:

# 530 "/opt/compiler-explorer/gcc-trunk-20230824/include/c++/14.0.0/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator==(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
    { return __x.base() == __y.base(); }

and

template<typename _Iterator>
    [[nodiscard]]
    constexpr bool
    operator==(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
    { return __x.base() == __y.base(); }

While for llvm libc++ only "template<typename _IteratorL, typename _IteratorR>" version is defined

My questions are:
1, Is llvm libc++ missing the implementation for "template<typename _Iterator>"
c++ standard contains the following description:

24.4.1.3.12  operator==                        [lib.reverse.iter.op==]

  template <class Iterator>
    bool operator==(
      const reverse_iterator<Iterator>& x,
      const reverse_iterator<Iterator>& y);

  Returns:
    x.current == y.current

refer to https://www.open-std.org/jtc1/sc22/open/n2356/lib-iterators.html

2, Does "std::operator==<std::vector::iterator>(x, y)" violate the latest c++ standard somehow?

Thanks! Correct me if there are anything I misunderstood.

[huihzhang]

Just another note, when removing #include <__format/formatter_bool.h> from include/vector, call of std::operator==<std::vector<int>::iterator>(x, y) is able to match with

template <class _Iter1, class _Iter2>
inline __attribute__((__visibility__("hidden"))) __attribute__((__exclude_from_explicit_instantiation__)) __attribute__((__abi_tag__("v170000"))) constexpr
bool
operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{
    return __x.base() == __y.base();
}

This looks more like a compiler bug other than source code error. Or I am missing something?

[frederick-vs-ja]

Is llvm libc++ missing the implementation for "template"

The "old" homogeneous overloads were replaced with heterogeneous overloads by LWG280, so I think libc++ is fine now.

It seems that libstdc++ has speculatively implemented LWG2858, while the issue hasn't been accepted now.

Does "std::operator==std::vector::iterator(x, y)" violate the latest c++ standard somehow?

This seems unspecified/underspecified to me. std::operator==<T>(x, y) can drag in an unspecified set of overloads, where no template argument is left to be deduced, and then causes unspecified instantiation which is needed for detection of convertibility.

This looks more like a compiler bug other than source code error. Or I am missing something?

I don't think this is a compiler bug. (It might be not even a bug.)

Currently, libc++'s <__format/formatter_bool.h> includes <__format/parser_std_format_spec.h>, which in turn includes <string>:

llvm-project/libcxx/include/__format/formatter_bool.h

Line 21 in 9d9c25f

#include <__format/parser_std_format_spec.h>

llvm-project/libcxx/include/__format/parser_std_format_spec.h

Line 39 in 9d9c25f

#include <string>

Then the overload which is problematic for std::operator==<std::vector::iterator>(x, y) is dragged in.

[huihzhang]

Thanks @frederick-vs-ja for the explanation!
Closing it as won't fix.