AST против синтезированных атрибутов нетерминальных парсеров

Во-первых, вещи редко используются для семантических действий (Boost Spirit: «Семантические действия — это зло»?)¹.

Во-вторых, моя интуиция подсказывает, что optional, вероятно, не нужен для векторных/строковых полей. На мой взгляд, контейнер последовательности уже является обобщением optional (где необязательное значение похоже на контейнер с максимальным размером 1).

В-третьих, насколько я помню, могут быть ограничения с поддержкой std::optional. Кажется, я неправильно помню из variant support Переход парсера Boost Spirit с boost::variant на std::variant.

Правила размножения

Теперь я бы посоветовал помнить о двух вещах:

1. Всегда сопоставляйте объявления AST как можно ближе к объявлениям ваших правил. В частности, ваш AST не различает листовые узлы и внутренние узлы, что вызывает путаницу, поскольку вы надеетесь, что оба правила «волшебным образом» совместимы с обоими.

2. Будьте конкретны в приведении типов. x3::rule делает это, и вы можете использовать его явно. Одно из моих повторяющихся устройств x3 — это as<T>[p] (или иногда его функциональная версия: as<T>(p, name)):

   template <typename T> struct as_type {
       auto operator[](auto p) const {
           struct Tag {};
           return x3::rule<Tag, T>{"as"} = p;
       }
   };
   
   template <typename T> static inline as_type<T> as{};
   

Обратите внимание, что некоторые (большинство?) ваших строк комментариев

// synthesize: std::string
// synthesize: double
// synthesize: std::optional<std::string>
// synthesize: std::pair< std::vector<...>, std::optional<std::string> >
// synthesized attribute: std::variant<node, std::optional<std::string>
// synthesize: std::pair<node, std::optional<double>>
// synthesize: std::pair<node, std::optional<double>>

не очень точны. Например. alpha >> *alnum имеет fusion::deque<char, std::string> > тип атрибута. Имейте в виду, что механизм распространения может сгладить тонкую разницу при создании экземпляра x3::move_to для фактической связанной ссылки.

На самом деле это так и есть, см. «Упрощение, очистка» ниже.

Но как есть, это распространяется вниз: leaf не optional<string> сейчас и так далее.

Поскольку вы определили branch без типа атрибута, его тип атрибута на самом деле x3::unused_type. Это означает, что subtree также не содержит vector<...>. Пришлось проверить, поэтому сделал сооружение:

template <typename ExpectedAttributeType> void check(auto p) {
    static_assert(
        std::is_same_v<
            ExpectedAttributeType,
            typename x3::traits::attribute_of<decltype(p), x3::unused_type>::type>);
};

И теперь мы можем видеть, что:

check<std::string>(name); // assuming a fixed `name` rule that coerces std::string
check<std::vector<std::string>>('(' >> name % ',' >> ')');

Но для парсера, который выставляет unused_type:

check<x3::unused_type>(x3::omit[name]);
check<std::vector<x3::unused_type>>('(' >> x3::omit[name] % ',' >> ')'); // FAILS!
check<x3::unused_type>('(' >> x3::omit[name] % ',' >> ')'); // Passes

Понимаете, что я имею в виду, когда говорю о строгом контроле? Волновой эффект приводит к совершенно другим типам атрибутов, чем вы ожидали.

Кроме того, pair<node, optional<double>> не будет совместим ни с одним из ваших типов AST (что, конечно же, просто ast::node).

Покажи, не говори

Поскольку я знаю, что вы быстро учитесь, и я не знаю, как лучше всего объяснить преобразования, которые я бы выполнял шаг за шагом, я просто покажу вам результат применения вышеуказанных принципов к коду вопроса:

x3::rule<class branch, ast::node> node{"node"};

auto name     = as<std::string>[x3::lexeme[x3::alpha >> *x3::alnum]];
auto length   = as<double>[':' >> x3::double_];
auto leaf     = as<std::string>[name | x3::attr(std::string{})];
auto children = '(' >> (node % ',') >> ')' | x3::attr(ast::nodes{});
auto node_def = children >> leaf >> -length;
auto tree     = x3::skip(x3::blank)[node >> ';' >> x3::eoi];

BOOST_SPIRIT_DEFINE(node);

Вы можете ваши ожидания:

void checks() {
    check<double>(length);
    check<std::string>(leaf);
    check<std::string>(name);
    check<ast::nodes>('(' >> node % ',' >> ')'); // Passes
    //check<ast::nodes>(children); // FAILS, actually variant<ast::nodes, ast::nodes> (!!)
    check<ast::nodes>(as<ast::nodes>[children]); // Trivially compatible
    check<ast::node>(tree);
}

Обратите внимание, насколько тонкими могут быть внутренние механизмы. Честно говоря, Spirit Qi был более предсказуемым и снисходительным, чем X3. Я подозреваю, что разница может быть в пользу удобства обслуживания и времени компиляции?_

Тестирование

Заимствуем некоторые тестовые примеры из Grammar не удается разобрать дерево с помощью Boost Spirit X3 и отладить печать проанализированного AST:

Live On Coliru принты

============ running internal tests:
"(,)"    PASS -> node { [node { [], "" }, node { [], "" }], "" }
"(A,B)F"     PASS -> node { [node { [], "A" }, node { [], "B" }], "F" }
"(A:10,B:10)F"   PASS -> node { [node { [], "A":10 }, node { [], "B":10 }], "F" }
============ running tree tests:
";"  PASS -> node { [], "" }
"(,);"   PASS -> node { [node { [], "" }, node { [], "" }], "" }
"(,,(,));"   PASS -> node { [node { [], "" }, node { [], "" }, node { [node { [], "" }, node { [], "" }], "" }], "" }
"(A,B,(C,D));"   PASS -> node { [node { [], "A" }, node { [], "B" }, node { [node { [], "C" }, node { [], "D" }], "" }], "" }
"(A,B,(C,D)E)F;"     PASS -> node { [node { [], "A" }, node { [], "B" }, node { [node { [], "C" }, node { [], "D" }], "E" }], "F" }
"(:0.1,:0.2,(:0.3,:0.4):0.5);"   PASS -> node { [node { [], "":0.1 }, node { [], "":0.2 }, node { [node { [], "":0.3 }, node { [], "":0.4 }], "":0.5 }], "" }
"(:0.1,:0.2,(:0.3,:0.4):0.5):0.0;"   PASS -> node { [node { [], "":0.1 }, node { [], "":0.2 }, node { [node { [], "":0.3 }, node { [], "":0.4 }], "":0.5 }], "":0 }
"(A:0.1,B:0.2,(C:0.3,D:0.4):0.5);"   PASS -> node { [node { [], "A":0.1 }, node { [], "B":0.2 }, node { [node { [], "C":0.3 }, node { [], "D":0.4 }], "":0.5 }], "" }
"(A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5)F;"     PASS -> node { [node { [], "A":0.1 }, node { [], "B":0.2 }, node { [node { [], "C":0.3 }, node { [], "D":0.4 }], "E":0.5 }], "F" }
"((B:0.2,(C:0.3,D:0.4)E:0.5)F:0.1)A;"    PASS -> node { [node { [node { [], "B":0.2 }, node { [node { [], "C":0.3 }, node { [], "D":0.4 }], "E":0.5 }], "F":0.1 }], "A" }

Упрощение, Очистка

После того, как все сделано, я обычно захожу и удаляю ненужные экземпляры правил.

Оказывается, неудивительно, что действительное соответствие AST вашим правилам 1: 1 делает все тривиально совместимым без принуждения. В вашем случае я бы, вероятно, также удалил optional<double>, поэтому позвольте мне показать вам, если вам интересно:

struct node {
    nodes       children;
    std::string name;
    double      length;
};

И правила становятся:

x3::rule<class branch, ast::node> node{"node"};

auto name     = x3::lexeme[x3::alpha >> *x3::alnum];
auto length   = ':' >> x3::double_ | x3::attr(0.0);
auto leaf     = name | x3::attr(std::string{});
auto children = '(' >> (node % ',') >> ')' | x3::attr(ast::nodes{});
auto node_def = children >> leaf >> -length;
auto tree     = x3::skip(x3::blank)[node >> ';' >> x3::eoi];

BOOST_SPIRIT_DEFINE(node);

На всякий случай давайте переформулируем checks, чтобы проверить только ожидаемую совместимость:

template <typename ExpectedAttributeType> void compatible(auto p) {
    static_assert(
        std::is_same_v<ExpectedAttributeType,
                       typename x3::traits::attribute_of<
                           decltype(x3::rule<struct _, ExpectedAttributeType>{} = p),
                           x3::unused_type>::type>);
};

void checks() {
    compatible<double>(length);
    compatible<std::string>(leaf);
    compatible<std::string>(name);
    compatible<ast::nodes>(children);
    compatible<ast::node>(tree);
}

Полный список

Прямой эфир на Колиру

#include <boost/fusion/include/adapted.hpp>
#include <boost/spirit/home/x3.hpp>
#include <iomanip>
#include <iostream>

namespace ast {
    using nodes = std::vector<struct node>;
    struct node {
        nodes       children;
        std::string name;
        double      length;
    };

    // for debug output
    static inline std::ostream& operator<<(std::ostream& os, node const& n) {
        os << "node { [";

        for (auto sep = ""; auto& c : n.children)
            os << std::exchange(sep, ", ") << c;

        os << "], " << quoted(n.name) ;

        if (n.length != 0)
            os << ":" << n.length;
        return os << " }";
    }
} // namespace ast

BOOST_FUSION_ADAPT_STRUCT(ast::node, children, name, length)

#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/include/std_pair.hpp>

namespace parser {
    namespace x3 = boost::spirit::x3;

    static x3::rule<class branch, ast::node> const node{"node"};

    static auto const name     = x3::lexeme[x3::alpha >> *x3::alnum];
    static auto const length   = ':' >> x3::double_ | x3::attr(0.0);
    static auto const leaf     = name | x3::attr(std::string{});
    static auto const children = '(' >> (node % ',') >> ')' | x3::attr(ast::nodes{});
    static auto const node_def = children >> leaf >> -length;
    static auto const tree     = x3::skip(x3::blank)[node >> ';' >> x3::eoi];

    BOOST_SPIRIT_DEFINE(node);

    template <typename ExpectedAttributeType> void compatible(auto p) {
        static_assert(
            std::is_same_v<ExpectedAttributeType,
                           typename x3::traits::attribute_of<
                               decltype(x3::rule<struct _, ExpectedAttributeType>{} = p),
                               x3::unused_type>::type>);
    };

    void checks() {
        compatible<double>(length);
        compatible<std::string>(leaf);
        compatible<std::string>(name);
        compatible<ast::nodes>(children);
        compatible<ast::node>(tree);
    }
} // namespace parser

namespace test {
    void run_tests(auto name, auto p, std::initializer_list<char const*> cases) {
        std::cerr << "============ running " << name << " tests:\n";
        for (std::string const input : cases)
        {
            ast::node n;
            auto      ok = parse(begin(input), end(input), p, n);

            std::cout << quoted(input) << "\t " << (ok ? "PASS" : "FAIL");
            if (ok)
                std::cout << " -> " << n << std::endl;
            else
                std::cout << std::endl;
        }
    }

    void internal() {
        run_tests("internal", parser::node,
                  {
                      "(,)",
                      "(A,B)F",
                      "(A:10,B:10)F",
                  });
    }

    void tree() {
        run_tests("tree", parser::tree,
            {
                ";",
                "(,);",
                "(,,(,));",
                "(A,B,(C,D));",
                "(A,B,(C,D)E)F;",
                "(:0.1,:0.2,(:0.3,:0.4):0.5);",
                "(:0.1,:0.2,(:0.3,:0.4):0.5):0.0;",
                "(A:0.1,B:0.2,(C:0.3,D:0.4):0.5);",
                "(A:0.1,B:0.2,(C:0.3,D:0.4)E:0.5)F;",
                "((B:0.2,(C:0.3,D:0.4)E:0.5)F:0.1)A;",
            });
    }
} // namespace test

int main() {
    test::internal();
    test::tree();
}

С идентичным выводом (за исключением подавленной длины 0.0 в выводе отладки).

¹ Справедливости ради, в X3 я буду более счастлив рассматривать их, так как их написание стало намного более естественным.