ibex 0.1.0 → 0.3.0

data/lib/ibex/normalize/declarations.rb

@@ -11,27 +11,162 @@ module Ibex
       @declared_tokens = {} #: Hash[String, IR::location]
       @precedence = {} #: Hash[String, IR::precedence]
       @precedence_locations = {} #: Hash[String, IR::location]
+      @display_names = {} #: Hash[String, String]
+      @display_name_locations = {} #: Hash[String, IR::location]
+      @semantic_types = {} #: Hash[String, String]
+      @semantic_type_locations = {} #: Hash[String, IR::location]
       @options = { result_var: true, omit_action_call: true }
+      @options[:cst] = true if @ast.cst
       @expected_conflicts = 0
+      @expected_rr_conflicts = nil
       @conversions = {} #: Hash[String, String]
+      @parser_parameters = [] #: Array[IR::parser_parameter]
+      @value_printers = {} #: Hash[String, IR::value_printer]
+      @recovery_sync_tokens = [] #: Array[String]
+      @recovery_sync_location = nil #: Frontend::Location?
+      @on_error_reduce_groups = [] #: Array[Array[String]]
+      @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
 
     # @rbs (Frontend::AST::declaration declaration) -> void
-    def read_declaration(declaration)
+    def read_declaration(declaration) # rubocop:disable Metrics/CyclomaticComplexity
       # @type self: Normalizer
       case declaration
-      when Frontend::AST::Tokens then declaration.names.each { |name| @declared_tokens[name] = declaration.loc.to_h }
+      when Frontend::AST::Tokens then read_tokens(declaration)
       when Frontend::AST::Precedence then read_precedence(declaration)
-      when Frontend::AST::Options then declaration.names.each { |name| read_option(name, declaration.loc) }
+      when Frontend::AST::Options then read_options(declaration)
       when Frontend::AST::Expect then @expected_conflicts = declaration.conflicts
-      when Frontend::AST::Start
-        @explicit_start = declaration.name
-        @start_location = declaration.loc
-      when Frontend::AST::Convert then declaration.pairs.each { |pair| @conversions[pair.name] = pair.expression }
+      when Frontend::AST::ExpectRR then @expected_rr_conflicts = declaration.conflicts
+      when Frontend::AST::Start, Frontend::AST::Recovery, Frontend::AST::OnErrorReduce, Frontend::AST::GrammarTest
+        read_parser_control_declaration(declaration)
+      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)
+      when Frontend::AST::Include then fail_at(declaration.loc, "includes must be resolved before normalization")
       end
     end
 
+    # @rbs (Frontend::AST::Start declaration) -> void
+    def read_start_declaration(declaration)
+      # @type self: Normalizer
+      fail_at(declaration.loc, "duplicate start declaration") if @explicit_starts
+      if declaration.names.length > 1 && @mode != :extended
+        fail_at(declaration.loc, "multiple start symbols require extended mode")
+      end
+      fail_at(declaration.loc, "start declaration requires at least one symbol") if declaration.names.empty?
+      unless declaration.names.uniq.length == declaration.names.length
+        fail_at(declaration.loc, "start symbols must be unique")
+      end
+
+      @explicit_starts = declaration.names
+      @start_location = declaration.loc
+    end
+
+    # @rbs (Frontend::AST::symbol_metadata | Frontend::AST::Parameter | Frontend::AST::Printer declaration) -> void
+    def read_extended_declaration(declaration)
+      if declaration.is_a?(Frontend::AST::Parameter)
+        read_parser_parameter(declaration)
+      elsif declaration.is_a?(Frontend::AST::Printer)
+        read_value_printer(declaration)
+      else
+        read_symbol_metadata_declaration(declaration)
+      end
+    end
+
+    # @rbs (Frontend::AST::Printer declaration) -> void
+    def read_value_printer(declaration)
+      # @type self: Normalizer
+      if @value_printers.key?(declaration.name)
+        fail_at(declaration.loc, "duplicate %printer declaration for #{declaration.name}")
+      end
+
+      @value_printers[declaration.name] = {
+        symbol: declaration.name, code: declaration.code, loc: declaration.loc.to_h
+      }
+    end
+
+    # @rbs () -> void
+    def validate_value_printers
+      @value_printers.each_value do |printer|
+        next if @symbols_by_name.key?(printer[:symbol])
+
+        location = printer[:loc]
+        raise Ibex::Error,
+              "#{location[:file]}:#{location[:line]}:#{location[:column]}: " \
+              "%printer references missing symbol #{printer[:symbol]}"
+      end
+    end
+
+    # @rbs (Frontend::AST::Parameter declaration) -> void
+    def read_parser_parameter(declaration)
+      # @type self: Normalizer
+      if @parser_parameters.any? { |parameter| parameter[:name] == declaration.name }
+        fail_at(declaration.loc, "duplicate %param declaration for #{declaration.name}")
+      end
+      unless declaration.name.match?(/\A[a-z_][a-zA-Z0-9_]*\z/)
+        fail_at(declaration.loc, "%param name #{declaration.name.inspect} must be a Ruby local identifier")
+      end
+      if Normalizer::RUBY_KEYWORDS.include?(declaration.name)
+        fail_at(declaration.loc, "%param name #{declaration.name.inspect} is a Ruby keyword")
+      end
+
+      @parser_parameters << { name: declaration.name, semantic_type: declaration.semantic_type }
+    end
+
+    # @rbs (Frontend::AST::Tokens declaration) -> void
+    def read_tokens(declaration)
+      # @type self: Normalizer
+      declaration.names.each { |name| @declared_tokens[name] = declaration.loc.to_h }
+      (declaration.aliases || {}).each do |name, value|
+        fail_at(declaration.loc, "duplicate display declaration for #{name}") if @display_names.key?(name)
+
+        @display_names[name] = value
+        @display_name_locations[name] = declaration.loc.to_h
+      end
+    end
+
+    # @rbs (Frontend::AST::Options declaration) -> void
+    def read_options(declaration)
+      declaration.names.each { |name| read_option(name, declaration.loc) }
+    end
+
+    # @rbs (Frontend::AST::Convert declaration) -> void
+    def read_conversions(declaration)
+      # @type self: Normalizer
+      declaration.pairs.each { |pair| @conversions[pair.name] = pair.expression }
+    end
+
+    # @rbs (Frontend::AST::symbol_metadata declaration) -> void
+    def read_symbol_metadata_declaration(declaration)
+      # @type self: Normalizer
+      if declaration.is_a?(Frontend::AST::DisplayName)
+        read_symbol_metadata(declaration, @display_names, @display_name_locations, "display")
+      else
+        read_symbol_metadata(declaration, @semantic_types, @semantic_type_locations, "type")
+      end
+    end
+
+    # @rbs (Frontend::AST::symbol_metadata declaration, Hash[String, String] values,
+    #   Hash[String, IR::location] locations, String label) -> void
+    def read_symbol_metadata(declaration, values, locations, label)
+      # @type self: Normalizer
+      if values.key?(declaration.name)
+        fail_at(declaration.loc, "duplicate #{label} declaration for #{declaration.name}")
+      end
+
+      values[declaration.name] = declaration.value
+      locations[declaration.name] = declaration.loc.to_h
+    end
+
     # @rbs (Frontend::AST::Precedence declaration) -> void
     def read_precedence(declaration)
       # @type self: Normalizer

data/lib/ibex/normalize/diagnostics.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module Ibex
   # Static grammar diagnostics used by Normalizer.
   module NormalizeDiagnostics
@@ -10,21 +8,41 @@ module Ibex
     # @rbs () -> void
     def validate_grammar
       # @type self: Normalizer
+      validate_symbol_metadata
       warn_duplicate_productions
       warn_unreachable_nonterminals
+      warn_unreachable_terminals
       warn_unused_terminals
+      warn_unused_precedence
       warn_empty_language
     end
 
+    # @rbs () -> void
+    def validate_symbol_metadata
+      # @type self: Normalizer
+      display_locations = @display_name_locations #: Hash[String, IR::location]
+      semantic_locations = @semantic_type_locations #: Hash[String, IR::location]
+      inline_rule_names = @inline_rule_names #: Set[String]
+      { display: display_locations, type: semantic_locations }.each do |label, locations|
+        locations.each do |name, location|
+          fail_hash(location, "#{label} declaration references undefined symbol #{name}") unless
+            symbol(name) || parameter_template?(name) || (label == :type && inline_rule_names.include?(name))
+        end
+      end
+    end
+
     # @rbs () -> void
     def warn_duplicate_productions
       # @type self: Normalizer
+      productions = @productions #: Array[IR::Production]
+      warnings = @warnings #: Array[IR::grammar_warning]
       seen = {} #: Hash[[Integer, Array[Integer]], Integer]
-      @productions.each do |production|
+      productions.each do |production|
         signature = [production.lhs, production.rhs] #: [Integer, Array[Integer]]
         if seen.key?(signature)
-          @warnings << { type: :duplicate_production, production: production.id, original: seen[signature],
-                         loc: production.origin[:loc] }
+          location = production.origin[:loc] #: IR::location?
+          warnings << { type: :duplicate_production, production: production.id, original: seen[signature],
+                        loc: location }
         else
           seen[signature] = production.id
         end
@@ -34,23 +52,27 @@ module Ibex
     # @rbs () -> void
     def warn_unreachable_nonterminals
       # @type self: Normalizer
+      symbols = @symbols #: Array[IR::GrammarSymbol]
+      warnings = @warnings #: Array[IR::grammar_warning]
       reachable = reachable_symbol_ids
-      @symbols.select(&:nonterminal?).each do |grammar_symbol|
-        next if reachable.include?(grammar_symbol.id) || grammar_symbol.name.start_with?("$")
+      symbols.select(&:nonterminal?).each do |grammar_symbol|
+        next if reachable.key?(grammar_symbol.id) || grammar_symbol.name.start_with?("$")
 
-        @warnings << { type: :unreachable_nonterminal, symbol: grammar_symbol.name, loc: grammar_symbol.location }
+        warnings << { type: :unreachable_nonterminal, symbol: grammar_symbol.name, loc: grammar_symbol.location }
       end
     end
 
-    # @rbs () -> Set[Integer]
+    # @rbs () -> Hash[Integer, true]
     def reachable_symbol_ids
       # @type self: Normalizer
-      start = required_symbol(@start_name).id
-      reachable = Set[start]
+      start_names = @start_names #: Array[String]
+      productions = @productions #: Array[IR::Production]
+      starts = start_names.map { |name| required_symbol(name).id }
+      reachable = starts.to_h { |id| [id, true] } #: Hash[Integer, true]
       loop do
         before = reachable.length
-        @productions.select { |production| reachable.include?(production.lhs) }.each do |production|
-          production.rhs.each { |id| reachable << id }
+        productions.select { |production| reachable.key?(production.lhs) }.each do |production|
+          production.rhs.each { |id| reachable[id] = true }
         end
         return reachable if reachable.length == before
       end
@@ -59,35 +81,83 @@ module Ibex
     # @rbs () -> void
     def warn_unused_terminals
       # @type self: Normalizer
-      used = @productions.flat_map(&:rhs).to_set
-      @symbols.select(&:terminal?).each do |grammar_symbol|
-        next if grammar_symbol.reserved || used.include?(grammar_symbol.id) || @precedence.key?(grammar_symbol.name)
+      productions = @productions #: Array[IR::Production]
+      symbols = @symbols #: Array[IR::GrammarSymbol]
+      precedence = @precedence #: Hash[String, IR::precedence]
+      warnings = @warnings #: Array[IR::grammar_warning]
+      used = productions.flat_map(&:rhs).to_h { |id| [id, true] } #: Hash[Integer, true]
+      symbols.select(&:terminal?).each do |grammar_symbol|
+        next if grammar_symbol.reserved || used.key?(grammar_symbol.id) || precedence.key?(grammar_symbol.name)
+
+        warnings << { type: :unused_terminal, symbol: grammar_symbol.name, loc: grammar_symbol.location }
+      end
+    end
+
+    # @rbs () -> void
+    def warn_unreachable_terminals
+      # @type self: Normalizer
+      productions = @productions #: Array[IR::Production]
+      declared_tokens = @declared_tokens #: Hash[String, IR::location]
+      warnings = @warnings #: Array[IR::grammar_warning]
+      reachable = reachable_symbol_ids
+      used = productions.flat_map(&:rhs).to_h { |id| [id, true] } #: Hash[Integer, true]
+      declared_tokens.each_key do |name|
+        grammar_symbol = required_symbol(name)
+        next unless used.key?(grammar_symbol.id)
+        next if reachable.key?(grammar_symbol.id)
 
-        @warnings << { type: :unused_terminal, symbol: grammar_symbol.name, loc: grammar_symbol.location }
+        warnings << { type: :unreachable_terminal, symbol: name, loc: declared_tokens[name] }
+      end
+    end
+
+    # @rbs () -> void
+    def warn_unused_precedence
+      # @type self: Normalizer
+      productions = @productions #: Array[IR::Production]
+      precedence = @precedence #: Hash[String, IR::precedence]
+      precedence_locations = @precedence_locations #: Hash[String, IR::location]
+      warnings = @warnings #: Array[IR::grammar_warning]
+      referenced = {} # @type var referenced: Hash[Integer, true]
+      productions.each do |production|
+        symbol_ids = referenced
+        production.rhs.each { |id| symbol_ids[id] = true }
+        symbol_ids[production.precedence_override] = true if production.precedence_override
+      end
+      precedence.each_key do |name|
+        grammar_symbol = required_symbol(name)
+        next if referenced.key?(grammar_symbol.id)
+
+        warnings << { type: :unused_precedence, symbol: name, loc: precedence_locations[name] }
       end
     end
 
     # @rbs () -> void
     def warn_empty_language
       # @type self: Normalizer
+      productions = @productions #: Array[IR::Production]
+      start_names = @start_names #: Array[String]
+      warnings = @warnings #: Array[IR::grammar_warning]
       productive = productive_terminal_ids
       loop do
         before = productive.length
-        @productions.each do |production|
-          productive << production.lhs if production.rhs.all? { |id| productive.include?(id) }
+        productions.each do |production|
+          productive[production.lhs] = true if production.rhs.all? { |id| productive.key?(id) }
         end
         break if productive.length == before
       end
-      return if productive.include?(required_symbol(@start_name).id)
+      start_names.each do |name|
+        next if productive.key?(required_symbol(name).id)
 
-      start_symbol = required_symbol(@start_name)
-      @warnings << { type: :empty_language, symbol: @start_name, loc: start_symbol.location }
+        start_symbol = required_symbol(name)
+        warnings << { type: :empty_language, symbol: name, loc: start_symbol.location }
+      end
     end
 
-    # @rbs () -> Set[Integer]
+    # @rbs () -> Hash[Integer, true]
     def productive_terminal_ids
       # @type self: Normalizer
-      @symbols.select { |grammar_symbol| productive_terminal?(grammar_symbol) }.to_set(&:id)
+      symbols = @symbols #: Array[IR::GrammarSymbol]
+      symbols.select { |grammar_symbol| productive_terminal?(grammar_symbol) }.to_h { |symbol| [symbol.id, true] }
     end
 
     # @rbs (IR::GrammarSymbol grammar_symbol) -> bool

data/lib/ibex/normalize/expander.rb

@@ -9,6 +9,9 @@ module Ibex
     def normalize_user_productions
       # @type self: Normalizer
       @ast.rules.each do |rule|
+        next if parameterized_rule?(rule)
+
+        @current_include_chain = @resolution&.include_chain_for(rule) || []
         rule.alternatives.each { |alternative| normalize_alternative(rule, alternative) }
       end
     end
@@ -18,7 +21,8 @@ module Ibex
       # @type self: Normalizer
       rhs = [] #: Array[String]
       named_refs = [] #: Array[IR::named_ref]
-      alternative.items.each do |item|
+      items = normalized_alternative_items(alternative)
+      items.each do |item|
         if item.is_a?(Frontend::AST::InlineAction)
           rhs << expand_inline_action(item, rhs.length, named_refs)
           next
@@ -28,14 +32,31 @@ module Ibex
         add_named_reference(item, named_refs, rhs.length - 1)
       end
       action = normalize_action(alternative.action, named_refs)
+      node = normalize_node_annotation(alternative, rhs)
       add_production(rule.lhs, rhs, action, alternative.precedence,
-                     { kind: :user, loc: alternative.loc.to_h })
+                     { kind: :user, loc: alternative.loc.to_h }, rule.documentation, node)
+    end
+
+    # @rbs (Frontend::AST::Alternative alternative) -> Array[Frontend::AST::item]
+    def normalized_alternative_items(alternative)
+      # @type self: Normalizer
+      explicit = alternative.items.grep(Frontend::AST::Empty)
+      if explicit.any?
+        fail_at(explicit.first.loc, "%empty must be the only item in an alternative") unless alternative.items.one?
+        return []
+      end
+
+      if alternative.items.empty? && (@mode.to_sym == :extended || @ast.extended)
+        @warnings << { type: :implicit_empty, loc: alternative.loc.to_h }
+      end
+      alternative.items
     end
 
     # @rbs (Frontend::AST::item item) -> String
     def normalize_item(item)
       # @type self: Normalizer
       return symbol_for_reference(item).name if item.is_a?(Frontend::AST::SymbolReference)
+      return specialize_parameterized_reference(item) if item.is_a?(Frontend::AST::ParameterizedReference)
       return expand_group(item) if item.is_a?(Frontend::AST::Group)
       return expand_optional(item) if item.is_a?(Frontend::AST::Optional)
       return expand_star(item) if item.is_a?(Frontend::AST::Star)
@@ -59,6 +80,12 @@ module Ibex
     def expand_optional(item)
       # @type self: Normalizer
       base = normalize_item(item.item)
+      build_optional(item, base)
+    end
+
+    # @rbs (Frontend::AST::Optional item, String base) -> String
+    def build_optional(item, base)
+      # @type self: Normalizer
       helper = new_helper("optional", item.loc)
       add_production(helper, [], synthetic_action("nil", item.loc), nil, synthetic_origin(:optional, item))
       add_production(helper, [base], synthetic_action("val[0]", item.loc), nil, synthetic_origin(:optional, item))
@@ -69,6 +96,12 @@ module Ibex
     def expand_star(item)
       # @type self: Normalizer
       base = normalize_item(item.item)
+      build_star(item, base)
+    end
+
+    # @rbs (Frontend::AST::Star item, String base) -> String
+    def build_star(item, base)
+      # @type self: Normalizer
       helper = new_helper("star", item.loc)
       add_production(helper, [], synthetic_action("[]", item.loc), nil, synthetic_origin(:star, item))
       add_production(helper, [helper, base], synthetic_action("val[0] + [val[1]]", item.loc), nil,
@@ -80,6 +113,12 @@ module Ibex
     def expand_plus(item)
       # @type self: Normalizer
       base = normalize_item(item.item)
+      build_plus(item, base)
+    end
+
+    # @rbs (Frontend::AST::Plus item, String base) -> String
+    def build_plus(item, base)
+      # @type self: Normalizer
       helper = new_helper("plus", item.loc)
       add_production(helper, [base], synthetic_action("[val[0]]", item.loc), nil, synthetic_origin(:plus, item))
       add_production(helper, [helper, base], synthetic_action("val[0] + [val[1]]", item.loc), nil,
@@ -92,6 +131,12 @@ module Ibex
       # @type self: Normalizer
       base = normalize_item(item.item)
       separator = normalize_item(item.separator)
+      build_separated_list(item, base, separator)
+    end
+
+    # @rbs (Frontend::AST::SeparatedList item, String base, String separator) -> String
+    def build_separated_list(item, base, separator)
+      # @type self: Normalizer
       helper = new_helper("separated_list", item.loc)
       unless item.nonempty
         add_production(helper, [], synthetic_action("[]", item.loc), nil, synthetic_origin(:separated_list, item))
@@ -110,12 +155,18 @@ module Ibex
       helper = new_helper("group", item.loc)
       item.alternatives.each do |alternative|
         rhs = alternative.map { |child| normalize_item(child) }
-        expression = group_value_expression(rhs.length)
-        add_production(helper, rhs, synthetic_action(expression, item.loc), nil, synthetic_origin(:group, item))
+        add_group_production(helper, rhs, item)
       end
       helper
     end
 
+    # @rbs (String helper, Array[String] rhs, Frontend::AST::Group item) -> void
+    def add_group_production(helper, rhs, item)
+      # @type self: Normalizer
+      expression = group_value_expression(rhs.length)
+      add_production(helper, rhs, synthetic_action(expression, item.loc), nil, synthetic_origin(:group, item))
+    end
+
     # @rbs (Integer length) -> String
     def group_value_expression(length)
       # @type self: Normalizer
@@ -125,28 +176,6 @@ module Ibex
       "val"
     end
 
-    # @rbs (Frontend::AST::Group group) -> void
-    def reject_group_named_references(group)
-      # @type self: Normalizer
-      reference = group.alternatives.flatten.filter_map { |item| named_reference_in(item) }.first
-      fail_at(reference.loc, "named references inside EBNF groups are not supported") if reference
-    end
-
-    # @rbs (Frontend::AST::item item) -> Frontend::AST::SymbolReference?
-    def named_reference_in(item)
-      # @type self: Normalizer
-      return item if item.is_a?(Frontend::AST::SymbolReference) && item.named_reference
-      if item.is_a?(Frontend::AST::Group)
-        return item.alternatives.flatten.filter_map { |child| named_reference_in(child) }.first
-      end
-      if item.is_a?(Frontend::AST::Optional) || item.is_a?(Frontend::AST::Star) ||
-         item.is_a?(Frontend::AST::Plus) || item.is_a?(Frontend::AST::SeparatedList)
-        return named_reference_in(item.item)
-      end
-
-      nil
-    end
-
     # @rbs (String kind, Frontend::Location location) -> String
     def new_helper(kind, location)
       # @type self: Normalizer
@@ -163,7 +192,7 @@ module Ibex
       IR::Action.new(code: code, location: location.to_h)
     end
 
-    # @rbs (Symbol kind, Frontend::AST::item item) -> Hash[Symbol, untyped]
+    # @rbs (Symbol kind, Frontend::AST::item item) -> Hash[Symbol, Object?]
     def synthetic_origin(kind, item)
       # @type self: Normalizer
       { kind: :"#{kind}_expansion", expression: NormalizeExpression.render(item), loc: item.loc.to_h }
@@ -177,42 +206,18 @@ module Ibex
       IR::Action.new(code: action.code, location: action.loc.to_h, named_refs: named_refs)
     end
 
-    # @rbs (Frontend::AST::item item, Array[IR::named_ref] refs, Integer index) -> void
-    def add_named_reference(item, refs, index)
-      # @type self: Normalizer
-      reference = unwrap_reference(item)
-      return unless reference
-
-      name = reference.named_reference
-      return unless name
-
-      fail_at(reference.loc, "reserved named reference #{name}") if Normalizer::RESERVED_NAMES.include?(name)
-      fail_at(reference.loc, "duplicate named reference #{name}") if refs.any? { |entry| entry[:name] == name }
-      refs << { name: name, index: index }
-    end
-
-    # @rbs (Frontend::AST::item item) -> Frontend::AST::SymbolReference?
-    def unwrap_reference(item)
-      # @type self: Normalizer
-      return item if item.is_a?(Frontend::AST::SymbolReference)
-      if item.is_a?(Frontend::AST::Optional) || item.is_a?(Frontend::AST::Star) ||
-         item.is_a?(Frontend::AST::Plus) || item.is_a?(Frontend::AST::SeparatedList)
-        return unwrap_reference(item.item)
-      end
-
-      nil
-    end
-
     # @rbs (String lhs_name, Array[String] rhs_names, IR::Action? action, String? precedence_name,
-    #   Hash[Symbol, untyped] origin) -> void
-    def add_production(lhs_name, rhs_names, action, precedence_name, origin)
+    #   Hash[Symbol, untyped] origin, ?String? documentation, ?IR::node_annotation? node) -> void
+    def add_production(lhs_name, rhs_names, action, precedence_name, origin, documentation = nil, node = nil)
       # @type self: Normalizer
-      lhs = symbol(lhs_name) || intern(lhs_name, :nonterminal, location: origin[:loc])
-      rhs = rhs_names.map { |name| symbol(name)&.id || fail_hash(origin[:loc], "undefined symbol #{name}") }
+      location = origin[:loc] #: IR::location
+      lhs = symbol(lhs_name) || intern(lhs_name, :nonterminal, location: location)
+      rhs = rhs_names.map { |name| symbol(name)&.id || fail_hash(location, "undefined symbol #{name}") }
       precedence = precedence_name && symbol(precedence_name)
-      fail_hash(origin[:loc], "undefined precedence symbol #{precedence_name}") if precedence_name && !precedence
+      fail_hash(location, "undefined precedence symbol #{precedence_name}") if precedence_name && !precedence
       @productions << IR::Production.new(id: @productions.length, lhs: lhs.id, rhs: rhs, action: action,
-                                         precedence_override: precedence&.id, origin: origin)
+                                         precedence_override: precedence&.id, origin: origin,
+                                         documentation: documentation, expansion: resolved_expansion, node: node)
     end
   end
 end