rigortype 0.3.4 → 0.3.6

data/lib/rigor/configuration.rb

@@ -6,6 +6,7 @@ require_relative "bleeding_edge"
 require_relative "ci_detector"
 require_relative "configuration/dependencies"
 require_relative "configuration/severity_profile"
+require_relative "configuration_error"
 require_relative "effects/entry_points"
 require_relative "effects/label"
 require_relative "effects/method_key"
@@ -358,10 +359,10 @@ module Rigor
     # {CLI::CheckCommand#load_check_configuration}).
     def self.load_with_includes(path, visited: Set.new)
       absolute = File.expand_path(path)
-      raise ArgumentError, "circular include: #{absolute}" if visited.include?(absolute)
+      raise ConfigurationError, "circular include: #{absolute}" if visited.include?(absolute)
 
-      raw = YAML.safe_load_file(absolute, aliases: false) || {}
-      raise ArgumentError, "config file must be a YAML mapping: #{absolute}" unless raw.is_a?(Hash)
+      raw = read_yaml(absolute)
+      raise ConfigurationError, "config file must be a YAML mapping: #{absolute}" unless raw.is_a?(Hash)
 
       base_dir = File.dirname(absolute)
       includes = Array(raw.delete("includes") || [])
@@ -370,6 +371,17 @@ module Rigor
       merge_includes(data, includes, base_dir, next_visited)
     end
 
+    # #433's sibling: a typo in the file the user is about to be told to fix is a configuration mistake
+    # like any other, and escaped as a `Psych::SyntaxError` backtrace naming a file inside Ruby's stdlib.
+    # Psych's own `#message` embeds the path in a parenthesised prefix that reads badly after `rigor: `,
+    # so the position is re-rendered in the `path:line:column` form the rest of Rigor's output uses.
+    def self.read_yaml(absolute)
+      YAML.safe_load_file(absolute, aliases: false) || {}
+    rescue Psych::SyntaxError => e
+      detail = [e.problem, e.context].compact.join(" ")
+      raise ConfigurationError, "#{absolute}:#{e.line}:#{e.column}: not valid YAML: #{detail}"
+    end
+
     def self.merge_includes(data, includes, base_dir, visited)
       return data if includes.empty?
 
@@ -377,7 +389,7 @@ module Rigor
       includes.each do |inc|
         inc_path = File.expand_path(inc.to_s, base_dir)
         unless File.exist?(inc_path)
-          raise ArgumentError, "include not found: #{inc.inspect} (referenced from #{base_dir})"
+          raise ConfigurationError, "include not found: #{inc.inspect} (referenced from #{base_dir})"
         end
 
         accumulated = deep_merge(accumulated, load_with_includes(inc_path, visited: visited))
@@ -737,7 +749,7 @@ module Rigor
 
       gate = value.to_s.to_sym
       unless VALID_EFFECTS_GATES.include?(gate)
-        raise ArgumentError,
+        raise ConfigurationError,
               "effects.snapshot.gate must be one of #{VALID_EFFECTS_GATES.inspect}, got #{value.inspect}"
       end
 
@@ -756,7 +768,7 @@ module Rigor
       entries.each do |entry|
         next if Effects::EntryPoints.glob?(entry) || Effects::EntryPoints.name?(entry)
 
-        raise ArgumentError,
+        raise ConfigurationError,
               "effects.snapshot.reach entry is neither a file glob nor a well-formed entry-point preset " \
               "name: #{entry.inspect} (a preset name is #{Effects::EntryPoints::NAME_PATTERN.inspect}; " \
               "anything carrying a path or glob character is treated as a file glob instead)"
@@ -768,7 +780,7 @@ module Rigor
     def coerce_effects_tolerated(value)
       labels = Array(value).map(&:to_s)
       labels.each do |label|
-        raise ArgumentError, "effects.tolerated is not a well-formed effect label: #{label.inspect}" unless
+        raise ConfigurationError, "effects.tolerated is not a well-formed effect label: #{label.inspect}" unless
           Effects::Label.valid?(label)
       end
       labels.uniq.sort.freeze
@@ -795,7 +807,7 @@ module Rigor
     def coerce_effects_labels(value)
       labels = Array(value).map(&:to_s)
       labels.each do |label|
-        raise ArgumentError, "effects.labels is not a well-formed effect label: #{label.inspect}" unless
+        raise ConfigurationError, "effects.labels is not a well-formed effect label: #{label.inspect}" unless
           Effects::Label.valid?(label)
       end
       labels.uniq.sort.freeze
@@ -809,7 +821,7 @@ module Rigor
       value.each_with_object({}) do |(key, labels), out|
         name = key.to_s
         unless Effects::MethodKey.valid?(name)
-          raise ArgumentError,
+          raise ConfigurationError,
                 "effects.attribution key is not a method key (`Owner#method` / `Owner.method`): #{name.inspect}"
         end
 
@@ -826,16 +838,16 @@ module Rigor
 
     def coerce_effects_envelope(entry, index)
       where = "effects.envelopes[#{index}]"
-      raise ArgumentError, "#{where} is not a mapping: #{entry.inspect}" unless entry.is_a?(Hash)
+      raise ConfigurationError, "#{where} is not a mapping: #{entry.inspect}" unless entry.is_a?(Hash)
 
       match = coerce_effects_envelope_selector(entry["match"], "#{where}.match")
       namespace = coerce_effects_envelope_selector(entry["namespace"], "#{where}.namespace")
       if match.nil? == namespace.nil?
-        raise ArgumentError, "#{where} must name exactly one of `match:` (a path glob) or `namespace:` " \
-                             "(a constant glob), got #{match.nil? ? 'neither' : 'both'}"
+        raise ConfigurationError, "#{where} must name exactly one of `match:` (a path glob) or `namespace:` " \
+                                  "(a constant glob), got #{match.nil? ? 'neither' : 'both'}"
       end
       unless entry.key?("effect")
-        raise ArgumentError, "#{where} has no `effect:` bound (write `effect: []` for the empty envelope)"
+        raise ConfigurationError, "#{where} has no `effect:` bound (write `effect: []` for the empty envelope)"
       end
 
       {
@@ -848,14 +860,14 @@ module Rigor
       return nil if value.nil?
 
       selector = value.to_s
-      raise ArgumentError, "#{where} is empty" if selector.strip.empty?
+      raise ConfigurationError, "#{where} is empty" if selector.strip.empty?
 
       selector.freeze
     end
 
     def coerce_effect_label_list(labels, where)
       labels.map(&:to_s).each do |label|
-        raise ArgumentError, "#{where} is not a well-formed effect label: #{label.inspect}" unless
+        raise ConfigurationError, "#{where} is not a well-formed effect label: #{label.inspect}" unless
           Effects::Label.valid?(label)
       end.uniq.sort.freeze
     end
@@ -886,7 +898,7 @@ module Rigor
       when Hash
         entry.to_h { |k, v| [k.to_s, v] }.freeze
       else
-        raise ArgumentError,
+        raise ConfigurationError,
               "plugin configuration entry must be a String or Hash, got #{entry.inspect}"
       end
     end
@@ -903,7 +915,7 @@ module Rigor
     def coerce_target_ruby(value)
       s = value.to_s
       unless s.match?(TARGET_RUBY_FORMAT)
-        raise ArgumentError,
+        raise ConfigurationError,
               "target_ruby must be a version (e.g. \"3.4\", \"4.0\", \"3.4.0\") or \"latest\", got #{value.inspect}"
       end
 
@@ -924,11 +936,11 @@ module Rigor
     # disabling parallelism.
     def coerce_parallel_workers(value)
       integer = Integer(value)
-      raise ArgumentError, "parallel.workers must be >= 0, got #{value.inspect}" if integer.negative?
+      raise ConfigurationError, "parallel.workers must be >= 0, got #{value.inspect}" if integer.negative?
 
       integer
     rescue TypeError, ArgumentError => e
-      raise ArgumentError, "parallel.workers must be a non-negative Integer, got #{value.inspect} (#{e.message})"
+      raise ConfigurationError, "parallel.workers must be a non-negative Integer, got #{value.inspect} (#{e.message})"
     end
 
     # ADR-22 WD2 (b) — `baseline: <path>` activates the file; `baseline: false` is the explicit-disable form
@@ -955,7 +967,7 @@ module Rigor
     def coerce_network_policy(value)
       sym = value.to_sym
       unless VALID_NETWORK_POLICIES.include?(sym)
-        raise ArgumentError,
+        raise ConfigurationError,
               "plugins_io.network must be one of #{VALID_NETWORK_POLICIES.inspect}, got #{value.inspect}"
       end
 
@@ -967,7 +979,7 @@ module Rigor
     def coerce_severity_profile(value)
       sym = value.to_sym
       unless SeverityProfile::VALID_PROFILES.include?(sym)
-        raise ArgumentError,
+        raise ConfigurationError,
               "severity_profile must be one of " \
               "#{SeverityProfile::VALID_PROFILES.inspect}, got #{value.inspect}"
       end
@@ -980,7 +992,7 @@ module Rigor
     # {SeverityProfile::VALID_SEVERITIES} symbols (`:error` / `:warning` / `:info` / `:off`). Unknown
     # severities raise; unknown rule ids are silently kept (the override is inert until the rule lands).
     def coerce_severity_overrides(value)
-      raise ArgumentError, "severity_overrides must be a Hash, got #{value.inspect}" unless value.is_a?(Hash)
+      raise ConfigurationError, "severity_overrides must be a Hash, got #{value.inspect}" unless value.is_a?(Hash)
 
       value.to_h do |k, v|
         # YAML 1.1 parses bare `off`/`on`/`no`/`yes`/`true`/`false` as booleans, so a user who wrote `off` (a
@@ -988,7 +1000,7 @@ module Rigor
         # `to_sym` blows up with a backtrace.
         unless v.is_a?(String) || v.is_a?(Symbol)
           hint = v == false ? %( — did you mean the string "off"?) : ""
-          raise ArgumentError,
+          raise ConfigurationError,
                 "severity_overrides[#{k.inspect}] is #{v.inspect}, a YAML boolean#{hint} " \
                 "Bare off/on/no/yes/true/false are parsed as booleans; quote the severity " \
                 "(e.g. \"off\")."
@@ -996,7 +1008,7 @@ module Rigor
 
         sym = v.to_sym
         unless SeverityProfile::VALID_SEVERITIES.include?(sym)
-          raise ArgumentError,
+          raise ConfigurationError,
                 "severity_overrides[#{k.inspect}] must be one of " \
                 "#{SeverityProfile::VALID_SEVERITIES.inspect}, got #{v.inspect}"
         end
@@ -1016,7 +1028,7 @@ module Rigor
       when Array then { "mode" => "list", "ids" => freeze_ids(value) }
       when Hash then coerce_bleeding_edge_hash(value)
       else
-        raise ArgumentError,
+        raise ConfigurationError,
               "bleeding_edge must be true, false, a list of feature ids, " \
               "or { all: true, except: [...] }, got #{value.inspect}"
       end.freeze

data/lib/rigor/configuration_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rigor
+  # A mistake in the project's configuration — a value `Configuration` cannot proceed on (the tier-2
+  # failures `docs/internal-spec/config.md` enumerates), or a `.rigor.yml` key the loader accepted whose
+  # meaning only resolves later, like an `effects.snapshot.reach:` preset name.
+  #
+  # It exists so the CLI can tell **the user got the file wrong** apart from **Rigor got itself wrong**.
+  # Both used to reach the terminal as an uncaught `ArgumentError` with a thirty-frame backtrace naming a
+  # file inside `lib/rigor/`, which reads as a crash: the reader's first move is to file a bug, not to
+  # fix the key the message already named (#433). {CLI#run} rescues this class and renders it as a single
+  # `rigor:` line.
+  #
+  # It stays an `ArgumentError` subclass deliberately. `Configuration` raised `ArgumentError` from every
+  # coercion since the beginning, that is the documented tier-2 contract, and callers outside the CLI —
+  # the language server, embedders, the suite — rescue it by that name. Narrowing the class is a
+  # presentation change, not a contract change.
+  class ConfigurationError < ArgumentError
+  end
+end

data/lib/rigor/effects/collector.rb

@@ -128,7 +128,7 @@ module Rigor
         # {Accumulator#record} is what stops it paying for the `Data` and the origin lookup below.
         return if accumulator.recorded?(node)
 
-        dynamic = receiver.is_a?(Type::Dynamic)
+        dynamic = dynamic_receiver?(receiver)
         class_name, kind = descriptor_for(receiver)
         accumulator.record(
           node,
@@ -160,9 +160,46 @@ module Rigor
         when Type::HashShape then ["Hash", :instance]
         when Type::Constant then [receiver.value.class.name, :instance]
         when Type::Dynamic then descriptor_for(receiver.static_facet)
+        when Type::Union then union_descriptor(receiver)
         end
       end
 
+      # Whether the typer's verdict on this receiver leaves its class a guess. A bare `Dynamic` is the
+      # original case; a union carrying a `Dynamic` arm is the same knowledge in a different shape, and
+      # before #455 it was the shape that said nothing — no class, no edge, and no taint, so the summary
+      # read *exhaustive* while an arm of its receiver was admittedly unknown.
+      def dynamic_receiver?(receiver)
+        return true if receiver.is_a?(Type::Dynamic)
+
+        receiver.is_a?(Type::Union) && receiver.members.any?(Type::Dynamic)
+      end
+
+      # A union projects to a class exactly when its non-nil arms all project to the SAME one (#455).
+      #
+      # `T?` is the case that pays, and it is not a corner: ADR-58 contributes a declaration-sourced
+      # `nil` to every instance variable not written in `initialize`, so **every cross-method ivar read
+      # is a union** — `@group.save` reads `Group | nil` where the same `Group.new.save` two lines up
+      # reads `Group`. Without this arm the receiver had no class, so the plugin row never matched, the
+      # edge was dropped, and the site contributed nothing *while the summary still read exhaustive*.
+      # Whether the nil arm means the call happens at all is a question for `possible-nil-receiver`; it
+      # says nothing about what the call does when it does happen, which is the only question here.
+      #
+      # Arms that disagree (`File | StringIO`) still project to nothing. Answering with either one would
+      # state an effect no single execution need perform, and answering with both is a shape the record
+      # has no room for — one call site carries one receiver class.
+      def union_descriptor(receiver)
+        descriptors = receiver.members.reject { |member| nil_member?(member) }.map { |member| descriptor_for(member) }
+        first = descriptors.first
+        return nil if first.nil?
+
+        descriptors.all? { |descriptor| descriptor == first } ? first : nil
+      end
+
+      def nil_member?(member)
+        (member.is_a?(Type::Constant) && member.value.nil?) ||
+          (member.is_a?(Type::Nominal) && member.class_name == "NilClass")
+      end
+
       # Fail-soft (WD13): the scan raising drops this file's summaries and never reaches `rigor check`.
       def build(accumulator)
         return FileCollection.empty(accumulator.path) if accumulator.root.nil?

data/lib/rigor/effects/definition_lines.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "method_key"
+
+module Rigor
+  module Effects
+    # Where a method key's `def` is written, resolved from the file the key was already traced to
+    # (#435).
+    #
+    # A drift row names the file out of `Runner#effect_sources`, which rides the cached summary entry
+    # and is therefore free. The **line** is not in any value the effects surfaces hold: the discovery
+    # tables {EnvelopeCheck::Positions} reads are built by one Prism parse of every project file, which
+    # is exactly what [ADR-104](../../../docs/adr/104-effects-boot-slim-probe.md) removed from this
+    # command — a warm `rigor effects check` is fast *because* it never parses the project.
+    #
+    # So this parses the drift's own files and nothing else: an index is built the first time a row asks
+    # about a path, and a report with no rows builds none. The cost is proportional to the drift, not to
+    # the project — the {EnvelopeCheck::DeferredPositions} shape (#479) applied one layer up, and the
+    # reason it can be one layer up is that the caller already knows the file.
+    #
+    # It is deliberately not a second discovery pass. It answers `def`s and only `def`s: a key whose
+    # method has no Ruby `def` at all — a synthesized accessor — keeps the file and loses the line,
+    # which is the same degradation `Positions` makes when it falls back to the class's own source.
+    class DefinitionLines
+      TOPLEVEL = "<toplevel>"
+      private_constant :TOPLEVEL
+
+      NO_LINES = {}.freeze
+      private_constant :NO_LINES
+
+      # @param key [String] an effect unit key — `Tracer::Loud#emit`, `Net::HTTP.get`.
+      # @param path [String] the file the key was traced to.
+      # @return [Integer, nil] the `def`'s line, or nil when this file does not spell that key with a
+      #   `def` — an unreadable file, a syntax error, and a synthesized method all land here.
+      def for(key:, path:)
+        index_for(path)[key]
+      end
+
+      private
+
+      def index_for(path)
+        @indexes ||= {}
+        @indexes[path] ||= build_index(path)
+      end
+
+      # First `def` wins: a file that reopens the same method twice has two lines and only one of them is
+      # where a reader starts.
+      def build_index(path)
+        result = Prism.parse_file(path.to_s)
+        return NO_LINES unless result.success?
+
+        {}.tap { |index| walk(result.value, [], singleton: false, index: index) }
+      rescue StandardError
+        NO_LINES
+      end
+
+      # The nesting is tracked, never resolved: `class Tracer::Loud` inside `module Tracer` spells a key
+      # this cannot see, and answering it would need the constant resolution an engine-free path does not
+      # have. A key it cannot spell keeps its file, which is what the row printed before this class existed.
+      def walk(node, nesting, singleton:, index:)
+        case node
+        when Prism::ModuleNode, Prism::ClassNode
+          name = constant_name(node.constant_path)
+          return if name.nil?
+
+          walk_children(node.body, nesting + [name], singleton: false, index: index)
+        when Prism::SingletonClassNode
+          walk_children(node.body, nesting, singleton: true, index: index)
+        when Prism::DefNode
+          record(node, nesting, singleton: singleton, index: index)
+          walk_children(node.body, nesting, singleton: singleton, index: index)
+        else
+          walk_children(node, nesting, singleton: singleton, index: index)
+        end
+      end
+
+      def walk_children(node, nesting, singleton:, index:)
+        node&.compact_child_nodes&.each { |child| walk(child, nesting, singleton: singleton, index: index) }
+      end
+
+      def record(node, nesting, singleton:, index:)
+        separator = singleton || node.receiver.is_a?(Prism::SelfNode) ? "." : "#"
+        owner = nesting.empty? ? TOPLEVEL : nesting.join("::")
+        key = "#{owner}#{separator}#{node.name}"
+        index[key] ||= node.location.start_line
+      end
+
+      def constant_name(node)
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode then node.full_name
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/effects/entry_points.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../configuration_error"
+
 module Rigor
   module Effects
     # The named entry-point presets `effects.snapshot.reach:` may adopt (ADR-103 WD14).
@@ -30,9 +32,19 @@ module Rigor
       # than becoming an unfindable key.
       NAME_PATTERN = /\A[a-z0-9][a-z0-9_-]*\z/
 
+      # A plugin's registration is wrong: a malformed preset name, or two plugins claiming one name with
+      # different globs. Nothing the user wrote, so it never reaches them as a configuration error —
+      # {PluginFacts} downgrades it to a warning.
       class Error < StandardError
       end
 
+      # The user's `effects.snapshot.reach:` names a preset no active plugin registered — the most common
+      # of these being chapter 03's `reach: [rails]` without `rigor-railties` in `plugins:` (#433). A
+      # {Rigor::ConfigurationError}, not an {Error}, because the offending text is in `.rigor.yml`: it is
+      # the CLI's to render as a `rigor:` line, not a crash.
+      class UnknownPreset < Rigor::ConfigurationError
+      end
+
       @presets = {}
 
       class << self
@@ -73,7 +85,8 @@ module Rigor
           Array(presets).each { |preset| register(preset.name, preset.globs) }
         end
 
-        # Every registered preset name, sorted. Empty in this slice.
+        # Every registered preset name, sorted. Empty until a plugin declaring `effect_entry_points:`
+        # loads, which is what makes {availability} worth printing.
         def names
           @presets.keys.sort.freeze
         end
@@ -83,6 +96,39 @@ module Rigor
           @presets[name.to_s]
         end
 
+        # The globs `name` stands for, or the configuration error that says what this project could have
+        # written instead.
+        #
+        # The existence check lives here and runs from the snapshot build rather than from
+        # `Configuration` — presets are registered by plugins, and the plugins load FROM the configuration
+        # being validated, so at load time the registry is still empty. See {name?} for the shape check
+        # that does run at load.
+        def resolve!(name)
+          globs_for(name) || raise(
+            UnknownPreset,
+            "effects.snapshot.reach names no registered entry-point preset: #{name.to_s.inspect} " \
+            "(#{availability})"
+          )
+        end
+
+        # What this project may write in `effects.snapshot.reach:`, as one parenthetical clause.
+        #
+        # Single-homed here because the answer is a property of the loaded plugin set rather than of any
+        # one message: the unregistered-preset error (#433) and the note `rigor effects update` prints
+        # when `reach:` is empty (#436) have to give the same answer, and neither can hard-code a list
+        # that moves with `plugins:`.
+        #
+        # @return [String]
+        def availability
+          if @presets.empty?
+            return "no plugin in this project registers an entry-point preset — a preset is named by the " \
+                   "plugin that models the framework, so listing that plugin under `plugins:` is what " \
+                   "registers one"
+          end
+
+          "presets registered in this project: #{names.join(', ')}"
+        end
+
         # Drops every registration. For specs only — production code registers and never unregisters.
         def reset!
           @presets = {}

data/lib/rigor/effects/envelope_check.rb

@@ -83,6 +83,21 @@ module Rigor
         end
       end
 
+      # {Positions} behind a thunk: the discovery tables — one Prism parse of every project file —
+      # are built on the first `.for`, which both judgments reach only once a finding is being
+      # constructed. A clean judgment, the common CI case, therefore forces no discovery and parses
+      # nothing; that is the whole point of this class existing rather than the pass forcing the
+      # tables up front.
+      class DeferredPositions
+        def initialize(&build)
+          @build = build
+        end
+
+        def for(key)
+          (@positions ||= @build.call).for(key)
+        end
+      end
+
       NO_FINDINGS = [].freeze
       private_constant :NO_FINDINGS
 
@@ -93,7 +108,9 @@ module Rigor
       # @param class_envelopes [Hash{String => Envelope}] class- / module-level envelopes, to distribute.
       # @param config_envelopes [Hash{String => Envelope}] `effects.envelopes:` entries already resolved
       #   to the classes they select ({ConfigEnvelopes.for_classes}), to distribute at the lowest precedence.
-      # @param positions [Positions] the discovery tables a finding's `def` position is read from.
+      # @param positions [Positions, DeferredPositions] the discovery tables a finding's `def`
+      #   position is read from — consulted only when a finding is built, so a deferred value's
+      #   discovery force is reached exactly as often as a finding exists.
       # @param apply_tolerated [Boolean] false judges against the undischarged-by-policy `proven` lane —
       #   the `--no-tolerated-effects` audit switch.
       # @return [Array<Finding>] sorted by position then key then label, so a run explains identically twice.

data/lib/rigor/effects/file_collection.rb

@@ -30,7 +30,16 @@ module Rigor
       # receiver, or a construct that is not a call). `kind` is `:instance` for a `Nominal` receiver and
       # `:singleton` for a `Singleton` one. `self_call` marks an implicit-self call, which is the only shape
       # whose failure to resolve is an `unresolved-self-call` taint rather than silence.
-      Edge = Data.define(:receiver_class, :kind, :selector, :self_call)
+      #
+      # `super_call` marks the edge a `super` contributes (#446). It carries the ENCLOSING unit's class and
+      # selector rather than a receiver's, and the propagator resolves it against the ancestry *above* that
+      # class with no closed-world override join — a different question from every other edge, which is why
+      # it is a field rather than a convention over the other three.
+      Edge = Data.define(:receiver_class, :kind, :selector, :self_call, :super_call) do
+        # Defaulted because every producer but the `super` one records an ordinary call, and an ordinary
+        # call is not a `super`.
+        def initialize(super_call: false, **) = super
+      end
 
       NO_TABLE = {}.freeze
       private_constant :NO_TABLE
@@ -144,17 +153,22 @@ module Rigor
       end
 
       # Edge lists are sorted so a marshalled worker collection and a sequential one are `==` and the
-      # report they feed is byte-identical. The key is TOTAL over the de-duplicated list — `self_call` is
-      # in it because two edges can otherwise agree on every other field, and `sort_by` is not stable.
+      # report they feed is byte-identical. The key is TOTAL over the de-duplicated list — `self_call` and
+      # `super_call` are in it because two edges can otherwise agree on every other field (`def emit; super;
+      # emit; end` records both), and `sort_by` is not stable.
       def freeze_edges(table)
         return NO_TABLE if table.empty?
 
         table.transform_values do |list|
           sorted = list.uniq
-          sorted.sort_by! { |edge| [edge.receiver_class.to_s, edge.kind.to_s, edge.selector, edge.self_call ? 1 : 0] }
+          sorted.sort_by! { |edge| edge_order(edge) }
           sorted.freeze
         end.freeze
       end
+
+      def edge_order(edge)
+        [edge.receiver_class.to_s, edge.kind.to_s, edge.selector, edge.self_call ? 1 : 0, edge.super_call ? 1 : 0]
+      end
     end
   end
 end