Support parser generation without %union directive (Bison compatibility)

## Motivation

When writing simple parser samples or prototypes, defining `%union` can be cumbersome and unnecessary. Bison allows users to generate
parsers without the `%union` directive, defaulting `YYSTYPE` to `int`. This PR brings the same convenience to lrama for better Bison
compatibility.

## How it works

When %union is not defined:
1. YYSTYPE defaults to int (same as Bison)
2. Semantic value references are generated without union member access
3. The parser works exactly like Bison-generated parsers

Author: ydah

lib/lrama/grammar/code/rule_action.rb

@@ -53,19 +53,31 @@ def reference_to_c(ref)
           case
           when ref.type == :dollar && ref.name == "$" # $$
             tag = ref.ex_tag || lhs.tag
-            raise_tag_not_found_error(ref) unless tag
-            # @type var tag: Lexer::Token::Tag
-            "(yyval.#{tag.member})"
+            if tag
+              # @type var tag: Lexer::Token::Tag
+              "(yyval.#{tag.member})"
+            elsif union_not_defined?
+              # When %union is not defined, YYSTYPE defaults to int
+              "(yyval)"
+            else
+              raise_tag_not_found_error(ref)
+            end
           when ref.type == :at && ref.name == "$" # @$
             "(yyloc)"
           when ref.type == :index && ref.name == "$" # $:$
             raise "$:$ is not supported"
           when ref.type == :dollar # $n
             i = -position_in_rhs + ref.index
             tag = ref.ex_tag || rhs[ref.index - 1].tag
-            raise_tag_not_found_error(ref) unless tag
-            # @type var tag: Lexer::Token::Tag
-            "(yyvsp[#{i}].#{tag.member})"
+            if tag
+              # @type var tag: Lexer::Token::Tag
+              "(yyvsp[#{i}].#{tag.member})"
+            elsif union_not_defined?
+              # When %union is not defined, YYSTYPE defaults to int
+              "(yyvsp[#{i}])"
+            else
+              raise_tag_not_found_error(ref)
+            end
           when ref.type == :at # @n
             i = -position_in_rhs + ref.index
             "(yylsp[#{i}])"
@@ -99,6 +111,11 @@ def lhs
           @rule.lhs
         end
 
+        # @rbs () -> bool
+        def union_not_defined?
+          lhs.tag.nil? && rhs.all? { |sym| sym.tag.nil? }
+        end
+
         # @rbs (Reference ref) -> bot
         def raise_tag_not_found_error(ref)
           raise "Tag is not specified for '$#{ref.value}' in '#{@rule.display_name}'"

sig/generated/lrama/grammar/code/rule_action.rbs

@@ -0,0 +1,25 @@
+/*
+ * Test case for parser without %union directive
+ */
+
+%{
+// Prologue
+%}
+
+%token NUMBER
+%token PLUS
+%token MINUS
+
+%%
+
+program: expr
+       ;
+
+expr: NUMBER
+    | expr PLUS NUMBER
+    | expr MINUS NUMBER
+    ;
+
+%%
+
+// Epilogue

spec/fixtures/common/no_union.y

@@ -0,0 +1,27 @@
+/*
+ * Test case for parser without %union but with typed tokens
+ */
+
+%{
+// Prologue
+%}
+
+%token <val> NUMBER
+%token PLUS
+%token MINUS
+
+%type <val> expr
+
+%%
+
+program: expr
+       ;
+
+expr: NUMBER
+    | expr PLUS NUMBER
+    | expr MINUS NUMBER
+    ;
+
+%%
+
+// Epilogue

spec/fixtures/common/no_union_with_type.y

@@ -0,0 +1,40 @@
+%option noinput nounput noyywrap never-interactive bison-bridge bison-locations
+
+%{
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "no_union.h"
+
+%}
+
+NUMBER [0-9]+
+
+%%
+
+{NUMBER} {
+    ((void) yylloc);
+    *yylval = atoi(yytext);
+    return NUMBER;
+}
+
+[+\-] {
+    return yytext[0];
+}
+
+[\n|\r\n] {
+    return(YYEOF);
+}
+
+[[:space:]] {}
+
+<<EOF>> {
+    return(YYEOF);
+}
+
+. {
+    fprintf(stderr, "Illegal character '%s'\n", yytext);
+    return(YYEOF);
+}
+
+%%

spec/fixtures/integration/no_union.l

@@ -0,0 +1,49 @@
+/*
+ * Integration test for parser without %union directive
+ * This test verifies that lrama can generate parsers without %union,
+ * just like Bison does (YYSTYPE defaults to int).
+ */
+
+%{
+#include <stdio.h>
+#include "no_union.h"
+#include "no_union-lexer.h"
+
+static int yyerror(YYLTYPE *loc, const char *str);
+%}
+
+%token NUMBER
+
+%locations
+
+%%
+
+program: /* empty */
+       | expr { printf("=> %d\n", $1); }
+       ;
+
+expr: NUMBER
+    | expr '+' NUMBER { $$ = $1 + $3; }
+    | expr '-' NUMBER { $$ = $1 - $3; }
+    ;
+
+%%
+
+static int yyerror(YYLTYPE *loc, const char *str)
+{
+  fprintf(stderr, "%d.%d-%d.%d: %s\n", loc->first_line, loc->first_column, loc->last_line, loc->last_column, str);
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+  if (argc == 2) {
+    yy_scan_string(argv[1]);
+  }
+
+  if (yyparse()) {
+    fprintf(stderr, "syntax error\n");
+    return 1;
+  }
+  return 0;
+}

spec/fixtures/integration/no_union.y

@@ -70,6 +70,12 @@ def generate_object(grammar_file_path, c_path, obj_path, command_args: [])
     end
   end
 
+  describe "parser without %union (YYSTYPE defaults to int)" do
+    it "returns 6 for '1 + 2 + 3'" do
+      test_parser("no_union", "1 + 2 + 3", "=> 6\n")
+    end
+  end
+
   it "prologue and epilogue are optional" do
     test_parser("prologue_epilogue_optional", "", "")
   end

spec/lrama/integration_spec.rb

@@ -117,6 +117,37 @@
   end
 
   describe '#parse' do
+    it "no_union" do
+      path = "common/no_union.y"
+      y = File.read(fixture_path(path))
+      grammar = Lrama::Parser.new(y, path).parse
+      grammar.prepare
+      grammar.validate!
+
+      expect(grammar.union).to be_nil
+      expect(grammar.nterms.sort_by(&:number)).to match_symbols([
+        Sym.new(id: T::Ident.new(s_value: "$accept"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 0, nullable: false),
+        Sym.new(id: T::Ident.new(s_value: "program"), alias_name: nil, number: 7, tag: nil, term: false, token_id: 1, nullable: false),
+        Sym.new(id: T::Ident.new(s_value: "expr"), alias_name: nil, number: 8, tag: nil, term: false, token_id: 2, nullable: false),
+      ])
+    end
+
+    it "no_union_with_type" do
+      path = "common/no_union_with_type.y"
+      y = File.read(fixture_path(path))
+      grammar = Lrama::Parser.new(y, path).parse
+      grammar.prepare
+      grammar.validate!
+
+      expect(grammar.union).to be_nil
+      expect(grammar.nterms.sort_by(&:number)).to match_symbols([
+        Sym.new(id: T::Ident.new(s_value: "$accept"), alias_name: nil, number: 6, tag: nil, term: false, token_id: 0, nullable: false),
+        Sym.new(id: T::Ident.new(s_value: "program"), alias_name: nil, number: 7, tag: nil, term: false, token_id: 1, nullable: false),
+        Sym.new(id: T::Ident.new(s_value: "expr"), alias_name: nil, number: 8, tag: T::Tag.new(s_value: "<val>"), term: false, token_id: 2, nullable: false),
+      ])
+      expect(grammar.terms.find {|t| t.id.s_value == "NUMBER" }.tag).to eq(T::Tag.new(s_value: "<val>"))
+    end
+
     it "basic" do
       path = "common/basic.y"
       y = File.read(fixture_path(path))