ibex 0.2.0 → 0.4.0

data/lib/ibex/normalize/lexer.rb

@@ -13,7 +13,7 @@ module Ibex
 
       states = ["INITIAL"] #: Array[String]
       rules = [] #: Array[IR::LexerRule]
-      warnings = [] #: Array[Hash[Symbol, untyped]]
+      warnings = [] #: Array[IR::lexer_warning]
       declaration.definitions.each do |definition|
         if definition.is_a?(Frontend::AST::LexerState)
           normalize_lexer_state(definition, states, rules, warnings)
@@ -29,7 +29,7 @@ module Ibex
     end
 
     # @rbs (Frontend::AST::LexerState definition, Array[String] states, Array[IR::LexerRule] rules,
-    #   Array[Hash[Symbol, untyped]] warnings) -> void
+    #   Array[IR::lexer_warning] warnings) -> void
     def normalize_lexer_state(definition, states, rules, warnings)
       # @type self: Normalizer
       fail_at(definition.loc, "lexer state INITIAL is reserved") if definition.name == "INITIAL"
@@ -43,7 +43,7 @@ module Ibex
     end
 
     # @rbs (Frontend::AST::LexerRule definition, String state, Integer id,
-    #   Array[Hash[Symbol, untyped]] warnings) -> IR::LexerRule
+    #   Array[IR::lexer_warning] warnings) -> IR::LexerRule
     def normalize_lexer_rule(definition, state, id, warnings)
       # @type self: Normalizer
       validate_lexer_token(definition)

data/lib/ibex/normalize/parameter_ebnf_lowering.rb

@@ -5,17 +5,17 @@ module Ibex
   module NormalizeParameterEbnfLowering
     private
 
-    # @rbs (Hash[Symbol, untyped] frame,
+    # @rbs (NormalizeParameters::parameter_frame frame,
     #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
     def lower_parameter_suffix(frame, item)
       frame.fetch(:operations).push([:finish_suffix, item], [:item, item.item])
     end
 
-    # @rbs (Hash[Symbol, untyped] frame,
+    # @rbs (NormalizeParameters::parameter_frame frame,
     #   Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus item) -> void
     def finish_parameter_suffix(frame, item)
       # @type self: Normalizer
-      base = frame.fetch(:values).pop
+      base = frame.fetch(:values).pop || raise(Ibex::Error, "missing parameter value")
       helper = case item
                when Frontend::AST::Optional then build_optional(item, base)
                when Frontend::AST::Star then build_star(item, base)
@@ -24,22 +24,22 @@ module Ibex
       frame.fetch(:values) << helper
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
     def lower_parameter_separated_list(frame, item)
       frame.fetch(:operations).push(
         [:finish_separated, item], [:item, item.separator], [:item, item.item]
       )
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::SeparatedList item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::SeparatedList item) -> void
     def finish_parameter_separated_list(frame, item)
       # @type self: Normalizer
-      separator = frame.fetch(:values).pop
-      base = frame.fetch(:values).pop
+      separator = frame.fetch(:values).pop || raise(Ibex::Error, "missing parameter value")
+      base = frame.fetch(:values).pop || raise(Ibex::Error, "missing parameter value")
       frame.fetch(:values) << build_separated_list(item, base, separator)
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::Group item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::Group item) -> void
     def lower_parameter_group(frame, item)
       # @type self: Normalizer
       reject_group_named_references(item)
@@ -51,7 +51,7 @@ module Ibex
       end
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item,
+    # @rbs (NormalizeParameters::parameter_frame frame, String helper, Frontend::AST::Group item,
     #   Array[Frontend::AST::item] alternative) -> void
     def start_parameter_group_alternative(frame, helper, item, alternative)
       operations = frame.fetch(:operations)
@@ -59,7 +59,8 @@ module Ibex
       alternative.reverse_each { |child| operations << [:item, child] }
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, String helper, Frontend::AST::Group item, Integer length) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, String helper,
+    #   Frontend::AST::Group item, Integer length) -> void
     def finish_parameter_group_alternative(frame, helper, item, length)
       # @type self: Normalizer
       rhs = frame.fetch(:values).pop(length)

data/lib/ibex/normalize/parameter_lowering.rb

@@ -5,13 +5,14 @@ module Ibex
   module NormalizeParameterLowering
     private
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
     def advance_parameter_alternative(frame)
       # @type self: Normalizer
       with_parameter_frame_context(frame) do
         operations = frame.fetch(:operations)
         if operations.any?
-          process_parameter_operation(frame, operations.pop)
+          operation = operations.pop #: NormalizeParameters::parameter_operation
+          process_parameter_operation(frame, operation)
         elsif parameter_items_remaining?(frame)
           start_parameter_item(frame)
         else
@@ -20,10 +21,10 @@ module Ibex
       end
     end
 
-    # @rbs (Hash[Symbol, untyped] frame) { () -> void } -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) { () -> void } -> void
     def with_parameter_frame_context(frame)
       # @type self: Normalizer
-      template, = frame.fetch(:current)
+      template, = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
       previous_chain = @current_include_chain
       previous_expansion = @current_parameter_expansion
       reference = frame.fetch(:reference)
@@ -37,16 +38,16 @@ module Ibex
       @current_parameter_expansion = previous_expansion
     end
 
-    # @rbs (Hash[Symbol, untyped] frame) -> bool
+    # @rbs (NormalizeParameters::parameter_frame frame) -> bool
     def parameter_items_remaining?(frame)
-      _template, _rule, alternative = frame.fetch(:current)
+      _template, _rule, alternative = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
       frame.fetch(:item_index) < alternative.items.length
     end
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
     def start_parameter_item(frame)
       # @type self: Normalizer
-      _template, _rule, alternative = frame.fetch(:current)
+      _template, _rule, alternative = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
       index = frame.fetch(:item_index)
       item = alternative.items.fetch(index)
       frame[:item_index] = index + 1
@@ -59,25 +60,41 @@ module Ibex
       end
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Array[untyped] operation) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, NormalizeParameters::parameter_operation operation) -> void
     def process_parameter_operation(frame, operation)
       # @type self: Normalizer
-      kind, *arguments = operation
+      kind = operation.fetch(0) #: Symbol
       case kind
-      when :item then lower_parameter_item(frame, arguments.fetch(0))
-      when :finish_item then finish_parameter_item(frame, arguments.fetch(0))
-      when :value then frame.fetch(:values) << arguments.fetch(0)
-      when :finish_suffix then finish_parameter_suffix(frame, arguments.fetch(0))
-      when :finish_separated then finish_parameter_separated_list(frame, arguments.fetch(0))
+      when :item
+        item = operation.fetch(1) #: Frontend::AST::item
+        lower_parameter_item(frame, item)
+      when :finish_item
+        item = operation.fetch(1) #: Frontend::AST::item
+        finish_parameter_item(frame, item)
+      when :value
+        value = operation.fetch(1) #: String
+        frame.fetch(:values) << value
+      when :finish_suffix
+        item = operation.fetch(1) #: Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus
+        finish_parameter_suffix(frame, item)
+      when :finish_separated
+        item = operation.fetch(1) #: Frontend::AST::SeparatedList
+        finish_parameter_separated_list(frame, item)
       when :group_alternative
-        start_parameter_group_alternative(frame, arguments.fetch(0), arguments.fetch(1), arguments.fetch(2))
+        helper = operation.fetch(1) #: String
+        item = operation.fetch(2) #: Frontend::AST::Group
+        alternative = operation.fetch(3) #: Array[Frontend::AST::item]
+        start_parameter_group_alternative(frame, helper, item, alternative)
       when :finish_group_alternative
-        finish_parameter_group_alternative(frame, arguments.fetch(0), arguments.fetch(1), arguments.fetch(2))
+        helper = operation.fetch(1) #: String
+        item = operation.fetch(2) #: Frontend::AST::Group
+        length = operation.fetch(3) #: Integer
+        finish_parameter_group_alternative(frame, helper, item, length)
       else raise Ibex::Error, "internal parameter lowering operation #{kind.inspect}"
       end
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
     def lower_parameter_item(frame, item)
       # @type self: Normalizer
       case item
@@ -96,25 +113,25 @@ module Ibex
       end
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::ParameterizedReference item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::ParameterizedReference item) -> void
     def lower_parameter_call(frame, item)
       # @type self: Normalizer
       helper, = schedule_parameter_specialization(item)
       frame.fetch(:values) << helper
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::item item) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void
     def finish_parameter_item(frame, item)
       # @type self: Normalizer
       rhs = frame.fetch(:rhs)
-      rhs << frame.fetch(:values).pop
+      rhs << (frame.fetch(:values).pop || raise(Ibex::Error, "missing parameter value"))
       add_named_reference(item, frame.fetch(:named_refs), rhs.length - 1)
     end
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
     def finish_parameter_alternative(frame)
       # @type self: Normalizer
-      _template, rule, alternative = frame.fetch(:current)
+      _template, rule, alternative = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
       action = normalize_action(alternative.action, frame.fetch(:named_refs))
       add_production(
         rule.lhs, frame.fetch(:rhs), action, alternative.precedence,

data/lib/ibex/normalize/parameters.rb

@@ -2,7 +2,33 @@
 
 module Ibex
   # Iterative, hygienic specialization of validated parameterized user rules.
+  # rubocop:disable Metrics/ModuleLength -- parameter-frame transitions are kept together for auditability.
   module NormalizeParameters
+    # @rbs!
+    #   type parameter_operation =
+    #     [:item | :finish_item, Frontend::AST::item] |
+    #     [:value, String] |
+    #     [:finish_suffix, Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus] |
+    #     [:finish_separated, Frontend::AST::SeparatedList] |
+    #     [:group_alternative, String, Frontend::AST::Group, Array[Frontend::AST::item]] |
+    #     [:finish_group_alternative, String, Frontend::AST::Group, Integer]
+    #   type parameter_frame = {
+    #     reference: Frontend::AST::ParameterizedReference,
+    #     arguments: Array[Frontend::AST::item],
+    #     helper: String,
+    #     bindings: Hash[String, Frontend::AST::item],
+    #     rendered_arguments: Array[String],
+    #     templates: Array[Frontend::AST::Rule],
+    #     template_index: Integer,
+    #     alternative_index: Integer,
+    #     current: [Frontend::AST::Rule, Frontend::AST::Rule, Frontend::AST::Alternative]?,
+    #     item_index: Integer,
+    #     rhs: Array[String],
+    #     named_refs: Array[IR::named_ref],
+    #     operations: Array[parameter_operation],
+    #     values: Array[String]
+    #   }
+
     private
 
     # @rbs (Frontend::AST::ParameterizedReference reference) -> String
@@ -111,7 +137,7 @@ module Ibex
 
     # @rbs (Frontend::AST::ParameterizedReference reference, String helper,
     #   Array[Frontend::AST::item] arguments, Array[String] rendered_arguments) ->
-    #   Hash[Symbol, untyped]
+    #   NormalizeParameters::parameter_frame
     def parameter_frame(reference, helper, arguments, rendered_arguments)
       # @type self: Normalizer
       formals = @parameter_formals.fetch(reference.name)
@@ -150,7 +176,7 @@ module Ibex
       @parameter_worklist_active = false
     end
 
-    # @rbs (Hash[Symbol, untyped] frame) -> bool
+    # @rbs (NormalizeParameters::parameter_frame frame) -> bool
     def prepare_parameter_alternative?(frame)
       # @type self: Normalizer
       templates = frame.fetch(:templates)
@@ -167,7 +193,7 @@ module Ibex
       false
     end
 
-    # @rbs (Hash[Symbol, untyped] frame, Frontend::AST::Rule template, Integer index) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame, Frontend::AST::Rule template, Integer index) -> void
     def prepare_parameter_alternative_entry(frame, template, index)
       # @type self: Normalizer
       alternative = substitute_parameter_alternative(
@@ -186,7 +212,7 @@ module Ibex
       frame[:values] = []
     end
 
-    # @rbs (Hash[Symbol, untyped] frame) -> void
+    # @rbs (NormalizeParameters::parameter_frame frame) -> void
     def clear_parameter_alternative(frame)
       frame[:current] = nil
       frame[:item_index] = 0
@@ -196,4 +222,5 @@ module Ibex
       frame[:values] = []
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/ibex/normalize/parser_configuration.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Ibex
+  # Converts a root parser declaration into the explicit current Grammar IR contract.
+  module NormalizeParserConfiguration
+    private
+
+    # @rbs (Frontend::AST::ParserConfiguration declaration) -> void
+    def read_parser_configuration(declaration)
+      # @type self: Normalizer
+      fail_at(declaration.loc, "parser declarations require extended mode") unless @mode == :extended
+      fail_at(declaration.loc, "duplicate parser declaration") if @parser_configuration
+
+      @parser_configuration = declaration
+    end
+
+    # @rbs () -> IR::ParserContract?
+    def normalized_parser_contract
+      # @type self: Normalizer
+      declaration = @parser_configuration
+      return unless declaration
+
+      entries = {} #: Hash[Symbol, IR::ParserContract::Entry]
+      declaration.settings.each do |setting|
+        validated_parser_setting_definition(setting)
+        fail_at(setting.loc, "duplicate parser setting #{setting.key}") if entries.key?(setting.key)
+
+        if setting.key == :cst_trivia && @options[:cst] != true
+          fail_at(setting.loc, "parser.cst_trivia requires pragma cst")
+        end
+
+        entries[setting.key] = IR::ParserContract::Entry.new(
+          setting.key, value: setting.value, location: parser_setting_location(setting), explicit: true
+        )
+      end
+      validate_isolated_entries(declaration)
+      IR::ParserContract.new(**entries)
+    end
+
+    # @rbs (Frontend::AST::ParserSetting setting) -> Hash[Symbol, Object?]
+    def validated_parser_setting_definition(setting)
+      # @type self: Normalizer
+      definition = IR::ParserContract::DEFINITIONS[setting.key]
+      unless %i[algorithm entries cst_trivia].include?(setting.key) && definition
+        fail_at(setting.loc, "unknown parser setting #{setting.key}")
+      end
+      unless definition.fetch(:values).include?(setting.value)
+        allowed = definition.fetch(:values).join(", ")
+        fail_at(setting.loc, "parser.#{setting.key} must be one of #{allowed}; got #{setting.value}")
+      end
+      definition
+    end
+
+    # @rbs (Frontend::AST::ParserConfiguration declaration) -> void
+    def validate_isolated_entries(declaration)
+      # @type self: Normalizer
+      setting = declaration.settings.find { |candidate| candidate.key == :entries && candidate.value == :isolated }
+      return unless setting && @start_names.length < 2
+
+      fail_at(setting.loc, "parser.entries isolated requires at least two start symbols")
+    end
+
+    # @rbs (Frontend::AST::ParserSetting setting) -> Location
+    def parser_setting_location(setting)
+      # @type self: Normalizer
+      location = setting.loc
+      Location.new(file: location.file, line: location.line, column: location.column)
+    end
+  end
+end

data/lib/ibex/normalize.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "normalize/declarations"
+require_relative "normalize/parser_configuration"
+require_relative "normalize/grammar_builder"
 require_relative "normalize/lexer"
 require_relative "normalize/recovery_declarations"
 require_relative "normalize/expression"
@@ -21,6 +23,8 @@ module Ibex
   # Converts a frontend AST into immutable Grammar IR.
   class Normalizer
     include NormalizeDeclarations
+    include NormalizeParserConfiguration
+    include NormalizeGrammarBuilder
     include NormalizeLexer
     include NormalizeRecoveryDeclarations
     include NormalizeParameterValidation
@@ -69,6 +73,7 @@ module Ibex
     # @rbs @on_error_reduce_groups: Array[Array[String]]
     # @rbs @grammar_tests: Array[IR::grammar_test]
     # @rbs @lexer_declaration: Frontend::AST::Lexer?
+    # @rbs @parser_configuration: Frontend::AST::ParserConfiguration?
     # @rbs @explicit_starts: Array[String]?
     # @rbs @start_names: Array[String]
     # @rbs @start_name: String
@@ -76,7 +81,7 @@ module Ibex
     # @rbs @parameter_templates: Hash[String, Array[Frontend::AST::Rule]]
     # @rbs @parameter_formals: Hash[String, Array[String]]
     # @rbs @parameter_specializations: Hash[[String, Array[String]], String]
-    # @rbs @parameter_worklist: Array[Hash[Symbol, untyped]]
+    # @rbs @parameter_worklist: Array[NormalizeParameters::parameter_frame]
     # @rbs @parameter_worklist_active: bool
     # @rbs @max_parameter_specializations: Integer
     # @rbs @current_parameter_expansion: IR::parameter_expansion?
@@ -114,7 +119,7 @@ module Ibex
       @helper_sequence = 0
       @current_include_chain = [] #: Array[IR::source_provenance]
       @parameter_specializations = {} #: Hash[[String, Array[String]], String]
-      @parameter_worklist = [] #: Array[Hash[Symbol, untyped]]
+      @parameter_worklist = [] #: Array[NormalizeParameters::parameter_frame]
       @parameter_worklist_active = false
       @max_parameter_specializations = max_parameter_specializations
       @max_inline_expansions = max_inline_expansions
@@ -131,33 +136,18 @@ module Ibex
       intern_reserved_symbols
       intern_declared_terminals
       intern_user_nonterminals
+      parser_contract = normalized_parser_contract
       normalize_user_productions
       expand_inline_rules
       validate_value_printers
       validate_recovery_declarations
       validate_grammar
-      IR::Grammar.new(class_name: @ast.class_name, superclass: @ast.superclass, start: @start_name,
-                      expect: @expected_conflicts, options: @options, symbols: @symbols,
-                      mode: @mode, starts: @start_names,
-                      expect_rr: @expected_rr_conflicts,
-                      parser_parameters: @parser_parameters,
-                      value_printers: @value_printers.values,
-                      grammar_tests: @grammar_tests,
-                      lexer: normalize_lexer,
-                      recovery: {
-                        sync_tokens: @recovery_sync_tokens,
-                        on_error_reduce: @on_error_reduce_groups
-                      },
-                      productions: @productions, user_code: normalized_user_code,
-                      conversions: @conversions, warnings: @warnings, user_code_chunks: normalized_user_code_chunks,
-                      source_provenance: {
-                        file: @ast.loc.file, root: @resolution&.root_directory, byte_span: nil
-                      })
+      build_grammar(parser_contract)
     end
 
     private
 
-    # @rbs (Symbol name, untyped value) -> void
+    # @rbs (Symbol name, Object value) -> void
     def validate_positive_limit!(name, value)
       return if value.is_a?(Integer) && value.positive?
 

data/lib/ibex/racc_migration/report.rb

@@ -5,6 +5,9 @@ require "json"
 
 module Ibex
   module RaccMigration
+    # @rbs!
+    #   type json_value = String | Integer | Float | bool | nil | Array[json_value] | Hash[String, json_value]
+
     # One immutable migration compatibility observation.
     class Finding
       SEVERITIES = %i[error warning info].freeze #: Array[Symbol]
@@ -30,7 +33,7 @@ module Ibex
         freeze
       end
 
-      # @rbs () -> Hash[String, untyped]
+      # @rbs () -> Hash[String, json_value]
       def to_h
         {
           "code" => @code,
@@ -61,7 +64,7 @@ module Ibex
       # @rbs () -> bool
       def compatible? = @findings.none? { |finding| finding.severity == :error }
 
-      # @rbs () -> Hash[String, untyped]
+      # @rbs () -> Hash[String, json_value]
       def to_h
         {
           "ibex_migration_check" => "racc",
@@ -73,7 +76,7 @@ module Ibex
         }
       end
 
-      # @rbs (*untyped) -> String
+      # @rbs (*Object?) -> String
       def to_json(*) = JSON.pretty_generate(to_h)
 
       # @rbs () -> String

data/lib/ibex/rake_task.rb

@@ -13,7 +13,7 @@ require_relative "cli"
 #     class Task
 #       def self.define_task: (Hash[String | Symbol, String | Array[String]]) -> Task
 #                           | (Hash[String | Symbol, String | Array[String]]) {
-#                               (untyped, untyped) -> void
+#                               (Object?, Object?) -> void
 #                             } -> Task
 #     end
 #

data/lib/ibex/samples.rb

@@ -7,17 +7,27 @@ module Ibex
     DEFAULT_MAX_EXPANSIONS = 100_000 #: Integer
 
     # @rbs (IR::Grammar grammar, ?seed: Integer, ?max_tokens: Integer, ?max_depth: Integer,
-    #   ?max_expansions: Integer) -> void
-    def initialize(grammar, seed: 0, max_tokens: 32, max_depth: 16, max_expansions: DEFAULT_MAX_EXPANSIONS)
+    #   ?max_expansions: Integer, ?strategy: Symbol | String, ?path_length: Integer) -> void
+    def initialize(grammar, seed: 0, max_tokens: 32, max_depth: 16, max_expansions: DEFAULT_MAX_EXPANSIONS,
+                   strategy: :random, path_length: 1)
       raise ArgumentError, "max_tokens must be positive" unless max_tokens.positive?
       raise ArgumentError, "max_depth must be positive" unless max_depth.positive?
       raise ArgumentError, "max_expansions must be positive" unless max_expansions.positive?
 
+      normalized_strategy = strategy.to_sym
+      unless %i[random coverage].include?(normalized_strategy)
+        raise ArgumentError, "strategy must be :random or :coverage"
+      end
+      raise ArgumentError, "path_length must be 1 or 2" unless [1, 2].include?(path_length)
+
       @grammar = grammar
       @random = Random.new(seed)
       @max_tokens = max_tokens
       @max_depth = max_depth
       @max_expansions = max_expansions
+      @strategy = normalized_strategy
+      @path_length = path_length
+      @path_coverage = Hash.new(0) #: Hash[Array[Integer], Integer]
       @productions = grammar.productions.group_by(&:lhs)
       @minimum_costs = compute_minimum_costs
       @minimum_heights = compute_minimum_heights
@@ -120,7 +130,7 @@ module Ibex
     # @rbs (IR::GrammarSymbol start, Integer remaining_expansions) -> [Array[String], Integer]
     def expand(start, remaining_expansions)
       result = [] #: Array[String]
-      work = [[start.id, 0]] #: Array[[Integer, Integer]]
+      work = [[start.id, 0, []]] #: Array[[Integer, Integer, Array[Integer]]]
       pending_minimum = minimum_cost!(start.id)
 
       while (entry = work.pop)
@@ -129,7 +139,7 @@ module Ibex
         end
 
         remaining_expansions -= 1
-        symbol_id, depth = entry
+        symbol_id, depth, path = entry
         pending_minimum -= minimum_cost!(symbol_id)
         symbol = @grammar.symbol_by_id(symbol_id) ||
                  raise(Ibex::Error, "(samples):1:1: missing symbol #{symbol_id}")
@@ -139,17 +149,30 @@ module Ibex
         end
 
         budget = @max_tokens - result.length - pending_minimum
-        production = choose_production(symbol_id, budget, depth)
+        production = choose_production(symbol_id, budget, depth, path)
+        production_path = (path + [production.id]).last(@path_length)
+        @path_coverage[production_path] += 1
         pending_minimum += production_cost(production) ||
                            raise(Ibex::Error, "(samples):1:1: no bounded derivation for symbol #{symbol_id}")
-        production.rhs.reverse_each { |child_id| work << [child_id, depth + 1] }
+        production.rhs.reverse_each { |child_id| work << [child_id, depth + 1, production_path] }
       end
 
       [result, remaining_expansions]
     end
 
-    # @rbs (Integer nonterminal_id, Integer budget, Integer depth) -> IR::Production
-    def choose_production(nonterminal_id, budget, depth)
+    # @rbs (Integer nonterminal_id, Integer budget, Integer depth, Array[Integer] path) -> IR::Production
+    def choose_production(nonterminal_id, budget, depth, path)
+      candidates = bounded_productions(nonterminal_id, budget)
+      candidates = minimum_height_productions(candidates) if depth >= @max_depth
+      return candidates.fetch(@random.rand(candidates.length)) if @strategy == :random
+
+      minimum_coverage = candidates.map { |production| path_count(path, production) }.min
+      least_covered = candidates.select { |production| path_count(path, production) == minimum_coverage }
+      least_covered.fetch(@random.rand(least_covered.length))
+    end
+
+    # @rbs (Integer nonterminal_id, Integer budget) -> Array[IR::Production]
+    def bounded_productions(nonterminal_id, budget)
       productions = @productions[nonterminal_id]
       raise Ibex::Error, "(samples):1:1: no bounded derivation for symbol #{nonterminal_id}" unless productions
 
@@ -159,11 +182,18 @@ module Ibex
       end
       raise Ibex::Error, "(samples):1:1: no bounded derivation for symbol #{nonterminal_id}" if candidates.empty?
 
-      if depth >= @max_depth
-        minimum = candidates.filter_map { |production| production_height(production) }.min
-        candidates = candidates.select { |production| production_height(production) == minimum }
-      end
-      candidates.fetch(@random.rand(candidates.length))
+      candidates
+    end
+
+    # @rbs (Array[IR::Production] candidates) -> Array[IR::Production]
+    def minimum_height_productions(candidates)
+      minimum = candidates.filter_map { |production| production_height(production) }.min
+      candidates.select { |production| production_height(production) == minimum }
+    end
+
+    # @rbs (Array[Integer] path, IR::Production production) -> Integer
+    def path_count(path, production)
+      @path_coverage[(path + [production.id]).last(@path_length)]
     end
 
     # @rbs (Integer symbol_id) -> Integer