Incomplete type `std::variant` used in nested name specifier

Question

I wrote the following code into a file named main.cpp. It involves the curiously recurring template pattern (CRTP) with the standard type std::variant.

#include 
#include 
#include 

template
struct either {
    std::vector arg;
};

template
struct maybe_either: std::variant>> {

    template
    maybe_either(U&& v):
      std::variant>>(std::forward(v)) {
    }
};

struct var {
  std::string name;
};

int main(int, char**) {
    auto expression = maybe_either(either>{});
    std::visit([&](auto&& v) {
        using T = std::decay_t;
        if constexpr (std::is_same_v) {
          // ...
        } else if constexpr (std::is_same_v>>) {
          // ...
        }
    }, expression);
    return 0;
}

When compiling it with the following command line, I get the error message below:

$ g++ -c -std=c++17 main.cpp
In file included from main.cpp:2:0:
/usr/include/c++/7/variant: In instantiation of ‘constexpr const size_t std::variant_size_v >’:
/usr/include/c++/7/variant:702:10:   required from ‘struct std::__detail::__variant::__gen_vtable&&, maybe_either&>’
/usr/include/c++/7/variant:1255:23:   required from ‘constexpr decltype(auto) std::visit(_Visitor&&, _Variants&& ...) [with _Visitor = main(int, char**)::; _Variants = {maybe_either&}]’
main.cpp:32:18:   required from here
/usr/include/c++/7/variant:97:29: error: incomplete type ‘std::variant_size >’ used in nested name specifier
     inline constexpr size_t variant_size_v = variant_size<_Variant>::value;
                             ^~~~~~~~~~~~~~
/usr/include/c++/7/variant: In instantiation of ‘constexpr const auto std::__detail::__variant::__gen_vtable&&, maybe_either&>::_S_vtable’:
/usr/include/c++/7/variant:711:29:   required from ‘struct std::__detail::__variant::__gen_vtable&&, maybe_either&>’
/usr/include/c++/7/variant:1255:23:   required from ‘constexpr decltype(auto) std::visit(_Visitor&&, _Variants&& ...) [with _Visitor = main(int, char**)::; _Variants = {maybe_either&}]’
main.cpp:32:18:   required from here
/usr/include/c++/7/variant:711:49: error: ‘_S_apply’ was not declared in this scope
       static constexpr auto _S_vtable = _S_apply();
                                         ~~~~~~~~^~

My class maybe_either derived from std::variant<...> can be used normally in other contexts, but when I call std::visit(...) on it, it fails to compile. What is wrong?

user_2069064 · Answer

This is basically LWG3052 which I'm trying to address in P2162.

maybe_either isn't a specialization of std::variant - it inherits from one. And std::visit is currently underspecified. It's not at all clear what kinds of "variants" are allowed to be visited.

libstdc++ implements the original suggested direction in that library issue, which is only specializations of std::variant (of which you are not). libc++, on the other hand, allows types that inherit from std::variant to be visited, so it accepts your example.

The intent is that the example as-is will become well-formed eventually. But until then, you'll have to ensure that the visit you do is directly on a std::variant. You can do so by adding your own member or non-member visit that does this cast for you, so the callers don't have to do it themselves.

For example, this:

template
struct maybe_either: std::variant>> {
    using base = typename maybe_either::variant;

    template
    maybe_either(U&& v):
      std::variant>>(std::forward(v)) {
    }

    template 
    decltype(auto) visit(F&& f) & {
        return std::visit(std::forward(f), static_cast(*this));
    }
};

allows this to work:

int main(int, char**) {
    auto expression = maybe_either(either>{});
    expression.visit([&](auto&& v) {
        using T = std::decay_t;
        if constexpr (std::is_same_v) {
          // ...
        } else if constexpr (std::is_same_v>>) {
          // ...
        }
    });
    return 0;
}

Incomplete type `std::variant<...>` used in nested name specifier

1 Answers