[modules][concepts] clang fails to correctly check constrained satisfaction when using modules

[FabioFracassi]

Consider the following (C++23) code:

auto str = std::string{"hello"};
auto s = std::basic_string_view{str};

this constructs a basic_string_view using CTAD and the C++23 range ctor. (In user code most people would probably use std::string_view{str}, but that is not the point here, I came across this when chasing the root cause for an issue in a formatter I wrote, and libc++ uses the above in its formatter implementation)

So far so good. This works as expected if I am using it in non module code. Now for the interesting part: if I try to import string/string_view/basic_string_view form a module

export module mystd;
export namespace std {
    using std::string;
    using std::string_view;
    using std::basic_string_view;
}

it stops working failing with error: constraints not satisfied.

I have been able to fix this by also explicitly exporting some -at least in my estimation- unrelated operator overloads (comparisons and +/-)

CE link with complete code: https://godbolt.org/z/qYchnbqKM. (Check with #define NO_WORKAROUND) to see the error.

leaving aside the issue that these are standard types and that the exported operators would be needed in a proper std module,
AFAIU it should not be necessary to explicitly export more than the types/names directly involved (i.e. string and basic_string_view)

tested on Clang/libc++ 16.0.x and trunk

[mordante]

Does this sound like a compiler bug @ChuanqiXu9 ?

[ChuanqiXu9]

This sounds a compiler bug to me. Let me take this.

BTW, it looks like the direct cause for the bug is that when the compiler runs at the line:

llvm-project/libcxx/include/__ranges/access.h

Line 49 in a940c23

{ _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;

the compiler will lookup operator== but the compiler found it is invisible so the compiler emits errors. And we can verify this by commenting out this line.
I feel it should be good enough here if the operator is reachable.

[llvmbot]

@llvm/issue-subscribers-clang-modules

[ChuanqiXu9]

Here is the reduced example:

//--- foo.h
class TypeA {};

template<class _Tp, class _Up>
concept __comparable = requires (_Tp &&__t, _Up &&__u) {
    __t == __u;
};

namespace ranges {
namespace __end {
  template <class _Tp>
  concept __member_end =
    requires(_Tp&& __t) {
        { __t.end() } -> __comparable<TypeA>;
    };

  struct __fn {
    template <class _Tp>
      requires __member_end<_Tp>
    constexpr auto operator()(_Tp&& __t) const
    {
      return true;
    }

    void operator()(auto&&) const = delete;
  };
}

inline namespace __cpo {
  inline constexpr auto end = __end::__fn{};
}
}

template <class _Tp>
concept range = requires(_Tp& __t) {
    ranges::end(__t);
};

template <class T>
class a {
public:
    a(T*) {}
    TypeA end() { return {}; }
};

template <class T>
class a_view {
public:
    template <class U>
    a_view(a<U>) {}
};
template <range _Range>
a_view(_Range) -> a_view<int>;

constexpr bool operator==(TypeA, TypeA) {
    return true;
}

//--- a.cppm
module;
#include "foo.h"
export module a;
export using ::a;
export using ::a_view;
export using ::operator==;

//--- b.cpp
// expected-no-diagnostics
import a;
void use() {
    auto _ = a{"char"};
    auto __ = a_view{_};
}

[mordante]

Thanks for the confirmation and quick fix @ChuanqiXu9 .