ibex 0.2.0 → 0.4.0

data/lib/ibex/cli.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 require "json"
 require "optparse"
 require_relative "version"
 require_relative "error"
+require_relative "configuration"
+require_relative "messages"
 require_relative "artifact_set"
 require_relative "generation_input"
 require_relative "generation_transaction"
@@ -18,9 +21,12 @@ require_relative "lalr/conflict"
 require_relative "lalr/on_error_reductions"
 require_relative "lalr/default_reductions"
 require_relative "lalr/build_metrics"
+require_relative "lalr/inadequacy_report"
 require_relative "lalr/direct_lookaheads"
 require_relative "lalr/ielr_partition"
 require_relative "lalr/builder"
+require_relative "lalr/unreachable_states"
+require_relative "impact"
 require_relative "codegen/ruby"
 require_relative "cli/counterexample_options"
 require_relative "cli/generation_error_messages"
@@ -30,24 +36,32 @@ require_relative "cli/outputs"
 module Ibex
   CLI_FEATURE_ROOT = File.expand_path("cli", __dir__ || raise("CLI source directory is unavailable")) #: String
   autoload :CLIAmbiguity, File.join(CLI_FEATURE_ROOT, "ambiguity")
+  autoload :CLIAnalysis, File.join(CLI_FEATURE_ROOT, "analysis")
+  autoload :CLIImpact, File.join(CLI_FEATURE_ROOT, "impact")
+  autoload :CLIBisonImport, File.join(CLI_FEATURE_ROOT, "bison_import")
   autoload :CLICoverage, File.join(CLI_FEATURE_ROOT, "coverage")
   autoload :CLIDebug, File.join(CLI_FEATURE_ROOT, "debug")
   autoload :CLIDiagnostics, File.join(CLI_FEATURE_ROOT, "diagnostics")
   autoload :CLIDocumentation, File.join(CLI_FEATURE_ROOT, "documentation")
   autoload :CLIErrorMessages, File.join(CLI_FEATURE_ROOT, "error_messages")
+  autoload :CLIEquiv, File.join(CLI_FEATURE_ROOT, "equiv")
   autoload :CLIExplain, File.join(CLI_FEATURE_ROOT, "explain")
   autoload :CLIFormatting, File.join(CLI_FEATURE_ROOT, "formatting")
+  autoload :CLIFix, File.join(CLI_FEATURE_ROOT, "fix")
+  autoload :CLIFuzz, File.join(CLI_FEATURE_ROOT, "fuzz")
   autoload :CLIGrammarTests, File.join(CLI_FEATURE_ROOT, "grammar_tests")
   autoload :CLIIRTools, File.join(CLI_FEATURE_ROOT, "ir_tools")
   autoload :CLILSP, File.join(CLI_FEATURE_ROOT, "lsp")
   autoload :CLIRaccMigration, File.join(CLI_FEATURE_ROOT, "racc_migration")
+  autoload :CLIReduce, File.join(CLI_FEATURE_ROOT, "reduce")
   autoload :CLISamples, File.join(CLI_FEATURE_ROOT, "samples")
+  autoload :CLIVerify, File.join(CLI_FEATURE_ROOT, "verify")
   autoload :CLIWatch, File.join(CLI_FEATURE_ROOT, "watch")
 
   # @rbs!
   #   interface _CLIOutput
-  #     def puts: (*untyped) -> untyped
-  #     def write: (String) -> untyped
+  #     def puts: (*Object?) -> Object?
+  #     def write: (String) -> Object?
   #   end
   #   interface _CLIInput
   #     def read: () -> String
@@ -66,6 +80,9 @@ module Ibex
   #     ?algorithm: Symbol,
   #     ?suggest_ielr: bool,
   #     ?entry_isolation: bool,
+  #     ?ielr_strategy: Symbol,
+  #     ?ielr_report: bool,
+  #     ?remove_unreachable: bool,
   #     ?warnings: Array[Symbol],
   #     ?output: String,
   #     ?embedded: bool,
@@ -105,7 +122,31 @@ module Ibex
   #     ?explain_token: String,
   #     ?explain_format: String,
   #     ?check_ambiguity: bool,
-  #     ?check_format: String
+  #     ?check_format: String,
+  #     ?fuzz_seed: Integer,
+  #     ?fuzz_count: Integer,
+  #     ?fuzz_max_tokens: Integer,
+  #     ?fuzz_max_depth: Integer,
+  #     ?fuzz_max_expansions: Integer,
+  #     ?fuzz_max_actions: Integer,
+  #     ?fuzz_max_stack: Integer,
+  #     ?fuzz_coverage_guided: bool,
+  #     ?fuzz_path_length: Integer,
+  #     ?fuzz_against: String,
+  #     ?fuzz_against_runtime: String,
+  #     ?fuzz_against_timeout: Integer,
+  #     ?fuzz_against_max_output: Integer,
+  #     ?fuzz_max_reduction_trials: Integer,
+  #     ?fuzz_regression_dir: String,
+  #     ?fuzz_save_regression: bool,
+  #     ?fuzz_format: String,
+  #     ?reduce_command: String,
+  #     ?reduce_mode: Symbol,
+  #     ?reduce_max_trials: Integer,
+  #     ?reduce_timeout: Integer,
+  #     ?reduce_max_output_bytes: Integer,
+  #     ?reduce_max_input_bytes: Integer,
+  #     ?reduce_format: String
   #   }
 
   # Command-line pipeline coordinator.
@@ -113,21 +154,29 @@ module Ibex
   class CLI
     SUBCOMMAND_HANDLERS = {
       "check" => %i[CLIAmbiguity run_check_command],
+      "diff" => %i[CLIAnalysis run_diff_command],
+      "impact" => %i[CLIImpact run_impact_command],
       "diagnose" => %i[CLIDiagnostics run_diagnose_command],
-      "coverage" => %i[CLICoverage run_coverage_command],
+      "coverage" => %i[CLICoverage run_coverage_command], "config" => %i[CLIConfig run_config_command],
       "debug" => %i[CLIDebug run_debug_command],
       "doc" => %i[CLIDocumentation run_documentation_command],
       "errors" => %i[CLIErrorMessages run_error_messages_command],
+      "equiv" => %i[CLIEquiv run_equiv_command],
       "explain" => %i[CLIExplain run_explain_command],
       "fmt" => %i[CLIFormatting run_format_command],
+      "fix" => %i[CLIFix run_fix_command],
+      "fuzz" => %i[CLIFuzz run_fuzz_command],
       "test" => %i[CLIGrammarTests run_grammar_tests_command],
       "lsp" => %i[CLILSP run_lsp_command],
+      "import" => %i[CLIBisonImport run_bison_import_command],
+      "metrics" => %i[CLIAnalysis run_metrics_command],
       "migrate-check" => %i[CLIRaccMigration run_migrate_check_command],
       "migrate-harness" => %i[CLIRaccMigration run_migrate_harness_command],
+      "reduce" => %i[CLIReduce run_reduce_command],
       "samples" => %i[CLISamples run_samples_command],
+      "verify" => %i[CLIVerify run_verify_command],
       "validate-ir" => %i[CLIIRTools run_validate_ir_command],
-      "compare" => %i[CLIIRTools run_compare_command],
-      "migrate-ir" => %i[CLIIRTools run_migrate_ir_command]
+      "compare" => %i[CLIIRTools run_compare_command]
     }.freeze #: Hash[String, [Symbol, Symbol]]
 
     include CLICounterexampleOptions
@@ -138,6 +187,10 @@ module Ibex
     # @rbs @stdout: _CLIOutput
     # @rbs @stderr: _CLIOutput
     # @rbs @options: cli_options
+    # @rbs @language: String
+    # @rbs @configuration_explicit_options: Hash[Symbol, bool]
+    # @rbs @generation_grammar: IR::Grammar?
+    # @rbs @generation_automaton: IR::Automaton?
 
     # rubocop:disable Layout/LineLength
     # @rbs (Array[String] arguments, ?stdin: _CLIInput, ?stdout: _CLIOutput, ?stderr: _CLIOutput, ?watch_clock: (^() -> Float)?, ?watch_sleeper: (^(Float) -> void)?, ?watch_iteration_hook: (^(Symbol, Integer, Array[String]) -> (Integer | Symbol | nil))?) -> Integer
@@ -157,13 +210,23 @@ module Ibex
       @watch_clock = watch_clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       @watch_sleeper = watch_sleeper || ->(seconds) { sleep(seconds) }
       @watch_iteration_hook = watch_iteration_hook || ->(_event, _iteration, _paths) {}
-      @options = { emit: "ruby", mode: :default, table: :compact, line_convert: true }
+      @language = Messages.language(ENV.fetch("IBEX_LANG", nil))
+      @options = {
+        emit: "ruby", mode: Configuration::Registry.fetch("grammar.mode").default,
+        table: Configuration::Registry.fetch("table.representation").default, line_convert: true
+      }
                  .merge(CLICounterexampleOptions::DEFAULTS)
+      @configuration_explicit_options = {}
+      @generation_grammar = nil
+      @generation_automaton = @analysis_configuration = nil
     end
     # rubocop:enable Layout/LineLength
 
     # @rbs (Array[String] arguments) -> Integer
     def run(arguments)
+      arguments = extract_language(arguments)
+      @generation_grammar = nil
+      @generation_automaton = @analysis_configuration = nil
       subcommand = dispatch_subcommand(arguments)
       return subcommand unless subcommand.nil?
 
@@ -183,12 +246,94 @@ module Ibex
         process_grammar(path)
       end
     rescue OptionParser::ParseError, Ibex::Error, SystemCallError, SystemStackError => e
-      @stderr.puts(e.message)
+      @stderr.puts(Messages.translate("cli.error", language: @language, detail: e.message))
       1
     end
 
     private
 
+    # @rbs (Symbol name) -> void
+    def mark_configuration_option(name)
+      @configuration_explicit_options[name] = true
+    end
+
+    # OptionParser accepts a heterogeneous set of operation and configuration
+    # values.  The CLIAdapter is the validation boundary for this dynamic map.
+    # @rbs (Symbol name, untyped value) -> void
+    def set_configuration_option(name, value)
+      @options[name] = value
+      mark_configuration_option(name)
+    end
+
+    # @rbs (String value) -> void
+    def select_configuration_mode(value)
+      set_configuration_option(:mode, value.to_sym)
+    end
+
+    # @rbs () -> Configuration::Resolver
+    def effective_configuration
+      grammar = @generation_grammar
+      contract = grammar&.parser_contract
+      @analysis_configuration || Configuration::CLIAdapter.new(
+        @options, explicit_keys: @configuration_explicit_options.keys
+      ).resolve(
+        grammar: contract&.configuration_values || {},
+        locations: contract&.configuration_locations || {}
+      )
+    end
+
+    # Resolve a command-local legacy option hash without promoting it into the
+    # reusable CLI instance's generation settings.
+    # @rbs (Hash[Symbol, untyped] options, explicit_keys: Array[Symbol]) -> Configuration::Resolver
+    def resolve_configuration_options(options, explicit_keys:)
+      Configuration::CLIAdapter.new(options, explicit_keys: explicit_keys).resolve
+    end
+
+    # @rbs (Hash[Symbol, untyped] options, String name) -> untyped
+    def local_configuration_value(options, name)
+      explicit_keys = options.fetch(:configuration_explicit)
+      resolve_configuration_options(options, explicit_keys: explicit_keys).value(name)
+    end
+
+    # @rbs (Hash[Symbol, untyped] options, Symbol name, untyped value) -> void
+    def set_local_configuration_option(options, name, value)
+      options[name] = value
+      options.fetch(:configuration_explicit) << name
+    end
+
+    # Configuration values have already been validated by Configuration::Resolver;
+    # callers narrow the value according to the option they are consuming.
+    # @rbs (String name) -> untyped
+    def configuration_value(name)
+      effective_configuration.value(name)
+    end
+
+    # @rbs (Array[String] arguments) -> Array[String]
+    def extract_language(arguments)
+      remaining = [] #: Array[String]
+      index = 0
+      while index < arguments.length
+        argument = arguments.fetch(index)
+        if argument == "--lang"
+          value = arguments[index + 1]
+          raise OptionParser::MissingArgument, "--lang" unless value
+
+          @language = Messages.language(value)
+          index += 2
+        elsif argument.start_with?("--lang=")
+          value = argument.delete_prefix("--lang=")
+          raise OptionParser::MissingArgument, "--lang" if value.empty?
+
+          @language = Messages.language(value)
+          index += 1
+        else
+          remaining << argument
+          index += 1
+        end
+      end
+      remaining
+    end
+
     # @rbs (Array[String] arguments) -> Integer?
     def dispatch_subcommand(arguments)
       definition = SUBCOMMAND_HANDLERS[arguments.first]
@@ -220,28 +365,42 @@ module Ibex
         add_error_messages_generation_option(options)
         add_compatibility_options(options)
         add_information_options(options)
-        options.separator("")
-        options.separator("Subcommands:")
-        options.separator("    check --ambiguity         search for ambiguity within explicit budgets")
-        options.separator("    coverage                  collect, merge, or check runtime coverage")
-        options.separator("    debug AUTOMATON [TOKEN]  simulate validated Automaton IR tables")
-        options.separator("    diagnose                  collect frontend diagnostics")
-        options.separator("    doc                       render grammar documentation")
-        options.separator("    errors --list|--update  list or update example-keyed syntax error messages")
-        options.separator("    explain                   explain selected parser conflicts")
-        options.separator("    fmt                       format grammar source")
-        options.separator("    test                      run grammar-declared source examples")
-        options.separator("    lsp                       run the language server over stdio")
-        options.separator("    migrate-check             statically check a racc grammar migration")
-        options.separator("    migrate-harness           generate a differential subprocess harness")
-        options.separator("    samples                   generate bounded terminal sentences")
-        options.separator("    validate-ir FILE          validate a versioned IR document")
-        options.separator("    compare BEFORE AFTER      compare two versioned IR documents")
-        options.separator("    migrate-ir INPUT --to=2   migrate a versioned IR document")
+        add_subcommand_help(options)
       end
     end
 
     # @rbs (OptionParser options) -> void
+    def add_subcommand_help(options)
+      options.separator("")
+      options.separator("Subcommands:")
+      options.separator("    check --ambiguity         search for ambiguity within explicit budgets")
+      options.separator(CONFIG_SUBCOMMAND_HELP)
+      options.separator("    debug AUTOMATON [TOKEN]  simulate validated Automaton IR tables")
+      options.separator("    diagnose                  collect frontend diagnostics")
+      options.separator("    diff OLD NEW              classify grammar and automaton changes")
+      options.separator("    impact GRAMMAR            report grammar change propagation")
+      options.separator("    doc                       render grammar documentation")
+      options.separator("    errors --list|--update  list or update example-keyed syntax error messages")
+      options.separator("    equiv LEFT RIGHT          search for bounded language differences")
+      options.separator("    explain                   explain selected parser conflicts")
+      options.separator("    fmt                       format grammar source")
+      options.separator("    fix                       propose bounded-equivalent conflict repairs")
+      options.separator("    fuzz                      run bounded grammar-derived differential fuzzing")
+      options.separator("    test                      run grammar-declared source examples")
+      options.separator("    lsp                       run the language server over stdio")
+      options.separator("    import bison FILE         import Bison grammar structure for analysis")
+      options.separator("    migrate-check             statically check a racc grammar migration")
+      options.separator("    migrate-harness           generate a differential subprocess harness")
+      options.separator("    metrics GRAMMAR           report deterministic grammar/table metrics")
+      options.separator("    reduce                    delta-debug a failing token, line, or byte sequence")
+      options.separator("    samples                   generate bounded terminal sentences")
+      options.separator("    verify AUTOMATON         independently verify Automaton IR semantics")
+      options.separator("    validate-ir FILE          validate the current IR document")
+      options.separator("    compare BEFORE AFTER      compare current IR documents")
+    end
+
+    # @rbs (OptionParser options) -> void
+    # rubocop:disable Metrics/MethodLength -- pipeline flags share one parser boundary.
     def add_pipeline_options(options)
       options.on("--emit=FORMAT", "ast, sets, lexer-ir, grammar-ir, automaton-ir, or ruby") do |value|
         @options[:emit] = value
@@ -249,38 +408,54 @@ module Ibex
       options.on("--from=FORMAT", %w[grammar-ir automaton-ir], "resume from IR JSON") do |value|
         @options[:from] = value
       end
-      options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| @options[:mode] = value.to_sym }
+      options.on("--mode=MODE", %w[default extended], "grammar mode") { |value| select_configuration_mode(value) }
       options.on("--table=FORMAT", %w[plain compact], "parser table format") do |value|
-        @options[:table] = value.to_sym
+        set_configuration_option(:table, value.to_sym)
       end
       options.on(
         "--cst-trivia=POLICY",
         %w[leading balanced drop attach],
         "leading, balanced, drop, or attach (alias for leading)"
       ) do |value|
-        @options[:cst_trivia] = value.to_sym
+        set_configuration_option(:cst_trivia, value.to_sym)
       end
       options.on("--algorithm=NAME", %w[slr lalr ielr lr1], "parser construction algorithm") do |value|
-        @options[:algorithm] = value.to_sym
+        set_configuration_option(:algorithm, value.to_sym)
+      end
+      options.on("--ielr-strategy=NAME", %w[direct partition], "IELR construction strategy") do |value|
+        @options[:ielr_strategy] = value.to_sym
+      end
+      options.on("--ielr-report", "report canonical-vs-IELR action differences") do
+        @options[:ielr_report] = true
+      end
+      options.on("--remove-unreachable", "compact unreachable IELR states after resolution") do
+        @options[:remove_unreachable] = true
       end
       options.on("--suggest-ielr", "check whether IELR removes unexpected LALR conflicts") do
         @options[:suggest_ielr] = true
       end
       options.on("--entry-isolation", "build independent state sets for each start symbol") do
-        @options[:entry_isolation] = true
+        set_configuration_option(:entry_isolation, true)
       end
       options.on("--warnings=CATEGORIES", "all, error, all,error, or none") do |value|
         @options[:warnings] = warning_categories(value)
       end
       options.on("--watch", "regenerate file outputs when grammar sources change") { @options[:watch] = true }
     end
+    # rubocop:enable Metrics/MethodLength
 
     # @rbs (OptionParser options) -> void
     def add_output_options(options)
       options.on("-o", "--output-file=FILE", "generated parser path") { |value| @options[:output] = value }
-      options.on("-E", "--embedded", "embed the Pure Ruby runtime") { @options[:embedded] = true }
-      options.on("-t", "--debug", "generate a debug-capable parser") { @options[:debug] = true }
-      options.on("-g", "obsolete alias for --debug") { @options[:debug] = true }
+      options.on("-E", "--embedded", "embed the Pure Ruby runtime") do
+        set_configuration_option(:embedded, true)
+      end
+      options.on("-t", "--debug", "generate a debug-capable parser") do
+        set_configuration_option(:debug, true)
+      end
+      options.on("-g", "obsolete alias for --debug") do
+        set_configuration_option(:debug, true)
+      end
       options.on("-v", "--verbose", "write an automaton report") { @options[:verbose] = true }
       add_counterexample_options(options)
       add_signature_output_options(options)
@@ -298,7 +473,7 @@ module Ibex
         @options[:log_file] = value
       end
       options.on("-e", "--executable [RUBY]", "add a shebang") do |value|
-        @options[:executable] = value || "/usr/bin/env ruby"
+        set_configuration_option(:executable, value || "/usr/bin/env ruby")
       end
     end
 
@@ -314,17 +489,23 @@ module Ibex
 
     # @rbs (OptionParser options) -> void
     def add_compatibility_options(options)
-      options.on("-F", "--frozen", "emit frozen string literals") { @options[:frozen] = true }
+      options.on("-F", "--frozen", "emit frozen string literals") do
+        set_configuration_option(:frozen, true)
+      end
       options.on("--line-convert-all", "convert all source lines") do
-        @options[:line_convert] = true
         @options[:line_convert_all] = true
+        set_configuration_option(:line_convert, true)
       end
       options.on("-l", "--no-line-convert", "use generated-file action lines") do
-        @options[:line_convert] = false
         @options[:line_convert_all] = false
+        set_configuration_option(:line_convert, false)
+      end
+      options.on("-a", "--no-omit-actions", "generate implicit action methods") do
+        set_configuration_option(:omit_actions, false)
+      end
+      options.on("--superclass=CLASS", "override parser superclass") do |value|
+        set_configuration_option(:superclass, value)
       end
-      options.on("-a", "--no-omit-actions", "generate implicit action methods") { @options[:omit_actions] = false }
-      options.on("--superclass=CLASS", "override parser superclass") { |value| @options[:superclass] = value }
       options.on("--check", "verify generated parser content without rewriting") { @options[:verify_output] = true }
       options.on("-C", "--check-only", "check grammar and exit") { @options[:check_only] = true }
       options.on("-S", "--output-status", "show pipeline status") { @options[:status] = true }
@@ -334,12 +515,55 @@ module Ibex
 
     # @rbs (OptionParser options) -> void
     def add_information_options(options)
+      options.on("--lang=LANG", "built-in diagnostic language (en or ja)") do |value|
+        @language = Messages.language(value)
+      end
       options.on("--version", "show version") { @options[:version] = true }
       options.on("--runtime-version", "show runtime version") { @options[:runtime_version] = true }
       options.on("--copyright", "show copyright") { @options[:copyright] = true }
       options.on("--help", "show help") { @options[:help] = true }
     end
 
+    # @rbs @analysis_configuration: Configuration::Resolver?
+
+    # @rbs (IR::Grammar grammar, ?options: Hash[Symbol, untyped], ?explicit_keys: Array[Symbol]) -> IR::Grammar
+    def activate_analysis_grammar(grammar, options: @options, explicit_keys: @configuration_explicit_options.keys)
+      adapter = Configuration::CLIAdapter.new(options, explicit_keys: explicit_keys)
+      cli = adapter.configuration_values
+      contract = grammar.parser_contract
+      grammar_values = contract&.configuration_values || {}
+      locations = contract&.configuration_locations || {}
+      overrides = {} #: Hash[String, Configuration::config_value]
+      algorithm = "parser.algorithm"
+      if grammar_values.key?(algorithm) && cli.key?(algorithm) &&
+         grammar_values.fetch(algorithm) != cli.fetch(algorithm)
+        overrides[algorithm] = cli.delete(algorithm)
+      end
+      source_locations = {} #: Hash[Symbol, Hash[String, Location]]
+      source_locations[:grammar] = locations unless locations.empty?
+      configuration = Configuration::Resolver.new(
+        grammar: grammar_values, cli: cli, analysis_overrides: overrides, locations: source_locations
+      )
+      @analysis_configuration = configuration
+      active = noncanonical_analysis_grammar(grammar, configuration)
+      @generation_grammar = active
+      report_noncanonical_analysis(configuration)
+      active
+    end
+
+    # @rbs (IR::Grammar grammar, Hash[Symbol, untyped] options, Array[Symbol] explicit_keys) ->
+    #   [IR::Grammar, Symbol, IR::Automaton]
+    def construct_analysis_automaton(grammar, options, explicit_keys)
+      active = activate_analysis_grammar(grammar, options: options, explicit_keys: explicit_keys)
+      algorithm = configuration_value("parser.algorithm") #: Symbol
+      automaton = LALR::Builder.new(
+        active, algorithm: algorithm, ielr_strategy: options.fetch(:ielr_strategy, :partition),
+                remove_unreachable: options.fetch(:remove_unreachable, false),
+                entry_isolation: configuration_value("parser.entries") == :isolated
+      ).build
+      [active, algorithm, automaton]
+    end
+
     # @rbs (OptionParser parser) -> Integer?
     def informational_result(parser)
       return print_version if @options[:version] || @options[:runtime_version]
@@ -359,9 +583,7 @@ module Ibex
 
     # @rbs () -> void
     def validate_generation_options
-      if @options[:entry_isolation] && @options[:from] == "automaton-ir"
-        raise Ibex::Error, "(cli):1:1: --entry-isolation cannot be combined with --from=automaton-ir"
-      end
+      validate_automaton_construction_options
 
       validate_watch_generation_options if @options[:watch]
       validate_manifest_generation_options
@@ -369,6 +591,18 @@ module Ibex
       validate_verification_generation_options
     end
 
+    # @rbs () -> void
+    def validate_automaton_construction_options
+      return unless @options[:from] == "automaton-ir"
+
+      if @configuration_explicit_options[:algorithm]
+        raise Ibex::Error, "(cli):1:1: --algorithm cannot be combined with --from=automaton-ir"
+      end
+      return unless @configuration_explicit_options[:entry_isolation]
+
+      raise Ibex::Error, "(cli):1:1: --entry-isolation cannot be combined with --from=automaton-ir"
+    end
+
     # @rbs () -> void
     def validate_manifest_generation_options
       return unless @options[:manifest]
@@ -511,20 +745,33 @@ module Ibex
       validate_generation_paths!(path, source_paths: resolution.files)
       return emit_ast(resolution.root) if @options[:emit] == "ast"
 
-      grammar = Normalizer.new(resolution, mode: @options[:mode]).normalize
+      grammar = Normalizer.new(resolution, mode: configuration_value("grammar.mode")).normalize
       dispatch_grammar(grammar, path)
     end
 
     # @rbs (String path) -> Frontend::Resolution
     def resolve_grammar_path(path)
       loader = Frontend::SourceLoader.new(record_reads: true)
-      @last_resolver = Frontend::Resolver.new(path, mode: @options[:mode], loader: loader)
+      @last_resolver = Frontend::Resolver.new(path, mode: configuration_value("grammar.mode"), loader: loader)
       @last_resolver.resolve
     end
 
     # @rbs (String path) -> IR::Grammar
     def normalize_grammar_path(path)
-      Normalizer.new(resolve_grammar_path(path), mode: @options[:mode]).normalize
+      source = File.binread(path)
+      if bison_source?(source)
+        require_relative "bison_import"
+        imported = BisonImport::Importer.new(source, file: path).run
+        ast = Frontend::Parser.new(imported.source, file: path, mode: :extended).parse
+        return Normalizer.new(ast, mode: :extended).normalize
+      end
+
+      Normalizer.new(resolve_grammar_path(path), mode: configuration_value("grammar.mode")).normalize
+    end
+
+    # @rbs (String source) -> bool
+    def bison_source?(source)
+      source.lines.count { |line| line.match?(%r{^\s*%%(?:\s|/|$)}) } >= 2
     end
 
     # @rbs (String path) -> Integer
@@ -548,6 +795,7 @@ module Ibex
 
     # @rbs (IR::Grammar grammar, String path) -> Integer
     def dispatch_grammar(grammar, path)
+      activate_generation_grammar(grammar)
       handle_grammar_warnings(grammar, path)
       if @options[:check_only]
         build_automaton(grammar, path) if @options[:warnings]&.include?(:error)
@@ -566,6 +814,7 @@ module Ibex
 
     # @rbs (IR::Automaton automaton, String path) -> Integer
     def dispatch_automaton(automaton, path)
+      activate_generation_grammar(automaton.grammar)
       handle_grammar_warnings(automaton.grammar, path)
       return 0 if @options[:check_only]
 
@@ -583,6 +832,36 @@ module Ibex
       raise Ibex::Error, "(cli):1:1: AST cannot be reconstructed from Automaton IR"
     end
 
+    # @rbs (IR::Grammar grammar) -> void
+    def activate_generation_grammar(grammar)
+      @analysis_configuration = nil
+      @generation_grammar = grammar
+      effective_configuration
+    end
+
+    # @rbs (IR::Grammar grammar, Configuration::Resolver configuration) -> IR::Grammar
+    def noncanonical_analysis_grammar(grammar, configuration)
+      selection = configuration.fetch("parser.algorithm")
+      return grammar if selection.canonical
+
+      require_relative "configuration/analysis_grammar"
+      algorithm = selection.value #: Symbol
+      Configuration::AnalysisGrammar.for_algorithm(grammar, algorithm)
+    end
+
+    # @rbs (Configuration::Resolver configuration) -> void
+    def report_noncanonical_analysis(configuration)
+      selection = configuration.fetch("parser.algorithm")
+      return if selection.canonical
+
+      analysis = selection.to_h.fetch("analysis") #: Hash[String, Configuration::json_value]
+      @stderr.puts(
+        "noncanonical analysis configuration: parser.algorithm " \
+        "declared=#{analysis.fetch('declared')} selected=#{analysis.fetch('selected')} " \
+        "override=true canonical_generation=false"
+      )
+    end
+
     # @rbs () -> Integer
     def print_version
       @stdout.puts("ibex #{VERSION}")
@@ -654,18 +933,27 @@ module Ibex
 
     # @rbs (IR::Automaton automaton, String input_path) -> Integer
     def generate_ruby(automaton, input_path)
+      @generation_automaton = automaton
+      line_mapping = configuration_value("source.line_mapping") #: Symbol
+      executable = configuration_value("build.executable") #: String?
+      table = configuration_value("table.representation") #: Symbol | String
+      embedded = configuration_value("runtime.embedded") #: bool
+      debug = configuration_value("build.debug") #: bool
+      omit_action_call = configuration_value("actions.omit_calls") #: bool?
+      superclass = configuration_value("parser.superclass") #: String?
+      cst_trivia = configuration_value("cst.trivia") #: Symbol | String
       source = Codegen::Ruby.new(
-        automaton, table: @options[:table], embedded: @options.fetch(:embedded, false),
-                   line_convert: @options.fetch(:line_convert), debug: @options.fetch(:debug, false),
-                   line_convert_all: @options.fetch(:line_convert_all, false),
-                   omit_action_call: @options[:omit_actions], superclass: @options[:superclass],
-                   executable: @options[:executable], cst_trivia: @options.fetch(:cst_trivia, :leading),
+        automaton, table: table, embedded: embedded,
+                   line_convert: line_mapping != :none, debug: debug,
+                   line_convert_all: line_mapping == :all,
+                   omit_action_call: omit_action_call, superclass: superclass,
+                   executable: executable, cst_trivia: cst_trivia,
                    error_messages: configured_error_messages(automaton)
       ).generate
       output_path = @options[:output] || default_output_path(input_path, ".rb")
       action_source = action_source_source(automaton) if @options[:action_source]
       write_action_source(output_path, action_source) if action_source
-      register_artifact(:parser, output_path, source, mode: (0o755 if @options[:executable]), status: true)
+      register_artifact(:parser, output_path, source, mode: (0o755 if executable), status: true)
       write_rbs(automaton, output_path) if @options[:rbs]
       finish_artifact_generation(@generation_sources)
     end
@@ -706,8 +994,10 @@ module Ibex
     # @rbs (IR::Automaton automaton) -> String
     def rbs_source(automaton)
       require_relative "codegen/rbs"
+      superclass = configuration_value("parser.superclass") #: String?
+      omit_action_call = configuration_value("actions.omit_calls") #: bool?
       Codegen::RBS.new(
-        automaton, superclass: @options[:superclass], omit_action_call: @options[:omit_actions]
+        automaton, superclass: superclass, omit_action_call: omit_action_call
       ).generate
     end
 
@@ -729,7 +1019,9 @@ module Ibex
     # @rbs (IR::Automaton automaton) -> String
     def action_source_source(automaton)
       require_relative "codegen/action_source"
-      Codegen::ActionSource.new(automaton, omit_action_call: @options[:omit_actions]).generate
+      Codegen::ActionSource.new(
+        automaton, omit_action_call: configuration_value("actions.omit_calls")
+      ).generate
     end
 
     # @rbs (IR::Automaton automaton, String input_path) -> Integer
@@ -742,11 +1034,14 @@ module Ibex
 
     # @rbs (IR::Grammar grammar, String input_path) -> IR::Automaton
     def build_automaton(grammar, input_path)
-      algorithm = @options[:algorithm] || :lalr
+      algorithm = configuration_value("parser.algorithm")
       report_status("building #{algorithm} automaton")
       automaton = LALR::Builder.new(
-        grammar, algorithm: algorithm, entry_isolation: @options[:entry_isolation] == true
+        grammar, algorithm: algorithm, ielr_strategy: @options.fetch(:ielr_strategy, :partition),
+                 remove_unreachable: @options.fetch(:remove_unreachable, false),
+                 entry_isolation: configuration_value("parser.entries") == :isolated
       ).build
+      write_ielr_report(grammar, automaton) if @options[:ielr_report]
       report_conflicts(automaton, input_path)
       suggest_ielr(automaton, input_path)
       write_report(automaton, input_path) if @options[:verbose] && !@options[:verify_output]
@@ -754,6 +1049,12 @@ module Ibex
       automaton
     end
 
+    # @rbs (IR::Grammar grammar, IR::Automaton automaton) -> void
+    def write_ielr_report(grammar, automaton)
+      canonical = LALR::Builder.new(grammar, algorithm: :lr1).build
+      @stdout.write(LALR::InadequacyReport.new(canonical, automaton).to_json)
+    end
+
     # @rbs (IR::Automaton automaton, String input_path) -> void
     def prepare_loaded_automaton(automaton, input_path)
       report_conflicts(automaton, input_path)
@@ -798,5 +1099,10 @@ module Ibex
       default_output_path(output_path, ".ibex.json")
     end
   end
+  CONFIG_SUBCOMMAND_HELP = [
+    "    coverage                  collect, merge, or check runtime coverage",
+    "    config                    explain effective configuration without running user code"
+  ].join("\n").freeze #: String
+  autoload :CLIConfig, File.join(CLI_FEATURE_ROOT, "config")
   # rubocop:enable Metrics/ClassLength
 end