Parser.cpp

Go to the documentation of this file.

#include <Ark/Compiler/AST/Parser.hpp>
 
#include <fmt/core.h>
 
namespace Ark::internal
{
    Parser::Parser(const unsigned debug, const bool interpret) :
        BaseParser(), m_interpret(interpret), m_logger("Parser", debug),
        m_ast(NodeType::List), m_imports({}), m_allow_macro_behavior(0),
        m_nested_nodes(0)
    {
        m_ast.push_back(Node(Keyword::Begin));
 
        m_parsers = {
            [this]() {
                return wrapped(&Parser::letMutSet, "variable assignment or declaration");
            },
            [this]() {
                return wrapped(&Parser::function, "function");
            },
            [this]() {
                return wrapped(&Parser::condition, "condition");
            },
            [this]() {
                return wrapped(&Parser::loop, "loop");
            },
            [this]() {
                return import_();
            },
            [this]() {
                return block();
            },
            [this]() {
                return wrapped(&Parser::macroCondition, "$if");
            },
            [this]() {
                return macro();
            },
            [this]() {
                return wrapped(&Parser::del, "del");
            },
            [this]() {
                return functionCall();
            },
            [this]() {
                return list();
            }
        };
    }
 
    void Parser::process(const std::string& filename, const std::string& code)
    {
        m_logger.traceStart("process");
        initParser(filename, code);
 
        while (!isEOF())
        {
            std::string comment;
            newlineOrComment(&comment);
            if (isEOF())
            {
                if (!comment.empty())
                    m_ast.list().back().attachCommentAfter(comment);
                break;
            }
 
            const auto pos = getCount();
            if (auto n = node())
            {
                m_ast.push_back(n->attachNearestCommentBefore(n->comment() + comment));
                comment.clear();
                if (spaceComment(&comment))
                    m_ast.list().back().attachCommentAfter(comment);
            }
            else
            {
                backtrack(pos);
                std::string out = peek();
                std::string message;
                if (out == ")")
                    message = "Unexpected closing paren";
                else if (out == "}")
                    message = "Unexpected closing bracket";
                else if (out == "]")
                    message = "Unexpected closing square bracket";
                else
                    errorWithNextToken("invalid syntax, expected node");
                errorWithNextToken(message);
            }
        }
 
        m_logger.traceEnd();
    }
 
    const Node& Parser::ast() const noexcept
    {
        return m_ast;
    }
 
    const std::vector<Import>& Parser::imports() const
    {
        return m_imports;
    }
 
    Node& Parser::setNodePosAndFilename(Node& node, const std::optional<FilePosition>& cursor) const
    {
        if (node.line() != 0 || node.col() != 0)
            return node;
 
        const auto [row, col] = cursor.value_or(getCursor());
        node.setPos(row, col);
        node.setFilename(m_filename);
        return node;
    }
 
    std::optional<Node> Parser::node()
    {
        ++m_nested_nodes;
 
        if (m_nested_nodes > MaxNestedNodes)
            errorWithNextToken(fmt::format("Too many nested node while parsing, exceeds limit of {}. Consider rewriting your code by breaking it in functions and macros.", MaxNestedNodes));
 
        // save current position in buffer to be able to go back if needed
        const auto position = getCount();
        std::optional<Node> result = std::nullopt;
 
        for (auto&& parser : m_parsers)
        {
            result = parser();
 
            if (result)
                break;
            backtrack(position);
        }
 
        // return std::nullopt only on parsing error, nothing matched, the user provided terrible code
        --m_nested_nodes;
        return result;
    }
 
    std::optional<Node> Parser::letMutSet()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        std::string token;
        if (!oneOf({ "let", "mut", "set" }, &token))
            return std::nullopt;
        std::string comment;
        newlineOrComment(&comment);
        leaf->attachNearestCommentBefore(comment);
 
        if (token == "let")
            leaf->push_back(Node(Keyword::Let));
        else if (token == "mut")
            leaf->push_back(Node(Keyword::Mut));
        else  // "set"
            leaf->push_back(Node(Keyword::Set));
 
        if (m_allow_macro_behavior > 0)
        {
            const auto position = getCount();
            if (const auto value = nodeOrValue(); value.has_value())
            {
                const auto sym = value.value();
                if (sym.nodeType() == NodeType::List || sym.nodeType() == NodeType::Symbol || sym.nodeType() == NodeType::Macro || sym.nodeType() == NodeType::Spread)
                    leaf->push_back(sym);
                else
                    error(fmt::format("Can not use a {} as a symbol name, even in a macro", nodeTypes[static_cast<std::size_t>(sym.nodeType())]), sym.repr());
            }
            else
                backtrack(position);
        }
 
        if (leaf->constList().size() == 1)
        {
            // we haven't parsed anything while in "macro state"
            std::string symbol_name;
            if (!name(&symbol_name))
                errorWithNextToken(token + " needs a symbol");
 
            leaf->push_back(Node(NodeType::Symbol, symbol_name));
        }
 
        comment.clear();
        newlineOrComment(&comment);
 
        if (auto value = nodeOrValue(); value.has_value())
            leaf->push_back(value.value().attachNearestCommentBefore(comment));
        else
            errorWithNextToken("Expected a value");
 
        return leaf;
    }
 
    std::optional<Node> Parser::del()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        if (!oneOf({ "del" }))
            return std::nullopt;
        leaf->push_back(Node(Keyword::Del));
 
        std::string comment;
        newlineOrComment(&comment);
 
        std::string symbol_name;
        if (!name(&symbol_name))
            errorWithNextToken("del needs a symbol");
 
        leaf->push_back(Node(NodeType::Symbol, symbol_name));
        leaf->list().back().attachNearestCommentBefore(comment);
        setNodePosAndFilename(leaf->list().back());
 
        return leaf;
    }
 
    std::optional<Node> Parser::condition()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        if (!oneOf({ "if" }))
            return std::nullopt;
 
        std::string comment;
        newlineOrComment(&comment);
 
        leaf->push_back(Node(Keyword::If));
 
        if (auto cond_expr = nodeOrValue(); cond_expr.has_value())
            leaf->push_back(cond_expr.value().attachNearestCommentBefore(comment));
        else
            errorWithNextToken("`if' needs a valid condition");
 
        comment.clear();
        newlineOrComment(&comment);
 
        if (auto value_if_true = nodeOrValue(); value_if_true.has_value())
            leaf->push_back(value_if_true.value().attachNearestCommentBefore(comment));
        else
            errorWithNextToken("Expected a node or value after condition");
 
        comment.clear();
        newlineOrComment(&comment);
 
        if (auto value_if_false = nodeOrValue(); value_if_false.has_value())
        {
            leaf->push_back(value_if_false.value().attachNearestCommentBefore(comment));
            comment.clear();
            if (newlineOrComment(&comment))
                leaf->list().back().attachCommentAfter(comment);
        }
        else if (!comment.empty())
            leaf->attachCommentAfter(comment);
 
        setNodePosAndFilename(leaf->list().back());
        return leaf;
    }
 
    std::optional<Node> Parser::loop()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        if (!oneOf({ "while" }))
            return std::nullopt;
 
        std::string comment;
        newlineOrComment(&comment);
 
        leaf->push_back(Node(Keyword::While));
 
        if (auto cond_expr = nodeOrValue(); cond_expr.has_value())
            leaf->push_back(cond_expr.value().attachNearestCommentBefore(comment));
        else
            errorWithNextToken("`while' needs a valid condition");
 
        comment.clear();
        newlineOrComment(&comment);
 
        if (auto body = nodeOrValue(); body.has_value())
            leaf->push_back(body.value().attachNearestCommentBefore(comment));
        else
            errorWithNextToken("Expected a node or value after loop condition");
 
        setNodePosAndFilename(leaf->list().back());
        return leaf;
    }
 
    std::optional<Node> Parser::import_()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        const auto [row, col] = getCursor();
        auto context = generateErrorContext("(");
        if (!accept(IsChar('(')))
            return std::nullopt;
 
        std::string comment;
        newlineOrComment(&comment);
        leaf->attachNearestCommentBefore(comment);
 
        if (!oneOf({ "import" }))
            return std::nullopt;
        comment.clear();
        newlineOrComment(&comment);
        leaf->push_back(Node(Keyword::Import));
 
        Import import_data;
        import_data.col = col;
        import_data.line = row;
 
        const auto pos = getCount();
        if (!packageName(&import_data.prefix))
            errorWithNextToken("Import expected a package name");
 
        if (import_data.prefix.size() > 255)
        {
            backtrack(pos);
            errorWithNextToken(fmt::format("Import name too long, expected at most 255 characters, got {}", import_data.prefix.size()));
        }
        import_data.package.push_back(import_data.prefix);
 
        Node packageNode(NodeType::List);
        setNodePosAndFilename(packageNode.attachNearestCommentBefore(comment));
        packageNode.push_back(Node(NodeType::Symbol, import_data.prefix));
 
        // first, parse the package name
        while (!isEOF())
        {
            // parsing package folder.foo.bar.yes
            if (accept(IsChar('.')))
            {
                std::string path;
                if (!packageName(&path))
                    errorWithNextToken("Package name expected after '.'");
                else
                {
                    packageNode.push_back(Node(NodeType::Symbol, path));
                    setNodePosAndFilename(packageNode.list().back());
                    import_data.package.push_back(path);
                    import_data.prefix = path;  // in the end we will store the last element of the package, which is what we want
 
                    if (path.size() > 255)
                    {
                        backtrack(pos);
                        errorWithNextToken(fmt::format("Import name too long, expected at most 255 characters, got {}", path.size()));
                    }
                }
            }
            else if (accept(IsChar(':')) && accept(IsChar('*')))  // parsing :*
            {
                leaf->push_back(packageNode);
                leaf->push_back(Node(NodeType::Symbol, "*"));
                setNodePosAndFilename(leaf->list().back());
 
                space();
                expectSuffixOrError(')', fmt::format("in import `{}'", import_data.toPackageString()), context);
 
                // save the import data structure to know we encounter an import node, and retrieve its data more easily later on
                import_data.with_prefix = false;
                import_data.is_glob = true;
                m_imports.push_back(import_data);
 
                return leaf;
            }
            else
                break;
        }
 
        Node symbols(NodeType::List);
        setNodePosAndFilename(symbols);
        // then parse the symbols to import, if any
        if (space())
        {
            comment.clear();
            newlineOrComment(&comment);
 
            while (!isEOF())
            {
                if (accept(IsChar(':')))  // parsing potential :a :b :c
                {
                    std::string symbol_name;
                    if (!name(&symbol_name))
                        errorWithNextToken("Expected a valid symbol to import");
                    if (symbol_name == "*")
                        error(fmt::format("Glob patterns can not be separated from the package, use (import {}:*) instead", import_data.toPackageString()), symbol_name);
 
                    if (symbol_name.size() >= 2 && symbol_name[symbol_name.size() - 2] == ':' && symbol_name.back() == '*')
                    {
                        backtrack(getCount() - 2);  // we can backtrack n-2 safely here because we know the previous chars were ":*"
                        error("Glob pattern can not follow a symbol to import", ":*");
                    }
 
                    symbols.push_back(Node(NodeType::Symbol, symbol_name).attachNearestCommentBefore(comment));
                    comment.clear();
                    setNodePosAndFilename(symbols.list().back());
                    import_data.symbols.push_back(symbol_name);
                    // we do not need the prefix when importing specific symbols
                    import_data.with_prefix = false;
                }
 
                if (!space())
                    break;
                comment.clear();
                newlineOrComment(&comment);
            }
 
            if (!comment.empty() && !symbols.list().empty())
                symbols.list().back().attachCommentAfter(comment);
        }
 
        leaf->push_back(packageNode);
        leaf->push_back(symbols);
        // save the import data
        m_imports.push_back(import_data);
 
        comment.clear();
        if (newlineOrComment(&comment))
            leaf->list().back().attachCommentAfter(comment);
 
        expectSuffixOrError(')', fmt::format("in import `{}'", import_data.toPackageString()), context);
        return leaf;
    }
 
    std::optional<Node> Parser::block()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        auto context = generateErrorContext("(");
        bool alt_syntax = false;
        std::string comment;
        if (accept(IsChar('(')))
        {
            newlineOrComment(&comment);
            if (!oneOf({ "begin" }))
                return std::nullopt;
        }
        else if (accept(IsChar('{')))
            alt_syntax = true;
        else
            return std::nullopt;
 
        leaf->setAltSyntax(alt_syntax);
        leaf->push_back(Node(Keyword::Begin).attachNearestCommentBefore(comment));
 
        comment.clear();
        newlineOrComment(&comment);
 
        while (!isEOF())
        {
            if (auto value = nodeOrValue(); value.has_value())
            {
                leaf->push_back(value.value().attachNearestCommentBefore(comment));
                comment.clear();
                newlineOrComment(&comment);
            }
            else
                break;
        }
 
        newlineOrComment(&comment);
        expectSuffixOrError(alt_syntax ? '}' : ')', "to close block", context);
        setNodePosAndFilename(leaf->list().back());
        leaf->list().back().attachCommentAfter(comment);
        return leaf;
    }
 
    std::optional<Node> Parser::functionArgs()
    {
        expect(IsChar('('));
        std::optional<Node> args { NodeType::List };
        setNodePosAndFilename(args.value());
 
        std::string comment;
        newlineOrComment(&comment);
        args->attachNearestCommentBefore(comment);
 
        bool has_captures = false;
 
        while (!isEOF())
        {
            const auto pos = getCursor();
            if (accept(IsChar('&')))  // captures
            {
                has_captures = true;
                std::string capture;
                if (!name(&capture))
                    break;
                Node capture_node = Node(NodeType::Capture, capture).attachNearestCommentBefore(comment);
                setNodePosAndFilename(capture_node, pos);
                args->push_back(capture_node);
            }
            else
            {
                const auto count = getCount();
                std::string symbol_name;
                if (!name(&symbol_name))
                    break;
                if (has_captures)
                {
                    backtrack(count);
                    error("Captured variables should be at the end of the argument list", symbol_name);
                }
 
                Node arg_node = Node(NodeType::Symbol, symbol_name).attachNearestCommentBefore(comment);
                setNodePosAndFilename(arg_node, pos);
                args->push_back(arg_node);
            }
 
            comment.clear();
            newlineOrComment(&comment);
        }
 
        if (accept(IsChar(')')))
            return args;
        return std::nullopt;
    }
 
    std::optional<Node> Parser::function()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        if (!oneOf({ "fun" }))
            return std::nullopt;
        leaf->push_back(Node(Keyword::Fun));
 
        std::string comment_before_args;
        newlineOrComment(&comment_before_args);
 
        while (m_allow_macro_behavior > 0)
        {
            const auto position = getCount();
 
            // args
            if (const auto value = nodeOrValue(); value.has_value())
            {
                // if value is nil, just add an empty argument bloc to prevent bugs when
                // declaring functions inside macros
                Node args = value.value();
                setNodePosAndFilename(args);
                if (args.nodeType() == NodeType::Symbol && args.string() == "nil")
                    leaf->push_back(Node(NodeType::List));
                else
                    leaf->push_back(args);
            }
            else
            {
                backtrack(position);
                break;
            }
 
            std::string comment;
            newlineOrComment(&comment);
            // body
            if (auto value = nodeOrValue(); value.has_value())
                leaf->push_back(value.value().attachNearestCommentBefore(comment));
            else
                errorWithNextToken("Expected a body for the function");
            setNodePosAndFilename(leaf->list().back());
            return leaf;
        }
 
        const auto position = getCount();
        if (auto args = functionArgs(); args.has_value())
            leaf->push_back(args.value().attachNearestCommentBefore(comment_before_args));
        else
        {
            backtrack(position);
 
            if (auto value = nodeOrValue(); value.has_value())
                leaf->push_back(value.value().attachNearestCommentBefore(comment_before_args));
            else
                errorWithNextToken("Expected an argument list");
        }
 
        std::string comment;
        newlineOrComment(&comment);
 
        if (auto value = nodeOrValue(); value.has_value())
            leaf->push_back(value.value().attachNearestCommentBefore(comment));
        else
            errorWithNextToken("Expected a body for the function");
 
        setNodePosAndFilename(leaf->list().back());
        return leaf;
    }
 
    std::optional<Node> Parser::macroCondition()
    {
        std::optional<Node> leaf { NodeType::Macro };
        setNodePosAndFilename(leaf.value());
 
        if (!oneOf({ "$if" }))
            return std::nullopt;
        leaf->push_back(Node(Keyword::If));
 
        std::string comment;
        newlineOrComment(&comment);
        leaf->attachNearestCommentBefore(comment);
 
        if (const auto cond_expr = nodeOrValue(); cond_expr.has_value())
            leaf->push_back(cond_expr.value());
        else
            errorWithNextToken("$if need a valid condition");
 
        comment.clear();
        newlineOrComment(&comment);
 
        if (auto value_if_true = nodeOrValue(); value_if_true.has_value())
            leaf->push_back(value_if_true.value().attachNearestCommentBefore(comment));
        else
            errorWithNextToken("Expected a node or value after condition");
 
        comment.clear();
        newlineOrComment(&comment);
 
        if (auto value_if_false = nodeOrValue(); value_if_false.has_value())
        {
            leaf->push_back(value_if_false.value().attachNearestCommentBefore(comment));
            comment.clear();
            newlineOrComment(&comment);
            leaf->list().back().attachCommentAfter(comment);
        }
 
        setNodePosAndFilename(leaf->list().back());
        return leaf;
    }
 
    std::optional<Node> Parser::macroArgs()
    {
        if (!accept(IsChar('(')))
            return std::nullopt;
 
        std::optional<Node> args { NodeType::List };
        setNodePosAndFilename(args.value());
 
        std::string comment;
        newlineOrComment(&comment);
        args->attachNearestCommentBefore(comment);
 
        std::vector<std::string> names;
        while (!isEOF())
        {
            const auto pos = getCount();
 
            std::string arg_name;
            if (!name(&arg_name))
                break;
            comment.clear();
            newlineOrComment(&comment);
            args->push_back(Node(NodeType::Symbol, arg_name).attachNearestCommentBefore(comment));
 
            if (std::ranges::find(names, arg_name) != names.end())
            {
                backtrack(pos);
                errorWithNextToken(fmt::format("Argument names must be unique, can not reuse `{}'", arg_name));
            }
            names.push_back(arg_name);
        }
 
        const auto pos = getCount();
        if (sequence("..."))
        {
            std::string spread_name;
            if (!name(&spread_name))
                errorWithNextToken("Expected a name for the variadic arguments list");
            args->push_back(Node(NodeType::Spread, spread_name));
 
            comment.clear();
            if (newlineOrComment(&comment))
                args->list().back().attachCommentAfter(comment);
 
            if (std::ranges::find(names, spread_name) != names.end())
            {
                backtrack(pos);
                errorWithNextToken(fmt::format("Argument names must be unique, can not reuse `{}'", spread_name));
            }
        }
 
        if (!accept(IsChar(')')))
            return std::nullopt;
        comment.clear();
        if (newlineOrComment(&comment))
        {
            if (args->list().empty())
                args->attachCommentAfter(comment);
            else
                args->list().back().attachCommentAfter(comment);
        }
 
        return args;
    }
 
    std::optional<Node> Parser::macro()
    {
        std::optional<Node> leaf { NodeType::Macro };
        setNodePosAndFilename(leaf.value());
 
        auto context = generateErrorContext("(");
        if (!accept(IsChar('(')))
            return std::nullopt;
        std::string comment;
        newlineOrComment(&comment);
 
        if (!oneOf({ "macro" }))
            return std::nullopt;
        newlineOrComment(&comment);
        leaf->attachNearestCommentBefore(comment);
 
        std::string symbol_name;
        if (!name(&symbol_name))
            errorWithNextToken("Expected a symbol to declare a macro");
        comment.clear();
        newlineOrComment(&comment);
 
        leaf->push_back(Node(NodeType::Symbol, symbol_name).attachNearestCommentBefore(comment));
 
        const auto position = getCount();
        if (const auto args = macroArgs(); args.has_value())
            leaf->push_back(args.value());
        else
        {
            // if we couldn't parse arguments, then we have a value
            backtrack(position);
 
            ++m_allow_macro_behavior;
            const auto value = nodeOrValue();
            --m_allow_macro_behavior;
 
            if (value.has_value())
                leaf->push_back(value.value());
            else
                errorWithNextToken(fmt::format("Expected an argument list, atom or node while defining macro `{}'", symbol_name));
 
            setNodePosAndFilename(leaf->list().back());
            comment.clear();
            if (newlineOrComment(&comment))
                leaf->list().back().attachCommentAfter(comment);
            expectSuffixOrError(')', fmt::format("to close macro `{}'", symbol_name), context);
            return leaf;
        }
 
        ++m_allow_macro_behavior;
        const auto value = nodeOrValue();
        --m_allow_macro_behavior;
 
        if (value.has_value())
            leaf->push_back(value.value());
        else if (leaf->list().size() == 2)  // the argument list is actually a function call and it's okay
        {
            setNodePosAndFilename(leaf->list().back());
            comment.clear();
            if (newlineOrComment(&comment))
                leaf->list().back().attachCommentAfter(comment);
 
            expectSuffixOrError(')', fmt::format("to close macro `{}'", symbol_name), context);
            return leaf;
        }
        else
        {
            backtrack(position);
            errorWithNextToken(fmt::format("Expected a value while defining macro `{}'", symbol_name), context);
        }
 
        setNodePosAndFilename(leaf->list().back());
        comment.clear();
        if (newlineOrComment(&comment))
            leaf->list().back().attachCommentAfter(comment);
 
        expectSuffixOrError(')', fmt::format("to close macro `{}'", symbol_name), context);
        return leaf;
    }
 
    std::optional<Node> Parser::functionCall()
    {
        auto context = generateErrorContext("(");
        if (!accept(IsChar('(')))
            return std::nullopt;
        std::string comment;
        newlineOrComment(&comment);
        auto cursor = getCursor();
 
        std::optional<Node> func;
        if (auto sym_or_field = anyAtomOf({ NodeType::Symbol, NodeType::Field }); sym_or_field.has_value())
            func = sym_or_field->attachNearestCommentBefore(comment);
        else if (auto nested = node(); nested.has_value())
            func = nested->attachNearestCommentBefore(comment);
        else
            return std::nullopt;
        comment.clear();
        newlineOrComment(&comment);
 
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value(), cursor);
        setNodePosAndFilename(func.value(), cursor);
        leaf->push_back(func.value());
 
        while (!isEOF())
        {
            if (auto arg = nodeOrValue(); arg.has_value())
            {
                leaf->push_back(arg.value().attachNearestCommentBefore(comment));
                comment.clear();
                newlineOrComment(&comment);
            }
            else
                break;
        }
 
        leaf->list().back().attachCommentAfter(comment);
 
        comment.clear();
        if (newlineOrComment(&comment))
            leaf->list().back().attachCommentAfter(comment);
 
        expectSuffixOrError(')', fmt::format("in function call to `{}'", func.value().repr()), context);
        return leaf;
    }
 
    std::optional<Node> Parser::list()
    {
        std::optional<Node> leaf { NodeType::List };
        setNodePosAndFilename(leaf.value());
 
        auto context = generateErrorContext("[");
        if (!accept(IsChar('[')))
            return std::nullopt;
        leaf->setAltSyntax(true);
        leaf->push_back(Node(NodeType::Symbol, "list"));
 
        std::string comment;
        newlineOrComment(&comment);
        leaf->attachNearestCommentBefore(comment);
 
        comment.clear();
        while (!isEOF())
        {
            if (auto value = nodeOrValue(); value.has_value())
            {
                leaf->push_back(value.value().attachNearestCommentBefore(comment));
                comment.clear();
                newlineOrComment(&comment);
            }
            else
                break;
        }
        leaf->list().back().attachCommentAfter(comment);
 
        expectSuffixOrError(']', "to end list definition", context);
        return leaf;
    }
 
    std::optional<Node> Parser::atom()
    {
        const auto pos = getCount();
 
        if (auto res = Parser::number(); res.has_value())
            return res;
        backtrack(pos);
 
        if (auto res = Parser::string(); res.has_value())
            return res;
        backtrack(pos);
 
        if (auto res = Parser::spread(); m_allow_macro_behavior > 0 && res.has_value())
            return res;
        backtrack(pos);
 
        if (auto res = Parser::field(); res.has_value())
            return res;
        backtrack(pos);
 
        if (auto res = Parser::symbol(); res.has_value())
            return res;
        backtrack(pos);
 
        if (auto res = Parser::nil(); res.has_value())
            return res;
        backtrack(pos);
 
        return std::nullopt;
    }
 
    std::optional<Node> Parser::anyAtomOf(const std::initializer_list<NodeType> types)
    {
        auto cursor = getCursor();
        if (auto value = atom(); value.has_value())
        {
            setNodePosAndFilename(value.value(), cursor);
            for (const auto type : types)
            {
                if (value->nodeType() == type)
                    return value;
            }
        }
        return std::nullopt;
    }
 
    std::optional<Node> Parser::nodeOrValue()
    {
        auto cursor = getCursor();
        if (auto value = atom(); value.has_value())
        {
            setNodePosAndFilename(value.value(), cursor);
            return value;
        }
        if (auto sub_node = node(); sub_node.has_value())
        {
            setNodePosAndFilename(sub_node.value(), cursor);
            return sub_node;
        }
 
        return std::nullopt;
    }
 
    std::optional<Node> Parser::wrapped(std::optional<Node> (Parser::*parser)(), const std::string& name)
    {
        auto cursor = getCursor();
        auto context = generateErrorContext("(");
        if (!prefix('('))
            return std::nullopt;
        std::string comment;
        newlineOrComment(&comment);
 
        if (auto result = (this->*parser)(); result.has_value())
        {
            result->attachNearestCommentBefore(result->comment() + comment);
            setNodePosAndFilename(result.value(), cursor);
 
            comment.clear();
            if (newlineOrComment(&comment))
                result.value().attachCommentAfter(comment);
 
            if (result->isListLike())
                setNodePosAndFilename(result->list().back());
            expectSuffixOrError(')', "after " + name, context);
 
            comment.clear();
            if (spaceComment(&comment))
                result.value().attachCommentAfter(comment);
 
            return result;
        }
 
        return std::nullopt;
    }
}