ibex 0.2.0 → 0.3.0

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.

data/sig/ibex/frontend/formatter.rbs

@@ -19,6 +19,8 @@ module Ibex
 
       type formatter_element = { segment: Segment, external: external_token?, role: Symbol?, gap: Array[Segment] }
 
+      type formatter_state = { section: :declarations | :rules, precedence_closer: external_token?, conversion: bool, conversion_name: bool, parser: bool, parser_key: bool, depth: Integer, rule_colon: bool }
+
       # @rbs (String source, ?file: String, ?mode: Symbol) -> String
       def self.format: (String source, ?file: String, ?mode: Symbol) -> String
 
@@ -45,32 +47,38 @@ module Ibex
       # @rbs (Array[formatter_element] elements) -> void
       def annotate_comment_indentation: (Array[formatter_element] elements) -> void
 
-      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol?
-      def token_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+      # @rbs (external_token external, formatter_state state) -> Symbol?
+      def token_role: (external_token external, formatter_state state) -> Symbol?
+
+      # @rbs (external_token external, formatter_state state) -> Symbol?
+      def document_token_role: (external_token external, formatter_state state) -> Symbol?
+
+      # @rbs (external_token external, formatter_state state) -> Symbol?
+      def nested_declaration_role: (external_token external, formatter_state state) -> Symbol?
 
-      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol?
-      def document_token_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+      # @rbs (formatter_state state) -> Symbol?
+      def section_end_role: (formatter_state state) -> Symbol?
 
-      # @rbs (Hash[Symbol, untyped] state) -> Symbol?
-      def section_end_role: (Hash[Symbol, untyped] state) -> Symbol?
+      # @rbs (external_token external, formatter_state state) -> Symbol?
+      def rule_token_role: (external_token external, formatter_state state) -> Symbol?
 
-      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol?
-      def rule_token_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol?
+      # @rbs (external_token external, formatter_state state) -> Symbol
+      def precedence_role: (external_token external, formatter_state state) -> Symbol
 
-      # @rbs (external_token external, Hash[Symbol, untyped] state) -> Symbol
-      def precedence_role: (external_token external, Hash[Symbol, untyped] state) -> Symbol
+      # @rbs (external_token external, Symbol? role, formatter_state state) -> void
+      def advance_role_state: (external_token external, Symbol? role, formatter_state state) -> void
 
-      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
-      def advance_role_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      # @rbs (external_token external, Symbol? role, formatter_state state) -> void
+      def advance_parser_state: (external_token external, Symbol? role, formatter_state state) -> void
 
-      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
-      def advance_precedence_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      # @rbs (external_token external, Symbol? role, formatter_state state) -> void
+      def advance_precedence_state: (external_token external, Symbol? role, formatter_state state) -> void
 
-      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
-      def advance_conversion_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      # @rbs (external_token external, Symbol? role, formatter_state state) -> void
+      def advance_conversion_state: (external_token external, Symbol? role, formatter_state state) -> void
 
-      # @rbs (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
-      def advance_rule_state: (external_token external, Symbol? role, Hash[Symbol, untyped] state) -> void
+      # @rbs (external_token external, Symbol? role, formatter_state state) -> void
+      def advance_rule_state: (external_token external, Symbol? role, formatter_state state) -> void
 
       # @rbs (formatter_element? previous, formatter_element current) -> String
       def separator: (formatter_element? previous, formatter_element current) -> String
@@ -113,23 +121,23 @@ module Ibex
       # @rbs (String text) -> bool
       def text_ends_with_newline?: (String text) -> bool
 
-      # @rbs (untyped left, untyped right) -> bool
-      def same_semantic_projection?: (untyped left, untyped right) -> bool
+      # @rbs (Object? left, Object? right) -> bool
+      def same_semantic_projection?: (Object? left, Object? right) -> bool
 
-      # @rbs (untyped left, untyped right) -> bool
-      def comparable_semantic_values?: (untyped left, untyped right) -> bool
+      # @rbs (Object? left, Object? right) -> bool
+      def comparable_semantic_values?: (Object? left, Object? right) -> bool
 
-      # @rbs (Hash[untyped, untyped] left, untyped right) -> bool
-      def comparable_semantic_hashes?: (Hash[untyped, untyped] left, untyped right) -> bool
+      # @rbs (Hash[Object?, Object?] left, Object? right) -> bool
+      def comparable_semantic_hashes?: (Hash[Object?, Object?] left, Object? right) -> bool
 
-      # @rbs (Array[[untyped, untyped]] pending, untyped left, untyped right) -> void
-      def append_semantic_children: (Array[[ untyped, untyped ]] pending, untyped left, untyped right) -> void
+      # @rbs (Array[[Object?, Object?]] pending, Object? left, Object? right) -> void
+      def append_semantic_children: (Array[[ Object?, Object? ]] pending, Object? left, Object? right) -> void
 
-      # @rbs (Struct[untyped] value) -> Array[Symbol]
-      def semantic_members: (Struct[untyped] value) -> Array[Symbol]
+      # @rbs (Struct[Object?] value) -> Array[Symbol]
+      def semantic_members: (Struct[Object?] value) -> Array[Symbol]
 
-      # @rbs (Hash[untyped, untyped] value) -> Array[untyped]
-      def semantic_keys: (Hash[untyped, untyped] value) -> Array[untyped]
+      # @rbs (Hash[Object?, Object?] value) -> Array[Object?]
+      def semantic_keys: (Hash[Object?, Object?] value) -> Array[Object?]
     end
   end
 end