ibex 0.2.0 → 0.3.0

data/lib/ibex/lsp/symbol_index.rb

@@ -20,10 +20,10 @@ module Ibex
         @snapshot_state = files.to_h do |file|
           snapshot = store.snapshot_for(file)
           [file, snapshot && [snapshot.fetch(:version), snapshot.fetch(:source)]]
-        end #: Hash[String, Array[untyped]?]
+        end #: Hash[String, [Integer?, String]?]
       end
 
-      # @rbs (String path, Hash[String, untyped] position) -> Array[Hash[String, untyped]]
+      # @rbs (String path, lsp_object position) -> Array[lsp_object]
       def definition(path, position)
         occurrence = occurrence_at(path, position)
         return [] unless occurrence
@@ -32,8 +32,7 @@ module Ibex
         matching(occurrence.key, role: :definition).map { |entry| location(entry) }
       end
 
-      # @rbs (String path, Hash[String, untyped] position, ?include_declaration: bool) ->
-      #   Array[Hash[String, untyped]]
+      # @rbs (String path, lsp_object position, ?include_declaration: bool) -> Array[lsp_object]
       def references(path, position, include_declaration: false)
         occurrence = occurrence_at(path, position)
         return [] unless occurrence
@@ -43,13 +42,13 @@ module Ibex
         entries.map { |entry| location(entry) }
       end
 
-      # @rbs (String path, Hash[String, untyped] position) -> Hash[String, untyped]?
+      # @rbs (String path, lsp_object position) -> lsp_object?
       def prepare_rename(path, position)
         occurrence = renameable_occurrence(path, position)
         { "range" => range(occurrence), "placeholder" => occurrence.name }
       end
 
-      # @rbs (String path, Hash[String, untyped] position, String new_name) -> Hash[String, untyped]
+      # @rbs (String path, lsp_object position, String new_name) -> lsp_object
       def rename(path, position, new_name)
         ensure_fresh!
         occurrence = renameable_occurrence(path, position)
@@ -78,7 +77,7 @@ module Ibex
         { "documentChanges" => document_changes }
       end
 
-      # @rbs (String path, Hash[String, untyped] position) -> Hash[String, untyped]?
+      # @rbs (String path, lsp_object position) -> lsp_object?
       def hover(path, position)
         occurrence = occurrence_at(path, position)
         return unless occurrence
@@ -94,7 +93,7 @@ module Ibex
 
       private
 
-      # @rbs (String path, Hash[String, untyped] position) -> SymbolOccurrence?
+      # @rbs (String path, lsp_object position) -> SymbolOccurrence?
       def occurrence_at(path, position)
         document = @documents[path]
         return unless document
@@ -106,17 +105,17 @@ module Ibex
         candidates.min_by { |entry| entry.span.length }
       end
 
-      # @rbs (Array[untyped] key, ?role: Symbol?) -> Array[SymbolOccurrence]
+      # @rbs (symbol_key key, ?role: Symbol?) -> Array[SymbolOccurrence]
       def matching(key, role: nil)
         @occurrences.select { |entry| entry.key == key && (!role || entry.role == role) }
       end
 
-      # @rbs (SymbolOccurrence occurrence) -> Hash[String, untyped]
+      # @rbs (SymbolOccurrence occurrence) -> lsp_object
       def location(occurrence)
         { "uri" => @store.uri_for(occurrence.path), "range" => range(occurrence) }
       end
 
-      # @rbs (SymbolOccurrence occurrence) -> Hash[String, untyped]
+      # @rbs (SymbolOccurrence occurrence) -> lsp_object
       def include_target_location(occurrence)
         target = occurrence.data.fetch(:target)
         point = { "line" => 0, "character" => 0 }
@@ -129,7 +128,7 @@ module Ibex
         PositionCodec.new(document.source).range(occurrence.span)
       end
 
-      # @rbs (String path, Hash[String, untyped] position) -> SymbolOccurrence
+      # @rbs (String path, lsp_object position) -> SymbolOccurrence
       def renameable_occurrence(path, position)
         occurrence = occurrence_at(path, position)
         unless occurrence && %i[rule terminal parameter].include?(occurrence.kind) &&
@@ -232,7 +231,8 @@ module Ibex
         lines << "Display: #{data[:display]}" if data[:display]
         lines << "Type: `#{data[:type]}`" if data[:type]
         if (precedence = data[:precedence])
-          lines << "Precedence: #{precedence[:associativity]} level #{precedence[:level]}"
+          precedence_data = precedence #: Hash[Symbol, symbol_data_value]
+          lines << "Precedence: #{precedence_data[:associativity]} level #{precedence_data[:level]}"
         end
         lines.join("\n\n")
       end

data/lib/ibex/lsp/symbol_index_builder.rb

@@ -14,8 +14,8 @@ module Ibex
         @occurrences = [] #: Array[SymbolOccurrence]
         @documents = {} #: Hash[String, Frontend::SourceDocument]
         @global_kinds = {} #: Hash[String, Symbol]
-        @rule_data = {} #: Hash[String, Hash[Symbol, untyped]]
-        @terminal_data = Hash.new { |hash, key| hash[key] = {} } #: Hash[String, Hash[Symbol, untyped]]
+        @rule_data = {} #: Hash[String, symbol_data]
+        @terminal_data = Hash.new { |hash, key| hash[key] = {} } #: Hash[String, symbol_data]
       end
 
       # @rbs () -> [Array[SymbolOccurrence], Hash[String, Frontend::SourceDocument]]
@@ -85,21 +85,25 @@ module Ibex
       # @rbs (String path, Array[Frontend::Token] tokens, Frontend::AST::Include declaration) -> void
       def collect_include(path, tokens, declaration)
         token = tokens.find { |candidate| candidate.type == :literal }
-        return unless token&.span
+        span = token&.span
+        return unless span
 
         target = canonical_include_target(declaration)
         return unless target
 
         add_occurrence(
           name: declaration.path, kind: :include, role: :reference, key: [:include, target],
-          path: path, span: token.span, data: { target: target }
+          path: path, span: span, data: { target: target }
         )
       end
 
       # @rbs (String path, Frontend::SourceDocument document, Frontend::AST::Rule rule) -> void
       def collect_rule_definition(path, document, rule)
         token = token_at(document, rule.loc, rule.lhs)
-        return unless token&.span
+        span = token&.span
+        return unless span
+
+        lhs_token = token #: Frontend::Token
 
         @global_kinds[rule.lhs] ||= :rule
         signature = "#{rule.lhs}#{parameter_signature(rule.parameters)}"
@@ -113,9 +117,9 @@ module Ibex
         @rule_data[rule.lhs] ||= data
         add_occurrence(
           name: rule.lhs, kind: :rule, role: :definition, key: global_key(rule.lhs),
-          path: path, span: token.span, data: data
+          path: path, span: span, data: data
         )
-        collect_parameters(path, document, rule, token)
+        collect_parameters(path, document, rule, lhs_token)
       end
 
       # @rbs (String path, Frontend::SourceDocument document, Frontend::AST::Rule rule,
@@ -125,11 +129,12 @@ module Ibex
 
         rule_id = lhs_token.span&.start_byte || 0
         rule.parameters.zip(parameter_tokens(document, lhs_token)).each do |parameter, token|
-          next unless token&.span
+          span = token&.span
+          next unless span
 
           add_occurrence(
             name: parameter, kind: :parameter, role: :definition,
-            key: parameter_key(path, rule_id, parameter), path: path, span: token.span,
+            key: parameter_key(path, rule_id, parameter), path: path, span: span,
             data: { rule: rule.lhs }
           )
         end
@@ -205,18 +210,19 @@ module Ibex
 
       # @rbs (String path, Frontend::Token token, String name) -> void
       def add_global_reference(path, token, name)
-        return unless token.span
+        span = token.span
+        return unless span
 
         kind = @global_kinds[name] || :terminal
         data = symbol_data(kind, name)
         add_occurrence(name: name, kind: kind, role: :reference, key: global_key(name),
-                       path: path, span: token.span, data: data)
+                       path: path, span: span, data: data)
       end
 
-      # @rbs (Symbol kind, String name) -> Hash[Symbol, untyped]
+      # @rbs (Symbol kind, String name) -> symbol_data
       def symbol_data(kind, name)
         data = kind == :rule ? @rule_data[name] : @terminal_data[name]
-        empty = {} #: Hash[Symbol, untyped]
+        empty = {} #: symbol_data
         data || empty
       end
 
@@ -226,25 +232,29 @@ module Ibex
         names.each do |name|
           index = remaining.index { |token| token.value == name }
           token = index && remaining.delete_at(index)
-          next unless token&.span
+          span = token&.span
+          next unless span
 
           @global_kinds[name] ||= kind
           add_occurrence(name: name, kind: kind, role: role, key: global_key(name),
-                         path: path, span: token.span, data: @terminal_data[name])
+                         path: path, span: span, data: @terminal_data[name])
         end
       end
 
-      # @rbs (**untyped attributes) -> void
-      def add_occurrence(**attributes)
-        @occurrences << SymbolOccurrence.new(**attributes)
+      # @rbs (name: String, kind: Symbol, role: Symbol, key: symbol_key, path: String,
+      #   span: Frontend::SourceSpan, data: symbol_data) -> void
+      def add_occurrence(name:, kind:, role:, key:, path:, span:, data:)
+        @occurrences << SymbolOccurrence.new(
+          name: name, kind: kind, role: role, key: key, path: path, span: span, data: data
+        )
       end
 
-      # @rbs (String name) -> Array[untyped]
+      # @rbs (String name) -> symbol_key
       def global_key(name)
         [:symbol, name]
       end
 
-      # @rbs (String path, Integer rule_id, String name) -> Array[untyped]
+      # @rbs (String path, Integer rule_id, String name) -> symbol_key
       def parameter_key(path, rule_id, name)
         [:parameter, path, rule_id, name]
       end

data/lib/ibex/lsp/symbol_occurrence.rb

@@ -2,15 +2,21 @@
 
 module Ibex
   module LSP
+    # @rbs!
+    #   type symbol_key = [:symbol, String] | [:parameter, String, Integer, String] | [:include, String]
+    #   type symbol_data_value = String | Symbol | Integer | bool | nil | Array[String] |
+    #     Hash[Symbol, symbol_data_value]
+    #   type symbol_data = Hash[Symbol, symbol_data_value]
+
     # A source-backed grammar symbol definition or reference.
     SymbolOccurrence = Struct.new(
       :name, #: String
       :kind, #: Symbol
       :role, #: Symbol
-      :key, #: Array[untyped]
+      :key, #: symbol_key
       :path, #: String
       :span, #: Frontend::SourceSpan
-      :data, #: Hash[Symbol, untyped]
+      :data, #: symbol_data
       keyword_init: true
     )
   end

data/lib/ibex/lsp/transport.rb

@@ -4,16 +4,26 @@ module Ibex
   module LSP
     # Reads and writes bounded LSP JSON-RPC messages over Content-Length framing.
     class Transport
+      # @rbs!
+      #   interface _Input
+      #     def read: (Integer length) -> String?
+      #     def readpartial: (Integer length) -> String
+      #   end
+      #   interface _Output
+      #     def write: (String value) -> Object?
+      #     def flush: () -> Object?
+      #   end
+
       HEADER_SEPARATOR = "\r\n\r\n"
 
-      # @rbs (untyped input, untyped output) -> void
+      # @rbs (_Input input, _Output output) -> void
       def initialize(input, output)
         @input = input
         @output = output
         @buffer = String.new(encoding: Encoding::BINARY)
       end
 
-      # @rbs () -> Hash[String, untyped]?
+      # @rbs () -> LSP::lsp_object?
       def read_message
         header = read_header
         return unless header
@@ -28,7 +38,7 @@ module Ibex
         raise ProtocolError.new("malformed JSON: #{e.message}", code: -32_700)
       end
 
-      # @rbs (Hash[String, untyped] message) -> void
+      # @rbs (LSP::lsp_object message) -> void
       def write_message(message)
         body = JSON.generate(message)
         if body.bytesize > Limits::MAX_OUTPUT_BYTES

data/lib/ibex/lsp/workspace.rb

@@ -17,7 +17,7 @@ module Ibex
       # @rbs (String uri, ?allow_missing: bool) -> String
       def path(uri, allow_missing: true)
         parsed = parse_file_uri(uri)
-        decoded = decode_path(parsed.path)
+        decoded = decode_path(parsed.path || raise(ArgumentError, "file URI must contain an absolute path"))
 
         canonical = @loader.canonical_path(decoded, allow_missing: allow_missing)
         return canonical if root_for(canonical)
@@ -48,11 +48,12 @@ module Ibex
       private
 
       # URI is a stdlib boundary whose implementation class varies by scheme.
-      # @rbs (String uri) -> untyped
+      # URI parsing returns a scheme-specific URI::Generic subclass.
+      # @rbs (String uri) -> URI::Generic
       def parse_file_uri(uri)
         validate_raw_authority!(uri)
         parsed = URI.parse(uri)
-        path = parsed.path
+        path = parsed.path || raise(ArgumentError, "file URI must contain an absolute path")
         local_host = parsed.host.nil? || parsed.host.empty? || parsed.host.casecmp?("localhost")
         unless parsed.scheme == "file" && local_host &&
                parsed.query.nil? && parsed.fragment.nil? && path&.start_with?("/")
@@ -77,7 +78,7 @@ module Ibex
       # @rbs (String uri) -> String
       def canonical_root(uri)
         parsed = parse_file_uri(uri)
-        decoded = decode_path(parsed.path)
+        decoded = decode_path(parsed.path || raise(ArgumentError, "file URI must contain an absolute path"))
         canonical = File.realpath(decoded)
         unless File.directory?(canonical)
           raise ProtocolError.new("workspace root is not a directory: #{uri}", code: -32_602)

data/lib/ibex/lsp/workspace_analyzer.rb

@@ -8,7 +8,7 @@ module Ibex
       WINDOWS_ABSOLUTE = %r{\A(?:[A-Za-z]:[\\/]|\\\\)} #: Regexp
 
       # @rbs!
-      #   type lsp_diagnostic = Hash[String, untyped]
+      #   type lsp_diagnostic = lsp_object
       #   type analyzed_document = {
       #     source: String,
       #     document: Frontend::SourceDocument?,

data/lib/ibex/lsp.rb

@@ -18,6 +18,7 @@ require_relative "lsp/symbol_index_source_queries"
 require_relative "lsp/symbol_index_precedence_references"
 require_relative "lsp/symbol_index_builder"
 require_relative "lsp/symbol_index"
+require_relative "lsp/parser_configuration_assistance"
 require_relative "lsp/request_support"
 require_relative "lsp/initialization_handlers"
 require_relative "lsp/document_handlers"

data/lib/ibex/messages/en.yml

@@ -0,0 +1,28 @@
+{
+  "version": 1,
+  "messages": {
+    "cli.error": "%{detail}",
+    "diagnostic.frontend.lexical_error": "%{detail}",
+    "diagnostic.frontend.syntax_error": "%{detail}",
+    "diagnostic.frontend.resolution_error": "%{detail}",
+    "diagnostic.generic": "%{detail}",
+    "label.warning": "warning",
+    "label.warning_as_error": "warning treated as error",
+    "warning.undeclared_terminal": "undeclared terminal %{symbol}",
+    "warning.unused_terminal": "unused terminal %{symbol}",
+    "warning.unused_precedence": "unused precedence %{symbol}",
+    "warning.unreachable_terminal": "declared terminal %{symbol} is unreachable",
+    "warning.unreachable_nonterminal": "unreachable nonterminal %{symbol}",
+    "warning.duplicate_production": "duplicate production %{production} (first defined as %{original})",
+    "warning.implicit_empty": "implicit empty alternative; write %%empty to document intent",
+    "warning.empty_language": "start symbol %{symbol} derives no terminal sentence",
+    "warning.lexer_redos": "lexer pattern may exhibit excessive backtracking",
+    "warning.lexer_redos_symbol": "lexer pattern for %{symbol} may exhibit excessive backtracking",
+    "conflict.shift_reduce_expected": "%{actual} shift/reduce conflicts; expected %{expected}",
+    "conflict.reduce_reduce_expected": "%{actual} reduce/reduce conflicts; expected %{expected}",
+    "conflict.reduce_reduce": "%{actual} reduce/reduce conflicts",
+    "conflict.treated_as_error": "%{detail}; conflict treated as error",
+    "conflict.count": "%{count} %{kind} conflict%{plural}",
+    "note.ielr": "note: --algorithm=ielr avoids %{avoided}; consider --algorithm=ielr"
+  }
+}

data/lib/ibex/messages/ja.yml

@@ -0,0 +1,28 @@
+{
+  "version": 1,
+  "messages": {
+    "cli.error": "エラー: %{detail}",
+    "diagnostic.frontend.lexical_error": "字句エラー: %{detail}",
+    "diagnostic.frontend.syntax_error": "構文エラー: %{detail}",
+    "diagnostic.frontend.resolution_error": "解決エラー: %{detail}",
+    "diagnostic.generic": "診断: %{detail}",
+    "label.warning": "警告",
+    "label.warning_as_error": "エラーとして扱われた警告",
+    "warning.undeclared_terminal": "未宣言の終端記号 %{symbol}",
+    "warning.unused_terminal": "未使用の終端記号 %{symbol}",
+    "warning.unused_precedence": "未使用の優先順位 %{symbol}",
+    "warning.unreachable_terminal": "宣言された終端記号 %{symbol} に到達できません",
+    "warning.unreachable_nonterminal": "非終端記号 %{symbol} に到達できません",
+    "warning.duplicate_production": "生成規則 %{production} は重複しています（最初の定義: %{original}）",
+    "warning.implicit_empty": "暗黙の空選択肢です。意図を示すには %%empty を記述してください",
+    "warning.empty_language": "開始記号 %{symbol} は終端記号列を導出しません",
+    "warning.lexer_redos": "字句パターンで過大なバックトラックが発生する可能性があります",
+    "warning.lexer_redos_symbol": "%{symbol} の字句パターンで過大なバックトラックが発生する可能性があります",
+    "conflict.shift_reduce_expected": "shift/reduce 競合は %{actual} 件です（期待値: %{expected}）",
+    "conflict.reduce_reduce_expected": "reduce/reduce 競合は %{actual} 件です（期待値: %{expected}）",
+    "conflict.reduce_reduce": "reduce/reduce 競合が %{actual} 件あります",
+    "conflict.treated_as_error": "%{detail}（競合をエラーとして扱いました）",
+    "conflict.count": "%{kind} 競合 %{count} 件%{plural}",
+    "note.ielr": "注記: --algorithm=ielr により %{avoided} を回避できます。--algorithm=ielr を検討してください"
+  }
+}

data/lib/ibex/messages.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "json"
+
+module Ibex
+  # Immutable built-in diagnostic translations, separate from user E00xx
+  # sentence-keyed parser error catalogs.
+  module Messages
+    ROOT = File.expand_path("messages", __dir__ || raise("message catalog directory is unavailable")) #: String
+    LANGUAGES = %w[en ja].freeze #: Array[String]
+
+    # @rbs (String? requested) -> String
+    def language(requested)
+      candidate = requested.to_s.downcase.tr("_", "-").split("-").first
+      LANGUAGES.include?(candidate) ? candidate : "en"
+    end
+    module_function :language
+
+    # @rbs (String id, ?language: String, **Object? values) -> String
+    def translate(id, language: "en", **values)
+      selected = catalog(self.language(language))
+      template = selected[id] || catalog("en").fetch(id) do
+        raise Ibex::Error, "(messages):1:1: unknown built-in message id #{id.inspect}"
+      end
+      template % values.transform_keys(&:to_sym)
+    rescue KeyError => e
+      raise Ibex::Error, "(messages):1:1: missing interpolation for #{id.inspect}: #{e.message}"
+    end
+    module_function :translate
+
+    # @rbs (String id) -> bool
+    def known?(id)
+      catalog("en").key?(id)
+    end
+    module_function :known?
+
+    # @rbs (String language) -> Hash[String, String]
+    def catalog(language)
+      @catalogs ||= {} #: Hash[String, Hash[String, String]]
+      @catalogs[language] ||= load_catalog(language)
+    end
+    module_function :catalog
+
+    # @rbs (String language) -> Hash[String, String]
+    def load_catalog(language)
+      path = File.join(ROOT, "#{language}.yml")
+      document = JSON.parse(File.binread(path))
+      unless document.is_a?(Hash) && document["version"] == 1 && document["messages"].is_a?(Hash)
+        raise Ibex::Error, "#{path}:1:1: invalid built-in message catalog"
+      end
+
+      document.fetch("messages").to_h do |id, value|
+        unless id.is_a?(String) && value.is_a?(String)
+          raise Ibex::Error, "#{path}:1:1: message ids and templates must be strings"
+        end
+
+        [id.freeze, value.freeze]
+      end.freeze
+    rescue Errno::ENOENT => e
+      raise Ibex::Error, "#{path}:1:1: cannot read built-in message catalog: #{e.message}"
+    rescue JSON::ParserError => e
+      raise Ibex::Error, "#{path}:1:1: invalid JSON-compatible YAML: #{e.message}"
+    end
+    module_function :load_catalog
+    private_class_method :load_catalog
+  end
+end

data/lib/ibex/metrics.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "set"
+
+module Ibex
+  # Deterministic structural metrics over normalized Grammar and Automaton IR.
+  class Metrics
+    # @rbs!
+    #   type report_value = String | Integer | Float | Array[report_value] | Hash[Symbol, report_value]
+
+    # @rbs (IR::Automaton automaton) -> void
+    def initialize(automaton)
+      @automaton = automaton
+      @grammar = automaton.grammar
+    end
+
+    # @rbs () -> Hash[Symbol, report_value]
+    def to_h
+      {
+        ibex_report: "metrics", schema_version: 1,
+        algorithm: @automaton.algorithm,
+        grammar_digest: @automaton.grammar_digest,
+        symbols: symbol_metrics,
+        grammar: grammar_metrics,
+        automaton: automaton_metrics
+      }
+    end
+
+    private
+
+    # @rbs () -> Hash[Symbol, Integer]
+    def symbol_metrics
+      { terminals: @grammar.terminals.length, nonterminals: @grammar.nonterminals.length }
+    end
+
+    # @rbs () -> Hash[Symbol, report_value]
+    def grammar_metrics
+      rule_counts = @grammar.productions.group_by(&:lhs).transform_values(&:length)
+      {
+        rules: rule_counts.length,
+        alternatives: @grammar.productions.length,
+        average_alternatives_per_rule: average(rule_counts.values),
+        maximum_branching: rule_counts.values.max || 0,
+        epsilon_productions: @grammar.productions.count { |production| production.rhs.empty? },
+        recursive_nonterminals: recursive_nonterminal_ids.map { |id| symbol_name(id) }.sort,
+        recursion_component_depth: recursion_component_depth,
+        warnings: @grammar.warnings.length
+      }
+    end
+
+    # @rbs () -> Hash[Symbol, report_value]
+    def automaton_metrics
+      {
+        states: @automaton.states.length,
+        transitions: @automaton.states.sum { |state| state.transitions.length },
+        action_cells: @automaton.states.sum { |state| state.actions.length },
+        goto_cells: @automaton.states.sum { |state| state.gotos.length },
+        default_reductions: @automaton.states.count(&:default_action),
+        conflicts: {
+          shift_reduce: @automaton.conflict_summary.fetch(:sr),
+          precedence_resolved_shift_reduce: @automaton.conflict_summary.fetch(:resolved_sr),
+          reduce_reduce: @automaton.conflict_summary.fetch(:rr)
+        }
+      }
+    end
+
+    # @rbs (Array[Integer] values) -> Float
+    def average(values)
+      return 0.0 if values.empty?
+
+      values.sum.fdiv(values.length).round(6)
+    end
+
+    # @rbs () -> Hash[Integer, Array[Integer]]
+    def dependency_graph
+      @dependency_graph ||= begin
+        graph = {} #: Hash[Integer, Array[Integer]]
+        @grammar.nonterminals.each { |symbol| graph[symbol.id] = [] }
+        @grammar.productions.each do |production|
+          production.rhs.each do |id|
+            symbol = @grammar.symbol_by_id(id)
+            graph.fetch(production.lhs) << id if symbol&.nonterminal?
+          end
+        end
+        graph.transform_values { |targets| targets.uniq.sort }
+      end
+    end
+
+    # @rbs () -> Hash[Integer, Set[Integer]]
+    def reachability
+      @reachability ||= dependency_graph.to_h do |source, _targets|
+        found = Set[source]
+        queue = [source]
+        cursor = 0
+        while cursor < queue.length
+          dependency_graph.fetch(queue.fetch(cursor)).each do |target|
+            next if found.include?(target)
+
+            found << target
+            queue << target
+          end
+          cursor += 1
+        end
+        [source, found]
+      end
+    end
+
+    # @rbs () -> Array[Array[Integer]]
+    def recursion_components
+      remaining = dependency_graph.keys.sort
+      components = [] #: Array[Array[Integer]]
+      until remaining.empty?
+        source = remaining.fetch(0)
+        component = remaining.select do |candidate|
+          reachability.fetch(source).include?(candidate) && reachability.fetch(candidate).include?(source)
+        end
+        components << component
+        remaining -= component
+      end
+      components
+    end
+
+    # @rbs () -> Array[Integer]
+    def recursive_nonterminal_ids
+      recursion_components.flat_map do |component|
+        next component if component.length > 1
+
+        id = component.fetch(0)
+        dependency_graph.fetch(id).include?(id) ? component : []
+      end
+    end
+
+    # Longest path after collapsing mutually recursive nonterminals.
+    # @rbs () -> Integer
+    def recursion_component_depth
+      components = recursion_components
+      component_for = {} #: Hash[Integer, Integer]
+      components.each_with_index { |ids, index| ids.each { |id| component_for[id] = index } }
+      edges = Array.new(components.length) { Set.new } #: Array[Set[Integer]]
+      dependency_graph.each do |source, targets|
+        targets.each do |target|
+          from = component_for.fetch(source)
+          to = component_for.fetch(target)
+          edges.fetch(from) << to unless from == to
+        end
+      end
+      longest_dag_path(edges)
+    end
+
+    # @rbs (Array[Set[Integer]] edges) -> Integer
+    def longest_dag_path(edges)
+      indegree = Array.new(edges.length, 0)
+      edges.each { |targets| targets.each { |target| indegree[target] += 1 } }
+      depths = Array.new(edges.length, 1)
+      queue = indegree.each_index.select { |index| indegree[index].zero? }
+      cursor = 0
+      while cursor < queue.length
+        source = queue.fetch(cursor)
+        edges.fetch(source).each do |target|
+          depths[target] = [depths[target], depths[source] + 1].max
+          indegree[target] -= 1
+          queue << target if indegree[target].zero?
+        end
+        cursor += 1
+      end
+      depths.max || 0
+    end
+
+    # @rbs (Integer id) -> String
+    def symbol_name(id)
+      @grammar.symbol_by_id(id)&.name || id.to_s
+    end
+  end
+end

data/lib/ibex/normalize/declarations.rb

@@ -28,6 +28,7 @@ module Ibex
       @on_error_reduce_locations = {} #: Hash[String, Frontend::Location]
       @grammar_tests = [] #: Array[IR::grammar_test]
       @lexer_declaration = nil #: Frontend::AST::Lexer?
+      @parser_configuration = nil #: Frontend::AST::ParserConfiguration?
       @node_shapes = {} #: Hash[String, Array[String]]
       @ast.declarations.each { |declaration| read_declaration(declaration) }
     end
@@ -46,6 +47,7 @@ module Ibex
       when Frontend::AST::Lexer
         fail_at(declaration.loc, "duplicate lexer declaration") if @lexer_declaration
         @lexer_declaration = declaration
+      when Frontend::AST::ParserConfiguration then read_parser_configuration(declaration)
       when Frontend::AST::Convert then read_conversions(declaration)
       when Frontend::AST::DisplayName, Frontend::AST::SemanticType, Frontend::AST::Parameter, Frontend::AST::Printer
         read_extended_declaration(declaration)