lalr1 | parser generator in Rust , for multiple languages

Although you don't include driver.cc or driver.hh in your question, I suspect that they are adapted from the example C++ code in the Bison manual. That code allows you to enable either scanner or parser tracing using command line flags. If you didn't include that part of the example code, I strongly suggest that you put it back in and enable the tracing. You'll find it much easier to see what is going on.

The immediate problem here is that when your scanner sees a -, it executes the action:

You all had the reason. The issue was that I had to sort all the includes, if you have this issue, make sure that you are importing all the files correctly.

In order for the token AND in that sentence to be recognised, there would have to be a derivation sequence leading from sentence' to multiadjective. There is no such sequence, as can easily be verified by doing a simple reachability graph (which is just a DFS).

That makes multiadjective useless in that grammar. It's slightly surprising that the tool you use doesn't warn you about that.

That's not the case for multinoun, which is reachable through the noun -> multinoun production. However, that creates a number of ambiguities, leading to shift/reduce conflicts. One example:

This change, which I believe was introduced in v3.2, applies only to the C++ skeleton (which happens to be the one you are requesting, lalr1.cc.) As far as I know, there is no way to disable it.

Although both yacc and bison describe $$ = $1 as the "default action", that's not really the case. The historic implementations perform $$ = $1 for all reductions, whether or not there is an explicit action. (Even if $1 doesn't exist, which would be the case for a production with an empty right-hand side.) That's probably not much of an issue for C parsers, but in C++ it could have unfortunate consequences. For example, the semantic type might not have an assignment operator. Or the assignment might do something which cannot easily be undone. The intent of the change was to make the default action actually a default action, so that it doesn't occur if there is an explicit action.

There was some discussion about this at the time. Originally, the change was proposed for both C and C++, but it was argued -- or, more accurately, I argued -- that many existing bison parsers assume the historic implementation. A classic case is an action which appends an element to a list by doing something like append($1, $3) or even append($$, $3) and assuming that's OK, because the parser already set $$ = $1. In the end, the bison maintainers decided to restrict the change to C++ in order to avoid breaking legacy C programs. Evidently, some legacy C++ programs were broken. Apparently this includes yours.

Using getters and setters to make std::variant work is actually pretty clever, but I don't know a simple way of making it work with new bison versions. You could compile your own bison executable, changing the string literal at line 301 of reader.c to whatever you want the default action to be. (A better fix would be to make the default action a bison %define, but that would be more work.) But if you don't want to recompile and maintain your own bison, you'd probably be better off finding a different solution.

In this context, it's worth noting that bison doesn't really care what a type tag looks like, within reason. You can even include parentheses, as long as they are balanced; whatever you use will be added to the stack reference after a member access operator (.). So instead of defining getter and setter methods, you could define your wrapper type with per-type member functions which return a reference (or reference proxy), and then use type declarations like %type non_terminal. That should make it possible for $$ = $1; to have the correct semantics, so that the default action works. That might make the rest of your code more readable, too.

You're missing commas in some of your object literals (specifically after both occurrences of type: BinaryExpression).

It looks like syntax simply ignores actions with syntax errors in --parse mode. If you actually compile the grammar to JavaScript using --output, you'll get an actual syntax error telling you where the mistake is when you try to run the generated file with node.

I'm not sure what you mean by "work" in your question. That online parser-generator reports shift-reduce conflicts for both the LR(1) and the LALR(1) algorithms, which is not suprising since your grammar includes the exponentially ambiguous