ibex 0.2.0 → 0.4.0

data/lib/ibex/cli/impact.rb

@@ -0,0 +1,393 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "json"
+require "optparse"
+require_relative "../diff"
+require_relative "../impact"
+
+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(arguments)
+      settings = impact_option_parser(arguments)
+      if settings[:help]
+        @stdout.puts(settings.fetch(:help))
+        return 0
+      end
+      paths = settings.fetch(:paths)
+      unless [1, 2].include?(paths.length)
+        raise Ibex::Error, "(impact):1:1: impact requires one grammar or two grammar files"
+      end
+
+      extend CLIAnalysis unless singleton_class.ancestors.include?(CLIAnalysis)
+      settings[:algorithm] = local_configuration_value(settings, "parser.algorithm")
+      analysis = if paths.length == 1
+                   potential_impact(paths, settings)
+                 else
+                   confirmed_impact(paths, settings)
+                 end
+      report, identities, gate_report = analysis
+      apply_baseline(report, identities, settings)
+      apply_baseline(gate_report, identities, settings)
+      write_impact_report(report, settings.fetch(:format))
+      Impact::Severity.fails?(gate_report, settings.fetch(:fail_on)) ? 1 : 0
+    end
+
+    # @rbs (Array[String]) -> Hash[Symbol, untyped]
+    def impact_option_parser(arguments)
+      settings = {
+        paths: [], symbols: [], depth: nil, kinds: [:all], severity: "medium", coverage: [],
+        fail_on: [], format: "json", update_baseline: false, configuration_explicit: [],
+        algorithm: Configuration::Registry.fetch("parser.algorithm").default,
+        mode: Configuration::Registry.fetch("grammar.mode").default
+      } #: Hash[Symbol, untyped]
+      # rubocop:disable Metrics/BlockLength
+      parser = OptionParser.new do |options|
+        options.banner = "Usage: ibex impact [options] GRAMMAR or OLD NEW"
+        options.on("--symbol=NAME[,NAME]", "seed nonterminals for a one-version analysis") do |value|
+          settings[:symbols].concat(value.split(",").map(&:strip))
+        end
+        options.on("--depth=N", Integer, "maximum propagation depth") do |value|
+          raise OptionParser::InvalidArgument, "--depth must be non-negative" if value.negative?
+
+          settings[:depth] = value
+        end
+        options.on("--kind=LIST", "reference, first, or follow") { |value| settings[:kinds] = parse_kinds(value) }
+        options.on("--severity=LEVEL", Impact::Severity::LEVELS, "minimum severity") do |value|
+          settings[:severity] = value
+        end
+        options.on("--coverage=PATH", "runtime coverage report (repeatable)") { |value| settings[:coverage] << value }
+        options.on("--baseline=PATH", "known conflict baseline") { |value| settings[:baseline] = value }
+        options.on("--update-baseline", "write the current conflict baseline") { settings[:update_baseline] = true }
+        options.on("--fail-on=LIST", "CI gate conditions") do |value|
+          settings[:fail_on] = Impact::Severity.validate_gates(value.split(",").map(&:strip))
+        end
+        options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "algorithm for grammar inputs") do |value|
+          set_local_configuration_option(settings, :algorithm, value.to_sym)
+        end
+        options.on("--mode=MODE", %w[default extended], "grammar mode") do |value|
+          set_local_configuration_option(settings, :mode, value.to_sym)
+          set_configuration_option(:mode, value.to_sym)
+        end
+        options.on("--format=FORMAT", %w[json text], "json or text") { |value| settings[:format] = value }
+        options.on("--help", "show help") { settings[:help] = options.to_s }
+      end
+      # rubocop:enable Metrics/BlockLength
+      settings[:paths] = parser.parse(arguments)
+      settings
+    end
+
+    # @rbs (String value) -> Array[Symbol]
+    def parse_kinds(value)
+      kinds = value.split(",").map(&:strip).map(&:to_sym)
+      unknown = kinds - %i[reference first follow]
+      raise OptionParser::InvalidArgument, "unknown impact kind #{unknown.first.inspect}" unless unknown.empty?
+
+      kinds.uniq
+    end
+
+    # @rbs (Array[String], Hash[Symbol, untyped]) -> [Hash[Symbol, Object?], Array[String], Hash[Symbol, Object?]]
+    def potential_impact(paths, settings)
+      automaton = load_analysis_automaton(paths.fetch(0), settings.fetch(:algorithm), explicit: algo_set?(settings))
+      names = settings.fetch(:symbols)
+      raise Ibex::Error, "(impact):1:1: one-version impact requires --symbol" if names.empty?
+
+      seeds = Impact::Seeds.new(automaton.grammar, names)
+      graph = Impact::Graph.new(automaton.grammar)
+      nodes, symbol_kinds = propagate(graph, seeds.ids, settings)
+      automaton_impact = Impact::AutomatonImpact.new(automaton, nodes.keys)
+      coverage = load_coverage(automaton, automaton_impact.production_ids, settings)
+      reporter = Impact::Report.new(
+        mode: "potential", algorithm: automaton.algorithm, grammar: automaton.grammar, before: nil, after: automaton,
+        seeds: seeds.records, nodes: nodes, symbol_kinds: symbol_kinds, set_changes: {},
+        automaton: potential_automaton_document(automaton, automaton_impact), actions: [], coverage: coverage.to_h,
+        minimum: settings.fetch(:severity), warnings: nullable_warnings(seeds, coverage)
+      )
+      [reporter.to_h, conflict_identities(automaton), reporter.to_h(minimum: "info")]
+    end
+
+    # @rbs (Array[String], Hash[Symbol, untyped]) -> [Hash[Symbol, Object?], Array[String], Hash[Symbol, Object?]]
+    def confirmed_impact(paths, settings)
+      before = load_analysis_automaton(paths.fetch(0), settings.fetch(:algorithm), explicit: algo_set?(settings))
+      after = load_analysis_automaton(paths.fetch(1), settings.fetch(:algorithm), explicit: algo_set?(settings))
+      diff = Diff.new(before, after).to_h
+      rules = diff.fetch(:rules) #: Hash[Symbol, Array[Hash[Symbol, Object?]]]
+      names = rules.values_at(:added, :removed, :changed).flatten.map do |record|
+        record.fetch(:id).to_s
+      end.uniq.sort
+      seed_names = names.select { |name| after.grammar.symbol(name) }
+      seeds = Impact::Seeds.new(after.grammar, seed_names, origin: "diff")
+      removed_seed_names = names.reject { |name| after.grammar.symbol(name) }
+      removed_seeds = Impact::Seeds.new(before.grammar, removed_seed_names, origin: "diff")
+      seed_records = (seeds.records + removed_seeds.records).sort_by { |record| record.fetch(:symbol).to_s }
+      symbol_changes = diff.fetch(:symbols) #: Hash[Symbol, Array[Hash[Symbol, Object?]]]
+      metadata_names = symbol_changes.values.flatten.map { |record| record.fetch(:id).to_s }.uniq.sort
+      graph = Impact::Graph.new(after.grammar)
+      nodes, symbol_kinds = propagate(graph, seeds.ids, settings)
+      set_changes, changed_kinds = compare_sets(before, after)
+      symbol_kinds = merge_symbol_kinds(symbol_kinds, changed_kinds, after.grammar)
+      precedence_kinds = precedence_symbol_kinds(symbol_changes, after.grammar)
+      symbol_kinds = merge_symbol_kinds(symbol_kinds, precedence_kinds, after.grammar)
+      automaton_impact = Impact::AutomatonImpact.new(after, nodes.keys)
+      actions = Impact::ActionImpact.new(before.grammar, after.grammar, affected_names: names).to_a
+      coverage = load_coverage(after, automaton_impact.production_ids, settings)
+      reporter = Impact::Report.new(
+        mode: "diff", algorithm: after.algorithm, grammar: after.grammar, before: before, after: after,
+        seeds: seed_records, nodes: nodes, symbol_kinds: symbol_kinds, set_changes: set_changes,
+        metadata_names: metadata_names,
+        automaton: confirmed_automaton_document(before, after, diff, automaton_impact), actions: actions,
+        coverage: coverage.to_h, minimum: settings.fetch(:severity), warnings: coverage.warnings
+      )
+      [reporter.to_h, conflict_identities(after), reporter.to_h(minimum: "info")]
+    end
+
+    # @rbs (Impact::Graph, Array[Integer], Hash[Symbol, untyped]) ->
+    #   [Hash[Integer, Impact::Node], Hash[Integer, Array[String]]]
+    def propagate(graph, seed_ids, settings)
+      kinds = settings.fetch(:kinds) == [:all] ? %i[reference first follow] : settings.fetch(:kinds)
+      nodes = {} #: Hash[Integer, Impact::Node]
+      symbol_kinds = Hash.new { |hash, key| hash[key] = [] } #: Hash[Integer, Array[String]]
+      kinds.each do |kind|
+        current = Impact::Propagation.new(graph).propagate(seed_ids, kind, max_depth: settings[:depth])
+        current.each do |id, node|
+          best = nodes[id]
+          nodes[id] = node if best.nil? || node.distance < best.distance
+          symbol_kinds[id] << kind.to_s unless node.distance.zero? && node.witness.empty?
+        end
+      end
+      [nodes.sort.to_h, symbol_kinds.transform_values { |value| value.uniq.sort }]
+    end
+
+    # @rbs (IR::Automaton, Array[Integer], Hash[Symbol, untyped]) -> Impact::CoverageImpact
+    def load_coverage(automaton, production_ids, settings)
+      reports = settings.fetch(:coverage).map { |path| [path, Coverage::Report.load_file(path)] }
+      Impact::CoverageImpact.new(automaton, production_ids, reports)
+    end
+
+    # @rbs (Impact::Seeds, Impact::CoverageImpact) -> Array[String]
+    def nullable_warnings(seeds, coverage)
+      warnings = coverage.warnings.dup
+      seeds.records.each do |seed|
+        next unless seed.fetch(:nullable_boundary)
+
+        warnings << "#{seed.fetch(:symbol)}: nullable boundary may make potential propagation " \
+                    "incomplete; compare two versions"
+      end
+      warnings
+    end
+
+    # @rbs (IR::Automaton, Impact::AutomatonImpact) -> Hash[Symbol, Object?]
+    def potential_automaton_document(automaton, impact)
+      added = conflict_identities(automaton).map { |id| { id: id, value: nil } } #: Array[Hash[Symbol, Object?]]
+      removed = [] #: Array[Hash[Symbol, Object?]]
+      changed = [] #: Array[Hash[Symbol, Object?]]
+      { states: { before: nil, after: automaton.states.length, delta: nil },
+        affected_states: impact.affected_states,
+        conflicts: { added: added, removed: removed, changed: changed },
+        unreachable: unreachable_state_ids(automaton),
+        unreachable_nonterminals: unreachable_nonterminal_names(automaton.grammar) }
+    end
+
+    # @rbs (IR::Automaton, IR::Automaton, Hash[Symbol, Object?], Impact::AutomatonImpact) -> Hash[Symbol, Object?]
+    def confirmed_automaton_document(before, after, diff, impact)
+      {
+        states: {
+          before: before.states.length, after: after.states.length, delta: after.states.length - before.states.length
+        },
+        affected_states: impact.affected_states, conflicts: diff.fetch(:conflicts),
+        unreachable: newly_unreachable_state_ids(before, after),
+        unreachable_nonterminals: newly_unreachable_nonterminal_names(before.grammar, after.grammar)
+      }
+    end
+
+    # @rbs (IR::Grammar) -> Array[String]
+    def unreachable_nonterminal_names(grammar)
+      grammar.warnings.filter_map do |warning|
+        next unless warning.fetch(:type).to_sym == :unreachable_nonterminal
+
+        warning.fetch(:symbol).to_s
+      end.uniq.sort
+    end
+
+    # @rbs (IR::Grammar, IR::Grammar) -> Array[String]
+    def newly_unreachable_nonterminal_names(before, after)
+      unreachable_nonterminal_names(after) - unreachable_nonterminal_names(before)
+    end
+
+    # @rbs (IR::Automaton) -> Array[Integer]
+    def unreachable_state_ids(automaton)
+      reachable = LALR::UnreachableStates.reachable_states(automaton.states, automaton.entry_states.values)
+      (0...automaton.states.length).to_a - reachable
+    end
+
+    # @rbs (IR::Automaton, IR::Automaton) -> Array[Integer]
+    def newly_unreachable_state_ids(before, after)
+      before_keys = unreachable_state_keys(before)
+      unreachable_state_ids(after).reject { |id| before_keys.include?(unreachable_state_key(after, id)) }
+    end
+
+    # @rbs (IR::Automaton) -> Array[String]
+    def unreachable_state_keys(automaton)
+      unreachable_state_ids(automaton).map { |id| unreachable_state_key(automaton, id) }
+    end
+
+    # @rbs (IR::Automaton, Integer) -> String
+    def unreachable_state_key(automaton, id)
+      state = automaton.states.fetch(id)
+      items = state.items.map do |item|
+        production_name = if item.production == LALR::Builder::AUGMENTED_PRODUCTION
+                            "$accept"
+                          else
+                            production = automaton.grammar.productions.fetch(item.production)
+                            production_shape(automaton.grammar, production.id)
+                          end
+        [production_name, item.dot,
+         item.lookaheads.map { |lookahead| automaton.grammar.symbol_by_id(lookahead)&.name || lookahead.to_s }]
+      end.sort_by(&:inspect)
+      JSON.generate(items)
+    end
+
+    # @rbs (IR::Automaton, IR::Automaton) ->
+    #   [Hash[String, Hash[Symbol, Object?]], Hash[String, Array[String]]]
+    def compare_sets(before, after)
+      before_sets = Analysis::Sets.new(before.grammar)
+      after_sets = Analysis::Sets.new(after.grammar)
+      names = (before.grammar.nonterminals.map(&:name) + after.grammar.nonterminals.map(&:name)).uniq.sort
+      changes = {} #: Hash[String, Hash[Symbol, Object?]]
+      kinds = {} #: Hash[String, Array[String]]
+      names.each do |name|
+        before_symbol = before.grammar.symbol(name)
+        after_symbol = after.grammar.symbol(name)
+        first = set_change(before_sets, after_sets, before_symbol, after_symbol, :first)
+        follow = set_change(before_sets, after_sets, before_symbol, after_symbol, :follow)
+        nullable = nullable_change(before_sets, after_sets, before_symbol, after_symbol)
+        next if set_change_empty?(first, follow, nullable)
+
+        changes[name] = { first: first, follow: follow, nullable: nullable }
+        kinds[name] = []
+        kinds[name] << "first" unless first[:added].empty? && first[:removed].empty?
+        kinds[name] << "follow" unless follow[:added].empty? && follow[:removed].empty?
+        kinds[name] << "nullable" if nullable
+      end
+      [changes, kinds]
+    end
+
+    # @rbs (Analysis::Sets, Analysis::Sets, IR::GrammarSymbol?, IR::GrammarSymbol?, Symbol) ->
+    #   Hash[Symbol, Array[String]]
+    def set_change(before, after, before_symbol, after_symbol, kind)
+      before_values = before_symbol&.nonterminal? ? before.public_send(kind, before_symbol) : [] #: Array[String]
+      after_values = after_symbol&.nonterminal? ? after.public_send(kind, after_symbol) : [] #: Array[String]
+      { added: after_values - before_values, removed: before_values - after_values }
+    end
+
+    # @rbs (Hash[Symbol, Array[String]], Hash[Symbol, Array[String]], Hash[Symbol, Object?]?) -> bool
+    def set_change_empty?(first, follow, nullable)
+      first_empty = first[:added].empty? && first[:removed].empty?
+      follow_empty = follow[:added].empty? && follow[:removed].empty?
+      first_empty && follow_empty && nullable.nil?
+    end
+
+    # @rbs (Analysis::Sets, Analysis::Sets, IR::GrammarSymbol?, IR::GrammarSymbol?) -> Hash[Symbol, Object?]?
+    def nullable_change(before, after, before_symbol, after_symbol)
+      return nil unless before_symbol || after_symbol
+
+      old = before_symbol ? before.nullable?(before_symbol) : false
+      current = after_symbol ? after.nullable?(after_symbol) : false
+      return nil if old == current
+
+      { before: old, after: current }
+    end
+
+    # @rbs (Hash[Integer, Array[String]], Hash[String, Array[String]], IR::Grammar) -> Hash[Integer, Array[String]]
+    def merge_symbol_kinds(symbol_kinds, changed_kinds, grammar)
+      result = symbol_kinds.transform_values(&:dup)
+      changed_kinds.each do |name, kinds|
+        id = grammar.symbol(name)&.id
+        next unless id
+
+        result[id] = (result.fetch(id, []) + kinds).uniq.sort
+      end
+      result
+    end
+
+    # @rbs (Hash[Symbol, Array[Hash[Symbol, Object?]]], IR::Grammar) -> Hash[String, Array[String]]
+    def precedence_symbol_kinds(symbol_changes, grammar)
+      result = {} #: Hash[String, Array[String]]
+      symbol_changes.fetch(:changed).each do |record|
+        before = record.fetch(:before)
+        after = record.fetch(:after)
+        next unless before.is_a?(Hash) && after.is_a?(Hash)
+        next if before.fetch(:precedence) == after.fetch(:precedence)
+
+        name = record.fetch(:id).to_s
+        result[name] = ["precedence"] if grammar.symbol(name)
+      end
+      result
+    end
+
+    # @rbs (IR::Automaton) -> Array[String]
+    def conflict_identities(automaton)
+      automaton.states.flat_map do |state|
+        state.conflicts.map { |conflict| conflict_identity(automaton.grammar, conflict) }
+      end.uniq.sort
+    end
+
+    # @rbs (IR::Grammar, Hash[Symbol, Object?]) -> String
+    def conflict_identity(grammar, conflict)
+      type = conflict.fetch(:type).to_s.to_sym
+      symbol = conflict.fetch(:symbol).to_s
+      if type == :shift_reduce
+        reduce = conflict.fetch(:reduce) #: Integer
+        "shift_reduce:#{symbol}:#{production_shape(grammar, reduce)}"
+      else
+        reduction_ids = conflict.fetch(:reductions) #: Array[Integer]
+        reductions = reduction_ids.map { |id| production_shape(grammar, id) }.sort
+        "reduce_reduce:#{symbol}:#{reductions.join('|')}"
+      end
+    end
+
+    # @rbs (IR::Grammar, Integer) -> String
+    def production_shape(grammar, id)
+      production = grammar.productions.fetch(id)
+      lhs = grammar.symbol_by_id(production.lhs)&.name || production.lhs.to_s
+      rhs = production.rhs.map { |symbol_id| grammar.symbol_by_id(symbol_id)&.name || symbol_id.to_s }
+      "#{lhs}->#{rhs.join(' ')}"
+    end
+
+    # @rbs (Hash[Symbol, Object?], Array[String], Hash[Symbol, untyped]) -> void
+    def apply_baseline(report, identities, settings)
+      path = settings[:baseline]
+      baseline = Impact::Baseline.new(path) if path
+      baseline.write(identities) if baseline && settings[:update_baseline]
+      return unless baseline
+
+      known = baseline.conflicts
+      conflicts = report.dig(:automaton, :conflicts, :added)
+      return unless conflicts
+
+      original_count = conflicts.length
+      conflicts.reject! { |entry| known.include?(entry.fetch(:id)) }
+      totals = report.fetch(:totals) #: Hash[Symbol, Integer]
+      totals[:critical] -= original_count - conflicts.length
+    end
+
+    # @rbs (Hash[Symbol, Object?], String) -> void
+    def write_impact_report(report, format)
+      return @stdout.puts(JSON.pretty_generate(report)) if format == "json"
+
+      symbols = report.fetch(:symbols) #: Array[untyped]
+      warnings = report.fetch(:warnings) #: Array[String]
+      @stdout.puts("impact mode=#{report.fetch(:mode)} symbols=#{symbols.length} " \
+                   "affected_states=#{report.dig(:automaton, :affected_states).length}")
+      warnings.each { |warning| @stdout.puts("warning: #{warning}") }
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength, Metrics/MethodLength, Metrics/AbcSize
+end

data/lib/ibex/cli/ir_tools.rb

@@ -1,22 +1,10 @@
 # frozen_string_literal: true
 
-require "tempfile"
 require_relative "../ir"
 
 module Ibex
-  # @rbs!
-  #   type migrate_ir_options = {
-  #     paths: Array[String],
-  #     ?to: Integer,
-  #     ?output: String
-  #   }
-
-  # CLI validation and structural comparison for versioned IR documents.
+  # CLI validation and structural comparison for current IR documents.
   module CLIIRTools
-    # @rbs!
-    #   private def same_file_target?: (String left, String right) -> bool
-    #   private def atomic_write_ir: (String path, String source) -> void
-
     private
 
     # @rbs (Array[String] arguments) -> Integer
@@ -30,7 +18,7 @@ module Ibex
              else
                "automaton"
              end
-      @stdout.puts("valid #{kind} IR v#{value.schema_version}")
+      @stdout.puts("valid current #{kind} IR")
       0
     end
 
@@ -49,50 +37,6 @@ module Ibex
       0
     end
 
-    # @rbs (Array[String] arguments) -> Integer
-    def run_migrate_ir_command(arguments)
-      settings = migrate_ir_options(arguments)
-      input = single_ir_path(settings.fetch(:paths), "migrate-ir")
-      output = settings[:output]
-      if output && same_file_target?(input, output)
-        raise Ibex::Error, "(cli):1:1: migrate-ir input and output paths must be distinct"
-      end
-
-      value = IR::Validator.validate(File.read(input))
-      target = settings[:to] || raise(Ibex::Error, "(cli):1:1: migrate-ir requires --to=VERSION")
-      if value.is_a?(IR::Lexer)
-        raise Ibex::Error, "(cli):1:1: lexer IR is already at its only supported schema version" unless
-          target == value.schema_version
-
-        source = IR::Serialize.dump(value)
-        output ? atomic_write_ir(output, source) : @stdout.write(source)
-        return 0
-      end
-      unless IR::SUPPORTED_SCHEMA_VERSIONS.include?(target)
-        raise Ibex::Error, "(cli):1:1: unsupported migration target schema_version #{target}"
-      end
-      if target < value.schema_version
-        raise Ibex::Error,
-              "(cli):1:1: downgrading schema_version #{value.schema_version} to #{target} is not supported"
-      end
-
-      source = IR::Serialize.dump(IR::Migration.to_version(value, to: target))
-      output ? atomic_write_ir(output, source) : @stdout.write(source)
-      0
-    end
-
-    # @rbs (Array[String] arguments) -> migrate_ir_options
-    def migrate_ir_options(arguments)
-      settings = { paths: [] } #: migrate_ir_options
-      parser = OptionParser.new do |options|
-        options.banner = "Usage: ibex migrate-ir INPUT --to=VERSION [-o FILE]"
-        options.on("--to=VERSION", Integer, "target schema version") { |value| settings[:to] = value }
-        options.on("-o FILE", "--output=FILE", "write atomically to FILE") { |value| settings[:output] = value }
-      end
-      settings[:paths] = parser.parse(arguments)
-      settings
-    end
-
     # @rbs (Array[String] arguments, String command) -> String
     def single_ir_path(arguments, command)
       return arguments.first if arguments.length == 1
@@ -101,7 +45,7 @@ module Ibex
     end
 
     # @rbs (IR::Grammar | IR::Automaton | IR::Lexer before,
-    #   IR::Grammar | IR::Automaton | IR::Lexer after) -> Hash[Symbol, untyped]
+    #   IR::Grammar | IR::Automaton | IR::Lexer after) -> Hash[Symbol, Object?]
     def compare_ir(before, after)
       return compare_grammars(before, after) if before.is_a?(IR::Grammar) && after.is_a?(IR::Grammar)
       if before.is_a?(IR::Automaton) && after.is_a?(IR::Automaton)
@@ -121,7 +65,7 @@ module Ibex
       raise Ibex::Error, "(cli):1:1: unsupported IR comparison"
     end
 
-    # @rbs (IR::Lexer before, IR::Lexer after) -> Hash[Symbol, untyped]
+    # @rbs (IR::Lexer before, IR::Lexer after) -> Hash[Symbol, Object?]
     def compare_lexers(before, after)
       before_rules = before.rules.map { |rule| [rule.state, rule.kind, rule.token, rule.pattern, rule.options] }
       after_rules = after.rules.map { |rule| [rule.state, rule.kind, rule.token, rule.pattern, rule.options] }
@@ -136,7 +80,7 @@ module Ibex
       }
     end
 
-    # @rbs (IR::Grammar before, IR::Grammar after) -> Hash[Symbol, untyped]
+    # @rbs (IR::Grammar before, IR::Grammar after) -> Hash[Symbol, Object?]
     def compare_grammars(before, after)
       before_symbols = before.symbols.map(&:name)
       after_symbols = after.symbols.map(&:name)

data/lib/ibex/cli/outputs.rb

@@ -5,23 +5,19 @@ module Ibex
   module CLIOutputs
     # @rbs!
     #   private def register_artifact: (Symbol, String, String, ?mode: Integer?, ?status: bool) -> Artifact
-
-    WARNING_MESSAGES = {
-      undeclared_terminal: ->(warning) { "undeclared terminal #{warning[:symbol]}" },
-      unused_terminal: ->(warning) { "unused terminal #{warning[:symbol]}" },
-      unused_precedence: ->(warning) { "unused precedence #{warning[:symbol]}" },
-      unreachable_terminal: ->(warning) { "declared terminal #{warning[:symbol]} is unreachable" },
-      unreachable_nonterminal: ->(warning) { "unreachable nonterminal #{warning[:symbol]}" },
-      duplicate_production: lambda do |warning|
-        "duplicate production #{warning[:production]} (first defined as #{warning[:original]})"
-      end,
-      implicit_empty: ->(_warning) { "implicit empty alternative; write %empty to document intent" },
-      empty_language: ->(warning) { "start symbol #{warning[:symbol]} derives no terminal sentence" },
-      lexer_redos: lambda do |warning|
-        subject = warning[:symbol] ? " for #{warning[:symbol]}" : ""
-        "lexer pattern#{subject} may exhibit excessive backtracking"
-      end
-    }.freeze #: Hash[Symbol, ^(IR::grammar_warning) -> String]
+    #   private def configuration_value: (String) -> Object?
+
+    WARNING_MESSAGE_IDS = {
+      undeclared_terminal: "warning.undeclared_terminal",
+      unused_terminal: "warning.unused_terminal",
+      unused_precedence: "warning.unused_precedence",
+      unreachable_terminal: "warning.unreachable_terminal",
+      unreachable_nonterminal: "warning.unreachable_nonterminal",
+      duplicate_production: "warning.duplicate_production",
+      implicit_empty: "warning.implicit_empty",
+      empty_language: "warning.empty_language",
+      lexer_redos: "warning.lexer_redos"
+    }.freeze #: Hash[Symbol, String]
 
     private
 
@@ -42,32 +38,45 @@ module Ibex
       categories = @options[:warnings]
       return if categories.nil? || categories.include?(:none) || grammar.warnings.empty?
 
-      messages = grammar.warnings.map { |warning| format_grammar_warning(warning, input_path) }
       if categories.include?(:error)
-        promoted = messages.map { |message| message.sub(": warning:", ": warning treated as error:") }
+        promoted = grammar.warnings.map do |warning|
+          format_grammar_warning(warning, input_path, promoted: true)
+        end
         raise Ibex::Error, promoted.join("\n")
       end
 
-      messages.each { |message| @stderr.puts(message) }
+      grammar.warnings.each { |warning| @stderr.puts(format_grammar_warning(warning, input_path)) }
     end
 
-    # @rbs (IR::grammar_warning warning, String input_path) -> String
-    def format_grammar_warning(warning, input_path)
+    # @rbs (IR::grammar_warning warning, String input_path, ?promoted: bool) -> String
+    def format_grammar_warning(warning, input_path, promoted: false)
       location = warning[:loc]
       rendered = if location
                    "#{location[:file] || input_path}:#{location[:line] || 1}:#{location[:column] || 1}"
                  else
                    "#{input_path}:1:1"
                  end
-      formatter = WARNING_MESSAGES.fetch(warning[:type]) { ->(item) { item[:type].to_s.tr("_", " ") } }
-      "#{rendered}: warning: #{formatter.call(warning)}"
+      label_id = promoted ? "label.warning_as_error" : "label.warning"
+      label = Messages.translate(label_id, language: @language)
+      "#{rendered}: #{label}: #{grammar_warning_message(warning)}"
+    end
+
+    # @rbs (IR::grammar_warning warning) -> String
+    def grammar_warning_message(warning)
+      id = WARNING_MESSAGE_IDS.fetch(warning[:type])
+      id = "warning.lexer_redos_symbol" if warning[:type] == :lexer_redos && warning[:symbol]
+      values = warning.to_h.transform_values(&:to_s) #: Hash[Symbol, String]
+      Messages.translate(id, language: @language, **values)
     end
 
     # @rbs (IR::Automaton automaton, String input_path) -> void
     def report_conflicts(automaton, input_path)
       messages = conflict_messages(automaton.conflict_summary, input_path)
       if @options[:warnings]&.include?(:error) && messages.any?
-        raise Ibex::Error, messages.map { |message| "#{message}; conflict treated as error" }.join("\n")
+        promoted = messages.map do |message|
+          Messages.translate("conflict.treated_as_error", language: @language, detail: message)
+        end
+        raise Ibex::Error, promoted.join("\n")
       end
 
       messages.each { |message| @stderr.puts(message) }
@@ -77,29 +86,44 @@ module Ibex
     def conflict_messages(summary, input_path)
       messages = [] #: Array[String]
       unless summary[:expectation_met]
-        messages << "#{input_path}:1:1: #{summary[:sr]} shift/reduce conflicts; expected #{summary[:expected_sr]}"
+        detail = Messages.translate(
+          "conflict.shift_reduce_expected",
+          language: @language,
+          actual: summary[:sr],
+          expected: summary[:expected_sr]
+        )
+        messages << "#{input_path}:1:1: #{detail}"
       end
       if summary.key?(:rr_expectation_met)
         unless summary[:rr_expectation_met]
-          messages << "#{input_path}:1:1: #{summary[:rr]} reduce/reduce conflicts; expected #{summary[:expected_rr]}"
+          detail = Messages.translate(
+            "conflict.reduce_reduce_expected",
+            language: @language,
+            actual: summary[:rr],
+            expected: summary[:expected_rr]
+          )
+          messages << "#{input_path}:1:1: #{detail}"
         end
       elsif summary[:rr].positive?
-        messages << "#{input_path}:1:1: #{summary[:rr]} reduce/reduce conflicts"
+        detail = Messages.translate("conflict.reduce_reduce", language: @language, actual: summary[:rr])
+        messages << "#{input_path}:1:1: #{detail}"
       end
       messages
     end
 
     # @rbs (IR::Automaton automaton, String input_path) -> void
+    # rubocop:disable Metrics/AbcSize -- the bounded comparison reports each conflict class independently.
     def suggest_ielr(automaton, input_path)
       return unless @options[:suggest_ielr]
       return unless automaton.algorithm == "lalr1"
-      return unless [nil, :lalr].include?(@options[:algorithm])
+      return unless configuration_value("parser.algorithm") == :lalr
 
       summary = automaton.conflict_summary
       return if summary[:expectation_met] && summary.fetch(:rr_expectation_met, summary[:rr].zero?)
 
       ielr = LALR::Builder.new(
-        automaton.grammar, algorithm: :ielr, entry_isolation: @options[:entry_isolation] == true
+        Configuration::AnalysisGrammar.for_algorithm(automaton.grammar, :ielr),
+        algorithm: :ielr, entry_isolation: configuration_value("parser.entries") == :isolated
       ).build
       removed_sr = [summary[:sr] - ielr.conflict_summary[:sr], 0].max
       removed_rr = [summary[:rr] - ielr.conflict_summary[:rr], 0].max
@@ -108,13 +132,16 @@ module Ibex
       avoided << conflict_count(removed_rr, "reduce/reduce") if removed_rr.positive?
       return if avoided.empty?
 
-      @stderr.puts("#{input_path}:1:1: note: --algorithm=ielr avoids #{avoided.join(' and ')}; " \
-                   "consider --algorithm=ielr")
+      conjunction = @language == "ja" ? "、" : " and "
+      detail = Messages.translate("note.ielr", language: @language, avoided: avoided.join(conjunction))
+      @stderr.puts("#{input_path}:1:1: #{detail}")
     end
+    # rubocop:enable Metrics/AbcSize
 
     # @rbs (Integer count, String kind) -> String
     def conflict_count(count, kind)
-      "#{count} #{kind} conflict#{'s' unless count == 1}"
+      plural = @language == "en" && count != 1 ? "s" : ""
+      Messages.translate("conflict.count", language: @language, count: count, kind: kind, plural: plural)
     end
 
     # @rbs (IR::Automaton automaton, String input_path) -> void