ibex 0.1.0

data/lib/ibex/codegen/report.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "symbol_labels"
+
+module Ibex
+  module Codegen
+    # Renders a human-readable state and conflict report from Automaton IR.
+    module Report
+      # @rbs!
+      #   private def append_state: (
+      #     Array[String] lines,
+      #     IR::AutomatonState state,
+      #     IR::Grammar grammar,
+      #     Array[IR::counterexample] examples,
+      #     Hash[Integer, String] labels
+      #   ) -> void
+      #   private def self.append_state: (
+      #     Array[String] lines,
+      #     IR::AutomatonState state,
+      #     IR::Grammar grammar,
+      #     Array[IR::counterexample] examples,
+      #     Hash[Integer, String] labels
+      #   ) -> void
+      #   private def append_counterexample: (Array[String] lines, IR::counterexample example, IR::Grammar grammar,
+      #     Hash[Integer, String] labels) -> void
+      #   private def self.append_counterexample: (Array[String] lines, IR::counterexample example, IR::Grammar grammar,
+      #     Hash[Integer, String] labels) -> void
+      #   private def append_tree: (Array[String] lines, untyped tree, String indentation, IR::Grammar grammar,
+      #     Hash[Integer, String] labels) -> void
+      #   private def self.append_tree: (Array[String] lines, untyped tree, String indentation, IR::Grammar grammar,
+      #     Hash[Integer, String] labels) -> void
+      #   private def format_item: (IR::AutomatonItem item, IR::Grammar grammar, Hash[Integer, String] labels) -> String
+      #   private def self.format_item: (IR::AutomatonItem item, IR::Grammar grammar,
+      #     Hash[Integer, String] labels) -> String
+      #   private def format_action: (IR::parser_action action) -> String
+      #   private def self.format_action: (IR::parser_action action) -> String
+      #   private def symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+      #   private def self.symbol_name: (Hash[Integer, String] labels, Integer id) -> String
+      #   private def tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
+      #   private def self.tree_label: (IR::Grammar grammar, Hash[Integer, String] labels, untyped value) -> untyped
+
+      # @rbs (IR::Automaton automaton, ?max_tokens: Integer, ?max_configurations: Integer) -> String
+      def render(automaton, max_tokens: LALR::Counterexample::DEFAULT_MAX_TOKENS,
+                 max_configurations: LALR::Counterexample::DEFAULT_MAX_CONFIGURATIONS)
+        grammar = automaton.grammar
+        labels = SymbolLabels.build(grammar)
+        lines = ["Algorithm: #{automaton.algorithm}", "States: #{automaton.states.length}", ""]
+        examples = LALR::Counterexample.new(
+          automaton, max_tokens: max_tokens, max_configurations: max_configurations
+        ).all.group_by { |example| example[:state] }
+        automaton.states.each do |state|
+          append_state(lines, state, grammar, examples.fetch(state.id, Array.new(0)), labels)
+        end
+        summary = automaton.conflict_summary
+        lines << "Conflicts: #{summary[:sr]} shift/reduce, #{summary[:rr]} reduce/reduce"
+        "#{lines.join("\n")}\n"
+      end
+      module_function :render
+
+      # @rbs skip
+      private
+
+      # @rbs skip
+      def append_state(lines, state, grammar, examples, labels)
+        lines << "State #{state.id}"
+        state.items.each { |item| lines << "  #{format_item(item, grammar, labels)}" }
+        state.actions.each do |token_id, action|
+          lines << "  on #{symbol_name(labels, token_id)}: #{format_action(action)}"
+        end
+        lines << "  default: #{format_action(state.default_action)}" if state.default_action
+        state.gotos.each { |symbol_id, target| lines << "  goto #{symbol_name(labels, symbol_id)}: #{target}" }
+        state.conflicts.each { |conflict| lines << "  conflict: #{conflict.inspect}" }
+        examples.each { |example| append_counterexample(lines, example, grammar, labels) }
+        lines << ""
+      end
+
+      # @rbs skip
+      def append_counterexample(lines, example, grammar, labels)
+        label = example[:unifying] ? "unifying counterexample" : "nonunifying witness"
+        sentence = example[:sentence].dup.insert(example[:lookahead_index], "•").join(" ")
+        lines << "  #{label}: #{sentence}"
+        example[:interpretations].each do |interpretation|
+          lines << "    #{interpretation[:kind]} derivation:"
+          append_tree(lines, interpretation[:tree], "      ", grammar, labels)
+        end
+      end
+
+      # @rbs skip
+      def append_tree(lines, tree, indentation, grammar, labels)
+        unless tree.is_a?(Hash)
+          lines << "#{indentation}#{tree_label(grammar, labels, tree)}"
+          return
+        end
+
+        symbol = tree_label(grammar, labels, tree[:symbol] || tree[:token])
+        unless tree[:children]
+          lines << "#{indentation}#{symbol}"
+          return
+        end
+
+        production = tree[:production] ? " (production #{tree[:production]})" : ""
+        lines << "#{indentation}#{symbol}#{production}"
+        tree[:children].each { |child| append_tree(lines, child, "#{indentation}  ", grammar, labels) }
+      end
+
+      # @rbs skip
+      def format_item(item, grammar, labels)
+        if item.production == LALR::Builder::AUGMENTED_PRODUCTION
+          rhs = [grammar.start]
+          lhs = "$accept"
+        else
+          production = grammar.productions.fetch(item.production)
+          rhs = production.rhs.map { |id| symbol_name(labels, id) }
+          lhs = symbol_name(labels, production.lhs)
+        end
+        rhs = rhs.dup.insert(item.dot, "•")
+        lookaheads = item.lookaheads.map { |id| symbol_name(labels, id) }.join(", ")
+        "#{lhs} -> #{rhs.join(' ')} [#{lookaheads}]"
+      end
+
+      # @rbs skip
+      def format_action(action)
+        case action[:type]
+        when :shift then "shift #{action[:state]}"
+        when :reduce then "reduce #{action[:production]}"
+        else action[:type].to_s
+        end
+      end
+
+      # @rbs skip
+      def symbol_name(labels, id)
+        labels.fetch(id) { raise Ibex::Error, "missing grammar symbol id #{id}" }
+      end
+
+      # @rbs skip
+      def tree_label(grammar, labels, value)
+        symbol = grammar.symbol(value.to_s)
+        symbol ? symbol_name(labels, symbol.id) : value
+      end
+      module_function :append_state, :append_counterexample, :append_tree, :format_item, :format_action, :symbol_name,
+                      :tree_label
+
+      class << self
+        private :append_state, :append_counterexample, :append_tree, :format_item, :format_action, :symbol_name,
+                :tree_label
+      end
+    end
+  end
+end

data/lib/ibex/codegen/ruby.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require_relative "../runtime/parser"
+
+module Ibex
+  module Codegen
+    # Generates a standalone Ruby parser class from Automaton IR.
+    class Ruby
+      # @rbs @automaton: IR::Automaton
+      # @rbs @grammar: IR::Grammar
+      # @rbs @table_format: Symbol
+      # @rbs @embedded: bool
+      # @rbs @line_convert: bool
+      # @rbs @line_convert_all: bool
+      # @rbs @debug: bool
+      # @rbs @omit_action_call: bool
+      # @rbs @superclass: String
+      # @rbs @executable: String?
+
+      # @rbs (IR::Automaton automaton, ?table: Symbol | String, ?embedded: bool, ?line_convert: bool,
+      #   ?line_convert_all: bool, ?debug: bool, ?omit_action_call: bool?, ?superclass: String?,
+      #   ?executable: String?) -> void
+      def initialize(automaton, table: :compact, embedded: false, line_convert: true, debug: false,
+                     line_convert_all: false, omit_action_call: nil, superclass: nil, executable: nil)
+        @automaton = automaton
+        @grammar = automaton.grammar
+        @table_format = table.to_sym
+        @embedded = embedded
+        @line_convert = line_convert
+        @line_convert_all = line_convert_all
+        @debug = debug
+        @omit_action_call = omit_action_call.nil? ? @grammar.options[:omit_action_call] : omit_action_call
+        @superclass = superclass || @grammar.superclass || "Ibex::Runtime::Parser"
+        @executable = executable
+      end
+
+      # @rbs () -> String
+      def generate
+        lines = [] #: Array[String]
+        lines << "#!#{@executable}" if @executable
+        lines.push("# frozen_string_literal: true", "# Generated by Ibex #{grammar_digest_comment}", "")
+        append_user_code(lines, "header")
+        append_runtime(lines)
+        modules, class_name = class_parts
+        modules.each { |name| lines << "module #{name}" }
+        lines << "class #{class_name} < #{@superclass}"
+        append_tables(lines)
+        append_actions(lines)
+        append_user_code(lines, "inner", indent: 2)
+        lines << "end"
+        modules.reverse_each { lines << "end" }
+        append_user_code(lines, "footer")
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_runtime(lines)
+        if @embedded
+          lines << embedded_source("../runtime/parser.rb")
+          lines << embedded_source("../../ibex/tables.rb")
+        else
+          lines << 'require "ibex/runtime"'
+          lines << 'require "ibex/tables"' if @table_format == :compact
+        end
+        lines << ""
+      end
+
+      # @rbs (String relative_path) -> String
+      def embedded_source(relative_path)
+        path = File.expand_path(relative_path, File.dirname(__FILE__))
+        File.read(path).lines.reject { |line| line.start_with?("# frozen_string_literal:") }.join.rstrip
+      end
+
+      # @rbs (Array[String] lines) -> void
+      def append_tables(lines)
+        table_set = Tables.build(@automaton, format: @table_format)
+        indent = "  "
+        lines << "#{indent}PARSER_TABLE_FORMAT_VERSION = #{Runtime::PARSER_TABLE_FORMAT_VERSION}"
+        lines << "#{indent}TOKEN_IDS = #{token_ids_literal}.freeze"
+        lines << "#{indent}TOKEN_NAMES = #{token_names_literal}.freeze"
+        lines << "#{indent}ACTIONS = #{table_literal(table_set.actions)}"
+        lines << "#{indent}GOTOS = #{table_literal(table_set.gotos)}"
+        lines << "#{indent}DEFAULT_ACTIONS = #{table_set.default_actions.inspect}.freeze"
+        lines << "#{indent}PRODUCTIONS = #{productions_literal}.freeze"
+        lines << "#{indent}PARSER_TABLES = { format_version: PARSER_TABLE_FORMAT_VERSION,"
+        lines << "#{indent}                  tokens: TOKEN_IDS, token_names: TOKEN_NAMES, actions: ACTIONS,"
+        lines << "#{indent}                  gotos: GOTOS, default_actions: DEFAULT_ACTIONS,"
+        lines << "#{indent}                  productions: PRODUCTIONS }.freeze"
+        lines << "#{indent}def self.parser_tables = PARSER_TABLES"
+        lines << "#{indent}DEBUG_ENABLED = #{@debug}"
+        lines << ""
+      end
+
+      # @rbs (untyped table) -> String
+      def table_literal(table)
+        return "#{table.inspect}.freeze" unless table.is_a?(Tables::Compact)
+
+        "Ibex::Tables::Compact.new(offsets: #{table.offsets.inspect}, values: #{table.values.inspect}, " \
+          "checks: #{table.checks.inspect}, row_count: #{table.row_count})"
+      end
+
+      # @rbs () -> String
+      def token_ids_literal
+        pairs = @grammar.terminals.filter_map do |terminal|
+          next if terminal.id.zero? || terminal.name == "error"
+
+          "#{external_token_expression(terminal)} => #{terminal.id}"
+        end
+        "{ #{pairs.join(', ')} }"
+      end
+
+      # @rbs (IR::GrammarSymbol terminal) -> String
+      def external_token_expression(terminal)
+        conversion = @grammar.conversions[terminal.name]
+        return "(#{conversion})" if conversion
+        return terminal.name if terminal.name.start_with?("'", '"')
+
+        ":#{terminal.name}"
+      end
+
+      # @rbs () -> String
+      def token_names_literal
+        entries = @grammar.terminals.map { |terminal| "#{terminal.id} => #{terminal.name.inspect}" }
+        "{ #{entries.join(', ')} }"
+      end
+
+      # @rbs () -> String
+      def productions_literal
+        entries = @grammar.productions.map do |production|
+          action = action_method?(production) ? ":_ibex_action_#{production.id}" : "nil"
+          "{ lhs: #{production.lhs}, length: #{production.rhs.length}, action: #{action} }"
+        end
+        "[#{entries.join(', ')}]"
+      end
+
+      # @rbs (Array[String] lines) -> void
+      def append_actions(lines)
+        @grammar.productions.each do |production|
+          next unless action_method?(production)
+
+          append_action_constant(lines, production)
+          append_action_method(lines, production)
+        end
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_action_constant(lines, production)
+        return unless production.action && @line_convert
+
+        lines << "  ACTION_CODE_#{production.id} = #{production.action.code.inspect}.freeze"
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_action_method(lines, production)
+        action = production.action
+        lines << "  private def _ibex_action_#{production.id}(val, _values)"
+        lines << "    val = _values.last(#{action.context_length})" if action&.context_length&.positive?
+        append_named_bindings(lines, action)
+        if action
+          append_semantic_code(lines, production)
+        else
+          lines << "    val[0]"
+        end
+        lines << "  end"
+        lines << ""
+      end
+
+      # @rbs (Array[String] lines, IR::Action? action) -> void
+      def append_named_bindings(lines, action)
+        return unless action&.named_refs&.any?
+
+        action.named_refs.each { |reference| lines << "    #{reference[:name]} = val[#{reference[:index]}]" }
+        names = action.named_refs.map { |reference| reference[:name] }
+        lines << "    _ibex_named_values = [#{names.join(', ')}]"
+      end
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_semantic_code(lines, production)
+        action = production.action || raise(Ibex::Error, "missing semantic action")
+        lines << "    result = val[0]" if @grammar.options[:result_var]
+        if @line_convert
+          evaluation = "eval(ACTION_CODE_#{production.id}, binding, #{action.location[:file].inspect}, " \
+                       "#{action.location[:line]})"
+          lines << "    #{@grammar.options[:result_var] ? evaluation : "return #{evaluation}"}"
+        else
+          action.code.lines.each { |line| lines << "    #{line.rstrip}" }
+        end
+        lines << "    result" if @grammar.options[:result_var]
+      end
+
+      # @rbs (IR::Production production) -> bool
+      def action_method?(production)
+        !!(production.action || !@omit_action_call)
+      end
+
+      # @rbs (Array[String] lines, String name, ?indent: Integer) -> void
+      def append_user_code(lines, name, indent: 0)
+        code = @grammar.user_code[name]
+        return if code.nil? || code.empty?
+
+        prefix = " " * indent
+        chunks = @grammar.user_code_chunks.fetch(name, Array.new(0))
+        if map_user_code?(name) && !chunks.empty?
+          chunks.each do |chunk|
+            location = chunk.location
+            lines << "#{prefix}eval(#{chunk.code.dump}, binding, #{location[:file].inspect}, #{location[:line]})"
+          end
+        elsif @line_convert_all
+          raise Ibex::Error, "(codegen):1:1: source locations are required to convert #{name} user code"
+        else
+          code.lines.each { |line| lines << "#{prefix}#{line.rstrip}" }
+        end
+        lines << ""
+      end
+
+      # @rbs (String name) -> bool
+      def map_user_code?(name)
+        @line_convert_all || (@line_convert && name == "inner")
+      end
+
+      # @rbs () -> [Array[String], String]
+      def class_parts
+        parts = @grammar.class_name.split("::")
+        [parts.take(parts.length - 1), parts.fetch(-1)]
+      end
+
+      # @rbs () -> String
+      def grammar_digest_comment
+        @automaton.grammar_digest.delete_prefix("sha256:").chars.first(12).join
+      end
+    end
+  end
+end

data/lib/ibex/codegen/symbol_labels.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ibex
+  module Codegen
+    # Builds human-facing symbol labels without changing Grammar IR identities.
+    module SymbolLabels
+      # @rbs (IR::Grammar grammar) -> Hash[Integer, String]
+      def self.build(grammar)
+        labels = grammar.symbols.to_h { |symbol| [symbol.id, symbol.name] }
+        grammar.productions.each do |production|
+          expression = production.origin[:expression]
+          labels[production.lhs] = expression if expression.is_a?(String)
+        end
+        labels
+      end
+    end
+  end
+end

data/lib/ibex/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  # Base error raised for invalid grammars and command failures.
+  class Error < StandardError; end
+end

data/lib/ibex/frontend/action_scanner.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module Ibex
+  module Frontend
+    # Extracts a balanced Ruby action while ignoring braces inside literals.
+    class ActionScanner
+      # @rbs!
+      #   type heredoc = {
+      #     identifier: String,
+      #     indented: bool,
+      #     length: Integer,
+      #     location: Location
+      #   }
+
+      PAIRED_DELIMITERS = { "(" => ")", "[" => "]", "{" => "}", "<" => ">" }.freeze #: Hash[String, String]
+      REGEX_PREFIXES = "=([{!,:;?&|+-*%^~<>" #: String
+
+      # @rbs @cursor: SourceCursor
+      # @rbs @pending_heredocs: Array[heredoc]
+
+      # @rbs (SourceCursor cursor) -> void
+      def initialize(cursor)
+        @cursor = cursor
+        @pending_heredocs = [] #: Array[heredoc]
+      end
+
+      # @rbs () -> Token
+      def scan
+        location = @cursor.location
+        @cursor.advance
+        start = @cursor.index
+        scan_code(1)
+        finish = @cursor.index
+        @cursor.advance
+        Token.new(type: :action, value: @cursor.source[start...finish], location: location)
+      rescue Ibex::Error
+        raise
+      rescue StandardError => e
+        raise Ibex::Error, "#{location}: unable to scan action: #{e.message}"
+      end
+
+      private
+
+      # @rbs (Integer depth) -> void
+      def scan_code(depth)
+        until @cursor.eof?
+          if @cursor.peek == "\n" && @pending_heredocs.any?
+            @cursor.advance
+            scan_pending_heredocs
+            next
+          end
+
+          index = @cursor.index
+          scan_special_character
+          next if @cursor.index != index
+
+          depth += 1 if @cursor.peek == "{"
+          depth -= 1 if @cursor.peek == "}"
+          return if depth.zero?
+
+          @cursor.advance
+        end
+        raise Ibex::Error, "#{@cursor.location}: unterminated action"
+      end
+
+      # @rbs () -> void
+      def scan_special_character
+        character = @cursor.peek
+        case character
+        when "'", '"', "`" then scan_quoted(character)
+        when "%" then scan_percent_literal
+        when "/" then scan_regexp if regexp_start?
+        when "#" then scan_comment
+        when "?" then scan_character_literal
+        when "<" then scan_heredoc if @cursor.peek(1) == "<"
+        end
+      end
+
+      # @rbs (String quote) -> void
+      def scan_quoted(quote)
+        start = @cursor.location
+        @cursor.advance
+        until @cursor.eof?
+          if @cursor.peek == "\\"
+            @cursor.advance(2)
+          elsif quote != "'" && @cursor.rest.start_with?("\#{")
+            @cursor.advance(2)
+            scan_interpolation
+          elsif @cursor.peek == quote
+            @cursor.advance
+            return
+          else
+            @cursor.advance
+          end
+        end
+        raise Ibex::Error, "#{start}: unterminated #{quote} string in action"
+      end
+
+      # @rbs () -> void
+      def scan_interpolation
+        depth = 1
+        until @cursor.eof?
+          character = @cursor.peek
+          raise Ibex::Error, "#{@cursor.location}: unterminated string interpolation" unless character
+
+          if ["'", '"', "`"].include?(character)
+            scan_quoted(character)
+            next
+          end
+          if character == "{"
+            depth += 1
+          elsif character == "}"
+            depth -= 1
+            @cursor.advance
+            return if depth.zero?
+
+            next
+          end
+          @cursor.advance
+        end
+        raise Ibex::Error, "#{@cursor.location}: unterminated string interpolation"
+      end
+
+      # @rbs () -> void
+      def scan_percent_literal
+        match = @cursor.rest.match(/\A%(?:[qQwWiIxrs])?([^\w\s])/)
+        return unless match
+
+        literal_prefix = match[0]
+        opener = match[1]
+        return unless literal_prefix && opener
+
+        closer = PAIRED_DELIMITERS.fetch(opener, opener)
+        @cursor.advance(literal_prefix.length)
+        scan_delimited(opener, closer)
+      end
+
+      # @rbs (String opener, String closer) -> void
+      def scan_delimited(opener, closer)
+        start = @cursor.location
+        depth = 1
+        until @cursor.eof?
+          if @cursor.peek == "\\"
+            @cursor.advance(2)
+            next
+          end
+          depth += 1 if opener != closer && @cursor.peek == opener
+          depth -= 1 if @cursor.peek == closer
+          @cursor.advance
+          return if depth.zero?
+        end
+        raise Ibex::Error, "#{start}: unterminated percent literal"
+      end
+
+      # @rbs () -> bool
+      def regexp_start?
+        prefix = @cursor.source.chars.take(@cursor.index).join.rstrip[-1]
+        prefix.nil? || REGEX_PREFIXES.include?(prefix)
+      end
+
+      # @rbs () -> void
+      def scan_regexp
+        start = @cursor.location
+        @cursor.advance
+        in_class = false
+        until @cursor.eof?
+          if @cursor.peek == "\\"
+            @cursor.advance(2)
+            next
+          end
+          in_class = true if @cursor.peek == "["
+          in_class = false if @cursor.peek == "]"
+          if @cursor.peek == "/" && !in_class
+            @cursor.advance
+            @cursor.advance while @cursor.peek&.match?(/[a-z]/i)
+            return
+          end
+          @cursor.advance
+        end
+        raise Ibex::Error, "#{start}: unterminated regular expression"
+      end
+
+      # @rbs () -> void
+      def scan_comment
+        @cursor.advance until @cursor.eof? || @cursor.peek == "\n"
+      end
+
+      # @rbs () -> void
+      def scan_character_literal
+        @cursor.advance
+        @cursor.advance if @cursor.peek == "\\"
+        @cursor.advance unless @cursor.eof?
+      end
+
+      # @rbs () -> void
+      def scan_heredoc
+        opener = heredoc_opener
+        return unless opener
+
+        @cursor.advance(opener[:length])
+        @pending_heredocs << opener
+      end
+
+      # @rbs () -> heredoc?
+      def heredoc_opener
+        prefix = @cursor.rest.match(/\A<<([~-]?)/)
+        return unless prefix
+
+        marker = prefix[0]
+        return unless marker
+
+        quote = @cursor.rest[marker.length]
+        identifier, length = if quote && ["'", '"', "`"].include?(quote)
+                               quoted_heredoc_identifier(marker, quote)
+                             else
+                               bare_heredoc_identifier(marker)
+                             end
+        return unless identifier
+
+        modifier = prefix[1] || ""
+        { identifier: identifier, indented: !modifier.empty?, length: length,
+          location: @cursor.location } #: heredoc
+      end
+
+      # @rbs (String prefix, String quote) -> [String, Integer]?
+      def quoted_heredoc_identifier(prefix, quote)
+        start = prefix.length + 1
+        finish = @cursor.rest.index(quote, start)
+        return unless finish
+
+        identifier = @cursor.rest[start...finish]
+        return unless identifier
+        return if identifier.match?(/[\r\n]/)
+
+        [identifier, finish + 1]
+      end
+
+      # @rbs (String prefix) -> [String?, Integer]
+      def bare_heredoc_identifier(prefix)
+        suffix = @cursor.rest[prefix.length..] || ""
+        identifier = suffix.match(/\A[A-Za-z_]\w*/)&.[](0)
+        [identifier, prefix.length + identifier.to_s.length]
+      end
+
+      # @rbs () -> void
+      def scan_pending_heredocs
+        @pending_heredocs.shift.then { |heredoc| scan_heredoc_body(heredoc) } until @pending_heredocs.empty?
+      end
+
+      # @rbs (heredoc heredoc) -> void
+      def scan_heredoc_body(heredoc)
+        identifier = heredoc[:identifier]
+        escaped_identifier = Regexp.escape(identifier)
+        prefix = heredoc[:indented] ? "[ \\t]*" : ""
+        terminator = /\A#{prefix}#{escaped_identifier}\r?\z/
+        until @cursor.eof?
+          line = @cursor.rest[/\A[^\n]*(?:\n|\z)/] || ""
+          content = line.delete_suffix("\n")
+          @cursor.advance(line.length)
+          return if content.match?(terminator)
+        end
+        raise Ibex::Error, "#{heredoc[:location]}: unterminated heredoc #{identifier}"
+      end
+    end
+  end
+end