ibex 0.1.0 → 0.3.0

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

@@ -0,0 +1,28 @@
+# Generated from lib/ibex/cli/ambiguity.rb with RBS::Inline
+
+module Ibex
+  # Bounded grammar ambiguity checking for CI and human inspection.
+  module CLIAmbiguity
+    private def print_help: (OptionParser) -> Integer
+
+    private def input_path: (Array[String]) -> String
+
+    private def positive_counterexample_limit: (Integer, String) -> Integer
+
+    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
+    def run_check_command: (Array[String] arguments) -> Integer
+
+    # @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/counterexample_options.rbs

@@ -3,6 +3,8 @@
 module Ibex
   # Counterexample report limits and their command-line validation.
   module CLICounterexampleOptions
+    @options: cli_options
+
     DEFAULTS: Hash[Symbol, Integer]
 
     private

data/sig/ibex/cli/coverage.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/cli/coverage.rb with RBS::Inline
+
+module Ibex
+  # CLI collection, merge, and threshold checks for runtime coverage.
+  module CLICoverage
+    private def same_file_target?: (String left, String right) -> bool
+
+    type coverage_output_options = { paths: Array[String], ?output: String }
+
+    type coverage_check_options = { paths: Array[String], min_states: Float, min_productions: Float }
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_collect: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_merge: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_coverage_check: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments, String command, String operands) -> coverage_output_options
+    def coverage_output_options: (Array[String] arguments, String command, String operands) -> coverage_output_options
+
+    # @rbs (Array[String] arguments) -> coverage_check_options
+    def coverage_check_options: (Array[String] arguments) -> coverage_check_options
+
+    # @rbs (Float value, String name) -> Float
+    def coverage_threshold: (Float value, String name) -> Float
+
+    # @rbs (Integer covered, Integer total) -> Float
+    def coverage_percentage: (Integer covered, Integer total) -> Float
+
+    # @rbs (Array[String] arguments, String command) -> String
+    def single_coverage_path: (Array[String] arguments, String command) -> String
+
+    # @rbs (Array[String] inputs, String? output) -> void
+    def reject_coverage_output_collision: (Array[String] inputs, String? output) -> void
+
+    # @rbs (Coverage::Report report, String? output) -> void
+    def write_coverage_report: (Coverage::Report report, String? output) -> void
+
+    # @rbs (String path, String source) -> void
+    def atomic_write_coverage: (String path, String source) -> void
+
+    # @rbs (String path) -> Integer
+    def coverage_file_mode: (String path) -> Integer
+  end
+end

data/sig/ibex/cli/debug.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/ibex/cli/debug.rb with RBS::Inline
+
+module Ibex
+  # Safe parser-table simulation subcommand.
+  module CLIDebug
+    type debug_options = { paths: Array[String], format: String, max_steps: Integer, max_stack: Integer }
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_debug_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String] arguments) -> debug_options
+    def debug_options: (Array[String] arguments) -> debug_options
+
+    # @rbs (Integer value, String name) -> Integer
+    def positive_debug_budget: (Integer value, String name) -> Integer
+
+    # @rbs (TableSimulation::Simulator simulator, String format) -> TableSimulation::Result
+    def simulate_debug_input: (TableSimulation::Simulator simulator, String format) -> TableSimulation::Result
+
+    # @rbs (TableSimulation::Result result, String format, steps_written: bool) -> void
+    def write_debug_result: (TableSimulation::Result result, String format, steps_written: bool) -> void
+
+    # @rbs (Array[TableSimulation::Step] steps) -> void
+    def write_debug_steps: (Array[TableSimulation::Step] steps) -> void
+  end
+end

data/sig/ibex/cli/diagnostics.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/ibex/cli/diagnostics.rb with RBS::Inline
+
+module Ibex
+  # Batch frontend diagnostics subcommand.
+  module CLIDiagnostics
+    DIAGNOSTICS_SCHEMA_VERSION: Integer
+
+    DEFAULT_MAX_DIAGNOSTICS: Integer
+
+    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
+    def run_diagnose_command: (Array[String] arguments) -> Integer
+
+    # Cross-file recovery is deliberately bounded to the first resolver error.
+    # @rbs (Frontend::ParseResult result, String path, Symbol mode) -> Frontend::ParseResult
+    def resolve_diagnostic_result: (Frontend::ParseResult result, String path, Symbol mode) -> Frontend::ParseResult
+
+    # @rbs (Ibex::Error error, String fallback_file) -> Frontend::Diagnostic
+    def resolution_diagnostic: (Ibex::Error error, String fallback_file) -> Frontend::Diagnostic
+
+    # @rbs (diagnostic_settings settings) -> OptionParser
+    def diagnostics_option_parser: (diagnostic_settings settings) -> OptionParser
+
+    # @rbs (String value) -> Integer
+    def positive_diagnostic_limit: (String value) -> Integer
+
+    # @rbs (Frontend::ParseResult result, format: String) -> void
+    def write_diagnostics: (Frontend::ParseResult result, format: String) -> void
+
+    # @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

@@ -0,0 +1,29 @@
+# Generated from lib/ibex/cli/documentation.rb with RBS::Inline
+
+module Ibex
+  # Generates standalone grammar documentation from the canonical include closure.
+  module CLIDocumentation
+    type documentation_settings = Hash[Symbol, untyped]
+
+    private def input_path: (Array[String]) -> String
+
+    private def same_file_target?: (String left, String right) -> bool
+
+    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
+    def run_documentation_command: (Array[String] arguments) -> Integer
+
+    # @rbs (String output, Array[String] grammar_files) -> void
+    def reject_documentation_output_collision: (String output, Array[String] grammar_files) -> void
+
+    # @rbs (documentation_settings settings) -> OptionParser
+    def documentation_option_parser: (documentation_settings settings) -> OptionParser
+  end
+end

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

@@ -0,0 +1,63 @@
+# Generated from lib/ibex/cli/error_messages.rb with RBS::Inline
+
+module Ibex
+  # CLI subcommand and generation-file handling for example-keyed errors.
+  module CLIErrorMessages
+    private def print_help: (OptionParser) -> Integer
+
+    private def input_path: (Array[String]) -> String
+
+    private def warning_categories: (String) -> Array[Symbol]
+
+    private def report_status: (String) -> void
+
+    private def handle_grammar_warnings: (IR::Grammar, String) -> void
+
+    private def build_automaton: (IR::Grammar, String) -> IR::Automaton
+
+    private def prepare_loaded_automaton: (IR::Automaton, String) -> void
+
+    private def default_output_path: (String, String) -> String
+
+    private def same_file_target?: (String, String) -> bool
+
+    private def normalize_grammar_path: (String) -> IR::Grammar
+
+    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
+    def run_error_messages_command: (Array[String] arguments) -> Integer
+
+    # @rbs () -> OptionParser
+    def error_messages_option_parser: () -> OptionParser
+
+    # @rbs (String input_path) -> IR::Automaton
+    def automaton_for_error_messages: (String input_path) -> IR::Automaton
+
+    # @rbs (String input_path) -> IR::Automaton
+    def automaton_from_ir_for_messages: (String input_path) -> IR::Automaton
+
+    # @rbs (IR::Automaton automaton, String input_path) -> void
+    def write_error_messages: (IR::Automaton automaton, String input_path) -> void
+
+    # @rbs () -> { max_tokens: Integer, max_configurations: Integer }
+    def error_message_search_limits: () -> { max_tokens: Integer, max_configurations: Integer }
+
+    # @rbs (Integer value, String option) -> Integer
+    def positive_messages_limit: (Integer value, String option) -> Integer
+
+    # @rbs (ErrorMessages::Update update) -> void
+    def write_error_message_update_report: (ErrorMessages::Update update) -> void
+
+    # @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

data/sig/ibex/cli/explain.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/ibex/cli/explain.rb with RBS::Inline
+
+module Ibex
+  # Dedicated command-line view for selected parser conflicts.
+  module CLIExplain
+    private def print_help: (OptionParser) -> Integer
+
+    private def input_path: (Array[String]) -> String
+
+    private def positive_counterexample_limit: (Integer, String) -> Integer
+
+    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
+    def run_explain_command: (Array[String] arguments) -> Integer
+
+    # @rbs () -> OptionParser
+    def explain_option_parser: () -> OptionParser
+
+    # @rbs (OptionParser options) -> void
+    def add_explain_search_options: (OptionParser options) -> void
+
+    private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?], ?explicit_keys: Array[Symbol]) -> IR::Grammar
+  end
+end