ibex 0.1.0 → 0.2.0

data/lib/ibex/codegen/ruby_actions.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "action_method_source"
+require_relative "ruby_ast"
+
+module Ibex
+  module Codegen
+    # Semantic-action method generation shared by direct and source-mapped
+    # Ruby output.
+    module RubyActions
+      include RubyAST
+
+      # @rbs @grammar: IR::Grammar
+      # @rbs @line_convert: bool
+      # @rbs @omit_action_call: bool
+      # @rbs @action_method_source: ActionMethodSource?
+
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_actions(lines)
+        @grammar.productions.each do |production|
+          next unless action_method?(production)
+
+          if production.node
+            source = ast_node_action_source(production)
+            source.lines.each { |line| lines << "  #{line.rstrip}" }
+            lines << ""
+          elsif composed_action?(production)
+            append_composed_action_method(lines, production)
+          elsif production.action && @line_convert
+            append_compiled_action_method(lines, production)
+          else
+            append_action_method(lines, production)
+          end
+        end
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_composed_action_method(lines, production)
+        action = production.action || raise(Ibex::Error, "missing composed semantic action")
+        plan = action.composition&.dig(:plan) || raise(Ibex::Error, "missing action composition plan")
+        steps = plan.fetch(:steps)
+        steps.each_with_index do |step, index|
+          append_composed_fragment_method(lines, production, step, index) if step[:code]
+        end
+        append_composed_orchestrator(lines, production, plan)
+      end
+
+      # @rbs (Array[String] lines, IR::Production production, Hash[Symbol, untyped] step, Integer index) -> void
+      def append_composed_fragment_method(lines, production, step, index)
+        source = action_method_source.composed_fragment_method_source(production, step, index)
+        if @line_convert
+          location = step.fetch(:loc)
+          lines << "  class_eval(#{source.dump}, #{location[:file].inspect}, #{location[:line]})"
+        elsif action_method_source.column_sensitive?(step.fetch(:code))
+          lines << source
+        else
+          source.lines.each { |line| lines << "  #{line.rstrip}" }
+        end
+        lines << ""
+      end
+
+      # @rbs (IR::Production production, Integer index) -> String
+      def composed_fragment_name(production, index)
+        action_method_source.composed_fragment_name(production, index)
+      end
+
+      # @rbs (Array[String] lines, IR::Production production, Hash[Symbol, untyped] plan) -> void
+      def append_composed_orchestrator(lines, production, plan)
+        lines << "  private def _ibex_action_#{production.id}" \
+                 "(val, _values, _ibex_locations, _ibex_location_stack, _ibex_location, " \
+                 "_ibex_lookahead_location)"
+        lines << "    _ibex_composed_values = val.dup"
+        lines << "    _ibex_composed_locations = _ibex_locations.dup"
+        plan.fetch(:steps).each_with_index do |step, index|
+          append_composed_step(lines, production, step, index)
+        end
+        lines.push("    _ibex_composed_values.last", "  end", "")
+      end
+
+      # @rbs (Array[String] lines, IR::Production production, Hash[Symbol, untyped] step, Integer index) -> void
+      def append_composed_step(lines, production, step, index)
+        inputs = step.fetch(:inputs)
+        lines << "    _ibex_step_values = _ibex_composed_values.values_at(#{inputs.join(', ')})"
+        lines << "    _ibex_step_locations = _ibex_composed_locations.values_at(#{inputs.join(', ')})"
+        lookahead = step[:lookahead]
+        boundary = lookahead ? "_ibex_locations[#{lookahead}]" : "_ibex_lookahead_location"
+        lines << "    _ibex_step_location = Ibex::Runtime::LocationSpan.for_reduction(" \
+                 "_ibex_step_locations, lookahead: #{boundary})"
+        result = if step[:code]
+                   stack_inputs = step.fetch(:stack_inputs)
+                   "#{composed_fragment_name(production, index)}(" \
+                     "_ibex_step_values, _values + _ibex_composed_values.values_at(#{stack_inputs.join(', ')}), " \
+                     "_ibex_step_locations, _ibex_location_stack + " \
+                     "_ibex_composed_locations.values_at(#{stack_inputs.join(', ')}), _ibex_step_location)"
+                 else
+                   "_ibex_step_values[0]"
+                 end
+        lines << "    _ibex_composed_values << #{result}"
+        lines << "    _ibex_composed_locations << _ibex_step_location"
+        lines << "    return _ibex_composed_values.last if @accept_requested || @semantic_error"
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_compiled_action_method(lines, production)
+        action = production.action || raise(Ibex::Error, "missing semantic action")
+        source = action_method_source.compiled_action_method_source(production)
+        lines << "  class_eval(#{source.dump}, #{action.location[:file].inspect}, #{action.location[:line]})"
+        lines << ""
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_action_method(lines, production)
+        source = action_method_source.direct_action_method_source(production)
+        if production.action && action_method_source.column_sensitive?(production.action.code)
+          lines << source
+        else
+          source.lines.each { |line| lines << "  #{line.rstrip}" }
+        end
+        lines << ""
+      end
+
+      # @rbs (IR::Production production) -> bool
+      def action_method?(production)
+        !!(production.node || production.action || !@omit_action_call)
+      end
+
+      # @rbs (IR::Production production) -> bool
+      def composed_action?(production)
+        production.action&.composition&.dig(:plan, :version) == 1
+      end
+
+      # @rbs () -> ActionMethodSource
+      def action_method_source
+        @action_method_source ||= ActionMethodSource.new(
+          @grammar, generated_action_abi: @generated_action_abi
+        )
+      end
+    end
+  end
+end

data/lib/ibex/codegen/ruby_ast.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Codegen
+    # Generates typed AST data classes and traversal bases from @node metadata.
+    module RubyAST
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_ast(lines)
+        definitions = ast_node_definitions
+        return if definitions.empty?
+
+        lines << "  module AST"
+        definitions.each_value do |node|
+          members = node.fetch(:fields).map { |field| ":#{field}" }.join(", ")
+          lines << "    #{node.fetch(:name)} = Ibex::Runtime::ASTData.define(#{members})"
+        end
+        lines << ""
+        append_visitor(lines, definitions)
+        lines << ""
+        append_listener(lines, definitions)
+        lines.push("  end", "")
+      end
+
+      # @rbs () -> Hash[String, IR::node_annotation]
+      def ast_node_definitions
+        @grammar.productions.filter_map(&:node).to_h { |node| [node.fetch(:name), node] }
+      end
+
+      # @rbs (Array[String] lines, Hash[String, IR::node_annotation] definitions) -> void
+      def append_visitor(lines, definitions)
+        lines.push("    class Visitor", "      def visit(node)", "        case node")
+        definitions.each_value do |node|
+          lines << "        when #{node.fetch(:name)} then visit_#{ast_method_name(node.fetch(:name))}(node)"
+        end
+        lines.push("        else visit_children(node)", "        end", "      end", "")
+        definitions.each_value do |node|
+          method = ast_method_name(node.fetch(:name))
+          lines.push("      def visit_#{method}(node)", "        visit_children(node)", "      end", "")
+        end
+        append_visit_children(lines)
+        lines << "    end"
+      end
+
+      # @rbs (Array[String] lines) -> void
+      def append_visit_children(lines)
+        lines.push(
+          "      def visit_children(node)",
+          "        children = if node.is_a?(Array)",
+          "                     node",
+          "                   elsif node.respond_to?(:deconstruct)",
+          "                     node.deconstruct",
+          "                   else",
+          "                     []",
+          "                   end",
+          "        children.each { |child| visit(child) }",
+          "        node",
+          "      end"
+        )
+      end
+
+      # @rbs (Array[String] lines, Hash[String, IR::node_annotation] definitions) -> void
+      def append_listener(lines, definitions)
+        lines.push("    class Listener", "      def walk(node)", "        enter(node)",
+                   "        listener_children(node).each { |child| walk(child) }", "        exit(node)", "        node",
+                   "      end", "")
+        append_listener_dispatch(lines, definitions, :enter)
+        lines << ""
+        append_listener_dispatch(lines, definitions, :exit)
+        lines << ""
+        definitions.each_value do |node|
+          method = ast_method_name(node.fetch(:name))
+          lines.push("      def enter_#{method}(_node); end", "      def exit_#{method}(_node); end")
+        end
+        lines << ""
+        lines.push(
+          "      def listener_children(node)",
+          "        return node if node.is_a?(Array)",
+          "        return node.deconstruct if node.respond_to?(:deconstruct)",
+          "",
+          "        []",
+          "      end",
+          "    end"
+        )
+      end
+
+      # @rbs (Array[String] lines, Hash[String, IR::node_annotation] definitions, :enter | :exit kind) -> void
+      def append_listener_dispatch(lines, definitions, kind)
+        lines.push("      def #{kind}(node)", "        case node")
+        definitions.each_value do |node|
+          method = ast_method_name(node.fetch(:name))
+          lines << "        when #{node.fetch(:name)} then #{kind}_#{method}(node)"
+        end
+        lines.push("        end", "      end")
+      end
+
+      # @rbs (IR::Production production) -> String
+      def ast_node_action_source(production)
+        node = production.node || raise(Ibex::Error, "missing AST node metadata")
+        parameters = node.fetch(:fields).each_index.map { |index| "v#{index}" }
+        arguments = node.fetch(:fields).each_index.map do |index|
+          "#{node.fetch(:fields).fetch(index)}: v#{index}"
+        end
+        [
+          "private def _ibex_action_#{production.id}(#{parameters.join(', ')})",
+          "  AST::#{node.fetch(:name)}.new(#{arguments.join(', ')})",
+          "end"
+        ].join("\n")
+      end
+
+      # @rbs (String name) -> String
+      def ast_method_name(name)
+        name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+      end
+    end
+  end
+end

data/lib/ibex/codegen/ruby_error_messages.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ibex
+  module Codegen
+    # Serializes immutable example-keyed error records into generated Ruby.
+    module RubyErrorMessages
+      private
+
+      # @rbs () -> String
+      def error_messages_literal
+        # @type self: Ruby
+        return "{}" if @error_messages.empty?
+
+        entries = @error_messages.map { |state, message| "#{state} => #{error_message_literal(message)}" }
+        "{ #{entries.join(', ')} }"
+      end
+
+      # @rbs (String | { id: String, message: String } message) -> String
+      def error_message_literal(message)
+        return message.inspect unless message.is_a?(Hash)
+
+        error_id = message.fetch(:id)
+        text = message.fetch(:message)
+        "{ id: #{error_id.inspect}, message: #{text.inspect} }.freeze"
+      end
+    end
+  end
+end

data/lib/ibex/codegen/ruby_lexer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Codegen
+    # Generated lexer tables and action methods.
+    module RubyLexer
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_lexer(lines)
+        # @type self: Ruby
+        lexer = @grammar.lexer
+        return unless lexer
+
+        lines << "  include Ibex::Runtime::GeneratedLexer"
+        lines << "  LEXER_STATES = #{lexer.states.inspect}.freeze"
+        append_lexer_rules(lines, lexer)
+        append_lexer_actions(lines, lexer)
+      end
+
+      # @rbs (Array[String] lines, IR::Lexer lexer) -> void
+      def append_lexer_rules(lines, lexer)
+        # @type self: Ruby
+        by_state = lexer.states.to_h do |state|
+          rules = lexer.rules.select { |rule| rule.state == state }.map { |rule| lexer_rule_literal(rule) }
+          [state.to_sym, "[#{rules.join(', ')}].freeze"]
+        end
+        source = by_state.map { |state, rules| "#{state.inspect} => #{rules}" }.join(", ")
+        lines << "  LEXER_RULES_BY_STATE = { #{source} }.freeze"
+        lines << ""
+      end
+
+      # @rbs (IR::LexerRule rule) -> String
+      def lexer_rule_literal(rule)
+        # @type self: Ruby
+        flags = 0
+        flags |= Regexp::IGNORECASE if rule.options.include?("i")
+        flags |= Regexp::MULTILINE if rule.options.include?("m")
+        flags |= Regexp::EXTENDED if rule.options.include?("x")
+        action = rule.action ? ":_ibex_lexer_action_#{rule.id}" : "nil"
+        terminal = rule.token && @grammar.symbol(rule.token)
+        token = terminal ? external_token_expression(terminal) : "nil"
+        regexp = "Regexp.new(#{"\\A(?:#{rule.pattern})".dump}, #{flags}).freeze"
+        "{ id: #{rule.id}, kind: #{rule.kind.inspect}, token: #{token}, " \
+          "regexp: #{regexp}, action: #{action} }.freeze"
+      end
+
+      # @rbs (Array[String] lines, IR::Lexer lexer) -> void
+      def append_lexer_actions(lines, lexer)
+        # @type self: Ruby
+        lexer.rules.each do |rule|
+          next unless rule.action
+
+          source = lexer_action_source(rule)
+          if @line_convert
+            location = rule.location
+            lines << "  class_eval(#{source.dump}, #{location[:file].inspect}, #{location[:line]})"
+          else
+            source.lines.each { |line| lines << "  #{line.rstrip}" }
+          end
+          lines << ""
+        end
+      end
+
+      # @rbs (IR::LexerRule rule) -> String
+      def lexer_action_source(rule)
+        action = rule.action || ""
+        binding = nil #: String?
+        if (match = action.match(/\A\s*\|([a-z_][a-zA-Z0-9_]*)\|\s*(.*)\z/m))
+          parameter = match[1] || "s"
+          binding = "#{parameter} = _ibex_lexeme"
+          action = match[2] || ""
+        end
+        lines = ["private def _ibex_lexer_action_#{rule.id}(_ibex_lexeme)"]
+        lines << "  #{binding}" if binding
+        lines << "  #{action}"
+        lines << "end"
+        "#{lines.join("\n")}\n"
+      end
+    end
+  end
+end

data/lib/ibex/codegen/ruby_syntax.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Codegen
+    # Generates typed Red syntax views from @node metadata.
+    module RubySyntax
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_syntax(lines)
+        # @type self: Ruby
+        definitions = syntax_node_definitions
+        return if definitions.empty? || !cst?
+
+        lines << "  module Syntax"
+        definitions.each_value { |definition| append_syntax_node(lines, definition) }
+        lines.push("  end", "")
+      end
+
+      # @rbs () -> Hash[String, Hash[Symbol, untyped]]
+      def syntax_node_definitions
+        # @type self: Ruby
+        slots = cst_metadata.fetch(:slots)
+        definitions = {} #: Hash[String, Hash[Symbol, untyped]]
+        @grammar.productions.each do |production|
+          node = production.node
+          next unless node
+
+          slot = slots.fetch(production.id)
+          name = node.fetch(:name)
+          previous = definitions[name]
+          fields = previous ? merge_syntax_fields(previous.fetch(:fields), slot.fetch(:fields)) : slot.fetch(:fields)
+          definitions[name] = { name: name, kind: slot.fetch(:node_kind), fields: fields }.freeze
+        end
+        definitions
+      end
+
+      # @rbs (Hash[String, untyped] left, Hash[String, untyped] right) -> Hash[String, untyped]
+      def merge_syntax_fields(left, right)
+        left.to_h do |name, left_slot|
+          right_slot = right.fetch(name)
+          left_index = left_slot.is_a?(Hash) ? left_slot.fetch(:index) : left_slot
+          right_index = right_slot.is_a?(Hash) ? right_slot.fetch(:index) : right_slot
+          raise Ibex::Error, "inconsistent CST slot for #{name}" unless left_index == right_index
+
+          [name, left_slot == right_slot ? left_slot : left_index]
+        end.freeze
+      end
+
+      # @rbs (Array[String] lines, Hash[Symbol, untyped] definition) -> void
+      def append_syntax_node(lines, definition)
+        name = definition.fetch(:name)
+        fields = definition.fetch(:fields)
+        lines.push(
+          "    class #{name} < Ibex::Runtime::CST::TypedNode",
+          "      KIND = #{definition.fetch(:kind)}",
+          "      def self.cast(node) = node.kind == KIND ? new(node) : nil"
+        )
+        fields.each do |field, slot|
+          index = slot.is_a?(Hash) ? slot.fetch(:index) : slot
+          lines << "      def #{field} = child_at_slot(#{index})"
+        end
+        append_repetition_accessors(lines, fields)
+        lines.push("    end", "")
+      end
+
+      # @rbs (Array[String] lines, Hash[String, untyped] fields) -> void
+      def append_repetition_accessors(lines, fields)
+        repeated = fields.select { |_field, slot| slot.is_a?(Hash) && slot[:extraction] }
+        repeated.each do |field, slot|
+          index = slot.fetch(:index)
+          separated = slot.fetch(:extraction) == :separated_list
+          lines << "      def each_#{field}_element = list_items(#{index}, separated: #{separated})"
+          next unless separated
+
+          method = "each_#{field}_separator"
+          lines << "      def #{method} = list_items(#{index}, separated: true, separators: true)"
+        end
+        return unless repeated.one?
+
+        field, slot = repeated.first
+        lines << "      alias each_element each_#{field}_element"
+        return unless slot.fetch(:extraction) == :separated_list
+
+        lines << "      alias each_separator each_#{field}_separator"
+      end
+    end
+  end
+end

data/lib/ibex/codegen/ruby_table_metadata.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Codegen
+    # Emits immutable identity and size metadata for generated parser tables.
+    module RubyTableMetadata
+      # @rbs @automaton: IR::Automaton
+      # @rbs @grammar: IR::Grammar
+
+      private
+
+      # @rbs (Array[String] lines, String indent) -> void
+      def append_table_metadata(lines, indent)
+        lines << "#{indent}PARSER_TABLE_FORMAT_VERSION = #{Runtime::PARSER_TABLE_FORMAT_VERSION}"
+        lines << "#{indent}GRAMMAR_DIGEST = #{@automaton.grammar_digest.inspect}.freeze"
+        lines << "#{indent}STATE_COUNT = #{@automaton.states.length}"
+        lines << "#{indent}PRODUCTION_COUNT = #{@grammar.productions.length}"
+        return unless @grammar.starts.length > 1
+
+        entries = @automaton.entry_states.map { |name, state| "#{name.to_sym.inspect} => #{state}" }
+        lines << "#{indent}ENTRY_STATES = { #{entries.join(', ')} }.freeze"
+      end
+
+      # @rbs (Array[String] lines) -> void
+      def append_entry_methods(lines)
+        return unless @grammar.starts.length > 1
+
+        @grammar.starts.each do |name|
+          lines << "  def parse_#{name}"
+          lines << "    drive_parser(-> { next_token }, initial_state: ENTRY_STATES.fetch(:#{name}))"
+          lines << "  end"
+          lines << ""
+        end
+      end
+
+      # @rbs () -> String
+      def entry_table_fields
+        return "" unless @grammar.starts.length > 1
+
+        " initial_state: ENTRY_STATES.fetch(:#{@grammar.start}), entry_states: ENTRY_STATES,"
+      end
+
+      # @rbs () -> String
+      def recovery_table_fields
+        names = @grammar.recovery[:sync_tokens]
+        return "" if names.empty?
+
+        ids = names.map do |name|
+          symbol = @grammar.symbol(name) || raise(Ibex::Error, "missing recovery sync token #{name}")
+          symbol.id
+        end
+        " recovery_sync_tokens: #{ids.inspect}.freeze,"
+      end
+    end
+  end
+end

data/lib/ibex/codegen/ruby_value_printers.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Codegen
+    # Emits declarative value-printer tables and methods for Ruby parsers.
+    module RubyValuePrinters
+      # @rbs @grammar: IR::Grammar
+      # @rbs @line_convert: bool
+      # @rbs @value_printer_action_method_source: ActionMethodSource?
+
+      private
+
+      # @rbs (Array[String] lines, String indent) -> void
+      def append_value_printer_table(lines, indent)
+        return if @grammar.value_printers.empty?
+
+        entries = @grammar.value_printers.map do |printer|
+          symbol = @grammar.symbol(printer[:symbol]) ||
+                   raise(Ibex::Error, "missing printer symbol #{printer[:symbol]}")
+          "#{symbol.id} => :_ibex_value_printer_#{symbol.id}"
+        end
+        lines << "#{indent}VALUE_PRINTERS = { #{entries.join(', ')} }.freeze"
+      end
+
+      # @rbs (Array[String] lines) -> void
+      def append_value_printers(lines)
+        @grammar.value_printers.each do |printer|
+          append_value_printer(lines, printer)
+          lines << ""
+        end
+      end
+
+      # @rbs (Array[String] lines, IR::value_printer printer) -> void
+      def append_value_printer(lines, printer)
+        symbol = @grammar.symbol(printer[:symbol]) ||
+                 raise(Ibex::Error, "missing printer symbol #{printer[:symbol]}")
+        source_builder = value_printer_action_method_source
+        source = source_builder.value_printer_method_source(symbol.id, printer)
+        if @line_convert
+          location = printer[:loc]
+          lines << "  class_eval(#{source.dump}, #{location[:file].inspect}, #{location[:line]})"
+        elsif source_builder.column_sensitive?(printer[:code])
+          lines << source
+        else
+          source.lines.each { |line| lines << "  #{line.rstrip}" }
+        end
+      end
+
+      # @rbs () -> ActionMethodSource
+      def value_printer_action_method_source
+        @value_printer_action_method_source ||= ActionMethodSource.new(@grammar)
+      end
+    end
+  end
+end

data/lib/ibex/codegen/symbol_labels.rb

@@ -6,7 +6,7 @@ module Ibex
     module SymbolLabels
       # @rbs (IR::Grammar grammar) -> Hash[Integer, String]
       def self.build(grammar)
-        labels = grammar.symbols.to_h { |symbol| [symbol.id, symbol.name] }
+        labels = grammar.symbols.to_h { |symbol| [symbol.id, symbol.display_name || symbol.name] }
         grammar.productions.each do |production|
           expression = production.origin[:expression]
           labels[production.lhs] = expression if expression.is_a?(String)