[clang] "Member access into incomplete type" error is issued by clang but not gcc/MSVC

[aelovikov-intel]

I don't know if clang or gcc/MSVC is correct here, so submitting the issue against the compiler that rejects the code. Godbolt link: https://godbolt.org/z/cMbo3drWa.

Same copy-pasted here:

#include <type_traits>

template <typename key_t>
struct key_tag {};
template <typename property_ty, typename key_t = property_ty>
struct property_base : key_tag<key_t> {
    constexpr auto get_property_impl(key_tag<key_t>) {
        return *static_cast<property_ty *>(this);
    }
};

template <typename...  property_tys>
struct properties : property_tys... {
    properties(property_tys... props) : property_tys(props)... {}

    using property_tys::get_property_impl...;

    template <typename key>
    using prop_t = decltype(std::declval<properties>().get_property_impl(key_tag<key>{}));

    template <typename key>
    static constexpr auto get_property() 
    -> std::enable_if_t<std::is_empty_v<prop_t<key>>, prop_t<key>> {
        return prop_t<key>{};
    }
    template <typename key>
    constexpr auto get_property(int = 0 /* Only needed for MSVC, gcc/clang are fine witout this */) 
    -> std::enable_if_t<!std::is_empty_v<prop_t<key>>, prop_t<key>> {
        return get_property_impl(key_tag<key>{});
    }
};

struct foo : property_base<foo> {};
struct bar : property_base<bar> { int x; };

int main() {
    properties pl{foo{}, bar{}};
}

clang's error:

<source>:19:55: error: member access into incomplete type 'properties<foo, bar>'
   19 |     using prop_t = decltype(std::declval<properties>().get_property_impl(key_tag<key>{}));
      |                                                       ^
<source>:18:5: note: in instantiation of template type alias 'prop_t' requested here
   18 |     template <typename key>
      |     ^
<source>:37:16: note: in instantiation of template class 'properties<foo, bar>' requested here
   37 |     properties pl{foo{}, bar{}};
      |                ^
<source>:13:8: note: definition of 'properties<foo, bar>' is not complete until the closing '}'
   13 | struct properties : property_tys... {
      |        ^
1 error generated.
Compiler returned: 1

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (aelovikov-intel)

I don't know if clang or gcc/MSVC is correct here, so submitting the issue against the compiler that rejects the code. Godbolt link: https://godbolt.org/z/cMbo3drWa.

Same copy-pasted here:

#include <type_traits>

template <typename key_t>
struct key_tag {};
template <typename property_ty, typename key_t = property_ty>
struct property_base : key_tag<key_t> {
    constexpr auto get_property_impl(key_tag<key_t>) {
        return *static_cast<property_ty *>(this);
    }
};

template <typename...  property_tys>
struct properties : property_tys... {
    properties(property_tys... props) : property_tys(props)... {}

    using property_tys::get_property_impl...;

    template <typename key>
    using prop_t = decltype(std::declval<properties>().get_property_impl(key_tag<key>{}));

    template <typename key>
    static constexpr auto get_property() 
    -> std::enable_if_t<std::is_empty_v<prop_t<key>>, prop_t<key>> {
        return prop_t<key>{};
    }
    template <typename key>
    constexpr auto get_property(int = 0 /* Only needed for MSVC, gcc/clang are fine witout this */) 
    -> std::enable_if_t<!std::is_empty_v<prop_t<key>>, prop_t<key>> {
        return get_property_impl(key_tag<key>{});
    }
};

struct foo : property_base<foo> {};
struct bar : property_base<bar> { int x; };

int main() {
    properties pl{foo{}, bar{}};
}

clang's error:

<source>:19:55: error: member access into incomplete type 'properties<foo, bar>'
   19 |     using prop_t = decltype(std::declval<properties>().get_property_impl(key_tag<key>{}));
      |                                                       ^
<source>:18:5: note: in instantiation of template type alias 'prop_t' requested here
   18 |     template <typename key>
      |     ^
<source>:37:16: note: in instantiation of template class 'properties<foo, bar>' requested here
   37 |     properties pl{foo{}, bar{}};
      |                ^
<source>:13:8: note: definition of 'properties<foo, bar>' is not complete until the closing '}'
   13 | struct properties : property_tys... {
      |        ^
1 error generated.
Compiler returned: 1

[keinflue]

I think this should be CWG 1836. After the resolution the code is well-formed. The incomplete member access in

template <typename key>
using prop_t = decltype(std::declval<properties>().get_property_impl(key_tag<key>{}));

should be allowed because it appears in the definition of properties.

[keinflue]

Possible duplicate of #83424.

[aelovikov-intel]

Another example based on @keinflue 's now deleted comment: https://godbolt.org/z/cP9Mnf7sx

#include <utility>

struct A {
    int i;
    using T = decltype(std::declval<A>().i);

    template <typename Self /* = A*/>
    using T2 = decltype(std::declval<Self>().i);

    auto foo() -> decltype(std::declval<A>().i) {
        return {};
    }

    auto bar() -> T2<A> {
        return {};
    }
};

Is T2 not working the same bug or a different one?

[keinflue]

I deleted my comment, because it was wrong. I did not think of CWG 1836 when answering.

Your new example should IMO be the same issue as in the original. Templating the type alias doesn't change that std::declval<Self>() is the class type currently being defined where it matters, at the point where the alias template is substituted in auto bar() -> T2<A>.

[aelovikov-intel]

My question isn't about T vs T2 (both fail), but foo (compiles fine with current clang) vs bar (fails).

Update: https://godbolt.org/z/nbW7W11h6

#include <utility>

template <typename Self /* = A*/>
using T1 = decltype(std::declval<Self>().i);

struct A {
    int i;

    // fine
    auto foo() -> decltype(std::declval<A>().i) {
        return {};
    }

    // fine
    auto bar1() -> T1<A> {
        return {};
    }

    template <typename Self /* = A*/>
    using T2 = decltype(std::declval<Self>().i);

    // fails
    auto bar2() -> T2<A> {
        return {};
    }
};

[keinflue]

Except for bar1, I think all of these should be well-formed after the wording change by CWG 1836, although I guess it was only really intended to fix foo.

bar1 is a bit unclear to me because for it the member access expression is not lexically located in the definition of A. Therefore the exception for completeness might not apply. However, it would make more sense to me if the context of substitution of the alias template specialization was considered for that purpose instead, which would be inside the definition of A. There are open CWG issues of the same kind, e.g. CWG 1554 regarding the context of access control checks.

[tambry]

Also hit this. My small repro:

#include <utility>

struct foo
{
   void bar();

   using returntype = decltype(std::declval<foo>().bar());
};

[ckwastra]

Some test code following the discussion in this post (CE):

template <class T> T &&declval();
struct S {
  int i;

  // - GCC/EDG: OK
  // - Clang: error: member access into incomplete type 'S'
  // - MSVC: error C2027: use of undefined type 'S'
  decltype(declval<S>().i) f1();

  auto f2() -> decltype(declval<S>().i); // OK

  template <class>
    // - GCC/EDG/MSVC: OK
    // - Clang: error: member access into incomplete type 'S'
    requires requires(S s) { s.i; }
  void g1();

  template <class>
  void g2()
    requires requires(S s) { s.i; }; // OK
};