X3: plain into variant of single element tuple

[Bockeman]

This code does not compile

#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/ast/variant.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

namespace x3        = boost::spirit::x3;
template <typename T>
  struct as_type{
    template <typename E>
    constexpr auto operator[](E e) const {return x3::rule<struct _, T> {} = e;}
  };
template <typename T>
  static inline constexpr as_type<T> as;
namespace ast {
  using namespace std;
  struct tagged_string  : std::string   {};
  enum token_enum   {lcomment, rcomment};
  struct tagged_token   {token_enum token;};
  struct comment_item   : x3::variant<tagged_string, tagged_token>
    {using base_type::base_type;using base_type::operator=;};
  struct comment    : std::vector<comment_item>{
    using std::vector<comment_item>::vector;
    using std::vector<comment_item>::operator=;
  };
  struct start_item : x3::variant<comment>
    {using base_type::base_type; using base_type::operator=;};
  struct start      : std::vector<start_item>{using std::vector<start_item>::vector;};
}
BOOST_FUSION_ADAPT_STRUCT(ast::tagged_token,        token)
namespace grammar {
  x3::symbols<ast::token_enum>  lcomment_token;
  x3::symbols<ast::token_enum>  rcomment_token;
  x3::rule<struct lcomment, ast::tagged_token>  const tagged_lcomment   = "tagged_lcomment";
  x3::rule<struct rcomment, ast::tagged_token>  const tagged_rcomment   = "tagged_rcomment";
  x3::rule<struct text,     ast::tagged_string> const tagged_text   = "tagged_text";
  x3::rule<struct comment,  ast::comment>       const comment       = "comment";
  x3::rule<struct start_rule,   ast::start>     const start_rule    = "start_rule";

  auto const tagged_lcomment_def    = lcomment_token;               // /*
  auto const tagged_rcomment_def    = rcomment_token;               // */
  auto const tagged_text_def        = *(x3::char_ - rcomment_token);        // not */

  // Compile fails:
  auto const comment_def    = lcomment_token > tagged_text > rcomment_token;            // /* ... */

  // Compiles ok, but ast is not correctly assembled:
  //auto const comment_def  = (x3::rule<class id>{}=lcomment_token) > tagged_text > tagged_rcomment;// /* ... */

  // Compiles ok, and ast is ok:
  //auto const comment_def  = as<ast::tagged_token>[lcomment_token] > tagged_text > tagged_rcomment;// /* ... */
  //auto const comment_def  = tagged_lcomment > tagged_text > tagged_rcomment;          // /* ... */

  auto const start_rule_def = x3::no_skip[+comment];    // 1 ... ;

  BOOST_SPIRIT_DEFINE(tagged_lcomment, tagged_rcomment, tagged_text, comment, start_rule);
}
int main() {
  char const*           iter    = "/** /**/", * const end   = iter + std::strlen(iter);
  ast::start            ast;
  grammar::lcomment_token.add   ("/*",      ast::lcomment);
  grammar::rcomment_token.add   ("*/",      ast::rcomment);
  bool ok           = parse(iter, end, grammar::start_rule, ast) && iter==end;
  if(ok)BOOST_ASSERT(3==boost::get<ast::comment>(ast[0].var).size());
  return !ok;
}

It seems the only way to successfully compile is to wrap the token (x3::symbols<>) into a rule (either inline, or with a separate rule definition). Is this an X3 implementation problem, or is it beyond the anticipated capabilities of X3?

[Kojoley]

Don't know variant or single element tuple or both, but not x3::symbols:

#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/ast/variant.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

namespace ast {
    struct tagged_token { int token; };
}
BOOST_FUSION_ADAPT_STRUCT(ast::tagged_token, token)

int main() {
    namespace x3 = boost::spirit::x3;
    char const* iter = "/** /**/", * const end = iter + std::strlen(iter);
    x3::variant<ast::tagged_token> x;
    x3::parse(iter, end, x3::attr(int{}), x);
}

[bfueldner]

It seems that not the single element variant is the problem. It depends on the number of struct/class members. No member works, two or more members works but not one member:

#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/ast/variant.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

#include <variant>

struct no_member {};

struct one_member {
    int a;
};
BOOST_FUSION_ADAPT_STRUCT(one_member, a)

struct two_members {
    int a{};
    int b{};
};
BOOST_FUSION_ADAPT_STRUCT(two_members, a, b)

int main()
{
    namespace x3 = boost::spirit::x3;

    char const* iter = "", * const end = iter + std::strlen(iter);
    std::variant<no_member, one_member, two_members> x;

    x3::parse(iter, end, x3::attr(no_member{}), x); // This line compiles
    x3::parse(iter, end, x3::attr(one_member{}), x); // This line failes
    x3::parse(iter, end, x3::attr(two_members{}), x); // This line compiles
}

Is there a workaround available for this behaviour?

[cppljevans]

Use boost::variant instead of std::variant.
The problem, I'd guess, is: https://www.boost.org/doc/libs/1_81_0/boost/spirit/home/x3/support/traits/is_variant.hpp doesn't consider std::variant as a variant.

[cppljevans]

OOPS! Adding obvious change to is_variant.hpp not enough. With the obvious change, now getting, using std::variant:

C:/msys64/home/evansl/prog_dev/boost.org/1_80_0download/download/boost/spirit/home/x3/support/traits/variant_has_substitute.hpp:23:40: error: no type named 'types' in 'std::variant<no_member, one_member, two_members>'
        typedef typename variant_type::types types;
                ~~~~~~~~~~~~~~~~~~~~~~~^~~~~

[cppljevans]

OOPS! Adding obvious change to is_variant.hpp not enough. With the obvious change, now getting, using std::variant:

C:/msys64/home/evansl/prog_dev/boost.org/1_80_0download/download/boost/spirit/home/x3/support/traits/variant_has_substitute.hpp:23:40: error: no type named 'types' in 'std::variant<no_member, one_member, two_members>'
        typedef typename variant_type::types types;
                ~~~~~~~~~~~~~~~~~~~~~~~^~~~~

However, changing obvious portion of variant_has_substitute.hpp to:

    template <typename Variant, typename T>
    struct variant_has_substitute_impl
    ;
    template <template<typename...>typename Variant, typename T, typename... Elements>
    struct variant_has_substitute_impl< Variant<Elements...>, T>
    {
        // Find a type from the Variant that can be a substitute for T.
        // return true_ if one is found, else false_

        typedef Variant<Elements...> variant_type;
        typedef fusion::vector<Elements...> types;

and #including <boost/fusion/container.hpp> before seems to solve problem.

[bfueldner]

@cppljevans Thank you for your response. Replacing std::variant with boost::variant (or x3::variant) did the trick!

Sorry for confusing with the original post of @Bockeman.