C++20 Concepts: Difference in the behavior of the compound requirement expression with a pointer-type member in GCC and Clang

user_14227535 0
Viewed 406

Consider the following code (Godbolt):

#include <iostream>
//#include <concepts>
#include <type_traits>

// Since the latest clang doesn't have <concepts>,
// took this here: https://en.cppreference.com/w/cpp/concepts/same_as
// Using of std::same_as still gives an error in GCC.
namespace detail {
    template< class T, class U >
    concept SameHelper = std::is_same_v<T, U>;
}

template< class T, class U >
concept same_as = detail::SameHelper<T, U> && detail::SameHelper<U, T>;

template<typename T>
concept HasStr = requires(T a) { { a.str } -> same_as<const char*>; };

struct A {
    const char* str = "A";
};

const char* f(HasStr auto has_str) {
    return has_str.str;
}

int main() {
    A a;
    std::cout << f(a) << "\n";
    return 0;
}

Clang 10.0.1 successfully compiles this program. But GCC 10.2 fails:

<source>: In function 'int main()':
<source>:28:21: error: use of function 'const char* f(auto:11) [with auto:11 = A]' with unsatisfied constraints
   28 |     std::cout << f(a) << "\n";
      |                     ^
<source>:22:13: note: declared here
   22 | const char* f(HasStr auto has_str) {
      |             ^
<source>:22:13: note: constraints not satisfied
<source>: In instantiation of 'const char* f(auto:11) [with auto:11 = A]':
<source>:28:21:   required from here
<source>:16:9:   required for the satisfaction of 'HasStr<auto:11>' [with auto:11 = A]
<source>:16:18:   in requirements with 'T a' [with T = A]
<source>:16:38: note: 'a.str' does not satisfy return-type-requirement, because
   16 | concept HasStr = requires(T a) { { a.str } -> same_as<const char*>; };
      |                                    ~~^~~
<source>:16:36: error: deduced expression type does not satisfy placeholder constraints
   16 | concept HasStr = requires(T a) { { a.str } -> same_as<const char*>; };
      |                                  ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:16:36: note: constraints not satisfied
<source>:9:13:   required for the satisfaction of 'SameHelper<T, U>' [with T = const char*&; U = const char*]
<source>:13:9:   required for the satisfaction of 'same_as<const char*&, const char*>'
<source>:9:31: note: the expression 'is_same_v<T, U> [with T = const char*&; U = const char*]' evaluated to 'false'
    9 |     concept SameHelper = std::is_same_v<T, U>;
      |                          ~~~~~^~~~~~~~~~~~~~~
Compiler returned: 1

The most interesting part is:

<source>:9:31: note: the expression 'is_same_v<T, U> [with T = const char*&; U = const char*]' evaluated to 'false'

As I understand it, in the compound requirement { a.str } expression has type const char*& instead of const char*. So, why is this happening? Which compiler is correct?

c++-concepts c++20 c++
1 Answers

By my reading of [expr.prim.req.compound]/1, GCC is correct to emit an error:

The immediately-declared constraint ([temp.param]) of the type-constraint for decltype((E)) shall be satisfied.

With an accompanying example:

requires {
  { E1 } -> C;
  { E2 } -> D<A₁, ⋯, An>;
};

is equivalent to

requires {
  E1; requires C<decltype((E1))>;
  E2; requires D<decltype((E2)), A₁, ⋯, An>;
};

decltype((a.str)) is indeed const char*&, so I would expect that this is what's passed to same_as.

user_9620890
Related