ibex 0.2.0 → 0.4.0

data/sig/ibex/analysis/sets.rbs

@@ -10,6 +10,13 @@ module Ibex
 
       attr_reader follow_bits: Array[Integer]
 
+      # The index is a symbol id; each value lists the symbols that must be
+      # recomputed when the indexed symbol's set changes. These edges already
+      # point in the impact-propagation direction.
+      attr_reader first_dependencies: Array[Array[Integer]]
+
+      attr_reader follow_dependencies: Array[Array[Integer]]
+
       @grammar: IR::Grammar
 
       # @rbs (IR::Grammar grammar) -> void
@@ -44,6 +51,9 @@ module Ibex
       # @rbs () -> void
       def compute_follow: () -> void
 
+      # @rbs (Array[Array[Integer]] dependencies) -> Array[Array[Integer]]
+      def freeze_dependencies: (Array[Array[Integer]] dependencies) -> Array[Array[Integer]]
+
       # @rbs (IR::Production production, Array[Array[Integer]] dependencies) -> void
       def initialize_follow: (IR::Production production, Array[Array[Integer]] dependencies) -> void
 

data/sig/ibex/bison_import/importer.rbs

@@ -0,0 +1,140 @@
+# Generated from lib/ibex/bison_import/importer.rb with RBS::Inline
+
+module Ibex
+  module BisonImport
+    # Converts Bison declarations and productions into analysis-only Ibex
+    # source without parsing or executing C.
+    # rubocop:disable Metrics/ClassLength -- declaration and rule recovery share one positioned directive report.
+    class Importer
+      type alternative = { items: Array[String], precedence: String? }
+
+      type rule = { lhs: String, alternatives: Array[alternative] }
+
+      DEFAULT_MAX_BYTES: Integer
+
+      DEFAULT_MAX_TOKENS: Integer
+
+      DEFAULT_MAX_RULES: Integer
+
+      DEFAULT_MAX_ACTIONS: Integer
+
+      # @rbs (String source, file: String, ?class_name: String?, ?max_bytes: Integer,
+      #   ?max_tokens: Integer, ?max_rules: Integer, ?max_actions: Integer) -> void
+      def initialize: (String source, file: String, ?class_name: String?, ?max_bytes: Integer, ?max_tokens: Integer, ?max_rules: Integer, ?max_actions: Integer) -> void
+
+      # @rbs () -> Result
+      def run: () -> Result
+
+      private
+
+      # @rbs () -> void
+      def validate_source: () -> void
+
+      # @rbs () -> [String, String, Integer]
+      def split_sections: () -> [ String, String, Integer ]
+
+      # @rbs (String source) -> void
+      def parse_declarations: (String source) -> void
+
+      # @rbs (String source) -> Array[{ name: String, detail: String, line: Integer, column: Integer }]
+      def declaration_chunks: (String source) -> Array[{ name: String, detail: String, line: Integer, column: Integer }]
+
+      # @rbs (String detail) -> void
+      def parse_token_declaration: (String detail) -> void
+
+      # @rbs (String association, String detail) -> void
+      def parse_precedence: (String association, String detail) -> void
+
+      # @rbs (String detail) -> void
+      def parse_start: (String detail) -> void
+
+      # @rbs (Array[Tokenizer::Token] tokens) -> Array[rule]
+      def parse_rules: (Array[Tokenizer::Token] tokens) -> Array[rule]
+
+      # @rbs (Array[Tokenizer::Token] tokens) -> void
+      def register_nonterminals: (Array[Tokenizer::Token] tokens) -> void
+
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor) -> [Integer, Integer]?
+      def next_lhs: (Array[Tokenizer::Token] tokens, Integer cursor) -> [ Integer, Integer ]?
+
+      # Bison permits a named reference between an LHS and its colon:
+      # `expression[result]: ...`.
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor) -> [Integer, Integer]?
+      def lhs_definition_at: (Array[Tokenizer::Token] tokens, Integer cursor) -> [ Integer, Integer ]?
+
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor) -> [Array[alternative], Integer]
+      def parse_alternatives: (Array[Tokenizer::Token] tokens, Integer cursor) -> [ Array[alternative], Integer ]
+
+      # @rbs (Array[Tokenizer::Token] tokens, Integer cursor, alternative alternative) -> Integer
+      def consume_rule_directive: (Array[Tokenizer::Token] tokens, Integer cursor, alternative alternative) -> Integer
+
+      # @rbs (Tokenizer::Token token) -> String
+      def render_symbol: (Tokenizer::Token token) -> String
+
+      # @rbs (Tokenizer::Token token) -> String
+      def render_action: (Tokenizer::Token token) -> String
+
+      # @rbs (String code) -> String
+      def transform_action: (String code) -> String
+
+      # @rbs (Array[rule] rules) -> String
+      def render_source: (Array[rule] rules) -> String
+
+      # @rbs () -> String
+      def structural_status: () -> String
+
+      # @rbs (Array[String] lines) -> void
+      def render_precedence: (Array[String] lines) -> void
+
+      # @rbs (Array[String] lines, rule rule) -> void
+      def render_rule: (Array[String] lines, rule rule) -> void
+
+      # @rbs (String name, Integer line, Integer column, String detail) -> void
+      def record_directive: (String name, Integer line, Integer column, String detail) -> void
+
+      # @rbs (String detail) -> Array[String]
+      def declaration_atoms: (String detail) -> Array[String]
+
+      # @rbs (String source) -> String
+      def strip_declaration_comments: (String source) -> String
+
+      # @rbs (String value) -> bool
+      def identifier_atom?: (String value) -> bool
+
+      # @rbs (String value) -> bool
+      def literal_atom?: (String value) -> bool
+
+      # @rbs (String value) -> String
+      def sanitize_symbol: (String value) -> String
+
+      # @rbs (String value) -> String
+      def terminal_name: (String value) -> String
+
+      # All imported nonterminals receive a lowercase namespace. This avoids
+      # Ibex's terminal-by-case convention and declaration keyword collisions.
+      # @rbs (String value) -> String
+      def nonterminal_name: (String value) -> String
+
+      # @rbs () -> String
+      def resolved_class_name: () -> String
+
+      # @rbs (String value) -> String
+      def sanitize_class_name: (String value) -> String
+
+      # @rbs (String value) -> Integer?
+      def first_integer: (String value) -> Integer?
+
+      # @rbs (Integer count) -> void
+      def check_rule_budget: (Integer count) -> void
+
+      # @rbs (Integer count, Tokenizer::Token token) -> void
+      def check_action_budget: (Integer count, Tokenizer::Token token) -> void
+
+      # @rbs (Integer value, Symbol name) -> Integer
+      def positive_limit: (Integer value, Symbol name) -> Integer
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def bounds: () -> Hash[Symbol, Integer]
+    end
+  end
+end

data/sig/ibex/bison_import/tokenizer.rbs

@@ -0,0 +1,91 @@
+# Generated from lib/ibex/bison_import/tokenizer.rb with RBS::Inline
+
+module Ibex
+  module BisonImport
+    # Iterative scanner for the punctuation needed to recover Bison rules.
+    class Tokenizer
+      # One structural token with a byte-oriented source position.
+      class Token
+        attr_reader type: Symbol
+
+        attr_reader value: String
+
+        attr_reader line: Integer
+
+        attr_reader column: Integer
+
+        # @rbs (type: Symbol, value: String, line: Integer, column: Integer) -> void
+        def initialize: (type: Symbol, value: String, line: Integer, column: Integer) -> void
+      end
+
+      IDENTIFIER_START: Regexp
+
+      IDENTIFIER_CONTINUE: Regexp
+
+      # @rbs (String source, start_line: Integer, max_tokens: Integer) -> void
+      def initialize: (String source, start_line: Integer, max_tokens: Integer) -> void
+
+      # @rbs () -> Array[Token]
+      def tokenize: () -> Array[Token]
+
+      private
+
+      # @rbs () -> Token
+      def scan_token: () -> Token
+
+      # @rbs () -> void
+      def skip_ignored: () -> void
+
+      # @rbs () -> String
+      def scan_identifier: () -> String
+
+      # @rbs () -> String
+      def scan_directive: () -> String
+
+      # @rbs (Integer quote) -> String
+      def scan_quoted: (Integer quote) -> String
+
+      # @rbs () -> String
+      def scan_action: () -> String
+
+      # @rbs (Integer? byte) -> bool
+      def skip_action_opaque?: (Integer? byte) -> bool
+
+      # @rbs (Integer opener, Integer closer) -> String
+      def scan_delimited: (Integer opener, Integer closer) -> String
+
+      # @rbs () -> void
+      def skip_block_comment: () -> void
+
+      # @rbs () -> void
+      def skip_line: () -> void
+
+      # @rbs (String value) -> Symbol
+      def punctuation_type: (String value) -> Symbol
+
+      # @rbs (Integer? byte) -> bool
+      def identifier_start?: (Integer? byte) -> bool
+
+      # @rbs (Integer? byte) -> bool
+      def identifier_continue?: (Integer? byte) -> bool
+
+      # @rbs (Integer? byte) -> bool
+      def whitespace?: (Integer? byte) -> bool
+
+      # @rbs (Integer count) -> void
+      def check_token_budget: (Integer count) -> void
+
+      # @rbs () -> Integer?
+      def current_byte: () -> Integer?
+
+      # @rbs () -> Integer?
+      def peek_byte: () -> Integer?
+
+      # @rbs () -> bool
+      def eof?: () -> bool
+
+      # @rbs () -> void
+      def advance: () -> void
+    end
+  end
+end

data/sig/ibex/bison_import.rbs

@@ -0,0 +1,95 @@
+# Generated from lib/ibex/bison_import.rb with RBS::Inline
+
+module Ibex
+  # Clean-room, nonexecuting import of Bison grammar structure.
+  module BisonImport
+    DIRECTIVES: Hash[String, Symbol]
+
+    FOREIGN_ACTION_SENTINEL: String
+
+    STRUCTURAL_STATUS_MARKER: String
+
+    STRUCTURE_NEUTRAL_UNSUPPORTED: Array[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
+
+    # One directive occurrence and its original source position.
+    class Directive
+      attr_reader name: String
+
+      attr_reader status: Symbol
+
+      attr_reader line: Integer
+
+      attr_reader column: Integer
+
+      attr_reader detail: String
+
+      # @rbs (name: String, status: Symbol, line: Integer, column: Integer, detail: String) -> void
+      def initialize: (name: String, status: Symbol, line: Integer, column: Integer, detail: String) -> void
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+    end
+
+    # One opaque C action and its mechanical reference rewrite.
+    class Action
+      attr_reader id: Integer
+
+      attr_reader line: Integer
+
+      attr_reader column: Integer
+
+      attr_reader original: String
+
+      attr_reader transformed: String
+
+      attr_reader encoded: String
+
+      # @rbs (id: Integer, line: Integer, column: Integer, original: String, transformed: String,
+      #   encoded: String) -> void
+      def initialize: (id: Integer, line: Integer, column: Integer, original: String, transformed: String, encoded: String) -> void
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+    end
+
+    # Immutable source artifact and versioned analysis report.
+    class Result
+      attr_reader source: String
+
+      attr_reader file: String
+
+      attr_reader class_name: String
+
+      attr_reader directives: Array[Directive]
+
+      attr_reader actions: Array[Action]
+
+      attr_reader rule_count: Integer
+
+      attr_reader bounds: Hash[Symbol, Integer]
+
+      # @rbs (source: String, file: String, class_name: String, directives: Array[Directive],
+      #   actions: Array[Action], rule_count: Integer, bounds: Hash[Symbol, Integer]) -> void
+      def initialize: (source: String, file: String, class_name: String, directives: Array[Directive], actions: Array[Action], rule_count: Integer, bounds: Hash[Symbol, Integer]) -> void
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+
+      # @rbs () -> Array[Directive]
+      def structural_unsupported: () -> Array[Directive]
+
+      # @rbs () -> bool
+      def structurally_complete?: () -> bool
+    end
+
+    # @rbs (String source) -> bool
+    def self?.bison_source?: (String source) -> bool
+  end
+end

data/sig/ibex/bounded_subprocess.rbs

@@ -0,0 +1,76 @@
+# Generated from lib/ibex/bounded_subprocess.rb with RBS::Inline
+
+module Ibex
+  # Captures one shell-free child process under wall-clock and output budgets.
+  class BoundedSubprocess
+    DEFAULT_TIMEOUT_SECONDS: Integer
+
+    DEFAULT_MAX_OUTPUT_BYTES: Integer
+
+    TERMINATION_GRACE_SECONDS: Float
+
+    POLL_SECONDS: Float
+
+    # Immutable observation of one bounded child-process execution.
+    class Result
+      attr_reader stdout: String
+
+      attr_reader stderr: String
+
+      attr_reader status: Process::Status
+
+      attr_reader timed_out: bool
+
+      attr_reader output_limited: bool
+
+      # @rbs (stdout: String, stderr: String, status: Process::Status,
+      #   timed_out: bool, output_limited: bool) -> void
+      def initialize: (stdout: String, stderr: String, status: Process::Status, timed_out: bool, output_limited: bool) -> void
+    end
+
+    # @rbs (timeout_seconds: Integer, max_output_bytes: Integer) -> void
+    def initialize: (timeout_seconds: Integer, max_output_bytes: Integer) -> void
+
+    # @rbs (Array[String] command, input: String) -> Result
+    def run: (Array[String] command, input: String) -> Result
+
+    private
+
+    # @rbs (Array[String] command, String input, File stdin, File stdout, File stderr) -> Result
+    def run_with_files: (Array[String] command, String input, File stdin, File stdout, File stderr) -> Result
+
+    # @rbs (Array[String] command, File stdin, File stdout, File stderr) -> Integer
+    def spawn_child: (Array[String] command, File stdin, File stdout, File stderr) -> Integer
+
+    # @rbs (Integer pid, String stdout_path, String stderr_path) ->
+    #   [Process::Status, bool, bool]
+    def wait: (Integer pid, String stdout_path, String stderr_path) -> [ Process::Status, bool, bool ]
+
+    # @rbs (Integer pid) -> Process::Status
+    def terminate: (Integer pid) -> Process::Status
+
+    # @rbs (Integer pid) -> void
+    def terminate_descendants: (Integer pid) -> void
+
+    # @rbs (String signal, Integer pid) -> void
+    def signal_process_tree: (String signal, Integer pid) -> void
+
+    # @rbs (Integer pid) -> bool
+    def process_group_alive?: (Integer pid) -> bool
+
+    # @rbs () -> bool
+    def process_groups?: () -> bool
+
+    # @rbs (Integer pid) -> Process::Status
+    def process_status: (Integer pid) -> Process::Status
+
+    # @rbs (String stdout_path, String stderr_path) -> bool
+    def output_exceeded?: (String stdout_path, String stderr_path) -> bool
+
+    # @rbs (String path) -> String
+    def read_bounded: (String path) -> String
+
+    # @rbs () -> Float
+    def monotonic_time: () -> Float
+  end
+end

data/sig/ibex/cli/ambiguity.rbs

@@ -11,6 +11,10 @@ module Ibex
 
     private def normalize_grammar_path: (String) -> IR::Grammar
 
+    private def configuration_value: (String) -> untyped
+
+    private def set_configuration_option: (Symbol, Object?) -> void
+
     private
 
     # @rbs (Array[String] arguments) -> Integer
@@ -18,5 +22,7 @@ module Ibex
 
     # @rbs () -> OptionParser
     def ambiguity_option_parser: () -> OptionParser
+
+    private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?], ?explicit_keys: Array[Symbol]) -> IR::Grammar
   end
 end

data/sig/ibex/cli/analysis.rbs

@@ -0,0 +1,43 @@
+# Generated from lib/ibex/cli/analysis.rb with RBS::Inline
+
+module Ibex
+  # CLI entry points for deterministic grammar diff and metrics reports.
+  module CLIAnalysis
+    type analysis_options = Hash[Symbol, untyped]
+
+    private def normalize_grammar_path: (String) -> IR::Grammar
+
+    private def set_configuration_option: (Symbol, Object?) -> void
+
+    private def local_configuration_value: (Hash[Symbol, untyped], String) -> untyped
+
+    private def set_local_configuration_option: (Hash[Symbol, untyped], Symbol, untyped) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_diff_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_metrics_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments, String command, operands: String) -> Hash[Symbol, untyped]
+    def analysis_options: (Array[String] arguments, String command, operands: String) -> Hash[Symbol, untyped]
+
+    # @rbs (String path, Symbol algorithm, explicit: bool) -> IR::Automaton
+    def load_analysis_automaton: (String path, Symbol algorithm, explicit: bool) -> IR::Automaton
+
+    # @rbs (IR::Grammar grammar, Symbol algorithm, bool algorithm_explicit) -> IR::Automaton
+    def build_analysis_automaton: (IR::Grammar grammar, Symbol algorithm, bool algorithm_explicit) -> IR::Automaton
+
+    # @rbs (Hash[Symbol, untyped] report, String format) -> void
+    def write_analysis_report: (Hash[Symbol, untyped] report, String format) -> void
+
+    # @rbs (Hash[Symbol, untyped] settings) -> bool
+    def algo_set?: (Hash[Symbol, untyped] settings) -> bool
+
+    private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, untyped], ?explicit_keys: Array[Symbol]) -> IR::Grammar
+
+    private def configuration_value: (String) -> untyped
+  end
+end

data/sig/ibex/cli/bison_import.rbs

@@ -0,0 +1,32 @@
+# Generated from lib/ibex/cli/bison_import.rb with RBS::Inline
+
+module Ibex
+  # CLI boundary for analysis-only Bison grammar import.
+  module CLIBisonImport
+    type bison_import_options = { format: String, max_bytes: Integer, max_tokens: Integer, max_rules: Integer, max_actions: Integer, ?output: String, ?class_name: String, ?help: bool }
+
+    private def same_file_target?: (String, String) -> bool
+
+    private def atomic_write_ir: (String, String) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_bison_import_command: (Array[String] arguments) -> Integer
+
+    # @rbs () -> bison_import_options
+    def default_bison_import_options: () -> bison_import_options
+
+    # @rbs (bison_import_options settings) -> OptionParser
+    def bison_import_option_parser: (bison_import_options settings) -> OptionParser
+
+    # @rbs (OptionParser options, bison_import_options settings) -> void
+    def add_bison_import_budgets: (OptionParser options, bison_import_options settings) -> void
+
+    # @rbs (String path, bison_import_options settings) -> BisonImport::Result
+    def build_bison_import: (String path, bison_import_options settings) -> BisonImport::Result
+
+    # @rbs (String input, String? output, String source) -> void
+    def write_bison_import: (String input, String? output, String source) -> void
+  end
+end

data/sig/ibex/cli/config.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/ibex/cli/config.rb with RBS::Inline
+
+module Ibex
+  # Static effective-configuration reporting for source grammars and Grammar IR.
+  module CLIConfig
+    type config_options = { format: String, mode: Symbol, configuration_explicit: Array[Symbol], ?from: String, ?algorithm: Symbol, ?entry_isolation: bool, ?cst_trivia: Symbol, ?superclass: String, ?omit_actions: bool, ?help: String }
+
+    private def input_path: (Array[String]) -> String
+
+    private def set_local_configuration_option: (Hash[Symbol, Object?], Symbol, Object?) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_config_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> [config_options, Array[String]]
+    def config_options: (Array[String] arguments) -> [ config_options, Array[String] ]
+
+    # @rbs (OptionParser options, config_options settings) -> void
+    def add_config_options: (OptionParser options, config_options settings) -> void
+
+    # @rbs (OptionParser options, config_options settings) -> void
+    def add_config_contract_options: (OptionParser options, config_options settings) -> void
+
+    # @rbs (String path, config_options settings) -> Configuration::Input
+    def load_configuration_input: (String path, config_options settings) -> Configuration::Input
+
+    # @rbs (String path) -> Configuration::Input
+    def load_grammar_ir_configuration: (String path) -> Configuration::Input
+
+    # @rbs (Configuration::Report report, String format) -> void
+    def write_configuration_report: (Configuration::Report report, String format) -> void
+  end
+end

data/sig/ibex/cli/diagnostics.rbs

@@ -7,10 +7,14 @@ module Ibex
 
     DEFAULT_MAX_DIAGNOSTICS: Integer
 
-    type diagnostic_settings = { format: String, max_diagnostics: Integer, mode: Symbol, ?help: bool }
+    type diagnostic_settings = Hash[Symbol, untyped]
 
     private def input_path: (Array[String]) -> String
 
+    private def local_configuration_value: (Hash[Symbol, Object?], String) -> Object?
+
+    private def set_local_configuration_option: (Hash[Symbol, Object?], Symbol, Object?) -> void
+
     private
 
     # @rbs (Array[String] arguments) -> Integer
@@ -32,7 +36,16 @@ module Ibex
     # @rbs (Frontend::ParseResult result, format: String) -> void
     def write_diagnostics: (Frontend::ParseResult result, format: String) -> void
 
-    # @rbs (Frontend::ParseResult result) -> Hash[String, untyped]
-    def diagnostics_document: (Frontend::ParseResult result) -> Hash[String, untyped]
+    # @rbs (Frontend::ParseResult result) -> Hash[String, Object?]
+    def diagnostics_document: (Frontend::ParseResult result) -> Hash[String, Object?]
+
+    # @rbs (Frontend::Diagnostic diagnostic) -> String
+    def localized_diagnostic_text: (Frontend::Diagnostic diagnostic) -> String
+
+    # @rbs (Frontend::Diagnostic diagnostic) -> Hash[Symbol, Object?]
+    def localized_diagnostic_hash: (Frontend::Diagnostic diagnostic) -> Hash[Symbol, Object?]
+
+    # @rbs (Frontend::Diagnostic diagnostic) -> String
+    def localized_diagnostic_message: (Frontend::Diagnostic diagnostic) -> String
   end
 end

data/sig/ibex/cli/documentation.rbs

@@ -3,7 +3,7 @@
 module Ibex
   # Generates standalone grammar documentation from the canonical include closure.
   module CLIDocumentation
-    type documentation_settings = { format: String, mode: Symbol, ?output: String, ?help: bool }
+    type documentation_settings = Hash[Symbol, untyped]
 
     private def input_path: (Array[String]) -> String
 
@@ -11,6 +11,10 @@ module Ibex
 
     private def atomic_write_ir: (String path, String source) -> void
 
+    private def local_configuration_value: (Hash[Symbol, Object?], String) -> Object?
+
+    private def set_local_configuration_option: (Hash[Symbol, Object?], Symbol, Object?) -> void
+
     private
 
     # @rbs (Array[String] arguments) -> Integer

data/sig/ibex/cli/equiv.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/ibex/cli/equiv.rb with RBS::Inline
+
+module Ibex
+  # CLI entry point for bounded language comparison.
+  module CLIEquiv
+    type equiv_options = Hash[Symbol, untyped]
+
+    private def normalize_grammar_path: (String) -> IR::Grammar
+
+    private def configuration_value: (String) -> untyped
+
+    private def set_configuration_option: (Symbol, Object?) -> void
+
+    private def local_configuration_value: (Hash[Symbol, Object?], String) -> Object?
+
+    private def set_local_configuration_option: (Hash[Symbol, Object?], Symbol, Object?) -> void
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_equiv_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> equiv_options
+    def equiv_options: (Array[String] arguments) -> equiv_options
+
+    # @rbs () -> equiv_options
+    def default_equiv_options: () -> equiv_options
+
+    # @rbs (OptionParser options, equiv_options settings) -> void
+    def add_equiv_search_options: (OptionParser options, equiv_options settings) -> void
+
+    # @rbs (String path, Symbol algorithm, explicit: bool) -> IR::Automaton
+    def load_equiv_automaton: (String path, Symbol algorithm, explicit: bool) -> IR::Automaton
+
+    # @rbs (IR::Grammar grammar, Symbol algorithm, bool algorithm_explicit) -> IR::Automaton
+    def build_equiv_automaton: (IR::Grammar grammar, Symbol algorithm, bool algorithm_explicit) -> IR::Automaton
+
+    # @rbs (Hash[Symbol, Object?] report, String format) -> void
+    def write_equiv_report: (Hash[Symbol, Object?] report, String format) -> void
+
+    # @rbs (equiv_options settings) -> bool
+    def algorithm_explicit_equiv?: (equiv_options settings) -> bool
+
+    private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?], ?explicit_keys: Array[Symbol]) -> IR::Grammar
+
+    # @rbs (Integer value, String name) -> Integer
+    def positive_equiv_option: (Integer value, String name) -> Integer
+  end
+end

data/sig/ibex/cli/error_messages.rbs

@@ -25,6 +25,10 @@ module Ibex
 
     private def record_generation_input: (String, String) -> GenerationInput
 
+    private def select_configuration_mode: (String) -> void
+
+    private def set_configuration_option: (Symbol, Object?) -> void
+
     private
 
     # @rbs (Array[String] arguments) -> Integer
@@ -53,5 +57,7 @@ module Ibex
 
     # @rbs (String path) -> Integer
     def messages_file_mode: (String path) -> Integer
+
+    private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?], ?explicit_keys: Array[Symbol]) -> IR::Grammar
   end
 end