ibex 0.2.0 → 0.4.0

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

@@ -3,22 +3,22 @@
 module Ibex
   module IR
     module Validator
-      # Structural and referential validation for a versioned Grammar IR JSON object.
+      # Structural and referential validation for a current Grammar IR JSON object.
       # rubocop:disable Metrics/ClassLength -- inline type contracts accompany one cohesive document validator.
       class GrammarDocument < Base
         ROOT_REQUIRED = %w[
           ibex_ir schema_version class_name superclass start expect options symbols productions user_code
-          conversions warnings
+          conversions warnings source_provenance parser_contract
+        ].freeze #: Array[String]
+        ROOT_OPTIONAL = %w[
+          user_code_chunks expect_rr params printers tests recovery lexer mode starts
         ].freeze #: Array[String]
-        ROOT_OPTIONAL = %w[user_code_chunks expect_rr].freeze #: Array[String]
-        V2_ROOT_REQUIRED = %w[source_provenance migration].freeze #: Array[String]
-        V2_ROOT_OPTIONAL = %w[params printers tests recovery lexer mode starts].freeze #: Array[String]
         SYMBOL_REQUIRED = %w[id name kind reserved prec loc].freeze #: Array[String]
         SYMBOL_OPTIONAL = %w[display_name semantic_type].freeze #: Array[String]
-        V2_SYMBOL_REQUIRED = %w[doc].freeze #: Array[String]
+        SYMBOL_METADATA_REQUIRED = %w[doc].freeze #: Array[String]
         PRODUCTION_REQUIRED = %w[id lhs rhs action prec_override origin].freeze #: Array[String]
-        V2_PRODUCTION_REQUIRED = %w[doc expansion].freeze #: Array[String]
-        V2_ACTION_REQUIRED = %w[composition].freeze #: Array[String]
+        PRODUCTION_METADATA_REQUIRED = %w[doc expansion].freeze #: Array[String]
+        ACTION_COMPOSITION_REQUIRED = %w[composition].freeze #: Array[String]
         ORIGIN_KINDS = %w[
           optional_expansion star_expansion plus_expansion separated_list_expansion group_expansion
         ].freeze #: Array[String]
@@ -27,15 +27,15 @@ module Ibex
           if in module next nil not or redo rescue retry return self super then true undef unless until when while yield
         ].freeze #: Array[String]
 
-        attr_reader :symbols_by_id #: Hash[Integer, Hash[String, untyped]]
-        attr_reader :symbols_by_name #: Hash[String, Hash[String, untyped]]
-        attr_reader :productions_by_id #: Hash[Integer, Hash[String, untyped]]
+        attr_reader :symbols_by_id #: Hash[Integer, json_object]
+        attr_reader :symbols_by_name #: Hash[String, json_object]
+        attr_reader :productions_by_id #: Hash[Integer, json_object]
 
-        # @rbs @data: Hash[String, untyped]
+        # @rbs @data: json_object
         # @rbs @path: String
         # @rbs @version: Integer
 
-        # @rbs (Hash[String, untyped] data, ?path: String, ?version: Integer) -> void
+        # @rbs (json_object data, ?path: String, ?version: Integer) -> void
         def initialize(data, path: "$", version: data.fetch("schema_version"))
           super()
           @data = data
@@ -48,34 +48,50 @@ module Ibex
 
         # @rbs () -> self
         def validate
-          required = ROOT_REQUIRED + (@version >= 2 ? V2_ROOT_REQUIRED : [])
-          optional = ROOT_OPTIONAL + (@version >= 2 ? V2_ROOT_OPTIONAL : [])
-          record(@data, @path, required, optional)
+          validate_root_record
           validate_envelope
           validate_header
           validate_options
-          validate_parser_parameters if @data.key?("params")
+          validate_parser_parameters_if_present
           validate_symbols
-          validate_value_printers if @data.key?("printers")
-          validate_grammar_tests if @data.key?("tests")
+          validate_optional_parser_metadata
           validate_reserved_symbols
           validate_start
-          validate_lexer if @data.key?("lexer")
-          validate_recovery if @data.key?("recovery")
           validate_productions
           validate_string_map(@data["user_code"], "#{@path}.user_code")
           validate_string_map(@data["conversions"], "#{@path}.conversions")
           validate_warnings
-          validate_user_code_chunks if @data.key?("user_code_chunks")
-          if @version >= 2
-            validate_source_provenance(@data["source_provenance"], "#{@path}.source_provenance")
-            validate_migration
-          end
+          validate_optional_source_metadata
           self
         end
 
         private
 
+        # @rbs () -> void
+        def validate_root_record
+          record(@data, @path, ROOT_REQUIRED, ROOT_OPTIONAL)
+        end
+
+        # @rbs () -> void
+        def validate_optional_parser_metadata
+          validate_value_printers if @data.key?("printers")
+          validate_grammar_tests if @data.key?("tests")
+          validate_lexer if @data.key?("lexer")
+          validate_recovery if @data.key?("recovery")
+          validate_parser_contract
+        end
+
+        # @rbs () -> void
+        def validate_parser_parameters_if_present
+          validate_parser_parameters if @data.key?("params")
+        end
+
+        # @rbs () -> void
+        def validate_optional_source_metadata
+          validate_user_code_chunks if @data.key?("user_code_chunks")
+          validate_source_provenance(@data["source_provenance"], "#{@path}.source_provenance")
+        end
+
         # @rbs () -> void
         def validate_envelope
           literal(@data["ibex_ir"], "#{@path}.ibex_ir", "grammar")
@@ -100,7 +116,6 @@ module Ibex
           boolean(options["omit_action_call"], "#{path}.omit_action_call")
           return unless options.key?("cst")
 
-          invalid("#{path}.cst", "requires schema_version 2") unless @version >= 2
           literal(options["cst"], "#{path}.cst", true)
           invalid("#{@path}.mode", "must be extended when CST construction is enabled") unless
             @data["mode"] == "extended"
@@ -159,10 +174,10 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, Integer index) -> void
+        # @rbs (json_value value, Integer index) -> void
         def validate_symbol(value, index)
           path = "#{@path}.symbols[#{index}]"
-          required = SYMBOL_REQUIRED + (@version >= 2 ? V2_SYMBOL_REQUIRED : [])
+          required = SYMBOL_REQUIRED + SYMBOL_METADATA_REQUIRED
           symbol = record(value, path, required, SYMBOL_OPTIONAL)
           id = nonnegative_integer(symbol["id"], "#{path}.id")
           invalid("#{path}.id", "must equal its array index #{index}") unless id == index
@@ -175,10 +190,10 @@ module Ibex
           validate_precedence(symbol["prec"], "#{path}.prec")
           location(symbol["loc"], "#{path}.loc")
           SYMBOL_OPTIONAL.each { |key| metadata(symbol[key], "#{path}.#{key}") if symbol.key?(key) }
-          nullable_string(symbol["doc"], "#{path}.doc") if @version >= 2
+          nullable_string(symbol["doc"], "#{path}.doc")
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_precedence(value, path)
           return if value.nil?
 
@@ -203,7 +218,7 @@ module Ibex
 
         # @rbs () -> void
         def validate_start
-          start = @data["start"]
+          start = nonempty_string(@data["start"], "#{@path}.start")
           symbol = @symbols_by_name[start]
           invalid("#{@path}.start", "references missing symbol #{start.inspect}") unless symbol
           invalid("#{@path}.start", "must reference a nonterminal") unless symbol["kind"] == "nonterminal"
@@ -253,7 +268,7 @@ module Ibex
           invalid(path, "must declare at least one recovery policy")
         end
 
-        # @rbs (untyped values, String path, kind: String) -> void
+        # @rbs (json_value values, String path, kind: String) -> void
         def validate_recovery_symbols(values, path, kind:)
           seen = {} #: Hash[String, bool]
           array(values, path).each_with_index do |name, index|
@@ -261,7 +276,7 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path, kind: String, seen: Hash[String, bool]) -> void
+        # @rbs (json_value value, String path, kind: String, seen: Hash[String, bool]) -> void
         def validate_recovery_symbol(value, path, kind:, seen:)
           name = nonempty_string(value, path)
           invalid(path, "duplicates symbol #{name.inspect}") if seen[name]
@@ -279,28 +294,27 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, Integer index) -> void
+        # @rbs (json_value value, Integer index) -> void
         def validate_production(value, index)
           path = "#{@path}.productions[#{index}]"
-          required = PRODUCTION_REQUIRED + (@version >= 2 ? V2_PRODUCTION_REQUIRED : [])
-          optional = @version >= 2 ? %w[node] : Array.new(0) #: Array[String]
+          required = PRODUCTION_REQUIRED + PRODUCTION_METADATA_REQUIRED
+          optional = %w[node] #: Array[String]
           production = record(value, path, required, optional)
           id = nonnegative_integer(production["id"], "#{path}.id")
           invalid("#{path}.id", "must equal its array index #{index}") unless id == index
           @productions_by_id[id] = production
           validate_lhs(production["lhs"], "#{path}.lhs")
-          validate_rhs(production["rhs"], "#{path}.rhs")
-          validate_action(production["action"], "#{path}.action", rhs_length: production["rhs"].length)
+          rhs = array(production["rhs"], "#{path}.rhs")
+          validate_rhs(rhs, "#{path}.rhs")
+          validate_action(production["action"], "#{path}.action", rhs_length: rhs.length)
           validate_precedence_override(production["prec_override"], "#{path}.prec_override")
           validate_origin(production["origin"], "#{path}.origin")
-          return unless @version >= 2
-
           nullable_string(production["doc"], "#{path}.doc")
           validate_expansion(production["expansion"], "#{path}.expansion")
-          validate_node_annotation(production["node"], "#{path}.node", rhs_length: production["rhs"].length)
+          validate_node_annotation(production["node"], "#{path}.node", rhs_length: rhs.length)
         end
 
-        # @rbs (untyped value, String path, rhs_length: Integer) -> void
+        # @rbs (json_value value, String path, rhs_length: Integer) -> void
         def validate_node_annotation(value, path, rhs_length:)
           return if value.nil?
 
@@ -320,7 +334,7 @@ module Ibex
           location(node["loc"], "#{path}.loc", nullable: false)
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_lhs(value, path)
           id = nonnegative_integer(value, path)
           symbol = @symbols_by_id[id]
@@ -328,7 +342,7 @@ module Ibex
           invalid(path, "must reference a nonterminal") unless symbol["kind"] == "nonterminal"
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_rhs(value, path)
           array(value, path).each_with_index do |id, index|
             id = nonnegative_integer(id, "#{path}[#{index}]")
@@ -336,24 +350,22 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path, rhs_length: Integer) -> void
+        # @rbs (json_value value, String path, rhs_length: Integer) -> void
         def validate_action(value, path, rhs_length:)
           return if value.nil?
 
-          required = %w[code loc named_refs context_length] + (@version >= 2 ? V2_ACTION_REQUIRED : [])
+          required = %w[code loc named_refs context_length] + ACTION_COMPOSITION_REQUIRED
           action = record(value, path, required)
           string(action["code"], "#{path}.code")
           location(action["loc"], "#{path}.loc", nullable: false)
           context_length = nonnegative_integer(action["context_length"], "#{path}.context_length")
           validate_named_refs(action["named_refs"], "#{path}.named_refs", limit: [rhs_length, context_length].max)
-          return unless @version >= 2
-
           validate_action_composition(
             action["composition"], "#{path}.composition", rhs_length: rhs_length
           )
         end
 
-        # @rbs (untyped value, String path, limit: Integer) -> void
+        # @rbs (json_value value, String path, limit: Integer) -> void
         def validate_named_refs(value, path, limit:)
           names = {} #: Hash[String, bool]
           array(value, path).each_with_index do |entry, index|
@@ -369,7 +381,7 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_precedence_override(value, path)
           return if value.nil?
 
@@ -379,7 +391,7 @@ module Ibex
           invalid(path, "must reference a terminal") unless symbol["kind"] == "terminal"
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_origin(value, path)
           origin = object(value, path)
           kind = string(field(origin, "kind", path), "#{path}.kind")
@@ -390,7 +402,7 @@ module Ibex
           location(origin["loc"], "#{path}.loc", nullable: false)
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_string_map(value, path)
           object(value, path).each do |key, item|
             string(key, path)
@@ -405,7 +417,7 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_warning(value, path)
           warning = record(value, path, %w[type loc], %w[symbol production original])
           nonempty_string(warning["type"], "#{path}.type")
@@ -415,13 +427,13 @@ module Ibex
           validate_warning_production(warning, "original", path) if warning.key?("original")
         end
 
-        # @rbs (Hash[String, untyped] warning, String path) -> void
+        # @rbs (json_object warning, String path) -> void
         def validate_warning_symbol(warning, path)
           name = nonempty_string(warning["symbol"], "#{path}.symbol")
           invalid("#{path}.symbol", "references missing symbol #{name.inspect}") unless @symbols_by_name.key?(name)
         end
 
-        # @rbs (Hash[String, untyped] warning, String field_name, String path) -> void
+        # @rbs (json_object warning, String field_name, String path) -> void
         def validate_warning_production(warning, field_name, path)
           id = nonnegative_integer(warning[field_name], "#{path}.#{field_name}")
           invalid("#{path}.#{field_name}", "references missing production id #{id}") unless @productions_by_id.key?(id)
@@ -430,11 +442,14 @@ module Ibex
         # @rbs () -> void
         def validate_lexer
           value = @data.fetch("lexer")
-          LexerDocument.new(value, path: "#{@path}.lexer").validate
-          value.fetch("rules").each_with_index do |rule, index|
-            next unless rule["kind"] == "token"
-
-            name = rule["token"]
+          lexer = value #: json_object
+          LexerDocument.new(lexer, path: "#{@path}.lexer").validate
+          rules = array(lexer.fetch("rules"), "#{@path}.lexer.rules")
+          rules.each_with_index do |rule, index|
+            rule_record = rule #: json_object
+            next unless rule_record["kind"] == "token"
+
+            name = nonempty_string(rule_record["token"], "#{@path}.lexer.rules[#{index}].token")
             symbol = @symbols_by_name[name]
             invalid("#{@path}.lexer.rules[#{index}].token", "references missing terminal #{name.inspect}") unless
               symbol&.fetch("kind") == "terminal"
@@ -455,7 +470,7 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path, ?nullable: bool) -> void
+        # @rbs (json_value value, String path, ?nullable: bool) -> void
         def validate_source_provenance(value, path, nullable: true)
           return if nullable && value.nil?
 
@@ -465,7 +480,7 @@ module Ibex
           validate_byte_span(source["byte_span"], "#{path}.byte_span")
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_byte_span(value, path)
           return if value.nil?
 
@@ -476,22 +491,35 @@ module Ibex
         end
 
         # @rbs () -> void
-        def validate_migration
-          path = "#{@path}.migration"
-          value = @data["migration"]
-          return if value.nil?
+        def validate_parser_contract
+          path = "#{@path}.parser_contract"
+          contract = record(@data["parser_contract"], path, %w[algorithm entries cst_trivia])
+          validate_contract_entry(contract["algorithm"], "#{path}.algorithm", %w[slr lalr ielr lr1])
+          validate_contract_entry(contract["entries"], "#{path}.entries", %w[shared isolated])
+          cst = validate_contract_entry(
+            contract["cst_trivia"], "#{path}.cst_trivia", %w[leading balanced drop]
+          )
+          return unless cst["explicit"]
+
+          invalid("#{path}.cst_trivia", "requires options.cst") unless @data.dig("options", "cst") == true
+        end
 
-          migration = record(value, path, %w[from_schema_version unavailable])
-          literal(migration["from_schema_version"], "#{path}.from_schema_version", 1)
-          values = array(migration["unavailable"], "#{path}.unavailable")
-          invalid("#{path}.unavailable", "must not be empty") if values.empty?
-          values.each_with_index do |name, index|
-            enum(name, "#{path}.unavailable[#{index}]", Migration::UNAVAILABLE_V1_METADATA)
+        # @rbs (untyped value, String, Array[String]) -> Hash[String, untyped]
+        def validate_contract_entry(value, path, allowed)
+          entry = record(value, path, %w[value explicit loc])
+          explicit = boolean(entry["explicit"], "#{path}.explicit")
+          unless explicit
+            literal(entry["value"], "#{path}.value", nil)
+            literal(entry["loc"], "#{path}.loc", nil)
+            return entry
           end
-          invalid("#{path}.unavailable", "must contain unique names") unless values.uniq.length == values.length
+
+          enum(entry["value"], "#{path}.value", allowed)
+          location(entry["loc"], "#{path}.loc", nullable: false)
+          entry
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_expansion(value, path)
           return if value.nil?
 
@@ -503,7 +531,7 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_parameter_expansion(value, path)
           return if value.nil?
 
@@ -514,7 +542,7 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path) -> void
+        # @rbs (json_value value, String path) -> void
         def validate_inline_expansion(value, path)
           return if value.nil?
 
@@ -522,7 +550,7 @@ module Ibex
           nonempty_string(inline["rule"], "#{path}.rule")
         end
 
-        # @rbs (untyped value, String path, rhs_length: Integer) -> void
+        # @rbs (json_value value, String path, rhs_length: Integer) -> void
         def validate_action_composition(value, path, rhs_length:)
           return if value.nil?
 
@@ -540,7 +568,7 @@ module Ibex
             composition.key?("plan")
         end
 
-        # @rbs (untyped value, String path, Integer rhs_length, Array[untyped] fragments) -> void
+        # @rbs (json_value value, String path, Integer rhs_length, Array[json_value] fragments) -> void
         def validate_action_composition_plan(value, path, rhs_length, fragments)
           plan = record(value, path, %w[version physical steps])
           literal(plan["version"], "#{path}.version", 1)
@@ -551,13 +579,15 @@ module Ibex
           invalid("#{path}.steps", "must align one-to-one with fragments") unless steps.length == fragments.length
           steps.each_with_index do |step, index|
             validate_action_composition_step(step, "#{path}.steps[#{index}]", physical, index)
-            next if step["kind"] == fragments.fetch(index)["kind"]
+            step_record = step #: json_object
+            fragment_record = fragments.fetch(index) #: json_object
+            next if step_record["kind"] == fragment_record["kind"]
 
             invalid("#{path}.steps[#{index}].kind", "must match the corresponding fragment")
           end
         end
 
-        # @rbs (untyped value, String path, Integer physical, Integer step_index) -> void
+        # @rbs (json_value value, String path, Integer physical, Integer step_index) -> void
         def validate_action_composition_step(value, path, physical, step_index)
           step = record(
             value, path,
@@ -581,7 +611,7 @@ module Ibex
           nullable_string(step["result_type"], "#{path}.result_type")
         end
 
-        # @rbs (Array[untyped] inputs, String path, Integer limit) -> void
+        # @rbs (Array[json_value] inputs, String path, Integer limit) -> void
         def validate_action_slots(inputs, path, limit)
           inputs.each_with_index do |input, index|
             slot_path = "#{path}[#{index}]"
@@ -590,7 +620,7 @@ module Ibex
           end
         end
 
-        # @rbs (untyped value, String path, Integer physical) -> void
+        # @rbs (json_value value, String path, Integer physical) -> void
         def validate_action_lookahead(value, path, physical)
           return if value.nil?
 

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

@@ -12,7 +12,7 @@ module Ibex
           id state kind token pattern pattern_kind options action loc
         ].freeze #: Array[String]
 
-        # @rbs (Hash[String, untyped] data, ?path: String) -> void
+        # @rbs (json_object data, ?path: String) -> void
         def initialize(data, path: "$")
           super()
           @data = data
@@ -70,7 +70,7 @@ module Ibex
           end
         end
 
-        # @rbs (Hash[String, untyped] rule, String path, String options) -> void
+        # @rbs (json_object rule, String path, String options) -> void
         def validate_pattern(rule, path, options)
           flags = 0
           flags |= Regexp::IGNORECASE if options.include?("i")

data/lib/ibex/ir/validator.rb

@@ -23,7 +23,8 @@ module Ibex
         supported = type == "lexer" ? SUPPORTED_LEXER_SCHEMA_VERSIONS : SUPPORTED_SCHEMA_VERSIONS
         unless supported.include?(version)
           expected = supported.join(", ")
-          raise Ibex::Error, "#{POSITION}: unsupported schema_version #{version.inspect}; expected one of #{expected}"
+          raise Ibex::Error,
+                "#{POSITION}: unsupported schema_version #{version.inspect}; expected the current format (#{expected})"
         end
 
         case type

data/lib/ibex/ir.rb

@@ -2,7 +2,6 @@
 
 require_relative "ir/grammar_ir"
 require_relative "ir/lexer_ir"
-require_relative "ir/migration"
 require_relative "ir/automaton_ir"
 require_relative "ir/serialize"
 require_relative "ir/validator"
@@ -11,6 +10,7 @@ module Ibex
   module IR
     # Shared static shapes used across analysis, automaton construction, and code generation.
     # @rbs!
+    #   type serialized_value = untyped
     #   type location = { file: String, line: Integer, column: Integer }
     #   type precedence = { associativity: Symbol, level: Integer }
     #   type named_ref = { name: String, index: Integer }
@@ -25,6 +25,9 @@ module Ibex
     #   type grammar_test = { expectation: :accept | :reject, source: String, loc: location }
     #   type node_annotation = { name: String, fields: Array[String], loc: location }
     #   type lexer_warning = { type: :redos, rule: Integer, loc: location }
+    #   type lexer_rule_document_value = Integer | String | Symbol | nil | location
+    #   type lexer_document_value = String | Integer | Array[String] |
+    #     Array[Hash[Symbol, lexer_rule_document_value]] | Array[lexer_warning] | source_provenance?
     #   type parameter_expansion = { rule: String, arguments: Array[String] }
     #   type inline_expansion = { rule: String }
     #   type production_expansion = {
@@ -56,7 +59,6 @@ module Ibex
     #     fragments: Array[action_fragment],
     #     ?plan: action_composition_plan
     #   }
-    #   type migration_metadata = { from_schema_version: Integer, unavailable: Array[String] }
     #   type user_code_chunks = Hash[String, Array[UserCodeChunk]]
     #   type grammar_options = { result_var: bool, omit_action_call: bool, ?cst: bool }
     #   type grammar_mode = :default | :extended
@@ -92,7 +94,18 @@ module Ibex
     #     ?expected_rr: Integer,
     #     ?rr_expectation_met: bool
     #   }
-    #   type interpretation = Hash[Symbol, untyped]
+    #   type derivation_node = {
+    #     symbol: String,
+    #     ?token: String,
+    #     ?production: Integer,
+    #     ?children: Array[derivation_node]
+    #   }
+    #   type interpretation = {
+    #     kind: Symbol,
+    #     tree: derivation_node?,
+    #     ?state: Integer,
+    #     ?production: Integer
+    #   }
     #   type counterexample = {
     #     state: Integer,
     #     type: Symbol,

data/lib/ibex/lalr/build_metrics.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 module Ibex
   module LALR
+    # Optional measurements are kept explicit for schema stability.
+    # rubocop:disable Metrics/ParameterLists
     # Immutable structural measurements from one automaton build. These counts
     # are intended for diagnostics and benchmarks, not parser behavior.
     class BuildMetrics
@@ -9,15 +12,60 @@ module Ibex
       attr_reader :canonical_states #: Integer?
       attr_reader :final_states #: Integer
       attr_reader :strategy #: Symbol
+      attr_reader :lr0_states #: Integer?
+      attr_reader :lr0_items #: Integer?
+      attr_reader :canonical_items #: Integer?
+      attr_reader :final_items #: Integer?
+      attr_reader :final_lookahead_items #: Integer?
+      attr_reader :propagation_edges #: Integer?
+      attr_reader :ielr_initial_partitions #: Integer?
+      attr_reader :ielr_final_partitions #: Integer?
+      attr_reader :ielr_annotations #: Integer?
+      attr_reader :ielr_annotated_states #: Integer?
+      attr_reader :ielr_inadequacies #: Integer?
+      attr_reader :ielr_split_stable_discarded #: Integer?
+      attr_reader :ielr_lalr_states #: Integer?
+      attr_reader :ielr_split_states #: Integer?
+      attr_reader :ielr_unreachable_removed #: Integer?
+      attr_reader :ielr_remergeable_candidates #: Integer?
 
-      # @rbs (construction_states: Integer, canonical_states: Integer?, final_states: Integer, strategy: Symbol) -> void
-      def initialize(construction_states:, canonical_states:, final_states:, strategy:)
+      # @rbs (construction_states: Integer, canonical_states: Integer?, final_states: Integer, strategy: Symbol,
+      #   ?lr0_states: Integer?, ?lr0_items: Integer?, ?canonical_items: Integer?, ?final_items: Integer?,
+      #   ?final_lookahead_items: Integer?, ?propagation_edges: Integer?, ?ielr_initial_partitions: Integer?,
+      #   ?ielr_final_partitions: Integer?, ?ielr_annotations: Integer?, ?ielr_annotated_states: Integer?,
+      #   ?ielr_inadequacies: Integer?, ?ielr_split_stable_discarded: Integer?, ?ielr_lalr_states: Integer?,
+      #   ?ielr_split_states: Integer?, ?ielr_unreachable_removed: Integer?,
+      #   ?ielr_remergeable_candidates: Integer?) -> void
+      def initialize(construction_states:, canonical_states:, final_states:, strategy:, lr0_states: nil, lr0_items: nil,
+                     canonical_items: nil, final_items: nil, final_lookahead_items: nil, propagation_edges: nil,
+                     ielr_initial_partitions: nil, ielr_final_partitions: nil, ielr_annotations: nil,
+                     ielr_annotated_states: nil, ielr_inadequacies: nil, ielr_split_stable_discarded: nil,
+                     ielr_lalr_states: nil, ielr_split_states: nil, ielr_unreachable_removed: nil,
+                     ielr_remergeable_candidates: nil)
         @construction_states = construction_states
         @canonical_states = canonical_states
         @final_states = final_states
         @strategy = strategy
+        @lr0_states = lr0_states
+        @lr0_items = lr0_items
+        @canonical_items = canonical_items
+        @final_items = final_items
+        @final_lookahead_items = final_lookahead_items
+        @propagation_edges = propagation_edges
+        @ielr_initial_partitions = ielr_initial_partitions
+        @ielr_final_partitions = ielr_final_partitions
+        @ielr_annotations = ielr_annotations
+        @ielr_annotated_states = ielr_annotated_states
+        @ielr_inadequacies = ielr_inadequacies
+        @ielr_split_stable_discarded = ielr_split_stable_discarded
+        @ielr_lalr_states = ielr_lalr_states
+        @ielr_split_states = ielr_split_states
+        @ielr_unreachable_removed = ielr_unreachable_removed
+        @ielr_remergeable_candidates = ielr_remergeable_candidates
         freeze
       end
     end
   end
 end
+
+# rubocop:enable Metrics/ParameterLists