rigortype 0.3.7 → 0.3.9

data/lib/rigor/sig_gen/generator.rb

@@ -4,9 +4,11 @@ require "prism"
 
 require_relative "../configuration"
 require_relative "../environment"
+require_relative "../project_environment"
 require_relative "../scope"
 require_relative "../reflection"
 require_relative "../type"
+require_relative "../source/constant_path"
 require_relative "../source/literals"
 require_relative "../source/node_children"
 require_relative "../inference/def_return_typer"
@@ -24,28 +26,38 @@ 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
     #   strictly accepts the inferred one (acceptance check under the engine's current `:gradual` mode; ADR-14
     #   reserves the eventual `:strict` mode).
+    # - A declared `void` return is never compared as a value type. It is the author's statement that the
+    #   return is not part of the contract, which no inference can synthesize, so the method classifies
+    #   `equivalent` carrying `void` itself as the declared spelling (#836; see {#declares_void?}).
+    # - A proposal that erases to an RBS literal never tightens an existing declaration: the declared type is
+    #   the author's abstraction over the body and the literal is what it hides (#837; see
+    #   {#pins_literal_over_declaration?}). A method with no declaration is unaffected — clause 1 still emits
+    #   the strictest carrier the body proves.
     class Generator # rubocop:disable Metrics/ClassLength
       # Methods the generator rendered into RBS that `rbs` itself rejects. Populated by {#build_candidate}; each
       # one is a Rigor rendering DEFECT, not a property of the user's code, so the CLI reports them as such.
       UnrenderableMethod = Data.define(:path, :class_name, :method_name, :rbs, :error)
 
-      # @return [Array<UnrenderableMethod>] empty on a healthy run; read after {#run}.
+      # @return empty on a healthy run; read after {#run}.
       attr_reader :unrenderable, :unresolvable_superclasses
 
-      # @param configuration [Rigor::Configuration]
-      # @param paths [Array<String>] files / directories to scan.
-      # @param observations [Hash{[String, Symbol] => Array<Array<Rigor::Type>>}]
+      # @param paths — files / directories to scan.
+      # @param observations — => Array<Array<Rigor::Type>>}]
       #   ADR-14 slice 3 — per-target-method arg-tuple observations
       #   produced by {ObservationCollector}. An empty Hash (the default)
       #   means "no observations available; emit `untyped` for every
@@ -80,10 +92,9 @@ module Rigor
         map.transform_values { |entries| entries.map { |entry| ObservedCall.from(entry) } }
       end
 
-      # @return [Array<MethodCandidate>]
       def run
-        @environment = build_environment
         resolved = resolve_paths(@paths)
+        @environment = build_environment(resolved)
         candidates = resolved.flat_map { |path| analyse_file(path, @environment) }
         demote_overridden_base_methods(
           demote_unresolvable_superclasses(resolve_superclass_spellings(candidates))
@@ -307,11 +318,13 @@ module Rigor
         )
       end
 
-      def build_environment
-        Environment.for_project(
-          libraries: @configuration.libraries,
-          signature_paths: @configuration.signature_paths
-        )
+      # Issue #821 — the SAME type universe `rigor check` analyses against: the project's `sig/`, the plugins,
+      # the bundle's per-gem signatures and the `rbs collection`. Built with two keywords only, the generator
+      # could not see a gem-declared superclass, and the skip guard above (`record_unresolvable_superclass`)
+      # then declined to emit every class descending from one — every Rails model, on a project whose
+      # collection was installed and whose `check` read it.
+      def build_environment(source_files = [])
+        ProjectEnvironment.build(configuration: @configuration, source_files: source_files)
       end
 
       def resolve_paths(args)
@@ -409,14 +422,22 @@ module Rigor
         end
       end
 
+      # [#722](https://github.com/rigortype/rigor/issues/722) residue 3 — the qualified name is built by
+      # `Source::ConstantPath.declaration_prefix`, the same reader the engine's declaration walks use, so a
+      # ROOTED header re-anchors here too. Appending the rendered name to the enclosing prefix wrote
+      # `class ::Foo` inside `module MyApp` out as `MyApp::Foo` — sig-gen's own copy of #708, and the one
+      # copy that persists its answer into a file the user keeps.
+      #
+      # `prefix` stays the nesting the header is WRITTEN in for {#record_superclass}: `::` re-anchors the
+      # declaration, not the superclass expression beside it, which Ruby still evaluates in the enclosing cref.
       def descend_into_namespace?(node, prefix, out)
-        name = qualified_constant_path(node.constant_path)
-        return false unless name
+        child_prefix = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
+        return false unless child_prefix
 
-        full = (prefix + [name]).join("::")
+        full = child_prefix.join("::")
         @namespace_kinds[full] = node.is_a?(Prism::ClassNode) ? :class : :module
         record_superclass(node, full, prefix)
-        walk_namespace_body(node, prefix + [name], out)
+        walk_namespace_body(node, child_prefix, out)
         true
       end
 
@@ -650,8 +671,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
@@ -659,7 +680,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,
@@ -668,57 +689,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)
@@ -746,10 +791,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)
 
@@ -763,20 +804,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
@@ -826,7 +853,14 @@ module Rigor
         )
       end
 
+      # The RBS spelling carried for a `void`-declared method, so `--diff` shows the author's own word rather
+      # than the `top` the translator would erase it to.
+      VOID_RETURN_RBS = "void"
+      private_constant :VOID_RETURN_RBS
+
       def compare_against_declared(path, def_node, class_name, kind, inferred, method_def)
+        return equivalent(path, def_node, class_name, kind, inferred, VOID_RETURN_RBS) if declares_void?(method_def)
+
         declared = build_declared_return(method_def)
         declared_rbs = declared&.erase_to_rbs
         inferred_rbs = inferred.erase_to_rbs
@@ -835,7 +869,7 @@ module Rigor
           return equivalent(path, def_node, class_name, kind, inferred, declared_rbs)
         end
 
-        unless tighter?(declared, inferred) && !computed_literal_tightening?(inferred, def_node)
+        unless tighter?(declared, inferred) && !literal_decline?(inferred, def_node)
           return equivalent(path, def_node, class_name, kind, inferred, declared_rbs)
         end
 
@@ -851,6 +885,28 @@ module Rigor
         )
       end
 
+      # Issue #836 — a declared `void` is return INTENT, never a wide value type waiting to be narrowed, so it
+      # is not compared against the body at all.
+      #
+      # `void` says the return value is not part of the method's contract. No synthesis can produce it: a type
+      # built from a body is always the type of the body's last expression, so `void` exists only on the
+      # CHECKING side, against a declaration the author wrote. That puts it in the same position ADR-107 gives
+      # a parameter type — authored intent inference cannot derive — and proposing the body's value for it is
+      # a category error rather than a false positive to tune.
+      #
+      # Mechanically the misreading came from the translator: `docs/type-specification/special-types.md`
+      # § `void` records that the engine maps RBS `void` to `top`, `Type::Top` accepts everything, so
+      # {#tighter?} answered "yes" for every `void`-declared method whose body happens to return a typed
+      # value. Seven of the fifteen tighter-returns in Rigor's own `sig/` were this shape, and the ADR-107 G3
+      # provenance gate inherited the misclassification with them.
+      #
+      # ANY overload declaring `void` is enough. One proposal is rendered for the whole method, so an overload
+      # set that mixes `void` with a value return still has an author saying "not part of the contract" about
+      # the return sig-gen would rewrite.
+      def declares_void?(method_def)
+        method_def.method_types.any? { |mt| mt.type.return_type.is_a?(RBS::Types::Bases::Void) }
+      end
+
       def build_declared_return(method_def)
         translated = method_def.method_types.filter_map { |mt| translate_method_type_return(mt) }
         return nil if translated.empty?
@@ -933,6 +989,48 @@ module Rigor
         inferred.is_a?(Type::Tuple) || inferred.is_a?(Type::HashShape)
       end
 
+      # The two reasons a `Type::Constant` the body proves is not the method's contract. Both say the same
+      # thing from opposite ends: the precision is real about this body and says nothing about the promise
+      # the method makes to its callers.
+      def literal_decline?(inferred, def_node)
+        computed_literal_tightening?(inferred, def_node) || pins_literal_over_declaration?(inferred)
+      end
+
+      # Issue #837 — a proposal that erases to an RBS LITERAL type never tightens an existing declaration.
+      #
+      # `Type::Top#describe` really does return `"top"`, but `describe` is the surface every `Rigor::Type::*`
+      # class implements and every one of them declares `String`. The declared nominal is the author's
+      # abstraction over the body, and the literal is the implementation detail that abstraction deliberately
+      # hides — the same reading #836 gave a declared `void`. ADR-107 § Decision puts both on the intent
+      # side: no synthesis produces an abstraction, because a type built from a body is always the type of
+      # the body's last expression, so the choice to be wider than the body only ever exists in a declaration
+      # someone wrote.
+      #
+      # The generator already answered this way whenever the declaration happened to be a UNION.
+      # `Configuration.discover` declares `String?` against a body proving `".rigor.dist.yml" |
+      # ".rigor.yml" | nil` and {#loses_declared_union_member?} refuses it, because no literal covers the
+      # declared `String`. Whether the author wrote `String` or `String?` is not a decision about literals,
+      # so the two shapes now answer alike.
+      #
+      # Scoped by the ERASURE, not by the carrier. `Type::Constant` also carries values RBS has no literal
+      # spelling for (`Float`, `Regexp`, `Set`, `Pathname`, `Date`, …) and those erase to the class name, so
+      # `def pi: () -> Numeric` against a body of `3.14` still proposes the ordinary nominal `Float`. A union
+      # is refused when ANY member is a literal: a mixed `("a" | Float)` pins `"a"` just as a bare one does.
+      # A literal nested inside a shape carrier (`[1, 2]`, a `HashShape` value) is a different question,
+      # already answered for the collection declarations that matter by {#narrows_collection_to_shape?}.
+      def pins_literal_over_declaration?(inferred)
+        members = inferred.is_a?(Type::Union) ? inferred.members : [inferred]
+        members.any? { |member| rbs_literal?(member) }
+      end
+
+      # `Type::Constant#erase_to_rbs` spells the values RBS writes as literal types (`true` / `false` /
+      # `nil`, an Integer, a Symbol, a String) as that literal and every other carrier as its value's class
+      # name. Asking which of the two branches it took keeps the list of literal-spellable classes from
+      # forking a second copy into this file.
+      def rbs_literal?(type)
+        type.is_a?(Type::Constant) && type.erase_to_rbs != type.value.class.name
+      end
+
       # Heuristic added after the third-round self-dogfood: `FallbackTracer#size` body is `@events.size`, where
       # `@events` is initialised to `[]` and never assigned again at the class-ivar pre-pass level. The
       # `Type::Tuple[]` (size 0) folds `.size` to `Constant<0>` — the carrier knows the empty-tuple cardinality
@@ -940,6 +1038,11 @@ module Rigor
       # signal is "the body's last expression is NOT a directly-authored literal but the inferred type IS a
       # Constant"; in that case the precision came from inference over an internal computation, not the
       # author's contract, so refuse to tighten.
+      #
+      # Since #837 the literal-ERASING half of this is refused whichever expression produced it. What stays
+      # this guard's own is the `Constant` that erases to a class name: `def average = @total / 2.0` folds to
+      # `Constant<2.5>` and would propose the perfectly ordinary `Float`, which is still the fold's answer
+      # about one body rather than the method's contract.
       def computed_literal_tightening?(inferred, def_node)
         return false unless inferred.is_a?(Type::Constant)
 
@@ -991,8 +1094,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
@@ -1028,30 +1131,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
@@ -1096,9 +1175,9 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_constant_path(node.constant_path)
-          if name
-            walk_attr_calls(node.body, prefix + [name], false, ctx) if node.body
+          child_prefix = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
+          if child_prefix
+            walk_attr_calls(node.body, child_prefix, false, ctx) if node.body
             return
           end
         when Prism::SingletonClassNode
@@ -1180,9 +1259,9 @@ module Rigor
 
         case node
         when Prism::ClassNode, Prism::ModuleNode
-          name = qualified_constant_path(node.constant_path)
-          if name
-            collect_init_ivar_obs(node.body, prefix + [name], result) if node.body
+          child_prefix = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
+          if child_prefix
+            collect_init_ivar_obs(node.body, child_prefix, result) if node.body
             return
           end
         when Prism::DefNode

data/lib/rigor/sig_gen/layout_index.rb

@@ -21,20 +21,19 @@ module Rigor
     # in multiple files for additive member contributions, but the writer only needs one canonical target per
     # class.
     class LayoutIndex
-      # @param signature_paths [Array<String, Pathname>, nil]
+      # @param signature_paths —
       #   the `.rigor.yml`-configured signature directories.
       #   When `nil` or empty, falls back to `<project_root>/sig`
       #   if it exists (matching `Environment.for_project`'s
       #   auto-detection convention).
-      # @param project_root [String, Pathname]
       def initialize(signature_paths:, project_root: Dir.pwd)
         @signature_paths = resolve_paths(signature_paths, project_root)
         @index = nil
       end
 
-      # @param class_name [String] fully-qualified Ruby class
+      # @param class_name — fully-qualified Ruby class
       #   name (e.g. `"Rigor::Type::Top"`).
-      # @return [Pathname, nil] absolute path of the sig file
+      # @return absolute path of the sig file
       #   that already declares this class, or `nil` when no
       #   existing declaration is found.
       def file_for(class_name)

data/lib/rigor/sig_gen/meta_class_shape.rb

@@ -29,11 +29,9 @@ module Rigor
 
       module_function
 
-      # @param kind [:data, :struct]
-      # @param members [Array<Symbol>] ordered member names from the ADR-48 layout.
-      # @param member_types [Hash{Symbol => String}] erased RBS spellings; a member with no entry renders `untyped`.
-      # @param keyword_init [Boolean] the `Struct.new(..., keyword_init: true)` flag; ignored for `:data`.
-      # @return [Shape]
+      # @param members — ordered member names from the ADR-48 layout.
+      # @param member_types — erased RBS spellings; a member with no entry renders `untyped`.
+      # @param keyword_init — the `Struct.new(..., keyword_init: true)` flag; ignored for `:data`.
       def of(kind:, members:, member_types: {}, keyword_init: false)
         types = members.to_h { |member| [member, member_types[member] || "untyped"] }
         accessors = kind == :struct ? struct_accessors(members, types) : readers(members, types)

data/lib/rigor/sig_gen/observation_collector.rb

@@ -3,8 +3,10 @@
 require "prism"
 
 require_relative "../environment"
+require_relative "../project_environment"
 require_relative "../scope"
 require_relative "../type"
+require_relative "../source/constant_path"
 require_relative "../source/literals"
 require_relative "../source/node_children"
 require_relative "../inference/scope_indexer"
@@ -18,7 +20,7 @@ module Rigor
     # for every `Prism::CallNode` whose receiver types as a `Type::Nominal`. The {Generator} consumes the
     # resulting map to render `--params=observed` RBS:
     #
-    # @return [Hash{[class_name, method_name] => Array<Array<Rigor::Type>>}]
+    # @return => Array<Array<Rigor::Type>>}]
     #
     # ADR-5 clause 2 compliance: the observed union is the MOST PERMISSIVE parameter contract the existing
     # callers prove sufficient — by construction it accepts every type any caller has already passed. The
@@ -32,10 +34,9 @@ module Rigor
     #   the collector cannot attribute them to a specific class.
     # - Zero-argument calls give no observation; methods are matched by `(class_name, method_name)` only.
     class ObservationCollector # rubocop:disable Metrics/ClassLength
-      # @param configuration [Rigor::Configuration]
-      # @param paths [Array<String>] observe paths (files /
+      # @param paths — observe paths (files /
       #   directories).
-      # @param source_paths [Array<String>] source-tree paths
+      # @param source_paths — source-tree paths
       #   (defaults to `configuration.paths`) pre-walked to
       #   register every project-defined class so that calls
       #   like `Foo.new.bar(x)` in the observe tree resolve
@@ -51,10 +52,11 @@ module Rigor
       def collect
         return {} if @paths.empty?
 
-        environment = build_environment
+        resolved = resolve_paths(@paths)
+        environment = build_environment(resolved)
         discovered_classes = preindex_source_classes
         observations = Hash.new { |h, k| h[k] = [] }
-        resolve_paths(@paths).each do |path|
+        resolved.each do |path|
           collect_from_file(path, environment, discovered_classes, observations)
         end
         observations.transform_values(&:freeze).freeze
@@ -62,11 +64,11 @@ module Rigor
 
       private
 
-      def build_environment
-        Environment.for_project(
-          libraries: @configuration.libraries,
-          signature_paths: @configuration.signature_paths
-        )
+      # Issue #821 — same universe as the generator and as `rigor check`; see
+      # {Generator#build_environment}. An observation collected against a narrower environment types its
+      # argument differently from the run that will consume it.
+      def build_environment(source_files = [])
+        ProjectEnvironment.build(configuration: @configuration, source_files: source_files)
       end
 
       def resolve_paths(args)
@@ -118,11 +120,11 @@ module Rigor
         return unless node.is_a?(Prism::Node)
 
         if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
-          name = qualified_constant_path(node.constant_path)
-          if name
-            full = (prefix + [name]).join("::")
+          child_prefix = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
+          if child_prefix
+            full = child_prefix.join("::")
             accumulator[full] = Type::Combinator.singleton_of(full)
-            walk_class_decls(node.body, prefix + [name], accumulator) if node.body
+            walk_class_decls(node.body, child_prefix, accumulator) if node.body
             return
           end
         end

data/lib/rigor/sig_gen/path_mapper.rb

@@ -21,9 +21,8 @@ module Rigor
     # When the source path is not under any configured source root (e.g. files supplied directly on the CLI
     # from outside `lib/`), the full relative path is preserved under the sig root.
     class PathMapper
-      # @param configuration [Rigor::Configuration]
-      # @param project_root [String, Pathname] (defaults to `Dir.pwd`)
-      # @param layout_index [LayoutIndex, nil] optional class
+      # @param project_root — (defaults to `Dir.pwd`)
+      # @param layout_index — optional class
       #   → existing sig file index; routes the target to the
       #   consolidated file when the class is already declared.
       def initialize(configuration:, project_root: Dir.pwd, layout_index: nil)
@@ -32,12 +31,11 @@ module Rigor
         @layout_index = layout_index
       end
 
-      # @param source_path [String]
-      # @param class_name [String, nil] fully-qualified Ruby
+      # @param class_name — fully-qualified Ruby
       #   class name. When supplied and matched by the
       #   `LayoutIndex`, the consolidated sig file's path is
       #   returned instead of the 1:1 mirror.
-      # @return [Pathname] absolute path of the target `.rbs`
+      # @return absolute path of the target `.rbs`
       #   file for the candidate.
       def target_for(source_path, class_name: nil)
         existing = existing_target_for(class_name)

data/lib/rigor/sig_gen/rbs_validity.rb

@@ -23,16 +23,16 @@ module Rigor
 
       module_function
 
-      # @param line [String] a rendered RBS method line, e.g. `def self.parse: (String) -> Integer`.
-      # @return [String, nil] the parse error's first line, or nil when the line is valid.
+      # @param line — a rendered RBS method line, e.g. `def self.parse: (String) -> Integer`.
+      # @return the parse error's first line, or nil when the line is valid.
       def method_line_error(line)
         return nil if line.nil?
 
         source_error("class #{PROBE_CLASS}\n  #{line}\nend\n")
       end
 
-      # @param source [String] a complete `.rbs` file's text.
-      # @return [String, nil] the parse error's first line, or nil when the file is valid.
+      # @param source — a complete `.rbs` file's text.
+      # @return the parse error's first line, or nil when the file is valid.
       def source_error(source)
         ::RBS::Parser.parse_signature(::RBS::Buffer.new(name: "(rigor sig-gen)", content: source))
         nil