ibex 0.2.0 → 0.3.0

data/lib/ibex/verify/action_correspondence.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# steep:ignore:start
+
+module Ibex
+  module Verify
+    # @rbs! type correspondence_action = IR::parser_action
+
+    # Compares resolved ACTION/GOTO behavior over all paired viable prefixes.
+    class ActionCorrespondence
+      # @rbs skip
+      Difference = Struct.new(:kind, :canonical_state, :target_state, :symbol, :canonical, :target,
+                              keyword_init: true) do
+        def initialize(**values)
+          super
+          freeze
+        end
+      end
+      # @rbs skip
+      Result = Struct.new(:differences, :explored, :truncated, keyword_init: true) do
+        def ok?
+          differences.empty? && !truncated
+        end
+      end
+
+      # @rbs!
+      #   class Difference < Struct[Symbol | Integer? | correspondence_action?]
+      #     attr_accessor kind: Symbol
+      #     attr_accessor canonical_state: Integer
+      #     attr_accessor target_state: Integer
+      #     attr_accessor symbol: Integer?
+      #     attr_accessor canonical: correspondence_action?
+      #     attr_accessor target: correspondence_action?
+      #     def self.new: (kind: Symbol, canonical_state: Integer, target_state: Integer,
+      #       symbol: Integer?, canonical: correspondence_action?, target: correspondence_action?) -> instance
+      #   end
+      #   class Result < Struct[Array[Difference] | Integer | bool]
+      #     attr_accessor differences: Array[Difference]
+      #     attr_accessor explored: Integer
+      #     attr_accessor truncated: bool
+      #     def self.new: (differences: Array[Difference], explored: Integer, truncated: bool) -> instance
+      #     def ok?: () -> bool
+      #   end
+
+      # @rbs (IR::Automaton canonical, IR::Automaton target, ?max_pairs: Integer) -> void
+      def initialize(canonical, target, max_pairs: nil)
+        @canonical = canonical
+        @target = target
+        @max_pairs = max_pairs || [canonical.states.length * 8, 1].max
+      end
+
+      # @rbs () -> Result
+      def verify
+        queue = @canonical.entry_states.map do |name, canonical_state|
+          [canonical_state, @target.entry_states[name]]
+        end
+        seen = {}
+        differences = []
+        truncated = false
+        until queue.empty?
+          canonical_id, target_id = queue.shift
+          key = [canonical_id, target_id]
+          next if seen[key]
+
+          if seen.length >= @max_pairs
+            truncated = true
+            break
+          end
+          seen[key] = true
+          canonical_state = @canonical.states[canonical_id]
+          target_state = @target.states[target_id]
+          unless canonical_state && target_state
+            differences << Difference.new(
+              kind: :state, canonical_state: canonical_id, target_state: target_id,
+              symbol: nil, canonical: canonical_state, target: target_state
+            )
+            next
+          end
+          compare_terminals(canonical_id, target_id, canonical_state, target_state, differences, queue)
+          compare_gotos(canonical_id, target_id, canonical_state, target_state, differences, queue)
+        end
+        Result.new(differences: differences.freeze, explored: seen.length, truncated: truncated)
+      end
+
+      private
+
+      # @rbs (Integer, Integer, IR::AutomatonState, IR::AutomatonState,
+      #   Array[Difference], Array[Array[Integer]]) -> void
+      def compare_terminals(canonical_id, target_id, canonical_state, target_state, differences, queue)
+        @canonical.grammar.terminals.each do |terminal|
+          left = effective_action(canonical_state, terminal.id)
+          right = effective_action(target_state, terminal.id)
+          if action_signature(left) != action_signature(right)
+            differences << Difference.new(
+              kind: :action, canonical_state: canonical_id, target_state: target_id,
+              symbol: terminal.id, canonical: left, target: right
+            )
+          end
+          queue << [left[:state], right[:state]] if left[:type] == :shift && right[:type] == :shift
+        end
+      end
+
+      # @rbs (Integer, Integer, IR::AutomatonState, IR::AutomatonState,
+      #   Array[Difference], Array[Array[Integer]]) -> void
+      def compare_gotos(canonical_id, target_id, canonical_state, target_state, differences, queue)
+        @canonical.grammar.nonterminals.each do |nonterminal|
+          left = canonical_state.gotos[nonterminal.id]
+          right = target_state.gotos[nonterminal.id]
+          if left.nil? != right.nil?
+            differences << Difference.new(
+              kind: :goto, canonical_state: canonical_id, target_state: target_id,
+              symbol: nonterminal.id, canonical: left, target: right
+            )
+          elsif left && right
+            queue << [left, right]
+          end
+        end
+      end
+
+      # @rbs (IR::AutomatonState, Integer) -> IR::parser_action
+      def effective_action(state, token_id)
+        state.actions.fetch(token_id, state.default_action || { type: :error })
+      end
+
+      # @rbs (IR::parser_action) -> Array[Object]
+      def action_signature(action)
+        case action[:type]
+        when :shift then [:shift]
+        when :reduce then [:reduce, action[:production]]
+        when :accept then [:accept]
+        else [:error]
+        end
+      end
+    end
+  end
+end
+# steep:ignore:end

data/lib/ibex/verify/language_witness.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "set"
+require_relative "../lalr/conflict"
+require_relative "../lalr/default_reductions"
+require_relative "../lalr/on_error_reductions"
+
+module Ibex
+  module Verify
+    # @rbs! type witness_status = :accepted | :error | :missing_entry | :shifted
+
+    # Compares canonical and submitted parser acceptance over a bounded set of
+    # terminal sequences.  This is a semantic witness, not a proof of language
+    # equivalence: the reference collection is complete within its budgets and
+    # the token enumeration is deliberately finite.
+    class LanguageWitness
+      class Difference
+        attr_reader :entry #: String
+        attr_reader :tokens #: Array[String]
+        attr_reader :canonical #: witness_status
+        attr_reader :target #: witness_status
+
+        # @rbs (entry: String, tokens: Array[String], canonical: witness_status,
+        #   target: witness_status) -> void
+        def initialize(entry:, tokens:, canonical:, target:)
+          @entry = entry.freeze
+          @tokens = tokens.dup.freeze
+          @canonical = canonical
+          @target = target
+          freeze
+        end
+      end
+
+      class Result
+        attr_reader :differences #: Array[Difference]
+        attr_reader :explored #: Integer
+        attr_reader :truncated #: bool
+        attr_reader :max_tokens #: Integer
+        attr_reader :max_cases #: Integer
+
+        # @rbs (differences: Array[Difference], explored: Integer, truncated: bool,
+        #   max_tokens: Integer, max_cases: Integer) -> void
+        def initialize(differences:, explored:, truncated:, max_tokens:, max_cases:)
+          @differences = differences.dup.freeze
+          @explored = explored
+          @truncated = truncated
+          @max_tokens = max_tokens
+          @max_cases = max_cases
+          freeze
+        end
+
+        # @rbs () -> bool
+        def ok?
+          differences.empty? && !truncated
+        end
+      end
+
+      # @rbs (IR::Grammar grammar, IR::Automaton target, ?max_tokens: Integer,
+      #   ?max_cases: Integer, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize(grammar, target, max_tokens: 6, max_cases: 10_000, max_states: 100_000,
+                     max_items: 1_000_000)
+        raise ArgumentError, "max_tokens must be nonnegative" if max_tokens.negative?
+        raise ArgumentError, "max_cases must be positive" unless max_cases.positive?
+
+        @grammar = grammar
+        @target = target
+        @max_tokens = max_tokens
+        @max_cases = max_cases
+        @canonical = CanonicalMachine.new(
+          grammar, max_states: max_states, max_items: max_items
+        )
+      end
+
+      # @rbs () -> Result
+      def verify
+        differences = [] #: Array[Difference]
+        explored = 0
+        truncated = false
+        token_ids = input_tokens.map(&:id)
+
+        @grammar.starts.each do |entry|
+          explored, truncated = verify_entry(entry, token_ids, differences, explored)
+          break if truncated
+        end
+
+        Result.new(
+          differences: differences.freeze, explored: explored, truncated: truncated,
+          max_tokens: @max_tokens, max_cases: @max_cases
+        )
+      end
+
+      private
+
+      # @rbs () -> Array[IR::GrammarSymbol]
+      def input_tokens
+        @grammar.terminals.reject { |terminal| ["$eof", "error"].include?(terminal.name) }
+      end
+
+      # @rbs (String, Array[Integer], Array[Difference], Integer) -> [Integer, bool]
+      def verify_entry(entry, token_ids, differences, explored)
+        queue = [[]] #: Array[Array[Integer]]
+        until queue.empty?
+          tokens = queue.shift
+          return [explored, true] if explored >= @max_cases
+
+          explored += 1
+          canonical = @canonical.simulate(entry, tokens)
+          target = simulate_target(entry, tokens)
+          if canonical != target
+            differences << Difference.new(
+              entry: entry, tokens: tokens.map { |id| token_name(id) },
+              canonical: canonical, target: target
+            )
+            return [explored, false]
+          end
+
+          # Keep the worklist breadth-first so a reported witness is as short
+          # as possible for each entry.
+          queue.concat(token_ids.map { |token_id| tokens + [token_id] }) if
+            tokens.length < @max_tokens
+        end
+        [explored, false]
+      end
+
+      # @rbs (Integer id) -> String
+      def token_name(id)
+        @grammar.symbol_by_id(id)&.name || raise(Ibex::Error, "missing terminal #{id}")
+      end
+
+      # @rbs (String entry, Array[Integer]) -> witness_status
+      def simulate_target(entry, tokens)
+        initial = @target.entry_states[entry]
+        return :missing_entry unless initial
+
+        machine = Machine.new(@target.states, @grammar)
+        machine.simulate(initial, tokens)
+      end
+
+      # Canonical collection is intentionally built here rather than through
+      # the production construction entry point, keeping this witness
+      # independent from construction code.
+      class CanonicalMachine
+        # @rbs (IR::Grammar grammar, max_states: Integer, max_items: Integer) -> void
+        def initialize(grammar, max_states:, max_items:)
+          collection = ReferenceCollection.new(
+            grammar, max_states: max_states, max_items: max_items
+          ).build(:lr1)
+          @grammar = grammar
+          @states = build_states(collection)
+          @entry_states = grammar.starts.each_with_index.to_h
+        end
+
+        # @rbs (String entry, Array[Integer]) -> witness_status
+        def simulate(entry, tokens)
+          state = @entry_states.fetch(entry)
+          Machine.new(@states, @grammar).simulate(state, tokens)
+        end
+
+        private
+
+        # @rbs (ReferenceCollection::Collection) -> Array[IR::AutomatonState]
+        def build_states(collection)
+          states = collection.states.each_with_index.map do |raw_items, state_id|
+            build_state(collection, raw_items, state_id)
+          end
+          states = LALR::OnErrorReductions.apply(@grammar, states)
+          LALR::DefaultReductions.apply(states, terminal_ids: @grammar.terminals.map(&:id))
+        end
+
+        # @rbs (ReferenceCollection::Collection, Set[Array[Integer]], Integer) -> IR::AutomatonState
+        def build_state(collection, raw_items, state_id)
+          item_map = Hash.new { |hash, key| hash[key] = Set.new } #: Hash[[Integer, Integer], Set[Integer]]
+          raw_items.each do |raw_item|
+            production = raw_item.fetch(0) #: Integer
+            dot = raw_item.fetch(1) #: Integer
+            lookahead = raw_item.fetch(2) #: Integer
+            item_map[[production, dot]] << lookahead
+          end
+          items = item_map.sort.map do |(production, dot), lookaheads|
+            IR::AutomatonItem.new(production: production, dot: dot, lookaheads: lookaheads.to_a)
+          end
+          transitions = collection.transitions.fetch(state_id)
+          actions = resolve_actions(items, transitions)
+          gotos = {} #: Hash[Integer, Integer]
+          transitions.each do |symbol_id, target|
+            gotos[symbol_id] = target if @grammar.symbol_by_id(symbol_id)&.nonterminal?
+          end
+          IR::AutomatonState.new(
+            id: state_id, items: items, transitions: transitions,
+            actions: actions, gotos: gotos
+          )
+        end
+
+        # @rbs (Array[IR::AutomatonItem], Hash[Integer, Integer]) -> Hash[Integer, IR::parser_action]
+        def resolve_actions(items, transitions)
+          candidates = transition_candidates(transitions)
+          completed_candidates(items, candidates)
+          resolver = LALR::ConflictResolver.new(@grammar)
+          candidates.keys.sort.to_h do |token_id|
+            action, = resolver.resolve(token_id, candidates.fetch(token_id))
+            [token_id, action || { type: :error }]
+          end
+        end
+
+        # @rbs (Hash[Integer, Integer]) -> Hash[Integer, Array[IR::parser_action]]
+        def transition_candidates(transitions)
+          candidates = Hash.new { |hash, key| hash[key] = [] } #: Hash[Integer, Array[IR::parser_action]]
+          transitions.each do |symbol_id, target|
+            next unless @grammar.symbol_by_id(symbol_id)&.terminal?
+
+            candidates[symbol_id] << { type: :shift, state: target }
+          end
+          candidates
+        end
+
+        # @rbs (Array[IR::AutomatonItem], Hash[Integer, Array[IR::parser_action]]) -> void
+        def completed_candidates(items, candidates)
+          items.each do |item|
+            next unless item.dot == rhs_for(item.production).length
+
+            action = if item.production.negative?
+                       { type: :accept } #: IR::accept_action
+                     else
+                       { type: :reduce, production: item.production } #: IR::reduce_action
+                     end
+            item.lookaheads.each { |lookahead| candidates[lookahead] << action }
+          end
+        end
+
+        # @rbs (Integer production_id) -> Array[Integer]
+        def rhs_for(production_id)
+          return [@grammar.symbol(@grammar.starts.fetch(-production_id - 1)).id] if
+            production_id.negative?
+
+          @grammar.productions.fetch(production_id).rhs
+        end
+      end
+
+      # A stack machine shared by the canonical reference and submitted IR.
+      class Machine
+        # @rbs (Array[IR::AutomatonState] states, IR::Grammar grammar) -> void
+        def initialize(states, grammar)
+          @states = states
+          @grammar = grammar
+          @eof = grammar.symbol("$eof") || raise(Ibex::Error, "missing $eof terminal")
+        end
+
+        # @rbs (Integer initial, Array[Integer]) -> witness_status
+        def simulate(initial, tokens)
+          stack = [initial]
+          tokens.each do |token_id|
+            status = consume(stack, token_id)
+            return status unless status == :shifted
+          end
+          loop do
+            status = consume(stack, @eof.id)
+            return :accepted if status == :accepted
+            return :error unless status == :shifted
+          end
+        end
+
+        private
+
+        # @rbs (Array[Integer], Integer) -> witness_status
+        def consume(stack, token_id)
+          steps = 0
+          loop do
+            steps += 1
+            return :error if steps > 10_000
+
+            state = @states.fetch(stack.last)
+            action = state.actions.fetch(token_id, state.default_action || { type: :error })
+            case action.fetch(:type)
+            when :shift
+              stack << action.fetch(:state)
+              return :shifted
+            when :reduce
+              production = @grammar.productions.fetch(action.fetch(:production))
+              return :error if production.rhs.length >= stack.length
+
+              production.rhs.length.times { stack.pop }
+              goto = @states.fetch(stack.last).gotos[production.lhs]
+              return :error unless goto
+
+              stack << goto
+            when :accept then return :accepted
+            else return :error
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ibex/verify/reference_collection.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "set"
+
+module Ibex
+  module Verify
+    # Independently derives canonical LR(1) and LR(0) item collections.
+    class ReferenceCollection
+      # Immutable canonical collection and its symbol transitions.
+      class Collection
+        attr_reader :states #: Array[Set[Array[Integer]]]
+        attr_reader :transitions #: Array[Hash[Integer, Integer]]
+
+        # @rbs (states: Array[Set[Array[Integer]]], transitions: Array[Hash[Integer, Integer]]) -> void
+        def initialize(states:, transitions:)
+          @states = states
+          @transitions = transitions
+          freeze
+        end
+      end
+
+      # @rbs (IR::Grammar grammar, ?max_states: Integer, ?max_items: Integer) -> void
+      def initialize(grammar, max_states: 100_000, max_items: 1_000_000)
+        raise ArgumentError, "max_states must be positive" unless max_states.positive?
+        raise ArgumentError, "max_items must be positive" unless max_items.positive?
+
+        @grammar = grammar
+        @max_states = max_states
+        @max_items = max_items
+        @sets = Analysis::Sets.new(grammar)
+        @productions = grammar.productions.group_by(&:lhs)
+        @item_count = 0
+      end
+
+      # @rbs (Symbol kind) -> Collection
+      def build(kind)
+        raise ArgumentError, "kind must be :lr0 or :lr1" unless %i[lr0 lr1].include?(kind)
+
+        @item_count = 0
+        seeds = @grammar.starts.map.with_index do |name, index|
+          raise Ibex::Error, "(verify):1:1: missing start symbol #{name}" unless @grammar.symbol(name)
+
+          item = kind == :lr1 ? [-index - 1, 0, eof_id] : [-index - 1, 0]
+          account_item
+          closure(Set[item], kind)
+        end
+        collection(seeds, kind)
+      end
+
+      private
+
+      # @rbs (Array[Set[Array[Integer]]] seeds, Symbol kind) -> Collection
+      def collection(seeds, kind)
+        states = [] #: Array[Set[Array[Integer]]]
+        transitions = [] #: Array[Hash[Integer, Integer]]
+        indexes = {} #: Hash[Array[Array[Integer]], Integer]
+        seeds.each { |seed| insert_state(states, indexes, seed) }
+        cursor = 0
+        while cursor < states.length
+          transitions[cursor] = {}
+          next_symbols(states.fetch(cursor)).each do |symbol_id|
+            target = go_to(states.fetch(cursor), symbol_id, kind)
+            target_id = insert_state(states, indexes, target)
+            transitions.fetch(cursor)[symbol_id] = target_id
+          end
+          cursor += 1
+        end
+        Collection.new(states: states.freeze, transitions: transitions.freeze).freeze
+      end
+
+      # @rbs (Array[Set[Array[Integer]]] states, Hash[Array[Array[Integer]], Integer] indexes,
+      #   Set[Array[Integer]] state) -> Integer
+      def insert_state(states, indexes, state)
+        key = state.to_a.sort
+        existing = indexes[key]
+        return existing if existing
+        if states.length >= @max_states
+          raise BudgetExceeded.new(
+            "(verify):1:1: reference collection exceeds #{@max_states} states", bounds: bounds
+          )
+        end
+
+        states << state.freeze
+        indexes[key] = states.length - 1
+      end
+
+      # @rbs (Set[Array[Integer]] seed, Symbol kind) -> Set[Array[Integer]]
+      def closure(seed, kind)
+        items = seed.dup
+        queue = seed.to_a
+        cursor = 0
+        while cursor < queue.length
+          item = queue.fetch(cursor)
+          cursor += 1
+          production_id = item.fetch(0)
+          dot = item.fetch(1)
+          lookahead = item[2]
+          symbol_id = rhs_for(production_id)[dot]
+          symbol = @grammar.symbol_by_id(symbol_id)
+          next unless symbol&.nonterminal?
+
+          productions = @productions.fetch(symbol.id) do
+            [] #: Array[IR::Production]
+          end
+          productions.each do |production|
+            if kind == :lr1
+              closure_lookaheads(production_id, dot, lookahead).each do |token|
+                add_item(items, queue, [production.id, 0, token])
+              end
+            else
+              add_item(items, queue, [production.id, 0])
+            end
+          end
+        end
+        items
+      end
+
+      # @rbs (Set[Array[Integer]] state, Integer symbol_id, Symbol kind) -> Set[Array[Integer]]
+      def go_to(state, symbol_id, kind)
+        moved = state.each_with_object(Set.new) do |item, result|
+          production_id = item.fetch(0)
+          dot = item.fetch(1)
+          lookahead = item[2]
+          next unless rhs_for(production_id)[dot] == symbol_id
+
+          result << (kind == :lr1 ? [production_id, dot + 1, lookahead] : [production_id, dot + 1])
+        end
+        closure(moved, kind)
+      end
+
+      # @rbs (Set[Array[Integer]] items, Array[Array[Integer]] queue, Array[Integer] item) -> void
+      def add_item(items, queue, item)
+        return if items.include?(item)
+
+        account_item
+        items << item
+        queue << item
+      end
+
+      # @rbs () -> void
+      def account_item
+        if @item_count >= @max_items
+          raise BudgetExceeded.new(
+            "(verify):1:1: reference collection exceeds #{@max_items} items", bounds: bounds
+          )
+        end
+
+        @item_count += 1
+      end
+
+      # @rbs (Set[Array[Integer]] state) -> Array[Integer]
+      def next_symbols(state)
+        state.filter_map { |item| rhs_for(item.fetch(0))[item.fetch(1)] }.uniq.sort
+      end
+
+      # @rbs (Integer production_id, Integer dot, Integer? inherited) -> Array[Integer]
+      def closure_lookaheads(production_id, dot, inherited)
+        suffix = rhs_for(production_id).drop(dot + 1)
+        bits = @sets.first_of_sequence(suffix)
+        bits |= (1 << inherited) if inherited && @sets.sequence_nullable?(suffix)
+        @grammar.terminals.filter_map { |terminal| terminal.id if bits.anybits?(1 << terminal.id) }
+      end
+
+      # @rbs (Integer production_id) -> Array[Integer]
+      def rhs_for(production_id)
+        return [start_symbol(production_id).id] if production_id.negative?
+
+        @grammar.productions.fetch(production_id).rhs
+      end
+
+      # @rbs (Integer production_id) -> IR::GrammarSymbol
+      def start_symbol(production_id)
+        name = @grammar.starts.fetch(-production_id - 1)
+        @grammar.symbol(name) || raise(Ibex::Error, "(verify):1:1: missing start symbol #{name}")
+      end
+
+      # @rbs () -> Integer
+      def eof_id
+        symbol = @grammar.symbol("$eof")
+        symbol&.id || raise(Ibex::Error, "(verify):1:1: grammar has no $eof terminal")
+      end
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def bounds
+        { max_states: @max_states, max_items: @max_items }
+      end
+    end
+  end
+end

data/lib/ibex/verify/result.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Verify
+    # One stable verifier finding.
+    class Violation
+      attr_reader :id #: String
+      attr_reader :location #: String
+      attr_reader :message #: String
+
+      # @rbs (id: String, location: String, message: String) -> void
+      def initialize(id:, location:, message:)
+        @id = id.freeze
+        @location = location.freeze
+        @message = message.freeze
+        freeze
+      end
+
+      # @rbs () -> Hash[Symbol, String]
+      def to_h
+        { id: @id, location: @location, message: @message }.freeze
+      end
+    end
+
+    # Immutable independent-verification report.
+    class Result
+      # @rbs!
+      #   type report_value = String | Integer | bool | Array[String] | Hash[Symbol, Integer]
+      #     | Array[Hash[Symbol, String]]
+
+      attr_reader :algorithm #: String
+      attr_reader :strict #: bool
+      attr_reader :checks #: Array[String]
+      attr_reader :violations #: Array[Violation]
+      attr_reader :bounds #: Hash[Symbol, Integer]
+
+      # @rbs (algorithm: String, strict: bool, checks: Array[String], violations: Array[Violation],
+      #   bounds: Hash[Symbol, Integer]) -> void
+      def initialize(algorithm:, strict:, checks:, violations:, bounds:)
+        @algorithm = algorithm.freeze
+        @strict = strict
+        @checks = checks.dup.freeze
+        @violations = violations.dup.freeze
+        @bounds = bounds.dup.freeze
+        freeze
+      end
+
+      # @rbs () -> bool
+      def valid? = @violations.empty?
+
+      # @rbs () -> Hash[Symbol, report_value]
+      def to_h
+        {
+          ibex_report: "verify", schema_version: 1, algorithm: @algorithm,
+          strict: @strict, checks: @checks, bounds: @bounds,
+          result: valid? ? "valid" : "invalid",
+          violations: @violations.map(&:to_h)
+        }.freeze
+      end
+    end
+
+    class BudgetExceeded < Ibex::Error
+      attr_reader :bounds #: Hash[Symbol, Integer]
+
+      # @rbs (String message, bounds: Hash[Symbol, Integer]) -> void
+      def initialize(message, bounds:)
+        @bounds = bounds.dup.freeze
+        super(message)
+      end
+    end
+  end
+end