ibex 0.1.0 → 0.3.0

data/sig/ibex/codegen/ruby.rbs

@@ -3,48 +3,104 @@
 module Ibex
   module Codegen
     # Generates a standalone Ruby parser class from Automaton IR.
+    # rubocop:disable Metrics/ClassLength -- generation stages are split into focused mixins.
     class Ruby
-      @executable: String?
+      include RubyActions
 
-      @superclass: String
+      include RubyErrorMessages
 
-      @omit_action_call: bool
+      include RubyTableMetadata
 
-      @debug: bool
+      include RubyValuePrinters
 
-      @line_convert_all: bool
+      include RubyLexer
 
-      @line_convert: bool
+      include RubyAST
 
-      @embedded: bool
+      include RubySyntax
 
-      @table_format: Symbol
+      @automaton: IR::Automaton
 
       @grammar: IR::Grammar
 
-      @automaton: IR::Automaton
+      @table_format: Symbol
+
+      @embedded: bool
+
+      @line_convert: bool
+
+      @line_convert_all: bool
+
+      @debug: bool
+
+      @omit_action_call: bool
+
+      @superclass: String
+
+      @executable: String?
+
+      @cst_trivia: Symbol
+
+      @error_messages: Hash[Integer, String | { id: String, message: String }]
+
+      @generated_action_abi: GeneratedActionABI::Cache
+
+      @runtime_require: String?
 
       # @rbs (IR::Automaton automaton, ?table: Symbol | String, ?embedded: bool, ?line_convert: bool,
       #   ?line_convert_all: bool, ?debug: bool, ?omit_action_call: bool?, ?superclass: String?,
-      #   ?executable: String?) -> void
-      def initialize: (IR::Automaton automaton, ?table: Symbol | String, ?embedded: bool, ?line_convert: bool, ?line_convert_all: bool, ?debug: bool, ?omit_action_call: bool?, ?superclass: String?, ?executable: String?) -> void
+      #   ?executable: String?, ?cst_trivia: Symbol | String, ?runtime_require: String?,
+      #   ?error_messages: Hash[Integer, String | { id: String, message: String }]) -> void
+      def initialize: (IR::Automaton automaton, ?table: Symbol | String, ?embedded: bool, ?line_convert: bool, ?line_convert_all: bool, ?debug: bool, ?omit_action_call: bool?, ?superclass: String?, ?executable: String?, ?cst_trivia: Symbol | String, ?runtime_require: String?, ?error_messages: Hash[Integer, String | { id: String, message: String }]) -> void
 
       # @rbs () -> String
       def generate: () -> String
 
       private
 
+      # @rbs () -> void
+      def reject_foreign_actions: () -> void
+
+      # Kept local so the generic generator does not load the optional Bison
+      # importer and its IR validation graph.
+      # @rbs () -> String
+      def foreign_action_sentinel: () -> String
+
       # @rbs (Array[String] lines) -> void
       def append_runtime: (Array[String] lines) -> void
 
-      # @rbs (String relative_path) -> String
-      def embedded_source: (String relative_path) -> String
-
       # @rbs (Array[String] lines) -> void
       def append_tables: (Array[String] lines) -> void
 
-      # @rbs (untyped table) -> String
-      def table_literal: (untyped table) -> String
+      # @rbs (Array[String] lines, String indent) -> void
+      def append_cst_metadata: (Array[String] lines, String indent) -> void
+
+      # @rbs (Array[String] lines, String indent, Tables::TableSet table_set) -> void
+      def append_parser_tables: (Array[String] lines, String indent, Tables::TableSet table_set) -> void
+
+      # @rbs (Array[String] lines) -> void
+      def append_parameter_initializer: (Array[String] lines) -> void
+
+      # Custom conversion expressions can return caller-owned mutable or
+      # inherently unshareable objects, so only standard token mappings are
+      # safe to freeze transitively.
+      # @rbs () -> bool
+      def shareable_parser_tables?: () -> bool
+
+      # @rbs () -> CSTMetadata::metadata
+      def cst_metadata: () -> CSTMetadata::metadata
+
+      # @rbs (Object? value) -> String
+      def deep_frozen_literal: (Object? value) -> String
+
+      # @rbs (Object? table) -> String
+      def table_literal: (Object? table) -> String
+
+      # @rbs (Array[untyped] values) -> String
+      def packed_integers_literal: (Array[untyped] values) -> String
+
+      # @rbs (Array[untyped] values) -> String
+      def packed_signed_integers_literal: (Array[untyped] values) -> String
 
       # @rbs () -> String
       def token_ids_literal: () -> String
@@ -55,26 +111,47 @@ module Ibex
       # @rbs () -> String
       def token_names_literal: () -> String
 
+      # @rbs () -> String
+      def symbol_names_literal: () -> String
+
       # @rbs () -> String
       def productions_literal: () -> String
 
-      # @rbs (Array[String] lines) -> void
-      def append_actions: (Array[String] lines) -> void
+      # @rbs () -> String
+      def plain_productions_literal: () -> String
+
+      # @rbs (IR::Production production, bool generated_action) -> String
+      def production_action_abi_literal: (IR::Production production, bool generated_action) -> String
+
+      # @rbs () -> String
+      def compact_productions_literal: () -> String
+
+      # @rbs (IR::Production production) -> Integer
+      def compact_production_flags: (IR::Production production) -> Integer
+
+      # @rbs () -> String
+      def compact_production_metadata_literal: () -> String
+
+      # Reductions that are the sole non-error behavior of a state may run
+      # before requesting another lexer token. This enables parser actions to
+      # select lexer_state without speculative lookahead.
+      # @rbs () -> String
+      def eager_reductions_literal: () -> String
 
-      # @rbs (Array[String] lines, IR::Production production) -> void
-      def append_action_constant: (Array[String] lines, IR::Production production) -> void
+      # @rbs (IR::AutomatonState state) -> IR::reduce_action?
+      def eager_lexer_feedback_reduction: (IR::AutomatonState state) -> IR::reduce_action?
 
-      # @rbs (Array[String] lines, IR::Production production) -> void
-      def append_action_method: (Array[String] lines, IR::Production production) -> void
+      # @rbs (IR::Action? action) -> [String, String]
+      def production_location_metadata: (IR::Action? action) -> [ String, String ]
 
-      # @rbs (Array[String] lines, IR::Action? action) -> void
-      def append_named_bindings: (Array[String] lines, IR::Action? action) -> void
+      # @rbs () -> bool
+      def uses_locations?: () -> bool
 
-      # @rbs (Array[String] lines, IR::Production production) -> void
-      def append_semantic_code: (Array[String] lines, IR::Production production) -> void
+      # @rbs (IR::Production production, IR::Action action) -> bool
+      def action_references_locations?: (IR::Production production, IR::Action action) -> bool
 
-      # @rbs (IR::Production production) -> bool
-      def action_method?: (IR::Production production) -> bool
+      # @rbs () -> bool
+      def cst?: () -> bool
 
       # @rbs (Array[String] lines, String name, ?indent: Integer) -> void
       def append_user_code: (Array[String] lines, String name, ?indent: Integer) -> void

data/sig/ibex/codegen/ruby_actions.rbs

@@ -0,0 +1,54 @@
+# Generated from lib/ibex/codegen/ruby_actions.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Semantic-action method generation shared by direct and source-mapped
+    # Ruby output.
+    module RubyActions
+      include RubyAST
+
+      @action_method_source: ActionMethodSource?
+
+      @omit_action_call: bool
+
+      @line_convert: bool
+
+      @grammar: IR::Grammar
+
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_actions: (Array[String] lines) -> void
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_composed_action_method: (Array[String] lines, IR::Production production) -> void
+
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
+      def append_composed_fragment_method: (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
+
+      # @rbs (IR::Production production, Integer index) -> String
+      def composed_fragment_name: (IR::Production production, Integer index) -> String
+
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_plan plan) -> void
+      def append_composed_orchestrator: (Array[String] lines, IR::Production production, IR::action_composition_plan plan) -> void
+
+      # @rbs (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
+      def append_composed_step: (Array[String] lines, IR::Production production, IR::action_composition_step step, Integer index) -> void
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_compiled_action_method: (Array[String] lines, IR::Production production) -> void
+
+      # @rbs (Array[String] lines, IR::Production production) -> void
+      def append_action_method: (Array[String] lines, IR::Production production) -> void
+
+      # @rbs (IR::Production production) -> bool
+      def action_method?: (IR::Production production) -> bool
+
+      # @rbs (IR::Production production) -> bool
+      def composed_action?: (IR::Production production) -> bool
+
+      # @rbs () -> ActionMethodSource
+      def action_method_source: () -> ActionMethodSource
+    end
+  end
+end

data/sig/ibex/codegen/ruby_ast.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/ibex/codegen/ruby_ast.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Generates typed AST data classes and traversal bases from @node metadata.
+    module RubyAST
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_ast: (Array[String] lines) -> void
+
+      # @rbs () -> Hash[String, IR::node_annotation]
+      def ast_node_definitions: () -> Hash[String, IR::node_annotation]
+
+      # @rbs (Array[String] lines, Hash[String, IR::node_annotation] definitions) -> void
+      def append_visitor: (Array[String] lines, Hash[String, IR::node_annotation] definitions) -> void
+
+      # @rbs (Array[String] lines) -> void
+      def append_visit_children: (Array[String] lines) -> void
+
+      # @rbs (Array[String] lines, Hash[String, IR::node_annotation] definitions) -> void
+      def append_listener: (Array[String] lines, Hash[String, IR::node_annotation] definitions) -> void
+
+      # @rbs (Array[String] lines, Hash[String, IR::node_annotation] definitions, :enter | :exit kind) -> void
+      def append_listener_dispatch: (Array[String] lines, Hash[String, IR::node_annotation] definitions, :enter | :exit kind) -> void
+
+      # @rbs (IR::Production production) -> String
+      def ast_node_action_source: (IR::Production production) -> String
+
+      # @rbs (String name) -> String
+      def ast_method_name: (String name) -> String
+    end
+  end
+end

data/sig/ibex/codegen/ruby_error_messages.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ibex/codegen/ruby_error_messages.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Serializes immutable example-keyed error records into generated Ruby.
+    module RubyErrorMessages
+      private
+
+      # @rbs () -> String
+      def error_messages_literal: () -> String
+
+      # @rbs (String | { id: String, message: String } message) -> String
+      def error_message_literal: (String | { id: String, message: String } message) -> String
+    end
+  end
+end

data/sig/ibex/codegen/ruby_lexer.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/ibex/codegen/ruby_lexer.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Generated lexer tables and action methods.
+    module RubyLexer
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_lexer: (Array[String] lines) -> void
+
+      # @rbs (Array[String] lines, IR::Lexer lexer) -> void
+      def append_lexer_rules: (Array[String] lines, IR::Lexer lexer) -> void
+
+      # @rbs (IR::LexerRule rule) -> String
+      def lexer_rule_literal: (IR::LexerRule rule) -> String
+
+      # @rbs (Array[String] lines, IR::Lexer lexer) -> void
+      def append_lexer_actions: (Array[String] lines, IR::Lexer lexer) -> void
+
+      # @rbs (IR::LexerRule rule) -> String
+      def lexer_action_source: (IR::LexerRule rule) -> String
+    end
+  end
+end

data/sig/ibex/codegen/ruby_syntax.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/ibex/codegen/ruby_syntax.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Generates typed Red syntax views from @node metadata.
+    module RubySyntax
+      type syntax_definition = Hash[Symbol, untyped]
+
+      private
+
+      # @rbs (Array[String] lines) -> void
+      def append_syntax: (Array[String] lines) -> void
+
+      # @rbs () -> Hash[String, syntax_definition]
+      def syntax_node_definitions: () -> Hash[String, syntax_definition]
+
+      # @rbs (Hash[String, CSTMetadata::field_slot] left, Hash[String, CSTMetadata::field_slot] right) -> Hash[String, CSTMetadata::field_slot]
+      def merge_syntax_fields: (Hash[String, CSTMetadata::field_slot] left, Hash[String, CSTMetadata::field_slot] right) -> Hash[String, CSTMetadata::field_slot]
+
+      # @rbs (Array[String] lines, syntax_definition definition) -> void
+      def append_syntax_node: (Array[String] lines, syntax_definition definition) -> void
+
+      # @rbs (Array[String] lines, Hash[String, CSTMetadata::field_slot] fields) -> void
+      def append_repetition_accessors: (Array[String] lines, Hash[String, CSTMetadata::field_slot] fields) -> void
+    end
+  end
+end

data/sig/ibex/codegen/ruby_table_metadata.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/ibex/codegen/ruby_table_metadata.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Emits immutable identity and size metadata for generated parser tables.
+    module RubyTableMetadata
+      @automaton: IR::Automaton
+
+      @grammar: IR::Grammar
+
+      private
+
+      # @rbs (Array[String] lines, String indent) -> void
+      def append_table_metadata: (Array[String] lines, String indent) -> void
+
+      # @rbs (Array[String] lines) -> void
+      def append_entry_methods: (Array[String] lines) -> void
+
+      # @rbs () -> String
+      def entry_table_fields: () -> String
+
+      # @rbs () -> String
+      def recovery_table_fields: () -> String
+    end
+  end
+end

data/sig/ibex/codegen/ruby_value_printers.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/ibex/codegen/ruby_value_printers.rb with RBS::Inline
+
+module Ibex
+  module Codegen
+    # Emits declarative value-printer tables and methods for Ruby parsers.
+    module RubyValuePrinters
+      @grammar: IR::Grammar
+
+      @line_convert: bool
+
+      @value_printer_action_method_source: ActionMethodSource?
+
+      private
+
+      # @rbs (Array[String] lines, String indent) -> void
+      def append_value_printer_table: (Array[String] lines, String indent) -> void
+
+      # @rbs (Array[String] lines) -> void
+      def append_value_printers: (Array[String] lines) -> void
+
+      # @rbs (Array[String] lines, IR::value_printer printer) -> void
+      def append_value_printer: (Array[String] lines, IR::value_printer printer) -> void
+
+      # @rbs () -> ActionMethodSource
+      def value_printer_action_method_source: () -> ActionMethodSource
+    end
+  end
+end

data/sig/ibex/configuration/analysis_grammar.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/ibex/configuration/analysis_grammar.rb with RBS::Inline
+
+module Ibex
+  module Configuration
+    # Produces an immutable Grammar IR view suitable for an explicitly
+    # noncanonical analysis algorithm. The source-owned contract remains the
+    # authority; callers must report the override through Configuration::Value.
+    module AnalysisGrammar
+      # @rbs (IR::Grammar grammar, Symbol algorithm) -> IR::Grammar
+      def self?.for_algorithm: (IR::Grammar grammar, Symbol algorithm) -> IR::Grammar
+    end
+  end
+end

data/sig/ibex/configuration/explanation.rbs

@@ -0,0 +1,195 @@
+# Generated from lib/ibex/configuration/explanation.rb with RBS::Inline
+
+module Ibex
+  module Configuration
+    # One observed configuration source and how it participated in selection.
+    class Evidence
+      STATUSES: Array[Symbol]
+
+      SOURCES: Array[Symbol]
+
+      attr_reader key: Key
+
+      attr_reader source: Symbol
+
+      attr_reader value: config_value
+
+      attr_reader status: Symbol
+
+      attr_reader location: Location?
+
+      attr_reader reason: String
+
+      # @rbs (Key key, source: Symbol, value: config_value, status: Symbol, reason: String,
+      #   ?location: Location?) -> void
+      def initialize: (Key key, source: Symbol, value: config_value, status: Symbol, reason: String, ?location: Location?) -> void
+
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
+
+      private
+
+      # @rbs (config_value value) -> (String | Integer | bool | nil)
+      def json_value: (config_value value) -> (String | Integer | bool | nil)
+    end
+
+    # Whether an input can prove the historical source of a selected setting.
+    class Recording
+      STATES: Array[Symbol]
+
+      attr_reader state: Symbol
+
+      attr_reader reason: String
+
+      # @rbs (Symbol state, String reason) -> void
+      def initialize: (Symbol state, String reason) -> void
+
+      # @rbs () -> Hash[String, String]
+      def to_h: () -> Hash[String, String]
+    end
+
+    # Canonical, static input facts used to build a configuration report.
+    class Input
+      KINDS: Array[Symbol]
+
+      attr_reader kind: Symbol
+
+      attr_reader path: String
+
+      attr_reader files: Array[String]
+
+      attr_reader schema_version: Integer?
+
+      attr_reader grammar_values: Hash[String, config_value]
+
+      attr_reader grammar_locations: Hash[String, Location]
+
+      attr_reader evidence: Hash[String, Array[Evidence]]
+
+      attr_reader recordings: Hash[String, Recording]
+
+      # @rbs (kind: Symbol, path: String, ?files: Array[String], ?schema_version: Integer?,
+      #   ?grammar_values: Hash[String, config_value], ?grammar_locations: Hash[String, Location],
+      #   ?evidence: Hash[String, Array[Evidence]], ?recordings: Hash[String, Recording]) -> void
+      def initialize: (kind: Symbol, path: String, ?files: Array[String], ?schema_version: Integer?, ?grammar_values: Hash[String, config_value], ?grammar_locations: Hash[String, Location], ?evidence: Hash[String, Array[Evidence]], ?recordings: Hash[String, Recording]) -> void
+
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
+
+      private
+
+      # @rbs (Symbol kind, String path, Array[String] files, Integer? schema_version,
+      #   Hash[String, config_value] grammar_values, Hash[String, Location] grammar_locations,
+      #   Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings) -> void
+      def assign_input: (Symbol kind, String path, Array[String] files, Integer? schema_version, Hash[String, config_value] grammar_values, Hash[String, Location] grammar_locations, Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings) -> void
+
+      # @rbs (Array[String] files, String path) -> void
+      def validate_files!: (Array[String] files, String path) -> void
+
+      # @rbs (Symbol kind, Integer? schema_version) -> void
+      def validate_schema_version!: (Symbol kind, Integer? schema_version) -> void
+
+      # @rbs (Hash[String, config_value] values, Hash[String, Location] locations,
+      #   Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings) -> void
+      def validate_entries!: (Hash[String, config_value] values, Hash[String, Location] locations, Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings) -> void
+
+      # @rbs (*Hash[Object?, Object?] values) -> void
+      def validate_fact_hashes!: (*Hash[Object?, Object?] values) -> void
+
+      # @rbs (Hash[String, config_value] values, Hash[String, Location] locations) -> void
+      def validate_locations!: (Hash[String, config_value] values, Hash[String, Location] locations) -> void
+
+      # @rbs (Hash[String, Array[Evidence]] evidence) -> void
+      def validate_evidence!: (Hash[String, Array[Evidence]] evidence) -> void
+
+      # @rbs (Hash[String, Recording] recordings) -> void
+      def validate_recordings!: (Hash[String, Recording] recordings) -> void
+
+      # @rbs (Hash[String, config_value] values) -> Hash[String, config_value]
+      def immutable_values: (Hash[String, config_value] values) -> Hash[String, config_value]
+    end
+
+    # A fixed-contract mismatch retained as structured report data.
+    class ConflictRecord
+      attr_reader key: Key
+
+      attr_reader declared: Value
+
+      attr_reader requested: Value
+
+      # @rbs (Conflict conflict) -> void
+      def initialize: (Conflict conflict) -> void
+
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
+
+      # @rbs () -> String
+      def message: () -> String
+
+      private
+
+      # @rbs (Value value) -> Hash[String, json_value]
+      def selection: (Value value) -> Hash[String, json_value]
+    end
+
+    # The effective value and all accepted or rejected evidence for one key.
+    class Explanation
+      attr_reader value: Value
+
+      attr_reader evidence: Array[Evidence]
+
+      attr_reader recording: Recording
+
+      # @rbs (Value value, evidence: Array[Evidence], recording: Recording) -> void
+      def initialize: (Value value, evidence: Array[Evidence], recording: Recording) -> void
+
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
+    end
+
+    # Deterministic, static-no-user-code explanation of every registered setting.
+    class Report
+      attr_reader input: Input
+
+      attr_reader explanations: Array[Explanation]
+
+      attr_reader conflicts: Array[ConflictRecord]
+
+      # @rbs (Input input, ?cli: Hash[String, config_value]) -> void
+      def initialize: (Input input, ?cli: Hash[String, config_value]) -> void
+
+      # @rbs () -> bool
+      def success?: () -> bool
+
+      # @rbs () -> Hash[String, json_value]
+      def to_h: () -> Hash[String, json_value]
+
+      # Deterministic JSON independent of caller hash insertion order.
+      # @rbs () -> String
+      def dump: () -> String
+
+      # @rbs () -> String
+      def render_text: () -> String
+
+      private
+
+      # @rbs (Key key, Hash[String, config_value] cli) -> Value
+      def resolve_key: (Key key, Hash[String, config_value] cli) -> Value
+
+      # @rbs (Value value, Hash[String, config_value] cli, ?conflict: ConflictRecord?) -> Explanation
+      def explanation: (Value value, Hash[String, config_value] cli, ?conflict: ConflictRecord?) -> Explanation
+
+      # @rbs (Key key, config_value raw, conflicting: bool) -> Evidence
+      def cli_evidence: (Key key, config_value raw, conflicting: bool) -> Evidence
+
+      # @rbs (config_value value) -> String
+      def display: (config_value value) -> String
+
+      # @rbs (Location location) -> String
+      def location_label: (Location location) -> String
+
+      # @rbs (Explanation entry) -> Array[String]
+      def render_explanation: (Explanation entry) -> Array[String]
+    end
+  end
+end

data/sig/ibex/configuration/inspector.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/configuration/inspector.rb with RBS::Inline
+
+module Ibex
+  module Configuration
+    # Converts parsed source or validated Grammar IR into static configuration facts.
+    # rubocop:disable Metrics/ModuleLength -- source and IR adapters share one closed evidence vocabulary.
+    module Inspector
+      # @rbs (Frontend::Resolution resolution) -> Input
+      def self?.from_source: (Frontend::Resolution resolution) -> Input
+
+      # @rbs (IR::Grammar grammar, path: String) -> Input
+      def self?.from_grammar_ir: (IR::Grammar grammar, path: String) -> Input
+
+      # @rbs (Hash[String, config_value] values, Hash[String, Location] locations,
+      #   Hash[String, Array[Evidence]] evidence, String name, config_value value,
+      #   Frontend::Location | Location location) -> void
+      def self?.add_source_fact: (Hash[String, config_value] values, Hash[String, Location] locations, Hash[String, Array[Evidence]] evidence, String name, config_value value, Frontend::Location | Location location) -> void
+
+      # @rbs (Frontend::AST::Root root, Hash[String, config_value] values, Hash[String, Location] locations,
+      #   Hash[String, Array[Evidence]] evidence) -> void
+      def self?.add_source_options: (Frontend::AST::Root root, Hash[String, config_value] values, Hash[String, Location] locations, Hash[String, Array[Evidence]] evidence) -> void
+
+      # @rbs (Frontend::AST::Root root, Hash[String, config_value] values, Hash[String, Location] locations,
+      #   Hash[String, Array[Evidence]] evidence) -> void
+      def self?.add_source_parser_contract: (Frontend::AST::Root root, Hash[String, config_value] values, Hash[String, Location] locations, Hash[String, Array[Evidence]] evidence) -> void
+
+      # @rbs (String name) -> bool?
+      def self?.option_value: (String name) -> bool?
+
+      # @rbs (Frontend::Location | Location location) -> Location
+      def self?.configuration_location: (Frontend::Location | Location location) -> Location
+
+      # @rbs (Key key, Array[[bool, Location]] occurrences, bool selected_value) -> Array[Evidence]
+      def self?.option_evidence: (Key key, Array[[ bool, Location ]] occurrences, bool selected_value) -> Array[Evidence]
+
+      # @rbs (Hash[String, config_value] values, Hash[String, Array[Evidence]] evidence,
+      #   Hash[String, Recording] recordings, String name, config_value value) -> void
+      def self?.add_ir_fact: (Hash[String, config_value] values, Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings, String name, config_value value) -> void
+
+      # @rbs (IR::Grammar grammar, Hash[String, config_value] values, Hash[String, Location] locations,
+      #   Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings) -> void
+      def self?.add_parser_contract: (IR::Grammar grammar, Hash[String, config_value] values, Hash[String, Location] locations, Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings) -> void
+
+      # @rbs (String name, IR::ParserContract::Entry entry, Hash[String, config_value] values,
+      #   Hash[String, Location] locations, Hash[String, Array[Evidence]] evidence,
+      #   Hash[String, Recording] recordings) -> void
+      def self?.add_contract_entry: (String name, IR::ParserContract::Entry entry, Hash[String, config_value] values, Hash[String, Location] locations, Hash[String, Array[Evidence]] evidence, Hash[String, Recording] recordings) -> void
+
+      # @rbs (IR::ParserContract contract) -> Hash[String, IR::ParserContract::Entry]
+      def self?.contract_entries: (IR::ParserContract contract) -> Hash[String, IR::ParserContract::Entry]
+    end
+  end
+end