ibex 0.3.0 → 0.4.0

data/lib/ibex/impact/seeds.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Ibex
+  module Impact
+    # Converts command-line symbols and Diff rule ids into analysis seeds.
+    class Seeds
+      # @rbs @grammar: IR::Grammar
+      # @rbs @sets: Analysis::Sets
+      # @rbs @records: Array[Hash[Symbol, Object?]]
+      # @rbs @ids: Array[Integer]
+      attr_reader :ids #: Array[Integer]
+      attr_reader :records #: Array[Hash[Symbol, Object?]]
+
+      # @rbs (IR::Grammar grammar, Array[String] names, ?origin: String) -> void
+      def initialize(grammar, names, origin: "symbol")
+        @grammar = grammar
+        @sets = Analysis::Sets.new(grammar)
+        @records = names.flat_map { |name| resolve(name, origin) }.sort_by { |record| seed_symbol(record) }
+        @ids = @records.map { |record| seed_id(record) }.uniq.freeze
+        @records = @records.freeze
+        freeze
+      end
+
+      # @rbs (IR::Grammar grammar, Hash[Symbol, Object?] diff, ?origin: String) -> Seeds
+      def self.from_diff(grammar, diff, origin: "diff")
+        rules = diff.fetch(:rules) #: Hash[Symbol, Object?]
+        names = %i[added removed changed].flat_map do |section|
+          records = rules.fetch(section) #: Array[Hash[Symbol, Object?]]
+          records.map { |record| record.fetch(:id).to_s }
+        end.uniq.sort
+        new(grammar, names, origin: origin)
+      end
+
+      private
+
+      # @rbs (Hash[Symbol, Object?] record) -> String
+      def seed_symbol(record)
+        record.fetch(:symbol) #: String
+      end
+
+      # @rbs (Hash[Symbol, Object?] record) -> Integer
+      def seed_id(record)
+        record.fetch(:id) #: Integer
+      end
+
+      # @rbs (String name, String origin) -> Array[Hash[Symbol, Object?]]
+      def resolve(name, origin)
+        definition = @grammar.symbol(name)
+        raise Ibex::Error, "(impact):1:1: unknown symbol #{name}" unless definition
+        raise Ibex::Error, "(impact):1:1: impact seed #{name} is not a nonterminal" unless definition.nonterminal?
+
+        [{ symbol: definition.name, id: definition.id, origin: origin,
+           nullable_boundary: nullable_boundary?(definition.id) }]
+      end
+
+      # @rbs (Integer) -> bool
+      def nullable_boundary?(id)
+        return true if @sets.nullable?(id)
+
+        @grammar.productions.any? do |production|
+          production.rhs.include?(id) && production.rhs.any? do |symbol_id|
+            @grammar.symbol_by_id(symbol_id)&.nonterminal? && @sets.nullable?(symbol_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ibex/impact/severity.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "json"
+require "optparse"
+
+module Ibex
+  module Impact
+    # Stores only conflict identities so a baseline is stable across state ids.
+    class Baseline
+      # @rbs (String path) -> void
+      def initialize(path)
+        @path = path
+      end
+
+      # @rbs () -> Array[String]
+      def conflicts
+        return [] unless File.file?(@path)
+
+        value = JSON.parse(File.binread(@path))
+        validate_document(value)
+        conflicts = value.fetch("conflicts") #: Array[untyped]
+        unless conflicts.all? { |identity| identity.is_a?(String) && !identity.empty? }
+          raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: conflicts must contain non-empty strings"
+        end
+
+        conflicts.sort.uniq
+      rescue JSON::ParserError => e
+        raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: #{e.message}"
+      end
+
+      # @rbs (Object?) -> void
+      def validate_document(value)
+        unless value.is_a?(Hash) && value.keys.sort == %w[conflicts schema_version]
+          raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: expected schema_version and conflicts"
+        end
+        unless value.fetch("conflicts").is_a?(Array)
+          raise Ibex::Error, "#{@path}:1:1: invalid impact baseline: conflicts must be an array"
+        end
+        return if value.fetch("schema_version") == 1
+
+        raise Ibex::Error, "#{@path}:1:1: unsupported impact baseline schema"
+      end
+
+      # @rbs (Array[String] identities) -> void
+      def write(identities)
+        File.write(@path, "#{JSON.pretty_generate({ 'schema_version' => 1, 'conflicts' => identities.sort.uniq })}\n")
+      end
+    end
+
+    # Severity ranking and CI gate evaluation for impact findings.
+    module Severity
+      LEVELS = %w[info low medium high critical].freeze #: Array[String]
+      FAIL_ON = %w[
+        new_conflict nullable_change first_change follow_change action_arity unreachable
+      ].freeze #: Array[String]
+      RANK = LEVELS.each_with_index.to_h.freeze #: Hash[String, Integer]
+      GATE_TO_KIND = {
+        "nullable_change" => "nullable", "first_change" => "first", "follow_change" => "follow"
+      }.freeze #: Hash[String, String]
+
+      module_function
+
+      # @rbs (String left, String right) -> String
+      def max(left, right)
+        RANK.fetch(left) >= RANK.fetch(right) ? left : right
+      end
+
+      # @rbs (Hash[String, Array[String]], Array[Hash[Symbol, String]]) -> Hash[String, String]
+      def symbols(changes, actions)
+        levels = Hash.new("info") #: Hash[String, String]
+        changes.each do |name, kinds|
+          kinds.each do |kind|
+            level = level_for_kind(kind)
+            levels[name] = max(levels[name], level)
+          end
+        end
+        actions.each do |finding|
+          name = finding.fetch(:production).split(" -> ").first
+          levels[name] = max(levels[name], finding.fetch(:severity))
+        end
+        levels
+      end
+
+      # @rbs (String) -> String
+      def level_for_kind(kind)
+        return "high" if %w[first follow nullable].include?(kind)
+        return "medium" if %w[reference precedence].include?(kind)
+
+        "low"
+      end
+
+      # @rbs (Hash[Symbol, Object?] report, Array[String] gates) -> bool
+      def fails?(report, gates)
+        return false if gates.empty?
+
+        return true if conflict_gate?(report, gates)
+        return true if unreachable_gate?(report, gates)
+        return true if action_gate?(report, gates)
+
+        symbol_records = report.fetch(:symbols, []) #: Array[Hash[Symbol, Object?]]
+        gates.any? do |gate|
+          kind = GATE_TO_KIND[gate]
+          kind && symbol_records.any? { |item| item[:kinds].is_a?(Array) && item[:kinds].include?(kind) }
+        end
+      end
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def conflict_gate?(report, gates)
+        gates.include?("new_conflict") && report.dig(:automaton, :conflicts, :added)&.any?
+      end
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def unreachable_gate?(report, gates)
+        return false unless gates.include?("unreachable")
+
+        states = report.dig(:automaton, :unreachable) || []
+        nonterminals = report.dig(:automaton, :unreachable_nonterminals) || []
+        states.any? || nonterminals.any?
+      end
+
+      # @rbs (Hash[Symbol, Object?], Array[String]) -> bool
+      def action_gate?(report, gates)
+        return false unless gates.include?("action_arity")
+
+        action_records = report.fetch(:actions, []) #: Array[Hash[Symbol, Object?]]
+        action_records.any? { |item| item[:severity] == "high" }
+      end
+
+      # @rbs (Array[String] gates) -> Array[String]
+      def validate_gates(gates)
+        unknown = gates - FAIL_ON
+        raise OptionParser::InvalidArgument, "unknown --fail-on value #{unknown.first.inspect}" unless unknown.empty?
+
+        gates.uniq
+      end
+    end
+  end
+end

data/lib/ibex/impact.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require_relative "impact/graph"
+require_relative "impact/propagation"
+require_relative "impact/seeds"
+require_relative "impact/automaton_impact"
+require_relative "impact/action_impact"
+require_relative "impact/coverage_impact"
+require_relative "impact/severity"
+require_relative "impact/report"
+
+module Ibex
+  module Impact
+  end
+end

data/lib/ibex/version.rb

@@ -2,5 +2,5 @@
 
 # Ibex generates and runs Pure Ruby LR parsers.
 module Ibex
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/ibex.rb

@@ -27,6 +27,7 @@ require_relative "ibex/verify"
 require_relative "ibex/equiv"
 require_relative "ibex/diff"
 require_relative "ibex/metrics"
+require_relative "ibex/impact"
 require_relative "ibex/fix"
 require_relative "ibex/bison_import"
 require_relative "ibex/grammar_tests"

data/schema/impact-v1.schema.json

@@ -0,0 +1,208 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ydah/ibex/main/schema/impact-v1.schema.json",
+  "title": "Ibex grammar impact report v1",
+  "type": "object",
+  "required": ["ibex_report", "schema_version", "mode", "algorithm", "grammar_digest", "seeds", "symbols", "automaton", "actions", "coverage", "warnings", "totals"],
+  "properties": {
+    "ibex_report": { "const": "impact" },
+    "schema_version": { "const": 1 },
+    "mode": { "enum": ["potential", "diff"] },
+    "algorithm": { "enum": ["slr", "lalr1", "ielr1", "lr1"] },
+    "grammar_digest": {
+      "type": "object",
+      "required": ["before", "after"],
+      "properties": {
+        "before": { "type": ["string", "null"], "pattern": "^sha256:[0-9a-f]{64}$" },
+        "after": { "type": ["string", "null"], "pattern": "^sha256:[0-9a-f]{64}$" }
+      },
+      "additionalProperties": false
+    },
+    "seeds": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["symbol", "origin", "nullable_boundary"],
+        "properties": {
+          "symbol": { "type": "string" },
+          "origin": { "enum": ["symbol", "diff"] },
+          "nullable_boundary": { "type": "boolean" }
+        },
+        "additionalProperties": false
+      },
+      "maxItems": 100000
+    },
+    "symbols": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/symbol" },
+      "maxItems": 100000
+    },
+    "automaton": {
+      "type": "object",
+      "required": ["states", "affected_states", "conflicts", "unreachable", "unreachable_nonterminals"],
+      "properties": {
+        "states": {
+          "type": "object",
+          "required": ["before", "after", "delta"],
+          "properties": {
+            "before": { "type": ["integer", "null"], "minimum": 0 },
+            "after": { "type": "integer", "minimum": 0 },
+            "delta": { "type": ["integer", "null"] }
+          },
+          "additionalProperties": false
+        },
+        "affected_states": { "type": "array", "items": { "type": "integer", "minimum": 0 }, "uniqueItems": true, "maxItems": 100000 },
+        "conflicts": { "$ref": "#/$defs/classification" },
+        "unreachable": { "type": "array", "items": { "type": "integer", "minimum": 0 }, "uniqueItems": true, "maxItems": 100000 },
+        "unreachable_nonterminals": {
+          "type": "array",
+          "items": { "type": "string" },
+          "uniqueItems": true,
+          "maxItems": 100000
+        }
+      },
+      "additionalProperties": false
+    },
+    "actions": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/action" },
+      "maxItems": 100000
+    },
+    "coverage": {
+      "type": "object",
+      "required": ["status", "reports"],
+      "properties": {
+        "status": { "enum": ["not_requested", "matched", "unmatched"] },
+        "reports": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["path", "productions"],
+            "properties": {
+              "path": { "type": "string" },
+              "productions": { "type": "array", "items": { "type": "integer", "minimum": 0 }, "uniqueItems": true, "maxItems": 100000 }
+            },
+            "additionalProperties": false
+          },
+          "maxItems": 100000
+        }
+      },
+      "additionalProperties": false
+    },
+    "warnings": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "maxItems": 100000 },
+    "totals": {
+      "type": "object",
+      "required": ["info", "low", "medium", "high", "critical"],
+      "properties": {
+        "info": { "type": "integer", "minimum": 0 },
+        "low": { "type": "integer", "minimum": 0 },
+        "medium": { "type": "integer", "minimum": 0 },
+        "high": { "type": "integer", "minimum": 0 },
+        "critical": { "type": "integer", "minimum": 0 }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "classification": {
+      "type": "object",
+      "required": ["added", "removed", "changed"],
+      "properties": {
+        "added": { "type": "array", "items": { "$ref": "#/$defs/classification_record" }, "maxItems": 100000 },
+        "removed": { "type": "array", "items": { "$ref": "#/$defs/classification_record" }, "maxItems": 100000 },
+        "changed": { "type": "array", "items": { "$ref": "#/$defs/classification_record" }, "maxItems": 100000 }
+      },
+      "additionalProperties": false
+    },
+    "classification_record": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": ["id", "value"],
+          "properties": { "id": { "type": "string" }, "value": {} },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": ["id", "before", "after"],
+          "properties": { "id": { "type": "string" }, "before": {}, "after": {} },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "change": {
+      "type": "object",
+      "required": ["added", "removed"],
+      "properties": {
+        "added": { "type": "array", "items": { "type": "string" }, "maxItems": 100000 },
+        "removed": { "type": "array", "items": { "type": "string" }, "maxItems": 100000 }
+      },
+      "additionalProperties": false
+    },
+    "symbol": {
+      "type": "object",
+      "required": ["symbol", "severity", "kinds", "distance", "component", "sets", "witness"],
+      "properties": {
+        "symbol": { "type": "string" },
+        "severity": { "enum": ["info", "low", "medium", "high", "critical"] },
+        "kinds": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "maxItems": 100000 },
+        "distance": { "type": "integer", "minimum": 0 },
+        "component": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "maxItems": 100000 },
+        "sets": {
+          "type": "object",
+          "required": ["first", "follow", "nullable"],
+          "properties": {
+            "first": { "$ref": "#/$defs/change" },
+            "follow": { "$ref": "#/$defs/change" },
+            "nullable": {
+              "type": ["object", "null"],
+              "required": ["before", "after"],
+              "properties": { "before": { "type": "boolean" }, "after": { "type": "boolean" } },
+              "additionalProperties": false
+            }
+          },
+          "additionalProperties": false
+        },
+        "witness": { "type": "array", "items": { "$ref": "#/$defs/witness" }, "maxItems": 100000 }
+      },
+      "additionalProperties": false
+    },
+    "witness": {
+      "type": "object",
+      "required": ["from", "to", "production", "loc"],
+      "properties": {
+        "from": { "type": "string" },
+        "to": { "type": "string" },
+        "production": { "type": ["string", "null"] },
+        "loc": {
+          "type": ["object", "null"],
+          "properties": {
+            "file": { "type": "string" },
+            "line": { "type": "integer", "minimum": 1 },
+            "column": { "type": "integer", "minimum": 1 }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "action": {
+      "type": "object",
+      "required": ["production", "severity", "reason", "context_length", "loc"],
+      "properties": {
+        "production": { "type": "string" },
+        "severity": { "enum": ["medium", "high"] },
+        "reason": { "type": "string" },
+        "context_length": {
+          "type": "object",
+          "required": ["before", "after"],
+          "properties": { "before": { "type": "integer", "minimum": 0 }, "after": { "type": "integer", "minimum": 0 } },
+          "additionalProperties": false
+        },
+        "loc": { "$ref": "#/$defs/witness/properties/loc" }
+      },
+      "additionalProperties": false
+    }
+  }
+}

data/sig/ibex/analysis/sets.rbs

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

data/sig/ibex/cli/impact.rbs

@@ -0,0 +1,95 @@
+# Generated from lib/ibex/cli/impact.rb with RBS::Inline
+
+module Ibex
+  # CLI adapter for potential and confirmed grammar impact reports.
+  # rubocop:disable Metrics/ModuleLength, Metrics/MethodLength, Metrics/AbcSize
+  module CLIImpact
+    include CLIAnalysis
+
+    private
+
+    # @rbs (Array[String] arguments) -> Integer
+    def run_impact_command: (Array[String] arguments) -> Integer
+
+    # @rbs (Array[String]) -> Hash[Symbol, untyped]
+    def impact_option_parser: (Array[String]) -> Hash[Symbol, untyped]
+
+    # @rbs (String value) -> Array[Symbol]
+    def parse_kinds: (String value) -> Array[Symbol]
+
+    # @rbs (Array[String], Hash[Symbol, untyped]) -> [Hash[Symbol, Object?], Array[String], Hash[Symbol, Object?]]
+    def potential_impact: (Array[String], Hash[Symbol, untyped]) -> [ Hash[Symbol, Object?], Array[String], Hash[Symbol, Object?] ]
+
+    # @rbs (Array[String], Hash[Symbol, untyped]) -> [Hash[Symbol, Object?], Array[String], Hash[Symbol, Object?]]
+    def confirmed_impact: (Array[String], Hash[Symbol, untyped]) -> [ Hash[Symbol, Object?], Array[String], Hash[Symbol, Object?] ]
+
+    # @rbs (Impact::Graph, Array[Integer], Hash[Symbol, untyped]) ->
+    #   [Hash[Integer, Impact::Node], Hash[Integer, Array[String]]]
+    def propagate: (Impact::Graph, Array[Integer], Hash[Symbol, untyped]) -> [ Hash[Integer, Impact::Node], Hash[Integer, Array[String]] ]
+
+    # @rbs (IR::Automaton, Array[Integer], Hash[Symbol, untyped]) -> Impact::CoverageImpact
+    def load_coverage: (IR::Automaton, Array[Integer], Hash[Symbol, untyped]) -> Impact::CoverageImpact
+
+    # @rbs (Impact::Seeds, Impact::CoverageImpact) -> Array[String]
+    def nullable_warnings: (Impact::Seeds, Impact::CoverageImpact) -> Array[String]
+
+    # @rbs (IR::Automaton, Impact::AutomatonImpact) -> Hash[Symbol, Object?]
+    def potential_automaton_document: (IR::Automaton, Impact::AutomatonImpact) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Automaton, IR::Automaton, Hash[Symbol, Object?], Impact::AutomatonImpact) -> Hash[Symbol, Object?]
+    def confirmed_automaton_document: (IR::Automaton, IR::Automaton, Hash[Symbol, Object?], Impact::AutomatonImpact) -> Hash[Symbol, Object?]
+
+    # @rbs (IR::Grammar) -> Array[String]
+    def unreachable_nonterminal_names: (IR::Grammar) -> Array[String]
+
+    # @rbs (IR::Grammar, IR::Grammar) -> Array[String]
+    def newly_unreachable_nonterminal_names: (IR::Grammar, IR::Grammar) -> Array[String]
+
+    # @rbs (IR::Automaton) -> Array[Integer]
+    def unreachable_state_ids: (IR::Automaton) -> Array[Integer]
+
+    # @rbs (IR::Automaton, IR::Automaton) -> Array[Integer]
+    def newly_unreachable_state_ids: (IR::Automaton, IR::Automaton) -> Array[Integer]
+
+    # @rbs (IR::Automaton) -> Array[String]
+    def unreachable_state_keys: (IR::Automaton) -> Array[String]
+
+    # @rbs (IR::Automaton, Integer) -> String
+    def unreachable_state_key: (IR::Automaton, Integer) -> String
+
+    # @rbs (IR::Automaton, IR::Automaton) ->
+    #   [Hash[String, Hash[Symbol, Object?]], Hash[String, Array[String]]]
+    def compare_sets: (IR::Automaton, IR::Automaton) -> [ Hash[String, Hash[Symbol, Object?]], Hash[String, Array[String]] ]
+
+    # @rbs (Analysis::Sets, Analysis::Sets, IR::GrammarSymbol?, IR::GrammarSymbol?, Symbol) ->
+    #   Hash[Symbol, Array[String]]
+    def set_change: (Analysis::Sets, Analysis::Sets, IR::GrammarSymbol?, IR::GrammarSymbol?, Symbol) -> Hash[Symbol, Array[String]]
+
+    # @rbs (Hash[Symbol, Array[String]], Hash[Symbol, Array[String]], Hash[Symbol, Object?]?) -> bool
+    def set_change_empty?: (Hash[Symbol, Array[String]], Hash[Symbol, Array[String]], Hash[Symbol, Object?]?) -> bool
+
+    # @rbs (Analysis::Sets, Analysis::Sets, IR::GrammarSymbol?, IR::GrammarSymbol?) -> Hash[Symbol, Object?]?
+    def nullable_change: (Analysis::Sets, Analysis::Sets, IR::GrammarSymbol?, IR::GrammarSymbol?) -> Hash[Symbol, Object?]?
+
+    # @rbs (Hash[Integer, Array[String]], Hash[String, Array[String]], IR::Grammar) -> Hash[Integer, Array[String]]
+    def merge_symbol_kinds: (Hash[Integer, Array[String]], Hash[String, Array[String]], IR::Grammar) -> Hash[Integer, Array[String]]
+
+    # @rbs (Hash[Symbol, Array[Hash[Symbol, Object?]]], IR::Grammar) -> Hash[String, Array[String]]
+    def precedence_symbol_kinds: (Hash[Symbol, Array[Hash[Symbol, Object?]]], IR::Grammar) -> Hash[String, Array[String]]
+
+    # @rbs (IR::Automaton) -> Array[String]
+    def conflict_identities: (IR::Automaton) -> Array[String]
+
+    # @rbs (IR::Grammar, Hash[Symbol, Object?]) -> String
+    def conflict_identity: (IR::Grammar, Hash[Symbol, Object?]) -> String
+
+    # @rbs (IR::Grammar, Integer) -> String
+    def production_shape: (IR::Grammar, Integer) -> String
+
+    # @rbs (Hash[Symbol, Object?], Array[String], Hash[Symbol, untyped]) -> void
+    def apply_baseline: (Hash[Symbol, Object?], Array[String], Hash[Symbol, untyped]) -> void
+
+    # @rbs (Hash[Symbol, Object?], String) -> void
+    def write_impact_report: (Hash[Symbol, Object?], String) -> void
+  end
+end

data/sig/ibex/impact/action_impact.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/ibex/impact/action_impact.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Checks only structured action metadata; action source remains opaque.
+    class ActionImpact
+      # @rbs @before: IR::Grammar
+      # @rbs @after: IR::Grammar
+      # @rbs @affected_names: Array[String]?
+      attr_reader findings: Array[Hash[Symbol, Object?]]
+
+      # @rbs (IR::Grammar before, IR::Grammar after, ?affected_names: Array[String]?) -> void
+      def initialize: (IR::Grammar before, IR::Grammar after, ?affected_names: Array[String]?) -> void
+
+      # @rbs () -> Array[Hash[Symbol, Object?]]
+      def to_a: () -> Array[Hash[Symbol, Object?]]
+
+      private
+
+      # @rbs () -> Array[Hash[Symbol, Object?]]
+      def compare: () -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (String name) -> Array[Hash[Symbol, Object?]]
+      def compare_rule: (String name) -> Array[Hash[Symbol, Object?]]
+
+      # @rbs (Array[IR::Production] before, Array[IR::Production] after) -> Array[[IR::Production, IR::Production]]
+      def pair_productions: (Array[IR::Production] before, Array[IR::Production] after) -> Array[[ IR::Production, IR::Production ]]
+
+      # @rbs (Array[IR::Production] unmatched, Array[IR::Production] after) -> Array[[IR::Production, IR::Production]]
+      def pair_exact_productions: (Array[IR::Production] unmatched, Array[IR::Production] after) -> Array[[ IR::Production, IR::Production ]]
+
+      # @rbs (Array[IR::Production] unmatched, Array[IR::Production] after,
+      #   Array[[IR::Production, IR::Production]]) -> Array[[IR::Production, IR::Production]]
+      def pair_by_location: (Array[IR::Production] unmatched, Array[IR::Production] after, Array[[ IR::Production, IR::Production ]]) -> Array[[ IR::Production, IR::Production ]]
+
+      # @rbs (IR::Grammar grammar, String name) -> Array[IR::Production]
+      def productions_for: (IR::Grammar grammar, String name) -> Array[IR::Production]
+
+      # @rbs (IR::Grammar grammar, IR::Production production) -> [Array[String], String?]
+      def production_signature: (IR::Grammar grammar, IR::Production production) -> [ Array[String], String? ]
+
+      # @rbs (IR::Production production) -> [Integer, Integer]?
+      def action_location_identity: (IR::Production production) -> [ Integer, Integer ]?
+
+      # @rbs (IR::Production before, IR::Production after) -> Hash[Symbol, Object?]
+      def finding_for: (IR::Production before, IR::Production after) -> Hash[Symbol, Object?]
+
+      # @rbs (IR::Action?, Integer, Integer) -> [String, String]
+      def finding_reason: (IR::Action?, Integer, Integer) -> [ String, String ]
+
+      # @rbs (IR::Action?, Integer) -> bool
+      def out_of_range?: (IR::Action?, Integer) -> bool
+
+      # @rbs (IR::Grammar grammar, IR::Production production) -> String
+      def production_name: (IR::Grammar grammar, IR::Production production) -> String
+    end
+  end
+end

data/sig/ibex/impact/automaton_impact.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/ibex/impact/automaton_impact.rb with RBS::Inline
+
+module Ibex
+  module Impact
+    # Maps propagated grammar symbols to parser states and conflict changes.
+    class AutomatonImpact
+      # @rbs @automaton: IR::Automaton
+      # @rbs @symbol_ids: Array[Integer]
+      # @rbs @production_ids: Array[Integer]
+      attr_reader affected_states: Array[Integer]
+
+      attr_reader production_ids: Array[Integer]
+
+      attr_reader conflict_states: Array[Integer]
+
+      # @rbs (IR::Automaton automaton, Array[Integer]) -> void
+      def initialize: (IR::Automaton automaton, Array[Integer]) -> void
+
+      # @rbs (Hash[Symbol, Object?] diff) -> Hash[Symbol, Object?]
+      def conflict_changes: (Hash[Symbol, Object?] diff) -> Hash[Symbol, Object?]
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+
+      private
+
+      # @rbs () -> Array[Integer]
+      def affected_productions: () -> Array[Integer]
+
+      # @rbs () -> Array[Integer]
+      def affected_state_ids: () -> Array[Integer]
+
+      # @rbs () -> Array[Integer]
+      def conflict_state_ids: () -> Array[Integer]
+    end
+  end
+end