rigortype 0.3.6 → 0.3.8

data/lib/rigor/sig_gen/generator.rb

@@ -24,12 +24,16 @@ module Rigor
     # body's last expression to derive an inferred return, looks up the project's existing RBS declaration (if
     # any), and emits one {MethodCandidate} per def.
     #
-    # The MVP keeps the scope deliberately narrow:
-    # - Only instance methods inside a `class` / `module` body are considered. Top-level / DSL-block / singleton
-    #   defs are skipped (`sig.skipped.complex-shape`).
-    # - Parameter signatures are hard-coded to `untyped` per ADR-14 § "Robustness principle compliance" clause 2;
-    #   `--params=observed` arrives in slice 3.
-    # - Optional / rest / keyword / block params disqualify the def (`sig.skipped.complex-shape`).
+    # The scope, as it stands after the slices that widened the MVP:
+    # - Instance and singleton methods inside a nameable `class` / `module` body are considered. Top-level /
+    #   DSL-block defs have no nameable receiver and are not candidates.
+    # - Parameter types are `untyped` per ADR-14 § "Robustness principle compliance" clause 2 unless
+    #   `--params=observed` supplies call-site observations; the parameter LIST always mirrors the def's runtime
+    #   shape (required / optional / rest / trailing / keyword / keyword-rest / forwarding / block). Issue #778
+    #   retired the slice-1 gate that skipped every shape beyond required positionals as
+    #   `sig.skipped.complex-shape`: the body typer binds every parameter to `untyped` when no RBS declares the
+    #   method, so the inferred return is the same clause-1 answer for every shape, and the renderer the
+    #   `initialize` stub already used spells them all.
     # - A `Dynamic[top]` inferred return becomes `sig.skipped.untyped-return` — emitting `untyped` would obscure
     #   rather than help.
     # - Tighter-return detection compares the RBS-erased spellings only when the existing declared return
@@ -41,7 +45,7 @@ module Rigor
       UnrenderableMethod = Data.define(:path, :class_name, :method_name, :rbs, :error)
 
       # @return [Array<UnrenderableMethod>] empty on a healthy run; read after {#run}.
-      attr_reader :unrenderable
+      attr_reader :unrenderable, :unresolvable_superclasses
 
       # @param configuration [Rigor::Configuration]
       # @param paths [Array<String>] files / directories to scan.
@@ -65,6 +69,10 @@ module Rigor
         @meta_layouts = {}
         # Whole-run, NOT per-file: a rendering defect is reported once at the end of the run.
         @unrenderable = []
+        # Issue #735 — whole-run too: `{ class name => the superclass token that resolves nowhere }`.
+        @unresolvable_superclasses = {}
+        # Issue #722 — whole-run: `{ class name => the lexical nesting its header is written in }`.
+        @superclass_nestings = {}
       end
 
       # Lifts legacy plain-`Array[Type]` observation entries into {ObservedCall} carriers. Specs from the
@@ -80,11 +88,229 @@ module Rigor
       def run
         @environment = build_environment
         resolved = resolve_paths(@paths)
-        resolved.flat_map { |path| analyse_file(path, @environment) }
+        candidates = resolved.flat_map { |path| analyse_file(path, @environment) }
+        demote_overridden_base_methods(
+          demote_unresolvable_superclasses(resolve_superclass_spellings(candidates))
+        )
       end
 
       private
 
+      # Issue #744 — a base class's method is NOT emitted when a project subclass overrides it and the
+      # override is not emitted itself.
+      #
+      # RBS resolves an undeclared subclass method through its ancestors, so a precise return written for
+      # the base becomes the subclass's answer. redmine's `FieldFormat::Base#target_class` honestly returns
+      # `nil`; `RecordList#target_class` overrides it with a real lookup that sig-gen could not type, and
+      # the emitted `def target_class: () -> nil` then produced four `undefined method … for nil` on the
+      # subclass's own working code, plus a `def.return-type-mismatch` telling the user their correct
+      # override was wrong.
+      #
+      # Emitting nothing puts both classes back on source inference, which answers correctly for each. The
+      # base keeps its signature whenever nothing overrides the method, and whenever the override IS
+      # emitted with a type of its own — the declaration is only dangerous when it is the only one.
+      #
+      # Whether an inherited declaration SHOULD outrank a class's own source `def` is a separate question
+      # (#744 half 2) and is not decided here: this pass only stops sig-gen manufacturing the conflict.
+      def demote_overridden_base_methods(candidates)
+        superclasses = candidates.each_with_object({}) do |candidate, acc|
+          (candidate.class_superclasses || {}).each { |name, sup| acc[name] = sup.sub(/\[.*\]\z/, "") }
+        end
+        return candidates if superclasses.empty?
+
+        overridden = unsigned_override_ancestors(candidates, superclasses)
+        return candidates if overridden.empty?
+
+        candidates.map do |candidate|
+          next candidate unless Classification::EMITTABLE.include?(candidate.classification)
+          next candidate unless overridden.include?([candidate.class_name, candidate.method_name])
+
+          demoted_candidate(candidate, :overridden_by_unsigned_subclass)
+        end
+      end
+
+      # `[class name, method name]` pairs an UNSIGNED override shadows: for every candidate that will not
+      # be emitted, every ancestor of its class paired with its method name.
+      def unsigned_override_ancestors(candidates, superclasses)
+        candidates.each_with_object(Set.new) do |candidate, acc|
+          next if Classification::EMITTABLE.include?(candidate.classification)
+          next if candidate.class_name.nil?
+
+          each_ancestor(candidate.class_name, superclasses) { |name| acc << [name, candidate.method_name] }
+        end
+      end
+
+      def each_ancestor(class_name, superclasses)
+        seen = {}
+        current = class_name
+        while (parent = superclasses[current]) && !seen[parent]
+          seen[parent] = true
+          yield parent
+          current = parent
+        end
+      end
+
+      def demoted_candidate(candidate, reason)
+        MethodCandidate.new(
+          path: candidate.path, class_name: candidate.class_name, method_name: candidate.method_name,
+          kind: candidate.kind, classification: Classification::SKIPPED, skip_reason: reason,
+          inferred_return: candidate.inferred_return, declared_return_rbs: candidate.declared_return_rbs,
+          namespace_kinds: candidate.namespace_kinds, class_shells: candidate.class_shells,
+          class_superclasses: candidate.class_superclasses
+        )
+      end
+
+      # Issue #722 — resolves each recorded superclass token to the class Ruby means by it, and rewrites the
+      # emitted spelling when the two differ.
+      #
+      # `record_superclass` kept the source token verbatim on the reasoning that "RBS resolves it relative to
+      # the emitted namespace, matching Ruby's lexical scope". That holds only while the emitted namespace
+      # equals the source nesting, and sig-gen FLATTENS: `module Admin; class Record2 < Record` is written
+      # out as the compact `class Admin::Record2 < Record`, and RBS resolves a compact header's superclass at
+      # the TOP level (verified against the rbs gem), so the emitted token silently re-points at `::Record`
+      # where the program means `Admin::Record`. The checker resolves the same declaration correctly, so the
+      # generated sidecar contradicted the analyzer that wrote it.
+      #
+      # Candidate order is Ruby's own for the superclass expression: the header's nesting innermost-first,
+      # then the bare name — the reading `Scope#ancestor_name_candidates` owns for the analyzer's class
+      # graph. The question here is about the EMITTED tree, so the "is this a class" test is this run's
+      # declarations plus the RBS environment rather than the discovery tables; keep the two orders in step.
+      def resolve_superclass_spellings(candidates)
+        return candidates if @superclass_nestings.empty?
+
+        known = candidates.each_with_object(Set.new) do |candidate, acc|
+          acc << candidate.class_name if candidate.class_name
+          acc.merge(candidate.class_shells || [])
+        end
+        rewrites = superclass_rewrites(known)
+        return candidates if rewrites.empty?
+
+        candidates.map do |candidate|
+          overlap = rewrites.slice(*candidate.class_superclasses.keys)
+          next candidate if overlap.empty?
+
+          rebuild_with_superclasses(candidate, candidate.class_superclasses.merge(overlap))
+        end
+      end
+
+      def superclass_rewrites(known)
+        @superclass_nestings.each_with_object({}) do |(full, (nesting, token)), acc|
+          next if token.nil? || nesting.empty?
+
+          resolved = resolve_superclass_token(token, nesting, known)
+          acc[full] = resolved if resolved && resolved != token
+        end
+      end
+
+      # The first candidate spelling that names a class this run declares or the RBS environment knows, or
+      # nil when none does — an unresolvable superclass is #735's business, not this pass's.
+      def resolve_superclass_token(token, nesting, known)
+        base = token.sub(/\[.*\]\z/, "")
+        args = token[base.length..] || ""
+        nesting.length.downto(1) do |i|
+          candidate = "#{nesting[0, i].join('::')}::#{base}"
+          return "#{candidate}#{args}" if known.include?(candidate) ||
+                                          Reflection.rbs_class_known?(candidate, environment: @environment)
+        end
+        token
+      end
+
+      def rebuild_with_superclasses(candidate, superclasses)
+        MethodCandidate.new(
+          path: candidate.path, class_name: candidate.class_name, method_name: candidate.method_name,
+          kind: candidate.kind, classification: candidate.classification,
+          inferred_return: candidate.inferred_return, declared_return_rbs: candidate.declared_return_rbs,
+          rbs: candidate.rbs, skip_reason: candidate.skip_reason,
+          namespace_kinds: candidate.namespace_kinds, class_shells: candidate.class_shells,
+          class_superclasses: superclasses
+        )
+      end
+
+      # Issue #735 — a generated declaration whose superclass chain does not terminate in a class the RBS
+      # environment knows is DROPPED rather than emitted.
+      #
+      # `record_superclass` is right that a subclass declaration must carry its superclass: without it the
+      # sidecar misrepresents the class and dispatch degrades. But emitting one the environment cannot
+      # resolve is worse than either — `RBS::NoSuperclassFoundError` collapses the class, so every call into
+      # it reads `Dynamic[top]` and the whole declaration is a liability. On redmine, `class Principal <
+      # ApplicationRecord` (nothing declares `ApplicationRecord`, and nothing could: the chain ends at
+      # `ActiveRecord::Base`, which no RBS in the environment carries) collapsed 98 classes on the very next
+      # run. A chain that LOOPS is dropped for the same reason, and is the shape that made an
+      # `AncestorBuilder` walk recurse until `SystemStackError` (#609).
+      #
+      # Dropping is the conservative end: no declaration leaves the class exactly as it was before sig-gen
+      # ran — source discovery and the plugins still type it. Emitting the class with the superclass merely
+      # OMITTED would be the harmful middle: the class becomes RBS-known with only the emitted methods, so
+      # every inherited call fires `call.undefined-method`.
+      def demote_unresolvable_superclasses(candidates)
+        superclasses = candidates.each_with_object({}) do |candidate, acc|
+          (candidate.class_superclasses || {}).each { |name, sup| acc[name] = sup }
+        end
+        # Everything this run declares, superclass or not: a chain that reaches `class Record` — emitted
+        # here, with no superclass of its own — terminates in a class the next run WILL know.
+        emitted = candidates.each_with_object(Set.new) do |candidate, acc|
+          acc << candidate.class_name if candidate.class_name
+          acc.merge(candidate.class_shells || [])
+        end
+        unresolvable = superclasses.each_with_object({}) do |(name, _sup), acc|
+          root = unresolved_superclass_root(name, superclasses, emitted)
+          acc[name] = root if root
+        end
+        return candidates if unresolvable.empty?
+
+        candidates.map do |candidate|
+          owner = unresolvable_for(candidate.class_name, unresolvable)
+          next candidate if owner.nil?
+
+          record_unresolvable_superclass(candidate, owner)
+        end
+      end
+
+      # A nested class or module goes with its wrapper. `WikiPage::Webhookable`'s declaration is emitted
+      # INSIDE `class WikiPage < ApplicationRecord`, so keeping the inner one while dropping the outer emits
+      # the unresolvable header anyway — the wrapper is not a candidate of its own and carries no methods,
+      # so nothing else would have demoted it.
+      def unresolvable_for(class_name, unresolvable)
+        return nil if class_name.nil?
+        return [class_name, unresolvable[class_name]] if unresolvable.key?(class_name)
+
+        unresolvable.each do |name, root|
+          return [name, root] if class_name.start_with?("#{name}::")
+        end
+        nil
+      end
+
+      # The first superclass token on `name`'s recorded chain that neither the RBS environment knows nor this
+      # run emits, or nil when the chain terminates in a known class. A chain that revisits a class returns
+      # that class's own superclass token — a cycle resolves nowhere.
+      def unresolved_superclass_root(name, superclasses, emitted, seen = {})
+        superclass = superclasses[name]
+        return nil if superclass.nil?
+        return superclass if seen[name]
+
+        seen[name] = true
+        # The recorded spelling may carry the type arguments {#generic_superclass_spelling} added; the
+        # resolvability question is about the class, so it is asked of the bare name.
+        base = superclass.sub(/\[.*\]\z/, "")
+        return nil if Reflection.rbs_class_known?(base, environment: @environment)
+        return superclass unless emitted.include?(base)
+
+        unresolved_superclass_root(base, superclasses, emitted, seen)
+      end
+
+      def record_unresolvable_superclass(candidate, owner)
+        class_name, root = owner
+        @unresolvable_superclasses[class_name] ||= root
+        MethodCandidate.new(
+          path: candidate.path, class_name: candidate.class_name, method_name: candidate.method_name,
+          kind: candidate.kind, classification: Classification::SKIPPED,
+          skip_reason: :unresolvable_superclass, inferred_return: candidate.inferred_return,
+          declared_return_rbs: candidate.declared_return_rbs,
+          namespace_kinds: candidate.namespace_kinds, class_shells: candidate.class_shells,
+          class_superclasses: candidate.class_superclasses
+        )
+      end
+
       def build_environment
         Environment.for_project(
           libraries: @configuration.libraries,
@@ -193,7 +419,7 @@ module Rigor
 
         full = (prefix + [name]).join("::")
         @namespace_kinds[full] = node.is_a?(Prism::ClassNode) ? :class : :module
-        record_superclass(node, full)
+        record_superclass(node, full, prefix)
         walk_namespace_body(node, prefix + [name], out)
         true
       end
@@ -207,11 +433,38 @@ module Rigor
       # superclass (`Class.new`, any other `CallNode`) is left unrecorded — a `Data.define` / `Struct.new` one is
       # already carried by {#register_meta_classes}, and the rest are un-representable, where guessing would
       # misfold.
-      def record_superclass(node, full)
+      def record_superclass(node, full, prefix)
         return unless node.is_a?(Prism::ClassNode)
 
         superclass = qualified_constant_path(node.superclass)
-        @class_superclasses[full] = superclass if superclass
+        return if superclass.nil?
+
+        # Issue #722 — the nesting the header is WRITTEN in, kept whole-run (not per-file scratch) because
+        # the name it resolves to may be a class another file declares. Resolved once every file has been
+        # walked, in {#resolve_superclass_spellings}.
+        spelling = generic_superclass_spelling(superclass)
+        # The token rides along because `@class_superclasses` is per-FILE scratch, reset before the next
+        # file, while this table is whole-run.
+        @superclass_nestings[full] = [prefix.dup, spelling]
+        @class_superclasses[full] = spelling
+      end
+
+      # Issue #735 — a GENERIC superclass has to be written with its arguments. `class Entries < Array`
+      # yields `RBS::InvalidTypeApplicationError: ::Array expects parameters [unchecked out E], but given
+      # args []`, which fails the build for that class exactly as an unresolvable superclass does — redmine
+      # subclasses `Array` five times. The element type is not something this pass can infer, so it is
+      # `untyped`: the subclass's OWN methods are what sig-gen is here to record, and `Array[untyped]` keeps
+      # the inherited surface resolving instead of collapsing the class.
+      def generic_superclass_spelling(superclass)
+        loader = @environment&.rbs_loader
+        return superclass if loader.nil?
+
+        arity = loader.class_type_param_names(superclass).size
+        return superclass if arity.zero?
+
+        "#{superclass}[#{(['untyped'] * arity).join(', ')}]"
+      rescue StandardError
+        superclass
       end
 
       # The ADR-48 member layouts for this file, in one table keyed by qualified class name. Reading the engine's
@@ -401,8 +654,8 @@ module Rigor
       end
 
       # Emits `def initialize: (<shape>) -> void`. The return is always `void` because Ruby's `initialize`
-      # return value is never meaningful. The parameter list mirrors the runtime shape (required / optional /
-      # rest / keyword / keyword-rest / block).
+      # return value is never meaningful. The parameter list mirrors the runtime shape through the same
+      # {#render_param_list} every other def renders with.
       #
       # When `--params=observed` populates `@observations` for `[class_name, :initialize]` (via the
       # `ObservationCollector`'s `.new` → `:initialize` routing), positional and keyword arg types come from the
@@ -410,7 +663,7 @@ module Rigor
       # clause 2.
       def initialize_stub_candidate(path, def_node, class_name)
         params = def_node.parameters
-        rbs = "def initialize: (#{render_initialize_param_list(params, class_name)})" \
+        rbs = "def initialize: (#{render_param_list(params, class_name, :initialize)})" \
               "#{block_signature_suffix(params)} -> void"
         build_candidate(
           path: path, class_name: class_name, method_name: :initialize,
@@ -419,57 +672,81 @@ module Rigor
         )
       end
 
-      def render_initialize_param_list(params, class_name)
+      # The RBS parameter list of a def, mirroring its runtime shape position by position: `untyped` per
+      # required positional, `?untyped` per optional, `*untyped` for a rest, one `untyped` per trailing
+      # positional after the rest, `name: untyped` / `?name: untyped` per keyword, `**untyped` for a keyword
+      # rest, and `*untyped, **untyped` for `...` forwarding (its block half is {#block_signature_suffix}'s).
+      # `**nil` declares that no keywords are accepted, which RBS cannot spell, so it renders nothing.
+      #
+      # Per ADR-5 clause 2 every position is `untyped` unless `--params=observed` supplied call-site
+      # observations, in which case each leading positional and each keyword carries the union of the types the
+      # arity-compatible observations passed there ({#arity_matched_observations}). The rest, the trailing
+      # positionals and the keyword rest stay `untyped`: an observation does not say which of its arguments the
+      # splat absorbed. Before #778 only `initialize` rendered through this path and every other def with a
+      # shape beyond required positionals was skipped as `sig.skipped.complex-shape`.
+      def render_param_list(params, class_name, method_name)
         return "" unless params.is_a?(Prism::ParametersNode)
 
-        observations = initialize_observations(class_name, params)
-        offset = 0
+        observations = arity_matched_observations(class_name, method_name, params)
         parts = []
-
-        params.requireds.each_with_index do |_, i|
-          parts << initialize_positional_type(observations, offset + i, "")
-        end
-        offset += params.requireds.size
-
-        params.optionals.each_with_index do |_, i|
-          parts << initialize_positional_type(observations, offset + i, "?")
-        end
-
+        params.requireds.each_index { |i| parts << positional_type(observations, i, "") }
+        offset = params.requireds.size
+        params.optionals.each_index { |i| parts << positional_type(observations, offset + i, "?") }
         parts << "*untyped" if params.rest
+        parts.concat(Array.new(params.posts.size, "untyped"))
         params.keywords.each { |kw| parts << render_keyword_param(kw, observations) }
-        parts << "**untyped" if params.keyword_rest
+        parts.concat(keyword_rest_parts(params))
         parts.join(", ")
       end
 
+      def keyword_rest_parts(params)
+        case params.keyword_rest
+        when Prism::ForwardingParameterNode
+          # `...` forwards positionals as well as keywords; a rest already rendered covers the former.
+          params.rest ? ["**untyped"] : ["*untyped", "**untyped"]
+        when Prism::KeywordRestParameterNode then ["**untyped"]
+        else []
+        end
+      end
+
       # The RBS block suffix for a `def` that takes a `&block` parameter, e.g. ` ?{ (*untyped) -> untyped }`.
       # A block belongs AFTER the parameter parens in RBS (`(params) ?{ block } -> ret`), not inside them —
       # emitting it as a comma-joined member produced `(**untyped, ?{ (?) -> void })`, which RBS rejects
       # (`optional keyword argument type is expected`) and which then collapsed the whole env build. sig-gen
       # never observes the block's own signature, so it is rendered maximally lenient (ADR-5): an optional
-      # block (`?{`, since a `&block` need not be passed) taking `*untyped` and returning `untyped`. Returns
-      # "" when the method takes no block.
+      # block (`?{`, since a `&block` need not be passed) taking `*untyped` and returning `untyped`. `...`
+      # forwards a block too and gets the same suffix. Returns "" when the method takes no block.
       def block_signature_suffix(params)
         return "" unless params.is_a?(Prism::ParametersNode)
-        return "" if params.block.nil?
+        return "" unless params.block || params.keyword_rest.is_a?(Prism::ForwardingParameterNode)
 
         " ?{ (*untyped) -> untyped }"
       end
 
-      # Picks observations under `[class_name, :initialize]` whose positional arity matches the def's accepted
-      # range (required..required+optional). Looser arities don't get used because they describe a different
-      # overload the stub cannot express.
-      def initialize_observations(class_name, params)
+      # Observations under `[class_name, method_name]` whose positional arity the def accepts: at least its
+      # required count (leading plus trailing), and, unless a rest or `...` absorbs the surplus, at most
+      # required plus optional. An arity outside that window describes a different overload the signature
+      # cannot express, so it says nothing about these positions. #778 widened the window for ordinary defs
+      # from the exact required count — `def optional(text = "x")` called as `optional` AND as `optional("y")`
+      # now credits both call sites.
+      def arity_matched_observations(class_name, method_name, params)
         return [] if @observations.empty?
 
-        list = @observations[[class_name, :initialize]] || []
-        min = params.requireds.size
-        max = min + params.optionals.size
-        list.select { |obs| (min..max).cover?(obs.positional.size) }
+        list = @observations[[class_name, method_name]] || []
+        min = params.requireds.size + params.posts.size
+        max = unbounded_positionals?(params) ? Float::INFINITY : min + params.optionals.size
+        list.select { |obs| obs.positional.size.between?(min, max) }
+      end
+
+      def unbounded_positionals?(params)
+        !params.rest.nil? || params.keyword_rest.is_a?(Prism::ForwardingParameterNode)
       end
 
-      def initialize_positional_type(observations, index, prefix)
+      # A bare union is a valid positional type in RBS (`(String | Integer, ?String | Integer)`), so unlike the
+      # return position it is not parenthesised.
+      def positional_type(observations, index, prefix)
         types = observations.filter_map { |obs| obs.positional[index] }
-        "#{prefix}#{types.empty? ? 'untyped' : paren_wrap_union(union_erase(types))}"
+        "#{prefix}#{union_erase(types)}"
       end
 
       def render_keyword_param(keyword, observations)
@@ -497,10 +774,6 @@ module Rigor
         return nil if initialize_excludes?(def_node, kind)
         return initialize_stub_candidate(path, def_node, class_name) if non_trivial_initialize?(def_node, kind)
 
-        unless simple_parameter_shape?(def_node.parameters)
-          return skipped(path, def_node, class_name, kind, :complex_shape)
-        end
-
         inferred = infer_return_type(def_node, scope_index)
         return skipped(path, def_node, class_name, kind, :untyped_return) if inferred.nil? || dynamic_top?(inferred)
 
@@ -514,20 +787,6 @@ module Rigor
         end
       end
 
-      # Required positionals only; the MVP's body-typing path gives well-defined returns for that shape.
-      # Optional / rest / keyword / block parameters route through the `sig.skipped.complex-shape` reason until
-      # slices 3+ widen the param policy.
-      def simple_parameter_shape?(params)
-        return true if params.nil?
-        return false unless params.is_a?(Prism::ParametersNode)
-
-        params.optionals.empty? &&
-          params.rest.nil? &&
-          params.keywords.empty? &&
-          params.keyword_rest.nil? &&
-          params.block.nil?
-      end
-
       # Mirrors the `def.return-type-mismatch` rule's body-type extraction: type the implicit-return expression
       # under the scope the indexer associated with the body. The parameter bindings (typed `untyped` per the
       # indexer's default) come from `with_local` inside `StatementEvaluator`; the result is the carrier the
@@ -742,8 +1001,8 @@ module Rigor
       end
 
       def render_rbs_line(def_node, inferred, class_name, kind)
-        arity = required_arity(def_node)
-        head = arity.zero? ? "()" : "(#{render_param_list(class_name, def_node.name, arity)})"
+        params = def_node.parameters
+        head = "(#{render_param_list(params, class_name, def_node.name)})#{block_signature_suffix(params)}"
         prefix = method_def_prefix(class_name, def_node.name, kind)
         "#{prefix}#{def_node.name}: #{head} -> #{paren_wrap_union(elaborated_rbs(inferred))}"
       end
@@ -779,30 +1038,6 @@ module Rigor
         false
       end
 
-      def required_arity(def_node)
-        params = def_node.parameters
-        params.is_a?(Prism::ParametersNode) ? params.requireds.size : 0
-      end
-
-      # Per ADR-5 clause 2 the default is `untyped` for every position. Observed-policy callers
-      # (`--params=observed`) pass an `observations:` map at construction time; the generator unions
-      # per-position arg types whose tuple arity matches the def's required-positional count. Observations from
-      # arities other than the def's count are discarded — they describe a different overload the MVP does not
-      # emit.
-      def render_param_list(class_name, method_name, arity)
-        tuples = matching_observations(class_name, method_name, arity)
-        return Array.new(arity, "untyped").join(", ") if tuples.empty?
-
-        Array.new(arity) { |i| union_erase(tuples.map { |obs| obs.positional[i] }) }.join(", ")
-      end
-
-      def matching_observations(class_name, method_name, arity)
-        return [] if @observations.empty?
-
-        list = @observations[[class_name, method_name]] || []
-        list.select { |obs| obs.positional.size == arity }
-      end
-
       def union_erase(types)
         return "untyped" if types.empty?
         return elaborated_rbs(types.first) if types.size == 1

data/lib/rigor/sig_gen/renderer.rb

@@ -14,7 +14,8 @@ module Rigor
     # - `:diff` — a unified-style diff comparing the existing RBS spelling (if any) against the inferred
     #   spelling. The MVP renders a minimal "- declared / + inferred" block; full per-file diffing arrives with
     #   slice 2's `--write` merge.
-    # - `:json` — machine-readable payload with the same classification table as `:print`.
+    # - `:json` — machine-readable payload with the same classification table as `:print`, plus every `skipped`
+    #   row with its `skip_reason` (#778).
     class Renderer
       def initialize(out:)
         @out = out
@@ -27,11 +28,10 @@ module Rigor
       #   {Classification} constants to include; an empty
       #   array means "all emittable classifications".
       def render(candidates:, mode:, format:, selection:)
-        filtered = filter(candidates, selection)
-
         case format
-        when "json" then render_json(filtered)
+        when "json" then render_json(filter(candidates, selection, with_skipped: true))
         when "text"
+          filtered = filter(candidates, selection)
           mode == :diff ? render_diff(filtered) : render_print(filtered)
         else
           raise ArgumentError, "unsupported format: #{format}"
@@ -40,14 +40,16 @@ module Rigor
 
       private
 
-      EMITTABLE = [Classification::NEW_FILE,
-                   Classification::NEW_METHOD,
-                   Classification::TIGHTER_RETURN].freeze
-      private_constant :EMITTABLE
-
-      def filter(candidates, selection)
-        active = selection.empty? ? EMITTABLE : selection
-        candidates.select { |c| active.include?(c.classification) }
+      # The emittable rows the selection asks for. JSON also carries every `skipped` row whatever the selection:
+      # ADR-14 makes the JSON payload the surface where `sig.skipped.*` is reported, and a consumer asking why a
+      # method is missing from its `sig/` needs the reason next to the rows that did emit (#778 — the rows were
+      # built with their `skip_reason` and then dropped here). `equivalent` rows stay out: nothing to do,
+      # nothing to explain.
+      def filter(candidates, selection, with_skipped: false)
+        active = selection.empty? ? Classification::EMITTABLE : selection
+        candidates.select do |c|
+          active.include?(c.classification) || (with_skipped && c.classification == Classification::SKIPPED)
+        end
       end
 
       def render_print(candidates)

data/lib/rigor/sig_gen/writer.rb

@@ -90,6 +90,9 @@ module Rigor
         target.exist? ? update_existing(source_path, target, candidates) : create_new(source_path, target, candidates)
       end
 
+      # Deliberately NARROWER than {Classification::EMITTABLE}: the write path has never produced a
+      # `:new_file` row (the generator does not classify one), and admitting it here would let a
+      # classification with no writer behind it decide that a target file must be created.
       EMITTABLE = [Classification::NEW_METHOD, Classification::TIGHTER_RETURN].freeze
       private_constant :EMITTABLE