[CTAD] Generated implicit deduction guides fails for inner / nested class when ctor has ref to outer class

[666kod666]

The generated implicit deduction guide is invalid for nested (inner) class template where:

• C++20+ standard is used.
• outer class is also class template.
• constructor matching invocation contains reference to outer class as parameter (in short form).

Sample:

// clang/gcc: -std=c++20 -Wall -O2 -pedantic
// msvc:      -std:c++20 -W4 -O2

#include <functional>

template <typename T>
struct A
{
    template <typename U>
    struct B
    {
        B(A& a, U& b)
            : m_a(std::ref(a)), m_b(std::ref(b))
        {}

        std::reference_wrapper<A> m_a;
        std::reference_wrapper<U> m_b;
    };

    // Generated implicit deduction is invalid and in more
    // complicated scenarios causes compiler to crash.
    // The implicit guide is correctly generated on
    // msvc and gcc.
    //
    // If you uncomment this explicit guide it will work:
    // template <typename U> B(A&, U&) -> B<U>;

    void fun()
    {
        int a = 1;

        B b1{*this, a};
    }
};

int main()
{
    A<long> a;
    a.fun();
}

For more sophisticated deduction the invalid CTAD / generated deduction guide can cause compiler crash (SIGSEGV on Linux, Access Violation on Windows (clang-cl)).

[llvmorg-github-actions]

@llvm/issue-subscribers-c-20

Author: Marcin Walkowiak (666kod666)

Details

The generated implicit deduction guide is invalid for nested (inner) class template where: * C++20+ standard is used. * outer class is also class template. * constructor matching invocation contains reference to outer class as parameter (in short form).

Sample:

// clang/gcc: -std=c++20 -Wall -O2 -pedantic
// msvc:      -std:c++20 -W4 -O2

#include <functional>

template <typename T>
struct A
{
    template <typename U>
    struct B
    {
        B(A& a, U& b)
            : m_a(std::ref(a)), m_b(std::ref(b))
        {}

        std::reference_wrapper<A> m_a;
        std::reference_wrapper<U> m_b;
    };

    // Generated implicit deduction is invalid and in more
    // complicated scenarios causes compiler to crash.
    // The implicit guide is correctly generated on
    // msvc and gcc.
    //
    // If you uncomment this explicit guide it will work:
    // template <typename U> B(A&, U&) -> B<U>;

    void fun()
    {
        int a = 1;

        B b1{*this, a};
    }
};

int main()
{
    A<long> a;
    a.fun();
}

For more sophisticated deduction the invalid CTAD / generated deduction guide can cause compiler crash (SIGSEGV on Linux, Access Violation on Windows (clang-cl)).

[llvmorg-github-actions]

@llvm/issue-subscribers-clang-frontend

Author: Marcin Walkowiak (666kod666)

Details

The generated implicit deduction guide is invalid for nested (inner) class template where: * C++20+ standard is used. * outer class is also class template. * constructor matching invocation contains reference to outer class as parameter (in short form).

Sample:

// clang/gcc: -std=c++20 -Wall -O2 -pedantic
// msvc:      -std:c++20 -W4 -O2

#include <functional>

template <typename T>
struct A
{
    template <typename U>
    struct B
    {
        B(A& a, U& b)
            : m_a(std::ref(a)), m_b(std::ref(b))
        {}

        std::reference_wrapper<A> m_a;
        std::reference_wrapper<U> m_b;
    };

    // Generated implicit deduction is invalid and in more
    // complicated scenarios causes compiler to crash.
    // The implicit guide is correctly generated on
    // msvc and gcc.
    //
    // If you uncomment this explicit guide it will work:
    // template <typename U> B(A&, U&) -> B<U>;

    void fun()
    {
        int a = 1;

        B b1{*this, a};
    }
};

int main()
{
    A<long> a;
    a.fun();
}

For more sophisticated deduction the invalid CTAD / generated deduction guide can cause compiler crash (SIGSEGV on Linux, Access Violation on Windows (clang-cl)).

[666kod666]

The sample that causes compiler to crash (requires boost headers + C++20):

#include <boost/container/deque.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/breadth_first_search.hpp>
#include <boost/graph/copy.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/graph_utility.hpp>
#include <boost/iterator/iterator_categories.hpp>

#include <concepts>
#include <functional>
#include <type_traits>
#include <variant>
#include <vector>

template <typename GraphTy, typename NodeIdTy = std::size_t>
concept bgl_graph =
    requires(GraphTy g)
    {
        typename GraphTy::vertex_descriptor;
        requires std::integral<typename GraphTy::vertex_descriptor> &&
                 std::convertible_to<NodeIdTy, typename GraphTy::vertex_descriptor> &&
                 std::convertible_to<typename GraphTy::vertex_descriptor, NodeIdTy>;

        typename boost::graph_traits<GraphTy>::directed_category;
        requires std::is_base_of_v<boost::bidirectional_tag, typename boost::graph_traits<GraphTy>::directed_category>;

        typename boost::graph_traits<GraphTy>::out_edge_iterator;
        requires std::random_access_iterator<typename boost::graph_traits<GraphTy>::out_edge_iterator> ||
                 std::is_convertible_v<boost::iterators::iterator_traversal_t<typename boost::graph_traits<GraphTy>::out_edge_iterator>,
                                                                              boost::random_access_traversal_tag>;

        typename boost::graph_traits<GraphTy>::edge_parallel_category;
        requires std::is_base_of_v<boost::allow_parallel_edge_tag,
                                   typename boost::graph_traits<GraphTy>::edge_parallel_category>;
    };

template <typename GraphTy, typename NodeIdTy = std::size_t>
concept bgl_mutable_graph =
    bgl_graph<GraphTy, NodeIdTy> &&
    requires (GraphTy& g, const typename GraphTy::vertex_descriptor& n)
    {
        { boost::add_vertex(g) } -> std::convertible_to<typename GraphTy::vertex_descriptor>;
        boost::clear_vertex(n, g);
        boost::remove_vertex(n, g);

        { boost::add_edge(n, n, g) }
            -> std::convertible_to<std::pair<typename boost::graph_traits<GraphTy>::edge_descriptor, bool>>;
    };

template <typename MGraphTy,
          typename IGraphTy = MGraphTy,
          std::integral NodeIdTy = std::size_t>
class sample_graph
{
    constexpr static bool can_freeze_ = !std::same_as<std::remove_cvref_t<IGraphTy>, std::remove_cvref_t<MGraphTy>>;

    using my_graph = std::conditional_t<can_freeze_, std::variant<MGraphTy, IGraphTy>, MGraphTy>;


    template <typename FunTy>
        requires std::invocable<FunTy, const MGraphTy&> &&
                 (!can_freeze_ || std::invocable<FunTy, const IGraphTy&>)
    constexpr auto with_ro_graph(FunTy&& fun) const
    noexcept(std::is_nothrow_invocable_v<FunTy, const MGraphTy&> &&
             (!can_freeze_ || std::is_nothrow_invocable_v<FunTy, const IGraphTy&>))
        -> std::conditional_t<can_freeze_,
                              std::common_type_t<std::invoke_result_t<FunTy, const MGraphTy&>,
                                                 std::invoke_result_t<FunTy, const IGraphTy&>>,
                              std::invoke_result_t<FunTy, const MGraphTy&>>
    {
        if constexpr (can_freeze_)
        {
            if (std::holds_alternative<IGraphTy>(m_graph))
                return std::invoke(std::forward<FunTy>(fun), std::get<IGraphTy>(m_graph));
            return std::invoke(std::forward<FunTy>(fun), std::get<MGraphTy>(m_graph));
        }
        else
            return std::invoke(std::forward<FunTy>(fun), m_graph);
    }


    template <typename ColorMapTy>
    struct marker_
        : boost::default_bfs_visitor
    {
        constexpr marker_(sample_graph& owner, ColorMapTy& colors)
            : m_owner(std::ref(owner)),  m_colors(std::ref(colors))
        {}


        template <typename ArrowTy, typename GraphTy>
        void examine_edge(const ArrowTy& a, const GraphTy& g)
        {
            auto t = boost::target(a, g);
            auto&& c = boost::get(m_colors.get(), t);
            if (c != boost::white_color || t >= m_owner.get().m_states.size())
                return;

            if (m_owner.get().m_states[t] >= 4)
            {
                c = boost::black_color;
                return;
            }

            ++m_owner.get().m_states[t];
        }

    private:
        std::reference_wrapper<sample_graph> m_owner;
        std::reference_wrapper<ColorMapTy> m_colors;
    };

    template <typename GraphTy>
    static void mark_nodes(sample_graph& o, GraphTy& g, const std::vector<NodeIdTy>& is)
    {
        auto rg = boost::make_reverse_graph<GraphTy>(g);

        auto cs = boost::make_vector_property_map<boost::default_color_type>(boost::get(boost::vertex_index, rg));
        auto q = boost::queue<NodeIdTy>();

        boost::breadth_first_visit(rg, is.cbegin(), is.cend(), q,
            marker_{o, cs}, cs);

        // CTAD - implicit deduction causes compiler to crash (adding type argument or explicit guide WA the issue):
        //boost::breadth_first_visit(rg, is.cbegin(), is.cend(), q,
        //    marker_<decltype(cs)>{o, cs}, cs);
    }

public:
    template <typename CMGraphTy = MGraphTy, typename CIGraphTy = IGraphTy, typename CNodeIdTy = NodeIdTy>
    constexpr sample_graph()
    {
        static_assert(std::integral<CNodeIdTy>);
        static_assert(bgl_mutable_graph<CMGraphTy, CNodeIdTy>);
        static_assert(bgl_graph<CIGraphTy, CNodeIdTy>);
    }

    void sample1(const std::vector<NodeIdTy>& is)
    {
        with_ro_graph([&, this](const auto& g)
        {
            mark_nodes(*this, g, is);
        });
    }

private:
    my_graph m_graph;
    boost::container::deque<int> m_states;
};

template <typename GraphTy>
    requires bgl_graph<GraphTy>
void sample_graph1(GraphTy& graph) {
    //auto
}


int main()
{

    using my_ig = boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS>;
    using my_node = my_ig::vertex_descriptor;

    sample_graph<my_ig, my_ig, my_node> g;
    g.sample1(std::vector<my_node>{});
}