ibex 0.2.0 → 0.4.0

data/sig/ibex/coverage/runtime_event_validator.rbs

@@ -4,65 +4,67 @@ module Ibex
   module Coverage
     # Dependency-free structural validation for runtime-event schema version 1.
     module RuntimeEventValidator
+      type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
       TOKEN_KEYS: Array[String]
 
       LOCATION_KEYS: Array[String]
 
       VALIDATORS: Hash[String, Symbol]
 
-      # @rbs (Hash[String, untyped] document) -> bool
-      def self.valid?: (Hash[String, untyped] document) -> bool
+      # @rbs (Hash[String, json_value] document) -> bool
+      def self.valid?: (Hash[String, json_value] document) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_start?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_start?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_shift?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_shift?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_reduce?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_reduce?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data, reasons: Array[String]) -> bool
-      private def self.valid_token_event?: (Hash[String, untyped] data, reasons: Array[String]) -> bool
+      # @rbs (Hash[String, json_value] data, reasons: Array[String]) -> bool
+      private def self.valid_token_event?: (Hash[String, json_value] data, reasons: Array[String]) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_error?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_error?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_discard?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_discard?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_reject?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_reject?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_recover?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_recover?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_accept?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_accept?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (Hash[String, untyped] data) -> bool
-      private def self.valid_token_fields?: (Hash[String, untyped] data) -> bool
+      # @rbs (Hash[String, json_value] data) -> bool
+      private def self.valid_token_fields?: (Hash[String, json_value] data) -> bool
 
-      # @rbs (untyped value) -> bool
-      private def self.summary?: (untyped value) -> bool
+      # @rbs (json_value value) -> bool
+      private def self.summary?: (json_value value) -> bool
 
-      # @rbs (untyped value) -> bool
-      private def self.composite_summary?: (untyped value) -> bool
+      # @rbs (json_value value) -> bool
+      private def self.composite_summary?: (json_value value) -> bool
 
-      # @rbs (untyped value) -> bool
-      private def self.location?: (untyped value) -> bool
+      # @rbs (json_value value) -> bool
+      private def self.location?: (json_value value) -> bool
 
-      # @rbs (Hash[String, untyped] data, Array[String] keys) -> bool
-      private def self.exact_keys?: (Hash[String, untyped] data, Array[String] keys) -> bool
+      # @rbs (Hash[String, json_value] data, Array[String] keys) -> bool
+      private def self.exact_keys?: (Hash[String, json_value] data, Array[String] keys) -> bool
 
-      # @rbs (untyped value) -> bool
-      private def self.integer?: (untyped value) -> bool
+      # @rbs (json_value value) -> bool
+      private def self.integer?: (json_value value) -> bool
 
-      # @rbs (untyped value) -> bool
-      private def self.optional_integer?: (untyped value) -> bool
+      # @rbs (json_value value) -> bool
+      private def self.optional_integer?: (json_value value) -> bool
 
-      # @rbs (untyped value) -> bool
-      private def self.optional_string?: (untyped value) -> bool
+      # @rbs (json_value value) -> bool
+      private def self.optional_string?: (json_value value) -> bool
     end
   end
 end

data/sig/ibex/delta_reducer.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/ibex/delta_reducer.rb with RBS::Inline
+
+module Ibex
+  # Deterministic, trial-bounded delta debugging over an ordered sequence.
+  class DeltaReducer
+    # Immutable outcome of a bounded reduction.
+    class Result
+      attr_reader items: Array[untyped]
+
+      attr_reader trials: Integer
+
+      attr_reader complete: bool
+
+      attr_reader original_size: Integer
+
+      # @rbs (items: Array[untyped], trials: Integer, complete: bool, original_size: Integer) -> void
+      def initialize: (items: Array[untyped], trials: Integer, complete: bool, original_size: Integer) -> void
+    end
+
+    # @rbs (?max_trials: Integer) -> void
+    def initialize: (?max_trials: Integer) -> void
+
+    # `failure` must return true while the failure of interest is preserved.
+    # @rbs [T] (Array[T] items) { (Array[T]) -> bool } -> Result
+    def minimize: [T] (Array[T] items) { (Array[T]) -> bool } -> Result
+
+    private
+
+    # @rbs (Integer length, Integer count) -> Array[Range[Integer]]
+    def partitions: (Integer length, Integer count) -> Array[Range[Integer]]
+
+    # @rbs (Integer trials) -> Integer
+    def checked_trial!: (Integer trials) -> Integer
+
+    # @rbs (Array[untyped] items, Integer trials, bool complete, Integer original_size) -> Result
+    def result: (Array[untyped] items, Integer trials, bool complete, Integer original_size) -> Result
+  end
+end

data/sig/ibex/diff.rbs

@@ -0,0 +1,47 @@
+# Generated from lib/ibex/diff.rb with RBS::Inline
+
+module Ibex
+  # Deterministic grammar and automaton change classification.
+  class Diff
+    # @rbs (IR::Automaton before, IR::Automaton after) -> void
+    def initialize: (IR::Automaton before, IR::Automaton after) -> void
+
+    # @rbs () -> Hash[Symbol, Object?]
+    def to_h: () -> Hash[Symbol, Object?]
+
+    private
+
+    # @rbs (Hash[String, Object?] before, Hash[String, Object?] after) -> Hash[Symbol, Object?]
+    def classify: (Hash[String, Object?] before, Hash[String, Object?] after) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Grammar grammar) -> Hash[String, Object?]
+    def symbol_records: (IR::Grammar grammar) -> Hash[String, Object?]
+
+    # @rbs (IR::Grammar grammar) -> Hash[String, Object?]
+    def rule_records: (IR::Grammar grammar) -> Hash[String, Object?]
+
+    # @rbs (IR::Grammar grammar, IR::Production production) -> Hash[Symbol, Object?]
+    def production_record: (IR::Grammar grammar, IR::Production production) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Automaton automaton) -> Hash[String, Object?]
+    def conflict_records: (IR::Automaton automaton) -> Hash[String, Object?]
+
+    # @rbs (IR::Grammar grammar, IR::conflict conflict) -> String
+    def conflict_identity: (IR::Grammar grammar, IR::conflict conflict) -> String
+
+    # @rbs (IR::Grammar grammar, Integer id) -> String
+    def production_shape: (IR::Grammar grammar, Integer id) -> String
+
+    # @rbs (IR::Grammar grammar, Integer id) -> String
+    def symbol_name: (IR::Grammar grammar, Integer id) -> String
+
+    # @rbs (IR::Grammar grammar) -> Hash[String, Object?]
+    def warning_records: (IR::Grammar grammar) -> Hash[String, Object?]
+
+    # @rbs () -> Hash[Symbol, Hash[Symbol, Integer]]
+    def numeric_metrics: () -> Hash[Symbol, Hash[Symbol, Integer]]
+
+    # @rbs (Integer before, Integer after) -> Hash[Symbol, Integer]
+    def change: (Integer before, Integer after) -> Hash[Symbol, Integer]
+  end
+end

data/sig/ibex/equiv/machine.rbs

@@ -0,0 +1,54 @@
+# Generated from lib/ibex/equiv/machine.rb with RBS::Inline
+
+module Ibex
+  class Equiv
+    # Immutable, semantic-action-free LR state-stack machine.
+    class Machine
+      class BudgetExceeded < Ibex::Error
+      end
+
+      # One product-search component.
+      class Configuration
+        attr_reader stack: Array[Integer]
+
+        attr_reader status: Symbol?
+
+        attr_reader actions: Integer
+
+        attr_reader reductions: Array[Integer]
+
+        # @rbs (stack: Array[Integer], status: Symbol?, actions: Integer, ?reductions: Array[Integer]) -> void
+        def initialize: (stack: Array[Integer], status: Symbol?, actions: Integer, ?reductions: Array[Integer]) -> void
+      end
+
+      # @rbs (IR::Automaton automaton, max_actions: Integer, max_stack: Integer) -> void
+      def initialize: (IR::Automaton automaton, max_actions: Integer, max_stack: Integer) -> void
+
+      # @rbs () -> Configuration
+      def start: () -> Configuration
+
+      # @rbs (Array[String] tokens) -> Configuration
+      def run: (Array[String] tokens) -> Configuration
+
+      # @rbs (Configuration configuration, String token) -> Configuration
+      def push: (Configuration configuration, String token) -> Configuration
+
+      # @rbs (Configuration configuration) -> Configuration
+      def finish: (Configuration configuration) -> Configuration
+
+      private
+
+      # @rbs (Configuration configuration, Integer token_id, eof: bool) -> Configuration
+      def consume: (Configuration configuration, Integer token_id, eof: bool) -> Configuration
+
+      # @rbs (Array[Integer] stack, Integer production_id) -> void
+      def apply_reduction!: (Array[Integer] stack, Integer production_id) -> void
+
+      # @rbs (Integer actions) -> void
+      def enforce_action_budget!: (Integer actions) -> void
+
+      # @rbs (Array[Integer] stack) -> void
+      def enforce_stack_budget!: (Array[Integer] stack) -> void
+    end
+  end
+end

data/sig/ibex/equiv.rbs

@@ -0,0 +1,129 @@
+# Generated from lib/ibex/equiv.rb with RBS::Inline
+
+module Ibex
+  # Bounded language comparison over two immutable parser automata.
+  # rubocop:disable Metrics/ClassLength -- the three comparison strategies share one report and budget contract.
+  class Equiv
+    type tree_node_signature = [ String, Array[String] ]
+
+    type tree_trace_entry = [ String, Array[String], tree_node_signature? ]
+
+    type terminal_signature = [ String, [ Symbol, Integer ]? ]
+
+    type production_signature = [ String, Array[String], String? ]
+
+    CAVEAT: String
+
+    DEFAULT_MAX_ACTIONS: Integer
+
+    DEFAULT_MAX_STACK: Integer
+
+    class Difference < Ibex::Error
+      attr_reader details: Hash[Symbol, Object?]
+
+      # @rbs (Hash[Symbol, Object?] details) -> void
+      def initialize: (Hash[Symbol, Object?] details) -> void
+    end
+
+    class BudgetExceeded < Ibex::Error
+      attr_reader details: Hash[Symbol, Object?]
+
+      # @rbs (Hash[Symbol, Object?] details) -> void
+      def initialize: (Hash[Symbol, Object?] details) -> void
+    end
+
+    # @rbs (IR::Automaton left, IR::Automaton right, ?sample_count: Integer, ?seed: Integer,
+    #   ?max_tokens: Integer, ?max_configurations: Integer, ?max_actions: Integer, ?max_stack: Integer,
+    #   ?rule_map: Hash[String, String]) -> void
+    def initialize: (IR::Automaton left, IR::Automaton right, ?sample_count: Integer, ?seed: Integer, ?max_tokens: Integer, ?max_configurations: Integer, ?max_actions: Integer, ?max_stack: Integer, ?rule_map: Hash[String, String]) -> void
+
+    # @rbs () -> Hash[Symbol, Object?]
+    def run: () -> Hash[Symbol, Object?]
+
+    private
+
+    # @rbs () -> Integer
+    def compare_samples: () -> Integer
+
+    # @rbs (IR::Grammar grammar, Integer seed) -> Array[Array[String]]
+    def generated_samples: (IR::Grammar grammar, Integer seed) -> Array[Array[String]]
+
+    # @rbs () -> Integer
+    def search_product: () -> Integer
+
+    # @rbs (Array[String] tokens, method: String) -> void
+    def compare_tokens!: (Array[String] tokens, method: String) -> void
+
+    # @rbs (Machine::Configuration left, Machine::Configuration right, Array[String] tokens) -> void
+    def compare_configurations!: (Machine::Configuration left, Machine::Configuration right, Array[String] tokens) -> void
+
+    # @rbs (Machine::Configuration left, Machine::Configuration right, Array[String] tokens, String method) -> void
+    def compare_results!: (Machine::Configuration left, Machine::Configuration right, Array[String] tokens, String method) -> void
+
+    # @rbs (Array[String] tokens, Symbol? left, Symbol? right, String method) -> bot
+    def raise_language_difference: (Array[String] tokens, Symbol? left, Symbol? right, String method) -> bot
+
+    # @rbs () -> bool
+    def structural_identity?: () -> bool
+
+    # @rbs () -> bool
+    def tree_structural_identity?: () -> bool
+
+    # @rbs (IR::Grammar grammar) -> Array[tree_node_signature]
+    def tree_grammar_signature: (IR::Grammar grammar) -> Array[tree_node_signature]
+
+    # @rbs (IR::node_annotation? node) -> tree_node_signature?
+    def node_signature: (IR::node_annotation? node) -> tree_node_signature?
+
+    # @rbs (IR::Automaton automaton, Machine::Configuration configuration, map_left: bool) -> Array[tree_trace_entry]
+    def tree_trace: (IR::Automaton automaton, Machine::Configuration configuration, map_left: bool) -> Array[tree_trace_entry]
+
+    # @rbs (IR::Grammar grammar, map_left: bool) -> Hash[Symbol, Object?]
+    def grammar_signature: (IR::Grammar grammar, map_left: bool) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Grammar grammar, map_left: bool) -> Hash[Symbol, Object?]
+    def recovery_signature: (IR::Grammar grammar, map_left: bool) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Grammar grammar) -> Array[terminal_signature]
+    def terminal_signatures: (IR::Grammar grammar) -> Array[terminal_signature]
+
+    # @rbs (IR::Grammar grammar, map_left: bool) -> Array[production_signature]
+    def production_signatures: (IR::Grammar grammar, map_left: bool) -> Array[production_signature]
+
+    # @rbs (IR::Grammar grammar, IR::Production production, map_left: bool) -> production_signature
+    def production_signature: (IR::Grammar grammar, IR::Production production, map_left: bool) -> production_signature
+
+    # @rbs (IR::Grammar grammar, Integer id) -> String
+    def symbol_name: (IR::Grammar grammar, Integer id) -> String
+
+    # @rbs (IR::Grammar grammar, String name, map_left: bool) -> String
+    def mapped_name: (IR::Grammar grammar, String name, map_left: bool) -> String
+
+    # @rbs () -> void
+    def validate_rule_map!: () -> void
+
+    # @rbs () -> void
+    def verify_inputs!: () -> void
+
+    # @rbs () -> Array[String]
+    def terminal_alphabet: () -> Array[String]
+
+    # @rbs (Machine::Configuration left, Machine::Configuration right) -> Array[Object?]
+    def product_key: (Machine::Configuration left, Machine::Configuration right) -> Array[Object?]
+
+    # @rbs (Machine::Configuration left, Machine::Configuration right) -> bool
+    def both_rejected?: (Machine::Configuration left, Machine::Configuration right) -> bool
+
+    # @rbs (structural: bool, samples: Integer, configurations: Integer) -> untyped
+    def successful_report: (structural: bool, samples: Integer, configurations: Integer) -> untyped
+
+    # @rbs () -> bool
+    def tree_requested?: () -> bool
+
+    # @rbs () -> Hash[Symbol, Integer]
+    def bounds: () -> Hash[Symbol, Integer]
+
+    # @rbs (Ibex::Error error) -> bool
+    def sample_budget_error?: (Ibex::Error error) -> bool
+  end
+end

data/sig/ibex/fix.rbs

@@ -0,0 +1,138 @@
+# Generated from lib/ibex/fix.rb with RBS::Inline
+
+module Ibex
+  # Bounded conflict-repair candidate generation and safety evaluation.
+  # rubocop:disable Metrics/ClassLength -- candidate generation and its three safety gates share one target identity.
+  class Fix
+    type candidate = { category: String, description: String, source: String?, algorithm: Symbol }
+
+    SCHEMA_VERSION: Integer
+
+    CATEGORIES: Array[String]
+
+    ADVICE_CATEGORIES: Array[String]
+
+    ADVICE_STATEMENT: String
+
+    class BudgetExceeded < Ibex::Error
+      attr_reader details: Hash[Symbol, Object?]
+
+      # @rbs (Hash[Symbol, Object?] details) -> void
+      def initialize: (Hash[Symbol, Object?] details) -> void
+    end
+
+    attr_reader sources: Hash[String, String]
+
+    # @rbs (String source, file: String, grammar: IR::Grammar, automaton: IR::Automaton, algorithm: Symbol,
+    #   mode: Symbol, ?state: Integer?, ?conflict_index: Integer?, ?max_candidates: Integer, ?max_builds: Integer,
+    #   ?equiv_max_tokens: Integer, ?equiv_max_configurations: Integer, ?equiv_samples: Integer,
+    #   ?verify_max_states: Integer, ?verify_max_items: Integer,
+    #   ?messages: ErrorMessages::Document?, ?message_file: String?) -> void
+    # rubocop:disable Metrics/ParameterLists
+    def initialize: (String source, file: String, grammar: IR::Grammar, automaton: IR::Automaton, algorithm: Symbol, mode: Symbol, ?state: Integer?, ?conflict_index: Integer?, ?max_candidates: Integer, ?max_builds: Integer, ?equiv_max_tokens: Integer, ?equiv_max_configurations: Integer, ?equiv_samples: Integer, ?verify_max_states: Integer, ?verify_max_items: Integer, ?messages: ErrorMessages::Document?, ?message_file: String?) -> void
+
+    # @rbs () -> Hash[Symbol, Object?]
+    def run: () -> Hash[Symbol, Object?]
+
+    private
+
+    # @rbs () -> [IR::AutomatonState, Integer, IR::conflict]
+    def select_target: () -> [ IR::AutomatonState, Integer, IR::conflict ]
+
+    # @rbs (IR::conflict conflict) -> Array[candidate]
+    def candidate_space: (IR::conflict conflict) -> Array[candidate]
+
+    # @rbs (IR::conflict conflict) -> Array[Hash[Symbol, Object?]]
+    def advice_space: (IR::conflict conflict) -> Array[Hash[Symbol, Object?]]
+
+    # @rbs (IR::conflict conflict) -> Array[candidate]
+    def precedence_declaration_candidates: (IR::conflict conflict) -> Array[candidate]
+
+    # @rbs (IR::conflict conflict) -> candidate?
+    def precedence_override_candidate: (IR::conflict conflict) -> candidate?
+
+    # @rbs () -> Array[candidate]
+    def algorithm_candidates: () -> Array[candidate]
+
+    # @rbs (IR::conflict conflict) -> candidate?
+    def inline_candidate: (IR::conflict conflict) -> candidate?
+
+    # @rbs (IR::conflict conflict) -> candidate
+    def expectation_candidate: (IR::conflict conflict) -> candidate
+
+    # @rbs (IR::conflict conflict) -> candidate?
+    def recovery_candidate: (IR::conflict conflict) -> candidate?
+
+    # @rbs (String category, String description, ?source: String?, ?algorithm: Symbol?) -> candidate
+    def candidate: (String category, String description, ?source: String?, ?algorithm: Symbol?) -> candidate
+
+    # @rbs (candidate candidate, IR::conflict target) -> Hash[Symbol, Object?]
+    def evaluate_candidate: (candidate candidate, IR::conflict target) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Automaton candidate, IR::conflict target) -> Hash[Symbol, String]?
+    def conflict_safety_failure: (IR::Automaton candidate, IR::conflict target) -> Hash[Symbol, String]?
+
+    # @rbs (IR::Automaton candidate) -> Hash[Symbol, String]?
+    def verification_safety_failure: (IR::Automaton candidate) -> Hash[Symbol, String]?
+
+    # @rbs (candidate candidate) -> IR::Automaton
+    def build_candidate: (candidate candidate) -> IR::Automaton
+
+    # @rbs (candidate candidate, Hash[Symbol, Object?] outcome, IR::conflict conflict, Integer number) ->
+    #   Hash[Symbol, Object?]
+    def proposal: (candidate candidate, Hash[Symbol, Object?] outcome, IR::conflict conflict, Integer number) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Automaton candidate) -> Hash[Symbol, Object?]
+    def message_catalog_impact: (IR::Automaton candidate) -> Hash[Symbol, Object?]
+
+    # @rbs (candidate candidate, Hash[Symbol, Object?] outcome) -> Hash[Symbol, Object?]
+    def rejection: (candidate candidate, Hash[Symbol, Object?] outcome) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::AutomatonState state, Integer index, IR::conflict conflict, Array[candidate] candidates,
+    #   Array[Hash[Symbol, Object?]] proposals, Array[Hash[Symbol, Object?]] rejections,
+    #   Array[Hash[Symbol, Object?]] advice) -> Hash[Symbol, Object?]
+    def report_for: (IR::AutomatonState state, Integer index, IR::conflict conflict, Array[candidate] candidates, Array[Hash[Symbol, Object?]] proposals, Array[Hash[Symbol, Object?]] rejections, Array[Hash[Symbol, Object?]] advice) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Automaton automaton) -> Array[[IR::AutomatonState, IR::conflict]]
+    def active_conflicts: (IR::Automaton automaton) -> Array[[ IR::AutomatonState, IR::conflict ]]
+
+    # @rbs (IR::conflict conflict) -> bool
+    def active_conflict?: (IR::conflict conflict) -> bool
+
+    # @rbs (IR::Automaton candidate, String target_fingerprint) -> bool
+    def increased_other_conflict?: (IR::Automaton candidate, String target_fingerprint) -> bool
+
+    # @rbs (IR::Automaton automaton) -> Hash[String, Integer]
+    def conflict_counts: (IR::Automaton automaton) -> Hash[String, Integer]
+
+    # @rbs (IR::Grammar grammar, IR::conflict conflict) -> String
+    def conflict_fingerprint: (IR::Grammar grammar, IR::conflict conflict) -> String
+
+    # @rbs (IR::Grammar grammar, Integer id) -> String
+    def production_shape: (IR::Grammar grammar, Integer id) -> String
+
+    # @rbs (IR::Grammar candidate_grammar) -> Hash[String, String]
+    def identity_rule_map: (IR::Grammar candidate_grammar) -> Hash[String, String]
+
+    # @rbs (String insertion) -> String
+    def insert_before_rule: (String insertion) -> String
+
+    # @rbs (String source, String insertion) -> String
+    def insert_before_rule_in: (String source, String insertion) -> String
+
+    # @rbs (Integer line_number, String suffix) -> String
+    def append_to_line: (Integer line_number, String suffix) -> String
+
+    # @rbs (String directive) -> String
+    def replace_or_insert_expectation: (String directive) -> String
+
+    # @rbs (String source, IR::conflict conflict) -> String
+    def update_expectation: (String source, IR::conflict conflict) -> String
+
+    # @rbs (String before, String after) -> String
+    def unified_diff: (String before, String after) -> String
+
+    # @rbs () -> Hash[Symbol, Integer]
+    def bounds: () -> Hash[Symbol, Integer]
+  end
+end

data/sig/ibex/frontend/ast.rbs

@@ -13,7 +13,7 @@ module Ibex
     module AST
       type symbol_metadata = DisplayName | SemanticType
 
-      type declaration = Include | Tokens | Precedence | Options | Expect | ExpectRR | Start | Recovery | OnErrorReduce | GrammarTest | Lexer | Convert | Parameter | Printer | symbol_metadata
+      type declaration = Include | Tokens | Precedence | Options | Expect | ExpectRR | Start | Recovery | OnErrorReduce | GrammarTest | Lexer | Convert | Parameter | Printer | ParserConfiguration | symbol_metadata
 
       type lexer_entry = LexerRule | LexerState
 
@@ -33,16 +33,18 @@ module Ibex
       end
 
       # Adds deterministic, recursively serializable hashes to Struct nodes.
-      # @rbs module-self Struct[untyped]
-      module Node : Struct[untyped]
-        def to_h: () -> untyped
+      # @rbs module-self Struct[Object?]
+      module Node : Struct[Object?]
+        # @rbs () -> Hash[Symbol, untyped]
+        def to_h: () -> Hash[Symbol, untyped]
 
         private
 
+        # @rbs (untyped value) -> untyped
         def serialize: (untyped value) -> untyped
       end
 
-      class Root < Struct[String | String? | Array[declaration] | Array[Rule] | user_code | Location | bool?]
+      class Root < Struct[String | String? | Array[declaration] | Array[Rule] | user_code | Location | bool? | Location?]
         attr_accessor class_name(): String
 
         attr_accessor superclass(): String?
@@ -59,8 +61,10 @@ module Ibex
 
         attr_accessor cst(): bool?
 
-        def self.new: (?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool?) -> instance
-                    | ({ ?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool? }) -> instance
+        attr_accessor extended_loc(): Location?
+
+        def self.new: (?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool?, ?extended_loc: Location?) -> instance
+                    | ({ ?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool?, ?extended_loc: Location? }) -> instance
       end
 
       class Fragment < Struct[Array[declaration] | Array[Rule] | Location]
@@ -282,6 +286,28 @@ module Ibex
                     | ({ ?name: String, ?code: String, ?loc: Location }) -> instance
       end
 
+      class ParserConfiguration < Struct[Array[ParserSetting] | Location]
+        attr_accessor settings(): Array[ParserSetting]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?settings: Array[ParserSetting], ?loc: Location) -> instance
+                    | ({ ?settings: Array[ParserSetting], ?loc: Location }) -> instance
+      end
+
+      class ParserSetting < Struct[Symbol | Location]
+        attr_accessor key(): Symbol
+
+        attr_accessor value(): Symbol
+
+        attr_accessor loc(): Location
+
+        def self.new: (?key: Symbol, ?value: Symbol, ?loc: Location) -> instance
+                    | ({ ?key: Symbol, ?value: Symbol, ?loc: Location }) -> instance
+      end
+
+      ROOT_ONLY_DECLARATION_NAMES: Hash[Class, String]
+
       class Alternative < Struct[Array[item] | InlineAction? | String? | NodeAnnotation? | Location]
         attr_accessor items(): Array[item]
 

data/sig/ibex/frontend/bootstrap_parser.rbs

@@ -10,6 +10,8 @@ module Ibex
 
       include BootstrapParserParameters
 
+      include ParserConfigurationSupport
+
       @mode: Symbol
 
       @index: Integer

data/sig/ibex/frontend/diagnostic.rbs

@@ -28,8 +28,8 @@ module Ibex
       # @rbs () -> String
       def to_s: () -> String
 
-      # @rbs () -> Hash[Symbol, untyped]
-      def to_h: () -> Hash[Symbol, untyped]
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
     end
 
     # Immutable output from a diagnostic parse.