ibex 0.2.0 → 0.3.0

data/lib/ibex/cli/fuzz_regressions.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "digest"
+require "fileutils"
+require "json"
+
+module Ibex
+  # @rbs!
+  #   type fuzz_external_description = {
+  #     command: String,
+  #     target_runtime: String,
+  #     timeout_seconds: Integer,
+  #     max_output_bytes: Integer,
+  #     host_ruby_engine: String,
+  #     host_ruby_version: String,
+  #     host_platform: String
+  #   }
+  #   type fuzz_external_target = [
+  #     ^(Array[String]) -> Symbol,
+  #     fuzz_external_description
+  #   ]
+
+  # Automatic bounded minimization and persistence for fuzz differences.
+  module CLIFuzzRegressions
+    # @rbs!
+    #   private def atomic_write_ir: (String path, String source) -> void
+
+    private
+
+    # @rbs (Fuzz fuzzer, Fuzz::Mismatch mismatch, String grammar_path,
+    #   fuzz_external_target? external) -> Integer
+    def write_minimized_fuzz_mismatch(fuzzer, mismatch, grammar_path, external)
+      details = minimized_fuzz_mismatch(fuzzer, mismatch, grammar_path, external)
+      report = {
+        ibex_report: "fuzz", schema_version: 1, result: "difference", mismatch: details
+      } #: Hash[Symbol, untyped]
+      report[:external] = external[1] if external
+      write_fuzz_report(report)
+      1
+    end
+
+    # @rbs (Hash[Symbol, untyped] report) -> void
+    def write_fuzz_report(report)
+      if @options.fetch(:fuzz_format, "json") == "json"
+        @stdout.puts JSON.pretty_generate(report)
+        return
+      end
+
+      @stdout.puts("result=#{report.fetch(:result)}")
+      case report.fetch(:result)
+      when "no_difference_within_bounds"
+        @stdout.puts("seed=#{report.fetch(:seed)} bounds=#{report.fetch(:bounds).inspect}")
+        @stdout.puts("no difference found within the declared bounds; this is not a proof of equivalence")
+      when "difference"
+        mismatch = report.fetch(:mismatch) #: Hash[Symbol, untyped]
+        @stdout.puts("kind=#{mismatch.fetch(:kind)} tokens=#{mismatch.fetch(:tokens).inspect}")
+        @stdout.puts("minimized=#{mismatch.fetch(:minimized_tokens).inspect} " \
+                     "reduction_complete=#{mismatch.dig(:reduction, :complete)}")
+        @stdout.puts("regression=#{mismatch.dig(:regression, :path)}") if mismatch[:regression]
+      when "budget_exhausted"
+        @stdout.puts("search incomplete: #{report.dig(:budget, :message)}")
+      end
+      external = report[:external] #: fuzz_external_description?
+      return unless external
+
+      @stdout.puts("target_runtime=#{external.fetch(:target_runtime)}")
+      @stdout.puts("target_command=#{external.fetch(:command)}")
+    end
+
+    # @rbs (Fuzz::BudgetExceeded error,
+    #   fuzz_external_target? external, phase: String) -> Integer
+    def write_fuzz_budget_report(error, external, phase:)
+      report = {
+        ibex_report: "fuzz", schema_version: 1, result: "budget_exhausted",
+        budget: error.details.merge(phase: phase)
+      } #: Hash[Symbol, untyped]
+      report[:external] = external[1] if external
+      write_fuzz_report(report)
+      2
+    end
+
+    # @rbs (Fuzz fuzzer, Fuzz::Mismatch mismatch, String grammar_path,
+    #   fuzz_external_target? external) -> Hash[Symbol, untyped]
+    def minimized_fuzz_mismatch(fuzzer, mismatch, grammar_path, external)
+      result = fuzzer.minimize(
+        mismatch, max_trials: @options.fetch(:fuzz_max_reduction_trials, 1_000)
+      )
+      details = mismatch.details.dup #: Hash[Symbol, untyped]
+      details[:minimized_tokens] = result.items
+      details[:reduction] = {
+        original_size: result.original_size, minimized_size: result.items.length,
+        trials: result.trials, complete: result.complete
+      }
+      regression = persist_fuzz_regression(
+        mismatch.details, result, grammar_path, external&.[](1)
+      )
+      details[:regression] = regression if regression
+      details
+    end
+
+    # @rbs (fuzz_mismatch mismatch, DeltaReducer::Result result, String grammar_path,
+    #   fuzz_external_description? external) -> Hash[Symbol, String]?
+    def persist_fuzz_regression(mismatch, result, grammar_path, external)
+      return if @options.fetch(:fuzz_save_regression, true) == false
+
+      directory = @options.fetch(:fuzz_regression_dir, "test/fuzz/regressions")
+      FileUtils.mkdir_p(directory)
+      document = fuzz_regression_document(mismatch, result, grammar_path, external)
+      source = "#{JSON.pretty_generate(document)}\n"
+      digest = Digest::SHA256.hexdigest(source)
+      seed = @options.fetch(:fuzz_seed, 0)
+      path = File.join(directory, "fuzz-seed-#{seed}-#{digest.slice(0, 16)}.json")
+      validate_fuzz_regression_target!(path)
+      atomic_write_ir(path, source)
+      { path: path, sha256: digest }
+    end
+
+    # @rbs (String path) -> void
+    def validate_fuzz_regression_target!(path)
+      return unless File.symlink?(path) || (File.exist?(path) && File.stat(path).nlink > 1)
+
+      raise Ibex::Error, "(fuzz):1:1: regression output refuses symlinks and files with multiple hard links"
+    end
+
+    # @rbs (fuzz_mismatch mismatch, DeltaReducer::Result result, String grammar_path,
+    #   fuzz_external_description? external) -> Hash[Symbol, Object?]
+    def fuzz_regression_document(mismatch, result, grammar_path, external)
+      document = {
+        ibex_report: "fuzz-regression", schema_version: 1, grammar: grammar_path,
+        seed: @options.fetch(:fuzz_seed, 0), kind: mismatch[:kind],
+        sentence: mismatch[:sentence],
+        algorithms: mismatch[:outcomes].keys.reject { |name| name == :external }.map(&:to_s),
+        original_tokens: mismatch[:tokens], minimized_tokens: result.items,
+        bounds: mismatch[:bounds],
+        reduction: {
+          original_size: result.original_size, minimized_size: result.items.length,
+          trials: result.trials, complete: result.complete
+        }
+      } #: Hash[Symbol, Object?]
+      document[:external] = external if external
+      document
+    end
+  end
+end

data/lib/ibex/cli/generation_artifacts.rb

@@ -12,6 +12,8 @@ module Ibex
     #   private def report_status: (String) -> void
     #   private def verify_file: (String, String, String) -> void
     #   private def default_output_path: (String, String) -> String
+    #   private def configuration_value: (String) -> Object?
+    #   private def effective_configuration: () -> Configuration::Resolver
 
     private
 
@@ -21,6 +23,7 @@ module Ibex
       @generation_statuses = [] #: Array[String]
       @generation_sources = [] #: Array[String]
       @generation_inputs = [] #: Array[GenerationInput]
+      @generation_automaton = nil
     end
 
     # @rbs (Symbol kind, String path, String content, ?mode: Integer?, ?status: bool) -> Artifact
@@ -120,19 +123,67 @@ module Ibex
       default_output_path(parser.path, ".ibex.json")
     end
 
-    # @rbs () -> Hash[String, untyped]
+    # @rbs () -> Hash[String, Object?]
     def generation_manifest_options
       keys = %i[
         action_source algorithm counterexample_max_configurations counterexample_max_tokens debug
         embedded emit entry_isolation executable frozen line_convert line_convert_all messages mode omit_actions rbs
         superclass table
       ]
-      options = {} #: Hash[String, untyped]
+      options = {} #: Hash[String, Object?]
       keys.each do |key|
         value = @options[key]
         options[key.to_s] = value unless value.nil?
       end
+      options["cst_trivia"] = effective_cst_trivia.to_s
+      append_ir_manifest_options(options)
       options
     end
+
+    # @rbs (Hash[String, Object?] options) -> void
+    def append_ir_manifest_options(options)
+      automaton = @generation_automaton
+      return unless automaton
+
+      grammar = automaton.grammar
+      contract = grammar.parser_contract
+      options["grammar_ir"] = {
+        "schema_version" => grammar.schema_version,
+        "digest" => automaton.grammar_digest,
+        "parser_contract" => stringify_contract(contract)
+      }
+      options["automaton_ir"] = {
+        "schema_version" => automaton.schema_version,
+        "algorithm" => automaton.algorithm,
+        "entry_construction" => automaton.entry_construction,
+        "construction_authority" => construction_authority
+      }
+      options["effective_configuration"] = manifest_effective_configuration
+    end
+
+    # @rbs () -> String
+    def construction_authority
+      @options[:from] == "automaton-ir" ? "embedded_automaton" : "grammar_contract"
+    end
+
+    # @rbs () -> Array[Hash[String, Object?]]
+    def manifest_effective_configuration
+      values = effective_configuration.to_h.fetch("configuration")
+      return values unless @options[:from] == "automaton-ir"
+
+      values.reject { |entry| %w[parser.algorithm parser.entries].include?(entry.fetch("key")) }
+    end
+
+    # @rbs (IR::ParserContract contract) -> Hash[String, Object?]
+    def stringify_contract(contract)
+      contract.to_h.to_h do |name, entry|
+        [name.to_s, entry.to_h { |key, value| [key.to_s, value] }]
+      end
+    end
+
+    # @rbs () -> Symbol
+    def effective_cst_trivia
+      configuration_value("cst.trivia") #: Symbol
+    end
   end
 end

data/lib/ibex/cli/generation_error_messages.rb

@@ -16,7 +16,7 @@ module Ibex
       end
     end
 
-    # @rbs (IR::Automaton automaton) -> Hash[Integer, untyped]
+    # @rbs (IR::Automaton automaton) -> Hash[Integer, String | { id: String, message: String }]
     def configured_error_messages(automaton)
       path = @options[:messages]
       return {} unless path

data/lib/ibex/cli/grammar_tests.rb

@@ -7,26 +7,19 @@ module Ibex
   # `%test` command parsing and human-readable result reporting.
   module CLIGrammarTests
     # @rbs!
-    #   type grammar_test_settings = {
-    #     mode: Symbol,
-    #     algorithm: Symbol,
-    #     entry_isolation: bool,
-    #     timeout: Integer,
-    #     coverage: Integer?,
-    #     ?help: bool
-    #   }
+    #   type grammar_test_settings = Hash[Symbol, untyped]
     #   private def print_help: (OptionParser) -> Integer
     #   private def resolve_grammar_path: (String) -> Frontend::Resolution
     #   private def handle_grammar_warnings: (IR::Grammar, String) -> void
     #   private def build_automaton: (IR::Grammar, String) -> IR::Automaton
+    #   private def configuration_value: (String) -> untyped
+    #   private def mark_configuration_option: (Symbol) -> void
 
     private
 
     # @rbs (Array[String] arguments) -> Integer
     def run_grammar_tests_command(arguments)
-      settings = {
-        mode: :default, algorithm: :lalr, entry_isolation: false, timeout: GrammarTests::DEFAULT_TIMEOUT, coverage: nil
-      } #: grammar_test_settings
+      settings = default_grammar_test_settings
       options = grammar_test_option_parser(settings)
       remaining = options.parse(arguments)
       return print_help(options) if settings[:help]
@@ -39,7 +32,7 @@ module Ibex
       @options[:algorithm] = settings[:algorithm]
       @options[:entry_isolation] = settings[:entry_isolation]
       resolution = resolve_grammar_path(path)
-      grammar = Normalizer.new(resolution, mode: settings[:mode]).normalize
+      grammar = normalize_analysis_grammar(resolution)
       handle_grammar_warnings(grammar, path)
       automaton = build_automaton(grammar, path)
       runner = GrammarTests::Runner.new(automaton, timeout: settings[:timeout])
@@ -51,16 +44,31 @@ module Ibex
       render_grammar_test_coverage(runner.production_coverage(results), coverage, failures)
     end
 
-    # @rbs (grammar_test_settings settings) -> OptionParser
+    # @rbs () -> Hash[Symbol, untyped]
+    def default_grammar_test_settings
+      {
+        mode: Configuration::Registry.fetch("grammar.mode").default,
+        algorithm: Configuration::Registry.fetch("parser.algorithm").default,
+        entry_isolation: Configuration::Registry.fetch("parser.entries").default == :isolated,
+        timeout: GrammarTests::DEFAULT_TIMEOUT, coverage: nil
+      }
+    end
+
+    # @rbs (Hash[Symbol, untyped] settings) -> OptionParser
     def grammar_test_option_parser(settings)
       OptionParser.new do |options|
         options.banner = "Usage: ibex test [options] grammarfile"
-        options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| settings[:mode] = value.to_sym }
+        options.on("--mode=MODE", %w[default extended], "grammar mode") do |value|
+          settings[:mode] = value.to_sym
+          mark_configuration_option(:mode)
+        end
         options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "parser construction algorithm") do |value|
           settings[:algorithm] = value.to_sym
+          mark_configuration_option(:algorithm)
         end
         options.on("--entry-isolation", "build independent state sets for each start symbol") do
           settings[:entry_isolation] = true
+          mark_configuration_option(:entry_isolation)
         end
         options.on("--timeout=SECONDS", Integer, "whole-suite timeout (default: 10)") do |value|
           raise OptionParser::InvalidArgument, "timeout must be positive" unless value.positive?
@@ -83,6 +91,16 @@ module Ibex
       raise OptionParser::InvalidArgument, "test accepts exactly one grammarfile"
     end
 
+    # @rbs (Frontend::Resolution resolution) -> IR::Grammar
+    def normalize_analysis_grammar(resolution)
+      grammar = Normalizer.new(resolution, mode: configuration_value("grammar.mode")).normalize
+      activate_analysis_grammar(grammar)
+    end
+
+    # @rbs!
+    #   private def activate_analysis_grammar: (IR::Grammar, ?options: Hash[Symbol, Object?],
+    #     ?explicit_keys: Array[Symbol]) -> IR::Grammar
+
     # @rbs (Array[GrammarTests::Result] results) -> Integer
     def render_grammar_test_results(results)
       failures = 0

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