Cannot use lexy::new_ but I can use a lambda with the same parameters as the constructor

[natinusala]

I have the following struct for a quoted string literal production:

struct StringLiteralExpressionSyntax: public ExpressionSyntax {
    String value; // String-specific type of the project I'm working on

    explicit StringLiteralExpressionSyntax(std::string value): value(value.c_str()) {}
};

In my expression production, I have the string literal production as an atom.

The expression value is as follows:

static constexpr auto value =
    lexy::as_list<std::vector<FunctionCallArgumentSyntax>> >>
    lexy::callback<ExpressionSyntaxPtr>(
        // Atoms
        lexy::forward<ExpressionSyntaxPtr>,
        lexy::new_<IntegerLiteralExpressionSyntax, ExpressionSyntaxPtr>,
        lexy::new_<StringLiteralExpressionSyntax, ExpressionSyntaxPtr>,
        lexy::new_<IdentifierExpressionSyntax, ExpressionSyntaxPtr>,
        // Operators
        lexy::new_<BinaryOperatorExpressionSyntax, ExpressionSyntaxPtr>,
        // Function call
        lexy::new_<FunctionCallExpressionSyntax, ExpressionSyntaxPtr>
    );

However, this gives me missing value callback overload for production when trying to build it.

It I change the lexy::new_<StringLiteralExpressionSyntax, ExpressionSyntaxPtr> by a lambda that explicitely constructs it, it works:

static constexpr auto value =
    lexy::as_list<std::vector<FunctionCallArgumentSyntax>> >>
    lexy::callback<ExpressionSyntaxPtr>(
        // Atoms
        lexy::forward<ExpressionSyntaxPtr>,
        lexy::new_<IntegerLiteralExpressionSyntax, ExpressionSyntaxPtr>,
        lexy::new_<IdentifierExpressionSyntax, ExpressionSyntaxPtr>,
        // Operators
        lexy::new_<BinaryOperatorExpressionSyntax, ExpressionSyntaxPtr>,
        // Function call
        lexy::new_<FunctionCallExpressionSyntax, ExpressionSyntaxPtr>,
        [](std::string str) {
            return ExpressionSyntaxPtr(new StringLiteralExpressionSyntax(str));
        }
    );

Why is that? Isn't lexy::new_ supposed to take theconstructor? This should be exactly equivalent.
Why does it work for integer literals (exact same structure except that it's int instead of std::string) but not for strings?

Thanks for your help!

[Spartan322]

An explicit constructor means you don't have automatic conversion, you must explicitly call the constructor to initialize a StringLiteralExpressionSyntax from a string, what callback is constructing the string? Cause if it doesn't pass specifically a std::string it will not convert and so fail to compile, however std::string itself can be constructed with implicit conversions. And if your other rules can produce an integer then no casting is needed.

[natinusala]

But then why does it work with all my other expression parts? They all follow the exact same pattern:

struct IdentifierExpressionSyntax: public ExpressionSyntax {
    IdentifierSyntax identifier;

    explicit IdentifierExpressionSyntax(IdentifierSyntax identifier): identifier(identifier) {};
};

struct IntegerLiteralExpressionSyntax: public ExpressionSyntax {
    int value;

    explicit IntegerLiteralExpressionSyntax(int value): value(value) {}
};

[Spartan322]

The only reason why they would work and not the string constructor is because you are directly giving those constructors the expected type, you're producing an IdentifierSyntax and an integer value in your rule, whereas you don't seem to be producing a std::string in your rule value, what is the rule that is producing the type? If its using using another production type to generate that then it would also be helpful to know the value callback of that type.

[natinusala]

I thought I posted it, here it is:

struct string_literal {
    static constexpr auto rule = [] {
        return dsl::quoted.limit(dsl::ascii::newline)(-dsl::ascii::control);
    }();

    static constexpr auto value = lexy::as_string<std::string, lexy::utf8_encoding>;
};

It should not matter anyway because to me, if it works with the lambda it should work with new_.

[Spartan322]

What about the rule of the production type the expression callbacks are produced in?

[natinusala]

Do you mean the expression atom?

static constexpr auto atom = dsl::parenthesized(dsl::p<nested_expression>) | dsl::p<integer_literal> | dsl::p<string_literal> | dsl::p<identifier>;

[foonathan]

Can you post a full compilable example? I've tried to reproduce it to this, but that one compiles:

struct ExpressionSyntax
{
    virtual ~ExpressionSyntax() = default;
};

struct StringLiteralExpressionSyntax : public ExpressionSyntax
{
    explicit StringLiteralExpressionSyntax(std::string value)
    {
        (void)value;
    }
};

struct string_literal
{
    static constexpr auto rule
        = [] { return dsl::quoted.limit(dsl::ascii::newline)(-dsl::ascii::control); }();

    static constexpr auto value = lexy::as_string<std::string, lexy::utf8_encoding>;
};

struct production
{
    static constexpr auto whitespace = dsl::ascii::space;

    static constexpr auto rule  = dsl::p<string_literal>;
    static constexpr auto value = lexy::callback<std::unique_ptr<ExpressionSyntax>>(
        lexy::new_<StringLiteralExpressionSyntax, std::unique_ptr<ExpressionSyntax>>);
};

My guess is that maybe there is some ambiguity in the overload set of the callback. Is there maybe anything else that produces something similar to std::string in your expression? Because new_ is templated while the lambda takes a std::string directly, it is treated differently in overload resolution.