ibex 0.1.0 → 0.2.0

data/sig/ibex/ir/validator/base.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/ibex/ir/validator/base.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      # Shared JSON-shape checks for the two version-1 IR documents.
+      class Base
+        POSITION: ::String
+
+        private
+
+        # @rbs (untyped value, String path, Array[String] required, ?Array[String] optional) -> Hash[String, untyped]
+        def record: (untyped value, String path, Array[String] required, ?Array[String] optional) -> Hash[String, untyped]
+
+        # @rbs (untyped value, String path) -> Hash[String, untyped]
+        def object: (untyped value, String path) -> Hash[String, untyped]
+
+        # @rbs (untyped value, String path) -> Array[untyped]
+        def array: (untyped value, String path) -> Array[untyped]
+
+        # @rbs (untyped value, String path) -> String
+        def string: (untyped value, String path) -> String
+
+        # @rbs (untyped value, String path) -> String
+        def nonempty_string: (untyped value, String path) -> String
+
+        # @rbs (untyped value, String path) -> Integer
+        def integer: (untyped value, String path) -> Integer
+
+        # @rbs (untyped value, String path) -> Integer
+        def nonnegative_integer: (untyped value, String path) -> Integer
+
+        # @rbs (untyped value, String path) -> bool
+        def boolean: (untyped value, String path) -> bool
+
+        # @rbs (untyped value, String path, untyped expected) -> void
+        def literal: (untyped value, String path, untyped expected) -> void
+
+        # @rbs (untyped value, String path, Array[String] values) -> String
+        def enum: (untyped value, String path, Array[String] values) -> String
+
+        # @rbs (untyped value, String path, ?nullable: bool) -> void
+        def location: (untyped value, String path, ?nullable: bool) -> void
+
+        # @rbs (untyped value, String path) -> Integer
+        def positive_integer: (untyped value, String path) -> Integer
+
+        # @rbs (untyped value, String path) -> String?
+        def nullable_string: (untyped value, String path) -> String?
+
+        # @rbs (untyped value, String path) -> void
+        def metadata: (untyped value, String path) -> void
+
+        # @rbs (Hash[String, untyped] value, String key, String path) -> untyped
+        def field: (Hash[String, untyped] value, String key, String path) -> untyped
+
+        # @rbs (String path, String key) -> String
+        def child_path: (String path, String key) -> String
+
+        # @rbs (String path, String message) -> bot
+        def invalid: (String path, String message) -> bot
+      end
+    end
+  end
+end

data/sig/ibex/ir/validator/grammar.rbs

@@ -0,0 +1,184 @@
+# Generated from lib/ibex/ir/validator/grammar.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      # Structural and referential validation for a versioned Grammar IR JSON object.
+      # rubocop:disable Metrics/ClassLength -- inline type contracts accompany one cohesive document validator.
+      class GrammarDocument < Base
+        ROOT_REQUIRED: Array[String]
+
+        ROOT_OPTIONAL: Array[String]
+
+        V2_ROOT_REQUIRED: Array[String]
+
+        V2_ROOT_OPTIONAL: Array[String]
+
+        SYMBOL_REQUIRED: Array[String]
+
+        SYMBOL_OPTIONAL: Array[String]
+
+        V2_SYMBOL_REQUIRED: Array[String]
+
+        PRODUCTION_REQUIRED: Array[String]
+
+        V2_PRODUCTION_REQUIRED: Array[String]
+
+        V2_ACTION_REQUIRED: Array[String]
+
+        ORIGIN_KINDS: Array[String]
+
+        RUBY_KEYWORDS: Array[String]
+
+        attr_reader symbols_by_id: Hash[Integer, Hash[String, untyped]]
+
+        attr_reader symbols_by_name: Hash[String, Hash[String, untyped]]
+
+        attr_reader productions_by_id: Hash[Integer, Hash[String, untyped]]
+
+        @version: Integer
+
+        @path: String
+
+        @data: Hash[String, untyped]
+
+        # @rbs (Hash[String, untyped] data, ?path: String, ?version: Integer) -> void
+        def initialize: (Hash[String, untyped] data, ?path: String, ?version: Integer) -> void
+
+        # @rbs () -> self
+        def validate: () -> self
+
+        private
+
+        # @rbs () -> void
+        def validate_envelope: () -> void
+
+        # @rbs () -> void
+        def validate_header: () -> void
+
+        # @rbs () -> void
+        def validate_options: () -> void
+
+        # @rbs () -> void
+        def validate_parser_parameters: () -> void
+
+        # @rbs () -> void
+        def validate_value_printers: () -> void
+
+        # @rbs () -> void
+        def validate_grammar_tests: () -> void
+
+        # @rbs () -> void
+        def validate_symbols: () -> void
+
+        # @rbs (untyped value, Integer index) -> void
+        def validate_symbol: (untyped value, Integer index) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_precedence: (untyped value, String path) -> void
+
+        # @rbs () -> void
+        def validate_reserved_symbols: () -> void
+
+        # @rbs (Integer id, String name) -> void
+        def validate_reserved_symbol: (Integer id, String name) -> void
+
+        # @rbs () -> void
+        def validate_start: () -> void
+
+        # @rbs (String start) -> void
+        def validate_multiple_starts: (String start) -> void
+
+        # @rbs () -> void
+        def validate_recovery: () -> void
+
+        # @rbs (untyped values, String path, kind: String) -> void
+        def validate_recovery_symbols: (untyped values, String path, kind: String) -> void
+
+        # @rbs (untyped value, String path, kind: String, seen: Hash[String, bool]) -> void
+        def validate_recovery_symbol: (untyped value, String path, kind: String, seen: Hash[String, bool]) -> void
+
+        # @rbs () -> void
+        def validate_productions: () -> void
+
+        # @rbs (untyped value, Integer index) -> void
+        def validate_production: (untyped value, Integer index) -> void
+
+        # @rbs (untyped value, String path, rhs_length: Integer) -> void
+        def validate_node_annotation: (untyped value, String path, rhs_length: Integer) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_lhs: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_rhs: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path, rhs_length: Integer) -> void
+        def validate_action: (untyped value, String path, rhs_length: Integer) -> void
+
+        # @rbs (untyped value, String path, limit: Integer) -> void
+        def validate_named_refs: (untyped value, String path, limit: Integer) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_precedence_override: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_origin: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_string_map: (untyped value, String path) -> void
+
+        # @rbs () -> void
+        def validate_warnings: () -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_warning: (untyped value, String path) -> void
+
+        # @rbs (Hash[String, untyped] warning, String path) -> void
+        def validate_warning_symbol: (Hash[String, untyped] warning, String path) -> void
+
+        # @rbs (Hash[String, untyped] warning, String field_name, String path) -> void
+        def validate_warning_production: (Hash[String, untyped] warning, String field_name, String path) -> void
+
+        # @rbs () -> void
+        def validate_lexer: () -> void
+
+        # @rbs () -> void
+        def validate_user_code_chunks: () -> void
+
+        # @rbs (untyped value, String path, ?nullable: bool) -> void
+        def validate_source_provenance: (untyped value, String path, ?nullable: bool) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_byte_span: (untyped value, String path) -> void
+
+        # @rbs () -> void
+        def validate_migration: () -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_expansion: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_parameter_expansion: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path) -> void
+        def validate_inline_expansion: (untyped value, String path) -> void
+
+        # @rbs (untyped value, String path, rhs_length: Integer) -> void
+        def validate_action_composition: (untyped value, String path, rhs_length: Integer) -> void
+
+        # @rbs (untyped value, String path, Integer rhs_length, Array[untyped] fragments) -> void
+        def validate_action_composition_plan: (untyped value, String path, Integer rhs_length, Array[untyped] fragments) -> void
+
+        # @rbs (untyped value, String path, Integer physical, Integer step_index) -> void
+        def validate_action_composition_step: (untyped value, String path, Integer physical, Integer step_index) -> void
+
+        # @rbs (Array[untyped] inputs, String path, Integer limit) -> void
+        def validate_action_slots: (Array[untyped] inputs, String path, Integer limit) -> void
+
+        # @rbs (untyped value, String path, Integer physical) -> void
+        def validate_action_lookahead: (untyped value, String path, Integer physical) -> void
+      end
+    end
+  end
+end

data/sig/ibex/ir/validator/lexer.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/ir/validator/lexer.rb with RBS::Inline
+
+module Ibex
+  module IR
+    module Validator
+      # Structural validation for the independently versioned Lexer IR.
+      class LexerDocument < Base
+        ROOT_REQUIRED: Array[String]
+
+        RULE_REQUIRED: Array[String]
+
+        # @rbs (Hash[String, untyped] data, ?path: String) -> void
+        def initialize: (Hash[String, untyped] data, ?path: String) -> void
+
+        # @rbs () -> self
+        def validate: () -> self
+
+        private
+
+        # @rbs () -> void
+        def validate_states: () -> void
+
+        # @rbs () -> void
+        def validate_rules: () -> void
+
+        # @rbs (Hash[String, untyped] rule, String path, String options) -> void
+        def validate_pattern: (Hash[String, untyped] rule, String path, String options) -> void
+
+        # @rbs () -> void
+        def validate_warnings: () -> void
+
+        # @rbs () -> void
+        def validate_source_provenance: () -> void
+      end
+    end
+  end
+end

data/sig/ibex/ir/validator.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ibex/ir/validator.rb with RBS::Inline
+
+module Ibex
+  module IR
+    # Validates a serialized public IR document before constructing immutable IR objects.
+    module Validator
+      POSITION: ::String
+
+      # @rbs (String source) -> (Grammar | Automaton | Lexer)
+      def self?.validate: (String source) -> (Grammar | Automaton | Lexer)
+
+      # @rbs (Automaton automaton) -> void
+      def self?.validate_automaton_digest: (Automaton automaton) -> void
+    end
+  end
+end

data/sig/ibex/ir.rbs

@@ -8,9 +8,43 @@ module Ibex
 
     type named_ref = { name: String, index: Integer }
 
+    type byte_span = { start: Integer, end: Integer }
+
+    type source_provenance = { file: String?, root: String?, byte_span: byte_span? }
+
+    type parser_parameter = { name: String, semantic_type: String? }
+
+    type value_printer = { symbol: String, code: String, loc: location }
+
+    type recovery_policy = { sync_tokens: Array[String], on_error_reduce: Array[Array[String]] }
+
+    type grammar_test = { expectation: :accept | :reject, source: String, loc: location }
+
+    type node_annotation = { name: String, fields: Array[String], loc: location }
+
+    type lexer_warning = { type: :redos, rule: Integer, loc: location }
+
+    type parameter_expansion = { rule: String, arguments: Array[String] }
+
+    type inline_expansion = { rule: String }
+
+    type production_expansion = { parameter: parameter_expansion?, inline: inline_expansion?, include_chain: Array[source_provenance] }
+
+    type action_fragment = { kind: :rule | :inline, source: source_provenance? }
+
+    type action_composition_step = { kind: :rule | :inline, rule: String?, code: String?, loc: location, named_refs: Array[named_ref], context_length: Integer, inputs: Array[Integer], stack_inputs: Array[Integer], lookahead: Integer?, result_var: bool, result_type: String? }
+
+    type action_composition_plan = { version: Integer, physical: Integer, steps: Array[action_composition_step] }
+
+    type action_composition = { strategy: String, fragments: Array[action_fragment], ?plan: action_composition_plan }
+
+    type migration_metadata = { from_schema_version: Integer, unavailable: Array[String] }
+
     type user_code_chunks = Hash[String, Array[UserCodeChunk]]
 
-    type grammar_options = { result_var: bool, omit_action_call: bool }
+    type grammar_options = { result_var: bool, omit_action_call: bool, ?cst: bool }
+
+    type grammar_mode = :default | :extended
 
     type grammar_warning = { type: Symbol, ?symbol: String, ?production: Integer, ?original: Integer, loc: location? }
 
@@ -28,13 +62,13 @@ module Ibex
 
     type conflict_resolution = { by: Symbol, chose: Symbol | Integer, ?associativity: Symbol }
 
-    type shift_reduce_conflict = { type: :shift_reduce, symbol: String, shift_to: Integer, reduce: Integer, resolution: conflict_resolution }
+    type shift_reduce_conflict = { type: :shift_reduce, symbol: String, shift_to: Integer, reduce: Integer, resolution: conflict_resolution, ?midrule_origins: Array[location], ?entries: Array[String], ?composite: bool }
 
-    type reduce_reduce_conflict = { type: :reduce_reduce, symbol: String, reductions: Array[Integer], resolution: conflict_resolution }
+    type reduce_reduce_conflict = { type: :reduce_reduce, symbol: String, reductions: Array[Integer], resolution: conflict_resolution, ?midrule_origins: Array[location], ?entries: Array[String], ?composite: bool }
 
     type conflict = shift_reduce_conflict | reduce_reduce_conflict
 
-    type conflict_summary = { sr: Integer, resolved_sr: Integer, rr: Integer, expected_sr: Integer, expectation_met: bool }
+    type conflict_summary = { sr: Integer, resolved_sr: Integer, rr: Integer, expected_sr: Integer, expectation_met: bool, ?expected_rr: Integer, ?rr_expectation_met: bool }
 
     type interpretation = Hash[Symbol, untyped]
 

data/sig/ibex/lalr/build_metrics.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/ibex/lalr/build_metrics.rb with RBS::Inline
+
+module Ibex
+  module LALR
+    # Immutable structural measurements from one automaton build. These counts
+    # are intended for diagnostics and benchmarks, not parser behavior.
+    class BuildMetrics
+      attr_reader construction_states: Integer
+
+      attr_reader canonical_states: Integer?
+
+      attr_reader final_states: Integer
+
+      attr_reader strategy: Symbol
+
+      # @rbs (construction_states: Integer, canonical_states: Integer?, final_states: Integer, strategy: Symbol) -> void
+      def initialize: (construction_states: Integer, canonical_states: Integer?, final_states: Integer, strategy: Symbol) -> void
+    end
+  end
+end

data/sig/ibex/lalr/builder.rbs

@@ -2,30 +2,61 @@
 
 module Ibex
   module LALR
-    # Builds canonical LR(1) states and merges states with equal LR(0) cores.
+    # Builds deterministic SLR, direct LALR(1), or canonical LR(1) automata.
+    # rubocop:disable Metrics/ClassLength -- collection strategies share one action/conflict construction path.
     class Builder
       AUGMENTED_PRODUCTION: Integer
 
       ALGORITHMS: Array[Symbol]
 
+      LALR_STRATEGIES: Array[Symbol]
+
+      @canonical_key_radices: [ Integer, Integer, Integer ]?
+
+      @canonical_item_cache: Hash[Integer, Array[Array[lr_item?]?]]?
+
+      @canonical_suffix_lookahead_cache: Hash[Integer, Hash[Integer, Hash[Integer, Array[Integer]]]]
+
+      @attribute_entries: bool
+
+      @entry_isolation: bool
+
+      @start_names: Array[String]
+
+      @metrics: BuildMetrics?
+
       @resolver: ConflictResolver
 
       @productions_by_lhs: Hash[Integer, Array[IR::Production]]
 
       @sets: Analysis::Sets
 
+      @lalr_strategy: Symbol
+
       @algorithm: Symbol
 
       @grammar: IR::Grammar
 
-      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
-      def initialize: (IR::Grammar grammar, ?algorithm: Symbol | String) -> void
+      attr_reader metrics: BuildMetrics?
+
+      # @rbs (IR::Grammar grammar, ?algorithm: Symbol | String, ?lalr_strategy: Symbol | String,
+      #   ?entry_isolation: bool, ?starts: Array[String]?, ?attribute_entries: bool) -> void
+      def initialize: (IR::Grammar grammar, ?algorithm: Symbol | String, ?lalr_strategy: Symbol | String, ?entry_isolation: bool, ?starts: Array[String]?, ?attribute_entries: bool) -> void
 
       # @rbs () -> IR::Automaton
       def build: () -> IR::Automaton
 
       private
 
+      # @rbs (Array[IR::AutomatonState] states) -> IR::conflict_summary
+      def conflict_summary: (Array[IR::AutomatonState] states) -> IR::conflict_summary
+
+      # @rbs () -> [Array[packed_items], transitions, Integer, Integer?, Symbol]
+      def automaton_collection: () -> [ Array[packed_items], transitions, Integer, Integer?, Symbol ]
+
+      # @rbs () -> String
+      def algorithm_name: () -> String
+
       # @rbs () -> [Array[item_set], transitions]
       def canonical_collection: () -> [ Array[item_set], transitions ]
 
@@ -35,21 +66,21 @@ module Ibex
       # @rbs (Array[Integer] suffix, Integer inherited) -> Array[Integer]
       def suffix_lookaheads: (Array[Integer] suffix, Integer inherited) -> Array[Integer]
 
+      # @rbs (Integer production_id, Integer dot, Integer inherited) -> Array[Integer]
+      def canonical_suffix_lookaheads: (Integer production_id, Integer dot, Integer inherited) -> Array[Integer]
+
+      # @rbs (Integer production_id, Integer dot, Integer lookahead) -> lr_item
+      def canonical_item: (Integer production_id, Integer dot, Integer lookahead) -> lr_item
+
       # @rbs (item_set items, Array[lr_item] queue, lr_item item) -> void
       def enqueue_item: (item_set items, Array[lr_item] queue, lr_item item) -> void
 
-      # @rbs (item_set items) -> Array[Integer]
-      def next_symbols: (item_set items) -> Array[Integer]
-
-      # @rbs (item_set items, Integer symbol_id) -> item_set
-      def go_to: (item_set items, Integer symbol_id) -> item_set
+      # @rbs (item_set items) -> Hash[Integer, item_set]
+      def shifted_kernels: (item_set items) -> Hash[Integer, item_set]
 
       # @rbs (Array[item_set] states, transitions transitions) -> [Array[packed_items], transitions]
       def merge_lalr: (Array[item_set] states, transitions transitions) -> [ Array[packed_items], transitions ]
 
-      # @rbs (Array[item_set] canonical_states, transitions canonical_transitions) -> [Array[packed_items], transitions]
-      def automaton_items: (Array[item_set] canonical_states, transitions canonical_transitions) -> [ Array[packed_items], transitions ]
-
       # @rbs (Array[item_set] states) -> Array[packed_items]
       def pack_canonical_items: (Array[item_set] states) -> Array[packed_items]
 
@@ -65,6 +96,12 @@ module Ibex
       # @rbs (Integer state_id, Array[IR::AutomatonItem] items, Hash[Integer, Integer] transitions) -> IR::AutomatonState
       def build_state: (Integer state_id, Array[IR::AutomatonItem] items, Hash[Integer, Integer] transitions) -> IR::AutomatonState
 
+      # Conflict hashes are produced locally immediately before this boundary.
+      # Keeping the parameter untyped avoids duplicating both discriminated
+      # hash variants solely to add their common optional provenance field.
+      # @rbs (untyped conflict) -> IR::conflict
+      def attribute_midrule_conflict: (untyped conflict) -> IR::conflict
+
       # @rbs (Array[IR::AutomatonItem] items, Hash[Integer, Array[IR::parser_action]] candidates) -> void
       def add_completed_actions: (Array[IR::AutomatonItem] items, Hash[Integer, Array[IR::parser_action]] candidates) -> void
 
@@ -75,11 +112,54 @@ module Ibex
       # @rbs (Integer production_id) -> Array[Integer]
       def rhs_for: (Integer production_id) -> Array[Integer]
 
-      # @rbs (item_set items) -> Array[item_core]
-      def core_key: (item_set items) -> Array[item_core]
+      # @rbs () -> [Integer, Integer, Integer]
+      def canonical_key_radices: () -> [ Integer, Integer, Integer ]
+
+      # @rbs (item_set items) -> Array[Integer]
+      def core_key: (item_set items) -> Array[Integer]
+
+      # @rbs (item_set items) -> Array[Integer]
+      def item_key: (item_set items) -> Array[Integer]
+
+      # @rbs (String name) -> Integer
+      def augmented_production: (String name) -> Integer
+
+      # @rbs (Integer production_id) -> String
+      def start_name_for_augmented: (Integer production_id) -> String
+
+      # @rbs (Array[packed_items] items) -> Hash[String, Integer]
+      def entry_states_for: (Array[packed_items] items) -> Hash[String, Integer]
+
+      # @rbs () -> IR::Automaton
+      def build_isolated_automaton: () -> IR::Automaton
+
+      # @rbs (String name) -> [String, IR::Automaton, BuildMetrics]
+      def isolated_entry: (String name) -> [ String, IR::Automaton, BuildMetrics ]
+
+      # @rbs (IR::AutomatonState state, Integer offset, String entry) -> IR::AutomatonState
+      def offset_state: (IR::AutomatonState state, Integer offset, String entry) -> IR::AutomatonState
+
+      # @rbs (IR::parser_action action, Integer offset) -> IR::parser_action
+      def offset_action: (IR::parser_action action, Integer offset) -> IR::parser_action
+
+      # @rbs (IR::parser_action? action, Integer offset) -> IR::parser_action?
+      def offset_default_action: (IR::parser_action? action, Integer offset) -> IR::parser_action?
+
+      # @rbs (IR::conflict conflict, Integer offset, String entry) -> IR::conflict
+      def offset_conflict: (IR::conflict conflict, Integer offset, String entry) -> IR::conflict
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) ->
+      #   Array[IR::AutomatonState]
+      def attribute_entry_conflicts: (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[IR::AutomatonState]
+
+      # @rbs (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[Array[String]]
+      def entry_reachability: (Array[IR::AutomatonState] states, Hash[String, Integer] entry_states) -> Array[Array[String]]
+
+      # @rbs () -> Set[Array[untyped]]
+      def isolated_conflict_fingerprints: () -> Set[Array[untyped]]
 
-      # @rbs (item_set items) -> Array[lr_item]
-      def item_key: (item_set items) -> Array[lr_item]
+      # @rbs (IR::conflict conflict) -> Array[untyped]
+      def conflict_fingerprint: (IR::conflict conflict) -> Array[untyped]
     end
   end
 end

data/sig/ibex/lalr/conflict_search.rbs

@@ -20,6 +20,8 @@ module Ibex
                     | ({ ?states: Array[Integer], ?nodes: Array[derivation_node] }) -> instance
       end
 
+      @initial_state: Integer
+
       @input_tokens: Array[Integer]
 
       @explored: Integer
@@ -38,6 +40,8 @@ module Ibex
 
       @automaton: IR::Automaton
 
+      attr_reader explored: Integer
+
       # @rbs (IR::Automaton automaton, IR::AutomatonState state, IR::conflict conflict,
       #   ?max_tokens: Integer, ?max_configurations: Integer) -> void
       def initialize: (IR::Automaton automaton, IR::AutomatonState state, IR::conflict conflict, ?max_tokens: Integer, ?max_configurations: Integer) -> void
@@ -45,6 +49,9 @@ module Ibex
       # @rbs () -> search_result?
       def call: () -> search_result?
 
+      # @rbs () -> bool
+      def exhausted?: () -> bool
+
       private
 
       # @rbs (Configuration current) -> Array[Configuration]
@@ -123,9 +130,6 @@ module Ibex
 
       # @rbs () -> Integer
       def count_configuration: () -> Integer
-
-      # @rbs () -> bool
-      def exhausted?: () -> bool
     end
   end
 end

data/sig/ibex/lalr/counterexample.rbs

@@ -14,6 +14,9 @@ module Ibex
       # @rbs () -> Array[IR::counterexample]
       def all: () -> Array[IR::counterexample]
 
+      # @rbs (Integer state_id, Integer conflict_index) -> IR::counterexample
+      def for_conflict: (Integer state_id, Integer conflict_index) -> IR::counterexample
+
       private
 
       # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
@@ -25,8 +28,8 @@ module Ibex
       # @rbs (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
       def reachability_example: (IR::AutomatonState state, IR::conflict conflict) -> IR::counterexample
 
-      # @rbs (Integer target) -> Array[Integer]
-      def shortest_state_path: (Integer target) -> Array[Integer]
+      # @rbs (Integer target, IR::conflict conflict) -> Array[Integer]
+      def shortest_state_path: (Integer target, IR::conflict conflict) -> Array[Integer]
 
       # @rbs () -> Hash[Integer, Array[Integer]]
       def compute_shortest_yields: () -> Hash[Integer, Array[Integer]]