ibex 0.1.0 → 0.2.0

data/lib/ibex/ir/serialize.rb

@@ -5,6 +5,7 @@ require "json"
 module Ibex
   module IR
     # Stable JSON serialization for versioned pipeline IR.
+    # rubocop:disable Metrics/ModuleLength -- explicit versioned fields keep serialization changes auditable.
     module Serialize
       # @rbs!
       #   private def validate_version: (untyped data) -> untyped
@@ -13,29 +14,39 @@ module Ibex
       #   private def self.load_grammar: (untyped data) -> untyped
       #   private def load_automaton: (untyped data) -> untyped
       #   private def self.load_automaton: (untyped data) -> untyped
+      #   private def load_lexer: (untyped data) -> untyped
+      #   private def self.load_lexer: (untyped data) -> untyped
       #   private def load_state: (untyped state, untyped grammar) -> untyped
       #   private def self.load_state: (untyped state, untyped grammar) -> untyped
       #   private def symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
       #   private def self.symbol_keyed: (untyped values, untyped grammar, ?actions: untyped) -> untyped
       #   private def normalize_action: (untyped value) -> untyped
       #   private def self.normalize_action: (untyped value) -> untyped
-      #   private def load_production: (untyped production) -> untyped
-      #   private def self.load_production: (untyped production) -> untyped
+      #   private def load_production: (untyped production, Integer schema_version) -> untyped
+      #   private def self.load_production: (untyped production, Integer schema_version) -> untyped
       #   private def load_user_code_chunks: (untyped chunks) -> untyped
       #   private def self.load_user_code_chunks: (untyped chunks) -> untyped
+      #   private def load_symbol_metadata: (untyped symbol, String field) -> String?
+      #   private def self.load_symbol_metadata: (untyped symbol, String field) -> String?
+      #   private def load_grammar_tests: (untyped tests) -> untyped
+      #   private def self.load_grammar_tests: (untyped tests) -> untyped
+      #   private def symbol_source_position: (untyped symbol) -> String
+      #   private def self.symbol_source_position: (untyped symbol) -> String
       #   private def symbolize: (untyped value) -> untyped
       #   private def self.symbolize: (untyped value) -> untyped
 
-      # @rbs (Grammar | Automaton value) -> String
+      # @rbs (Grammar | Automaton | Lexer value) -> String
       def dump(value)
         "#{JSON.pretty_generate(value.to_h)}\n"
       end
       module_function :dump
 
-      # @rbs (String source) -> (Grammar | Automaton)
+      # @rbs (String source) -> (Grammar | Automaton | Lexer)
       def load(source)
         data = JSON.parse(source)
         type = data.fetch("ibex_ir") { raise Ibex::Error, "(ir):1:1: missing ibex_ir discriminator" }
+        return load_lexer(data) if type == "lexer"
+
         validate_version(data)
         return load_grammar(data) if type == "grammar"
         return load_automaton(data) if type == "automaton"
@@ -52,33 +63,74 @@ module Ibex
       # @rbs skip
       def validate_version(data)
         version = data["schema_version"]
-        return if version == SCHEMA_VERSION
+        return if SUPPORTED_SCHEMA_VERSIONS.include?(version)
 
-        raise Ibex::Error, "(ir):1:1: unsupported schema_version #{version.inspect}; expected #{SCHEMA_VERSION}"
+        expected = SUPPORTED_SCHEMA_VERSIONS.join(", ")
+        raise Ibex::Error, "(ir):1:1: unsupported schema_version #{version.inspect}; expected one of #{expected}"
       end
 
       # @rbs skip
-      def load_grammar(data)
+      def load_grammar(data) # rubocop:disable Metrics/AbcSize -- explicit fields preserve the public IR contract.
         empty_chunks = {} #: Hash[String, untyped]
+        empty_parameters = [] #: Array[untyped]
+        empty_printers = [] #: Array[untyped]
+        empty_tests = [] #: Array[untyped]
+        empty_recovery = { "sync_tokens" => [], "on_error_reduce" => [] } #: Hash[String, untyped]
+        schema_version = data.fetch("schema_version")
         symbols = data.fetch("symbols").map do |symbol|
           GrammarSymbol.new(id: symbol.fetch("id"), name: symbol.fetch("name"), kind: symbol.fetch("kind"),
                             reserved: symbol.fetch("reserved"), precedence: symbolize(symbol["prec"]),
-                            location: symbolize(symbol["loc"]))
+                            location: symbolize(symbol["loc"]),
+                            display_name: load_symbol_metadata(symbol, "display_name"),
+                            semantic_type: load_symbol_metadata(symbol, "semantic_type"),
+                            documentation: symbol["doc"])
         end
-        productions = data.fetch("productions").map { |production| load_production(production) }
+        productions = data.fetch("productions").map { |production| load_production(production, schema_version) }
         Grammar.new(class_name: data.fetch("class_name"), superclass: data["superclass"], start: data.fetch("start"),
                     expect: data.fetch("expect"), options: symbolize(data.fetch("options")), symbols: symbols,
+                    mode: (data["mode"] || "default").to_sym,
+                    starts: data["starts"],
+                    expect_rr: data["expect_rr"],
+                    parser_parameters: symbolize(data.fetch("params", empty_parameters)),
+                    value_printers: symbolize(data.fetch("printers", empty_printers)),
+                    grammar_tests: load_grammar_tests(data.fetch("tests", empty_tests)),
+                    lexer: data["lexer"] && load_lexer(data.fetch("lexer")),
+                    recovery: symbolize(data.fetch("recovery", empty_recovery)),
                     productions: productions, user_code: data.fetch("user_code"),
                     conversions: data.fetch("conversions"), warnings: symbolize(data.fetch("warnings")),
-                    user_code_chunks: load_user_code_chunks(data.fetch("user_code_chunks", empty_chunks)))
-      end
+                    user_code_chunks: load_user_code_chunks(data.fetch("user_code_chunks", empty_chunks)),
+                    schema_version: schema_version, source_provenance: symbolize(data["source_provenance"]),
+                    migration: symbolize(data["migration"]))
+      end # rubocop:enable Metrics/AbcSize
 
       # @rbs skip
       def load_automaton(data)
         grammar = load_grammar(data.fetch("grammar"))
         states = data.fetch("states").map { |state| load_state(state, grammar) }
         Automaton.new(grammar: grammar, states: states, conflict_summary: symbolize(data.fetch("conflict_summary")),
-                      algorithm: data.fetch("algorithm"), grammar_digest: data.fetch("grammar_digest"))
+                      algorithm: data.fetch("algorithm"), grammar_digest: data.fetch("grammar_digest"),
+                      schema_version: data.fetch("schema_version"), entry_states: data["entry_states"])
+      end
+
+      # @rbs skip
+      def load_lexer(data)
+        version = data.fetch("schema_version")
+        unless SUPPORTED_LEXER_SCHEMA_VERSIONS.include?(version)
+          expected = SUPPORTED_LEXER_SCHEMA_VERSIONS.join(", ")
+          raise Ibex::Error,
+                "(ir):1:1: unsupported lexer schema_version #{version.inspect}; expected one of #{expected}"
+        end
+        rules = data.fetch("rules").map do |rule|
+          LexerRule.new(
+            id: rule.fetch("id"), state: rule.fetch("state"), kind: rule.fetch("kind").to_sym,
+            token: rule["token"], pattern: rule.fetch("pattern"), pattern_kind: rule.fetch("pattern_kind").to_sym,
+            options: rule.fetch("options"), action: rule["action"], location: symbolize(rule.fetch("loc"))
+          )
+        end
+        Lexer.new(
+          states: data.fetch("states"), rules: rules, warnings: symbolize(data.fetch("warnings")),
+          schema_version: version, source_provenance: symbolize(data["source_provenance"])
+        )
       end
 
       # @rbs skip
@@ -112,16 +164,19 @@ module Ibex
       end
 
       # @rbs skip
-      def load_production(production)
+      def load_production(production, schema_version)
         action_data = production["action"]
         action = if action_data
                    Action.new(code: action_data.fetch("code"), location: symbolize(action_data["loc"]),
                               named_refs: symbolize(action_data.fetch("named_refs")),
-                              context_length: action_data.fetch("context_length"))
+                              context_length: action_data.fetch("context_length"),
+                              composition: symbolize(action_data["composition"]))
                  end
         Production.new(id: production.fetch("id"), lhs: production.fetch("lhs"), rhs: production.fetch("rhs"),
                        action: action, precedence_override: production["prec_override"],
-                       origin: symbolize(production.fetch("origin")))
+                       origin: symbolize(production.fetch("origin")), documentation: production["doc"],
+                       expansion: schema_version >= 2 ? symbolize(production["expansion"]) : nil,
+                       node: schema_version >= 2 ? symbolize(production["node"]) : nil)
       end
 
       # @rbs skip
@@ -134,6 +189,39 @@ module Ibex
         end
       end
 
+      # @rbs skip
+      def load_symbol_metadata(symbol, field)
+        value = symbol[field]
+        return nil if value.nil?
+
+        position = symbol_source_position(symbol)
+        raise Ibex::Error, "#{position}: #{field} must be a String or null" unless value.is_a?(String)
+        raise Ibex::Error, "#{position}: #{field} must not be empty" if value.strip.empty?
+        raise Ibex::Error, "#{position}: #{field} must be a single line" if value.match?(/[\r\n]/)
+        raise Ibex::Error, "#{position}: #{field} must not contain control characters" if
+          value.match?(/[[:cntrl:]]/)
+
+        value
+      end
+
+      # @rbs skip
+      def symbol_source_position(symbol)
+        location = symbol["loc"]
+        return "(ir):1:1" unless location.is_a?(Hash)
+
+        file = location["file"]
+        line = location["line"]
+        column = location["column"]
+        return "(ir):1:1" unless file.is_a?(String) && line.is_a?(Integer) && column.is_a?(Integer)
+
+        "#{file}:#{line}:#{column}"
+      end
+
+      # @rbs skip
+      def load_grammar_tests(tests)
+        symbolize(tests).map { |test| test.merge(expectation: test.fetch(:expectation).to_sym) }
+      end
+
       # @rbs skip
       def symbolize(value)
         case value
@@ -142,13 +230,16 @@ module Ibex
         else value
         end
       end
-      module_function :validate_version, :load_grammar, :load_automaton, :load_state, :symbol_keyed,
-                      :normalize_action, :load_production, :load_user_code_chunks, :symbolize
+      module_function :validate_version, :load_grammar, :load_automaton, :load_lexer, :load_state, :symbol_keyed,
+                      :normalize_action, :load_production, :load_user_code_chunks, :load_symbol_metadata,
+                      :symbol_source_position, :load_grammar_tests, :symbolize
 
       class << self
-        private :validate_version, :load_grammar, :load_automaton, :load_state, :symbol_keyed,
-                :normalize_action, :load_production, :load_user_code_chunks, :symbolize
+        private :validate_version, :load_grammar, :load_automaton, :load_lexer, :load_state, :symbol_keyed,
+                :normalize_action, :load_production, :load_user_code_chunks, :load_symbol_metadata,
+                :symbol_source_position, :load_grammar_tests, :symbolize
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/ibex/ir/validator/automaton.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+module Ibex
+  module IR
+    module Validator
+      # Structural and referential validation for a versioned Automaton IR JSON object.
+      # rubocop:disable Metrics/ClassLength -- inline type contracts accompany one cohesive document validator.
+      class AutomatonDocument < Base
+        ROOT_REQUIRED = %w[
+          ibex_ir schema_version algorithm grammar_digest grammar states conflict_summary
+        ].freeze #: Array[String]
+        V2_ROOT_OPTIONAL = %w[entry_states].freeze #: Array[String]
+        STATE_REQUIRED = %w[id items transitions actions gotos default_action conflicts].freeze #: Array[String]
+        ACTION_TYPES = %w[shift reduce accept error].freeze #: Array[String]
+        RESOLUTION_KINDS = %w[definition_order default_shift precedence associativity].freeze #: Array[String]
+
+        # @rbs @data: Hash[String, untyped]
+        # @rbs @states_by_id: Hash[Integer, Hash[String, untyped]]
+        # @rbs @grammar: GrammarDocument
+        # @rbs @version: Integer
+
+        # @rbs (Hash[String, untyped] data, ?version: Integer) -> void
+        def initialize(data, version: data.fetch("schema_version"))
+          super()
+          @data = data
+          @version = version
+          @states_by_id = {} #: Hash[Integer, Hash[String, untyped]]
+        end
+
+        # @rbs () -> self
+        def validate
+          record(@data, "$", ROOT_REQUIRED, @version >= 2 ? V2_ROOT_OPTIONAL : [])
+          literal(@data["ibex_ir"], "$.ibex_ir", "automaton")
+          literal(@data["schema_version"], "$.schema_version", @version)
+          enum(@data["algorithm"], "$.algorithm", %w[slr lalr1 ielr1 lr1])
+          validate_digest
+          grammar = object(@data["grammar"], "$.grammar")
+          literal(grammar["schema_version"], "$.grammar.schema_version", @version)
+          @grammar = GrammarDocument.new(grammar, path: "$.grammar", version: @version).validate
+          validate_state_records
+          validate_entry_states
+          validate_state_contents
+          validate_conflict_summary
+          self
+        end
+
+        private
+
+        # @rbs () -> void
+        def validate_entry_states
+          value = @data["entry_states"]
+          if value.nil?
+            invalid("$.entry_states", "is required for multiple start symbols") if @data.dig("grammar", "starts")
+            return
+          end
+
+          entries = object(value, "$.entry_states")
+          expected = @data.dig("grammar", "starts") || [@data.dig("grammar", "start")]
+          invalid("$.entry_states", "keys must equal grammar starts in order") unless entries.keys == expected
+          entries.each do |name, state|
+            nonnegative_integer(state, "$.entry_states.#{name}")
+            invalid("$.entry_states.#{name}", "references missing state #{state}") unless @states_by_id[state]
+          end
+        end
+
+        # @rbs () -> void
+        def validate_digest
+          digest = string(@data["grammar_digest"], "$.grammar_digest")
+          invalid("$.grammar_digest", "must be a sha256 digest") unless digest.match?(/\Asha256:[0-9a-f]{64}\z/)
+        end
+
+        # @rbs () -> void
+        def validate_state_records
+          states = array(@data["states"], "$.states")
+          invalid("$.states", "must contain at least one state") if states.empty?
+          states.each_with_index do |value, index|
+            path = "$.states[#{index}]"
+            state = record(value, path, STATE_REQUIRED)
+            id = nonnegative_integer(state["id"], "#{path}.id")
+            invalid("#{path}.id", "must equal its array index #{index}") unless id == index
+            @states_by_id[id] = state
+          end
+        end
+
+        # @rbs () -> void
+        def validate_state_contents
+          @states_by_id.each do |id, state|
+            path = "$.states[#{id}]"
+            validate_items(state["items"], "#{path}.items")
+            validate_transitions(state["transitions"], "#{path}.transitions")
+            validate_actions(state["actions"], "#{path}.actions")
+            validate_gotos(state["gotos"], "#{path}.gotos")
+            validate_parser_action(state["default_action"], "#{path}.default_action", nullable: true)
+            validate_conflicts(state["conflicts"], "#{path}.conflicts")
+          end
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_items(value, path)
+          array(value, path).each_with_index do |item, index|
+            item_path = "#{path}[#{index}]"
+            item = record(item, item_path, %w[production dot lookaheads])
+            production = integer(item["production"], "#{item_path}.production")
+            validate_item_production(production, item["dot"], item_path)
+            validate_lookaheads(item["lookaheads"], "#{item_path}.lookaheads")
+          end
+        end
+
+        # @rbs (Integer production_id, untyped dot_value, String path) -> void
+        def validate_item_production(production_id, dot_value, path)
+          dot = nonnegative_integer(dot_value, "#{path}.dot")
+          if production_id == -1
+            invalid("#{path}.dot", "must not exceed 1 for the augmented production") if dot > 1
+            return
+          end
+          production = @grammar.productions_by_id[production_id]
+          invalid("#{path}.production", "references missing production id #{production_id}") unless production
+          invalid("#{path}.dot", "exceeds production #{production_id} length") if dot > production["rhs"].length
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_lookaheads(value, path)
+          array(value, path).each_with_index do |name, index|
+            name = string(name, "#{path}[#{index}]")
+            symbol = @grammar.symbols_by_name[name]
+            invalid("#{path}[#{index}]", "references missing symbol #{name.inspect}") unless symbol
+            invalid("#{path}[#{index}]", "must reference a terminal") unless symbol["kind"] == "terminal"
+          end
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_transitions(value, path)
+          symbol_map(value, path) do |target, target_path, _symbol|
+            validate_state_reference(target, target_path)
+          end
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_actions(value, path)
+          symbol_map(value, path, kind: "terminal") do |action, action_path, _symbol|
+            validate_parser_action(action, action_path)
+          end
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_gotos(value, path)
+          symbol_map(value, path, kind: "nonterminal") do |target, target_path, _symbol|
+            validate_state_reference(target, target_path)
+          end
+        end
+
+        # @rbs (untyped value, String path, ?kind: String?) { (untyped, String, Hash[String, untyped]) -> void } -> void
+        def symbol_map(value, path, kind: nil, &block)
+          object(value, path).each do |name, item|
+            item_path = child_path(path, name)
+            symbol = @grammar.symbols_by_name[name]
+            invalid(item_path, "references missing symbol #{name.inspect}") unless symbol
+            invalid(item_path, "must reference a #{kind}") if kind && symbol["kind"] != kind
+            block.call(item, item_path, symbol)
+          end
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_state_reference(value, path)
+          id = nonnegative_integer(value, path)
+          invalid(path, "references missing state id #{id}") unless @states_by_id.key?(id)
+        end
+
+        # @rbs (untyped value, String path, ?nullable: bool) -> void
+        def validate_parser_action(value, path, nullable: false)
+          return if nullable && value.nil?
+
+          action = object(value, path)
+          type = enum(field(action, "type", path), "#{path}.type", ACTION_TYPES)
+          required = case type
+                     when "shift" then %w[type state]
+                     when "reduce" then %w[type production]
+                     else %w[type]
+                     end
+          record(action, path, required)
+          validate_state_reference(action["state"], "#{path}.state") if type == "shift"
+          validate_production_reference(action["production"], "#{path}.production") if type == "reduce"
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_production_reference(value, path)
+          id = nonnegative_integer(value, path)
+          invalid(path, "references missing production id #{id}") unless @grammar.productions_by_id.key?(id)
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_conflicts(value, path)
+          array(value, path).each_with_index do |conflict, index|
+            conflict_path = "#{path}[#{index}]"
+            conflict = object(conflict, conflict_path)
+            type = enum(field(conflict, "type", conflict_path), "#{conflict_path}.type",
+                        %w[shift_reduce reduce_reduce])
+            if type == "shift_reduce"
+              validate_shift_reduce(conflict, conflict_path)
+            else
+              validate_reduce_reduce(conflict, conflict_path)
+            end
+          end
+        end
+
+        # @rbs (Hash[String, untyped] conflict, String path) -> void
+        def validate_shift_reduce(conflict, path)
+          record(conflict, path, %w[type symbol shift_to reduce resolution], %w[midrule_origins entries composite])
+          validate_conflict_symbol(conflict["symbol"], "#{path}.symbol")
+          validate_state_reference(conflict["shift_to"], "#{path}.shift_to")
+          validate_production_reference(conflict["reduce"], "#{path}.reduce")
+          validate_resolution(conflict["resolution"], "#{path}.resolution")
+          validate_midrule_origins(conflict["midrule_origins"], "#{path}.midrule_origins") if
+            conflict.key?("midrule_origins")
+          validate_conflict_entries(conflict, path)
+        end
+
+        # @rbs (Hash[String, untyped] conflict, String path) -> void
+        def validate_reduce_reduce(conflict, path)
+          record(conflict, path, %w[type symbol reductions resolution], %w[midrule_origins entries composite])
+          validate_conflict_symbol(conflict["symbol"], "#{path}.symbol")
+          reductions = array(conflict["reductions"], "#{path}.reductions")
+          invalid("#{path}.reductions", "must contain at least two productions") if reductions.length < 2
+          reductions.each_with_index do |id, index|
+            validate_production_reference(id, "#{path}.reductions[#{index}]")
+          end
+          if reductions.uniq.length != reductions.length
+            invalid("#{path}.reductions", "must contain unique production ids")
+          end
+          validate_resolution(conflict["resolution"], "#{path}.resolution", reductions: reductions)
+          validate_midrule_origins(conflict["midrule_origins"], "#{path}.midrule_origins") if
+            conflict.key?("midrule_origins")
+          validate_conflict_entries(conflict, path)
+        end
+
+        # @rbs (Hash[String, untyped] conflict, String path) -> void
+        def validate_conflict_entries(conflict, path)
+          if conflict.key?("entries")
+            starts = @data.dig("grammar", "starts") || [@data.dig("grammar", "start")]
+            entries = array(conflict["entries"], "#{path}.entries")
+            invalid("#{path}.entries", "must not be empty") if entries.empty?
+            entries.each_with_index do |name, index|
+              name = nonempty_string(name, "#{path}.entries[#{index}]")
+              invalid("#{path}.entries[#{index}]", "is not a grammar start symbol") unless starts.include?(name)
+            end
+            invalid("#{path}.entries", "must be unique") unless entries.uniq.length == entries.length
+          end
+          boolean(conflict["composite"], "#{path}.composite") if conflict.key?("composite")
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_midrule_origins(value, path)
+          origins = array(value, path)
+          invalid(path, "must not be empty") if origins.empty?
+          origins.each_with_index { |origin, index| location(origin, "#{path}[#{index}]") }
+        end
+
+        # @rbs (untyped value, String path) -> void
+        def validate_conflict_symbol(value, path)
+          name = string(value, path)
+          symbol = @grammar.symbols_by_name[name]
+          invalid(path, "references missing symbol #{name.inspect}") unless symbol
+          invalid(path, "must reference a terminal") unless symbol["kind"] == "terminal"
+        end
+
+        # @rbs (untyped value, String path, ?reductions: Array[Integer]?) -> void
+        def validate_resolution(value, path, reductions: nil)
+          resolution = record(value, path, %w[by chose], %w[associativity])
+          enum(resolution["by"], "#{path}.by", RESOLUTION_KINDS)
+          if reductions
+            chosen = resolution["chose"]
+            validate_production_reference(chosen, "#{path}.chose")
+            invalid("#{path}.chose", "must be one of the reductions") unless reductions.include?(chosen)
+          else
+            enum(resolution["chose"], "#{path}.chose", %w[shift reduce error])
+          end
+          return unless resolution.key?("associativity")
+
+          enum(resolution["associativity"], "#{path}.associativity", %w[left right nonassoc])
+        end
+
+        # @rbs () -> void
+        def validate_conflict_summary
+          path = "$.conflict_summary"
+          summary = record(
+            @data["conflict_summary"], path, %w[sr resolved_sr rr expected_sr expectation_met],
+            %w[expected_rr rr_expectation_met]
+          )
+          %w[sr resolved_sr rr expected_sr].each do |key|
+            nonnegative_integer(summary[key], "#{path}.#{key}")
+          end
+          boolean(summary["expectation_met"], "#{path}.expectation_met")
+          if summary.key?("expected_rr") || summary.key?("rr_expectation_met")
+            nonnegative_integer(summary["expected_rr"], "#{path}.expected_rr")
+            boolean(summary["rr_expectation_met"], "#{path}.rr_expectation_met")
+          end
+          validate_conflict_counts(summary, path)
+          validate_expectation(summary, path)
+        end
+
+        # @rbs (Hash[String, untyped] summary, String path) -> void
+        def validate_conflict_counts(summary, path)
+          conflicts = @states_by_id.values.flat_map { |state| state["conflicts"] }
+          shift_reduce = conflicts.select { |conflict| conflict["type"] == "shift_reduce" }
+          counts = {
+            "sr" => shift_reduce.count { |conflict| conflict.dig("resolution", "by") == "default_shift" },
+            "resolved_sr" => shift_reduce.count { |conflict| conflict.dig("resolution", "by") != "default_shift" },
+            "rr" => conflicts.count { |conflict| conflict["type"] == "reduce_reduce" }
+          }
+          counts.each do |key, actual|
+            next if summary[key] == actual
+
+            label = key == "rr" ? "reduce/reduce" : "shift/reduce"
+            invalid("#{path}.#{key}", "must equal the #{actual} recorded #{label} conflicts")
+          end
+        end
+
+        # @rbs (Hash[String, untyped] summary, String path) -> void
+        def validate_expectation(summary, path)
+          grammar_expect = @data.fetch("grammar").fetch("expect")
+          unless summary["expected_sr"] == grammar_expect
+            invalid("#{path}.expected_sr", "must equal embedded grammar expect #{grammar_expect}")
+          end
+          expected_met = summary["sr"] == summary["expected_sr"]
+          unless summary["expectation_met"] == expected_met
+            invalid("#{path}.expectation_met", "must be #{expected_met} for the recorded shift/reduce count")
+          end
+
+          grammar_expect_rr = @data.fetch("grammar")["expect_rr"]
+          return if grammar_expect_rr.nil?
+
+          unless summary["expected_rr"] == grammar_expect_rr
+            invalid("#{path}.expected_rr", "must equal embedded grammar expect_rr #{grammar_expect_rr}")
+          end
+          rr_expected_met = summary["rr"] == summary["expected_rr"]
+          return if summary["rr_expectation_met"] == rr_expected_met
+
+          invalid("#{path}.rr_expectation_met",
+                  "must be #{rr_expected_met} for the recorded reduce/reduce count")
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end