rigortype 0.4.4 → 0.4.5

data/lib/rigor/scope/resolution_chain.rb

@@ -300,17 +300,24 @@ module Rigor
       # `Kernel` or `Enumerable` on any reopening. So each candidate name files the negative method edge of every
       # {Relevance::HOOKS} name on its singleton side (`method:Comparable.included`, the key a new `def
       # self.included` satisfies); a file adding any other method to the module re-checks nothing, and once the
-      # module is declared its sites carry later edits and the removal. The edges are a function of the chain alone,
-      # so a consumer files them once per chain ({Analysis::DependencyRecorder.file_chain_once}, #1590). A hook
-      # written another way — an instance `def included` in a module extended onto the external, a
-      # `define_singleton_method(:included)` — satisfies no such key and is not seen.
+      # module is declared its sites carry later edits and the removal. #1661 — each name also files `mixin:<name>`,
+      # which `IncrementalSession#mark_affected` fires when the module's unpositioned mixin edges move: a new file
+      # that taints it (`module Comparable; include(*MODS); end`) without a hook. The key is the qualified candidate,
+      # the spelling the chain resolves a project entry by. The unpositioned table may key the owner by a relative
+      # spelling (`Constants` inside `class File`), so the producer also fires every recorded `mixin:` key ending in
+      # `::<owner>` (`IncrementalSession#mixin_keys`); a taint on a project `Foo::Base` still re-checks no reader of
+      # an external `Lib::Base`. An ambiguous spelling has no candidate and files none: no project module can resolve
+      # it, so no taint can mark it. The edges are a function of the chain alone, so a consumer files them once per
+      # chain ({Analysis::DependencyRecorder.file_chain_once}, #1590). A hook written another way — an instance `def
+      # included` in a module extended onto the external, a `define_singleton_method(:included)` — satisfies no such
+      # key and is not seen.
       def record_hooks(scope)
         externals = (@memo[:externals] ||= @entries.select(&:external?).freeze)
         return if externals.empty?
 
         Analysis::DependencyRecorder.file_chain_once(self, :hooks, scope.discovery) do
           externals.each do |entry|
-            entry.candidates.each { |name| Analysis::DependencyRecorder.read_keys(ResolutionChain.hook_keys(name)) }
+            entry.candidates.each { |name| Analysis::DependencyRecorder.read_keys(ResolutionChain.external_keys(name)) }
           end
         end
       end
@@ -393,12 +400,18 @@ module Rigor
       end
 
       @hook_keys = {}
+      @external_keys = {}
 
       # The frozen `method:Name.hook` negative keys of `name`'s {Relevance::HOOKS}, built once per name.
       def self.hook_keys(name)
         @hook_keys[name] ||= Relevance::HOOKS.map { |hook| "method:#{name}.#{hook}".freeze }.freeze
       end
 
+      # {hook_keys} plus the `mixin:<name>` key an external entry files for its unpositioned mixins (#1661).
+      def self.external_keys(name)
+        @external_keys[name] ||= (hook_keys(name) + ["mixin:#{name}".freeze]).freeze
+      end
+
       def record_head(scope, start, side)
         ResolutionChain.record_class(scope, @root) unless start.zero? && @entries.first&.name == @root
         start.times { |index| ResolutionChain.record_entry(scope, @entries[index], side) }
@@ -440,6 +453,28 @@ module Rigor
         @entries[@level_starts[index]...finish]
       end
 
+      # Issue #1624 — whether the chain's last class has a superclass the tables cannot name, so ancestors the chain
+      # does not list follow it where a chain otherwise ends in the implicit `Object`: a superclass written as an
+      # expression (`class K < Struct.new(:a)`, `< Data.define(:a)`, `< Class.new(Base)`, `< pick_base`), which the
+      # superclass table records as `nil`, or a class a constant write creates (`K = Class.new(Base)`,
+      # `K = Struct.new(:a)`, `K = Data.define(:a)`), which has no superclass entry. The constructor's methods
+      # (`members`, the member readers, a block's `def`s) and everything it inherits live in that unlisted part.
+      # Every fact read here is filed under the last class's class edge, which a read reaching the tail has passed.
+      def opaque_tail?(scope)
+        @memo.fetch(:opaque_tail) do
+          last = level_count.positive? ? @level_classes[level_count - 1] : nil
+          @memo[:opaque_tail] = !last.nil? && ResolutionChain.opaque_superclass?(scope, last)
+        end
+      end
+
+      def self.opaque_superclass?(scope, name)
+        superclasses = scope.discovery.discovered_superclasses
+        return superclasses[name].nil? if superclasses.key?(name)
+
+        scope.discovery.discovered_parameter_envelopes[name]&.key?(DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK) ||
+          !(scope.struct_member_layout(name) || scope.data_member_layout(name)).nil?
+      end
+
       # Each complete level up to the first superclass the project does not declare, as `[class_name,
       # modules, externals]`: the level's class, the project modules around it (each once), and the candidate
       # lists of the ancestors in it the project does not declare — the shape `call.wrong-arity` reads.

data/lib/rigor/scope.rb

@@ -1213,13 +1213,28 @@ module Rigor
     # wrong-arity rules consult this map to suppress diagnostics for methods the user has defined dynamically,
     # even when no RBS sig describes them.
     # A name defined on both sides of one class records {DiscoveryIndex::METHOD_KIND_BOTH} and matches either kind.
+    #
+    # Issue #2121 — a hit is an ADR-46 read. The table carries what no `def` symbol edge covers — an `attr_*`, an
+    # `alias` or a `define_method` (a cross-file `def` is withheld from it) — so an answer that read a hit records
+    # the class edge to the files declaring `class_name` and the name edge `defines:<method_name>`: deleting the
+    # `attr_accessor` re-checks the caller it silenced, whether or not the deleting file declares the class. A miss
+    # records nothing here; the readers that act on one record their own negative edges.
     def discovered_method?(class_name, method_name, kind)
       table = @discovery.discovered_methods[class_name.to_s]
       return false unless table
 
       recorded = table[method_name.to_sym]
-      recorded == kind || recorded == DiscoveryIndex::METHOD_KIND_BOTH
+      return false unless recorded == kind || recorded == DiscoveryIndex::METHOD_KIND_BOTH
+
+      record_discovered_method(class_name, method_name) if Analysis::DependencyRecorder.active?
+      true
+    end
+
+    def record_discovered_method(class_name, method_name)
+      record_class_dependency(class_name)
+      Analysis::DependencyRecorder.read_name(:defines, method_name)
     end
+    private :record_discovered_method
 
     # ADR-34 § "Decision" — predicate identifying a toplevel-shaped scope (no enclosing `class` / `module` body).
     # True at the top of a file AND inside a top-level `def` body (since toplevel defs leave `self_type` nil per
@@ -1410,6 +1425,27 @@ module Rigor
                         call_node)
     end
 
+    # Issue #1569 — whether `def_node`, written in this file, is a module function of `class_name`: a `:both`
+    # deferred-range row over the def (a bare `module_function` before it, or `module_function def x`;
+    # `ModuleFunctionState.prescan_deferred`), or a `:singleton` row for the name after the def
+    # (`module_function :x`) whose singleton copy is this def (`ModuleFunctionState.each_singleton_copy`).
+    def module_function_def?(class_name, def_node)
+      path = source_path
+      return false if path.nil?
+
+      ranges = discovered_deferred_ranges[path]
+      return false if ranges.nil?
+
+      start = def_node.location.start_offset
+      ranges.any? do |(row_start, _finish, name, kind, owner)|
+        next false unless name == def_node.name && owner == class_name.to_s
+
+        (kind == :both && row_start == start) ||
+          (kind == :singleton && row_start > start &&
+           singleton_def_for(class_name, name)&.location&.start_offset == start)
+      end
+    end
+
     # Shared ordering half of the two `*_def_shadows_call?` predicates, over this file's
     # `discovered_deferred_ranges` (issue #1097). `exists` — a recorded `"path:line"` site or the
     # method-existence table — says a def of `method_name`/`kind` on `class_name` is known at all; a
@@ -1917,8 +1953,15 @@ module Rigor
     # Issue #992 — one class's `discovered_parameter_envelopes` bucket (`{[kind, method_name] => envelope}` plus
     # the class-wide marks), or an empty Hash. Records the ADR-46 class edge first: a verdict read off the
     # bucket depends on every file that declares the class, and a `memoize :f` added to one of them moves it.
+    #
+    # Issue #1833 — and the name edge `mark:<last segment>`: a file that does not declare the class may still mark it
+    # (`x.singleton_class.prepend(Comparable)`, `o.extend(Helper)` in a method body, a `refine` block), and
+    # `IncrementalSession#mark_affected` fires the key when such a mark appears or vanishes.
     def parameter_envelopes_of(class_name)
-      record_class_dependency(class_name) if Analysis::DependencyRecorder.active?
+      if Analysis::DependencyRecorder.active?
+        record_class_dependency(class_name)
+        Analysis::DependencyRecorder.read_last_segment(:mark, class_name.to_s)
+      end
       @discovery.discovered_parameter_envelopes[class_name.to_s] || EMPTY_PARAMETER_ENVELOPES
     end
 

data/lib/rigor/sig_gen/alias_index.rb

@@ -2,6 +2,7 @@
 
 require_relative "../inference/rbs_type_translator"
 require_relative "type_elaborator"
+require_relative "../rooted_glob"
 
 module Rigor
   module SigGen
@@ -101,7 +102,7 @@ module Rigor
           dir = path.is_a?(Pathname) ? path : Pathname(path.to_s)
           next [] unless dir.directory?
 
-          Dir.glob(dir.join("**", "*.rbs").to_s).map { |p| File.expand_path(p) }
+          RootedGlob.glob(dir, "**/*.rbs").map { |p| File.expand_path(p) }
         end.to_set
       end
 

data/lib/rigor/sig_gen/classification.rb

@@ -60,7 +60,10 @@ module Rigor
         inline_differs: "sig.skipped.inline-differs",
         # #1676 — a plain top-level `def` defines a private `Object` method and has no class to write a
         # declaration under, so it is reported rather than silently dropped. Whether to emit it stays open.
-        top_level_def: "sig.skipped.top-level-def"
+        top_level_def: "sig.skipped.top-level-def",
+        # #1968 — a bare `public` / `private` / `protected` that may not run (in control flow or a block) sits
+        # between a bare `module_function` and the def, so whether the def is a module function is unknown.
+        uncertain_module_function: "sig.skipped.uncertain-module-function"
       }.freeze
     end
   end

data/lib/rigor/sig_gen/generator.rb

@@ -8,6 +8,7 @@ require_relative "../project_environment"
 require_relative "../scope"
 require_relative "../reflection"
 require_relative "../type"
+require_relative "../inference/reflective_ivar_write"
 require_relative "../source/constant_path"
 require_relative "../source/literals"
 require_relative "../source/node_children"
@@ -25,6 +26,7 @@ require_relative "inline_declarations"
 require_relative "layout_index"
 require_relative "method_candidate"
 require_relative "writer"
+require_relative "../rooted_glob"
 
 module Rigor
   module SigGen
@@ -98,6 +100,7 @@ module Rigor
         # (`build_candidate`, `method_def_prefix`) a never-nil invariant without per-call-site defensive guards.
         @namespace_kinds = {}
         @module_function_methods = Set.new
+        @uncertain_module_function_defs = Set.new.compare_by_identity
         @class_shells = Set.new
         @class_superclasses = {}
         @meta_layouts = {}
@@ -446,7 +449,7 @@ module Rigor
       def resolve_paths(args)
         args.flat_map do |arg|
           if File.directory?(arg)
-            Dir.glob(File.join(arg, "**/*.rb"), sort: true)
+            RootedGlob.glob(arg, "**/*.rb")
           elsif File.file?(arg) && arg.end_with?(".rb")
             [arg]
           else
@@ -463,10 +466,7 @@ module Rigor
         base_scope = Scope.empty(environment: environment)
         scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
 
-        @namespace_kinds = {}
-        @module_function_methods = Set.new
-        @class_shells = Set.new
-        @class_superclasses = {}
+        reset_file_maps
         @meta_layouts = collect_meta_layouts(scope_index)
         register_meta_classes
         defs = collect_method_definitions(parse_result.value, scope_index)
@@ -488,6 +488,15 @@ module Rigor
           collect_attr_candidates(parse_result.value, path, scope_index, obs_ivar_map)
       end
 
+      # The per-file scratch state {#analyse_file} starts each file with.
+      def reset_file_maps
+        @namespace_kinds = {}
+        @module_function_methods = Set.new
+        @uncertain_module_function_defs = Set.new.compare_by_identity
+        @class_shells = Set.new
+        @class_superclasses = {}
+      end
+
       # Walks the AST collecting `(def_node, class_name, kind)` tuples for every `def` Rigor can re-type. Slice 1
       # covered instance `def foo` methods inside a nameable `class` / `module` body. Slice 4 extends this to
       # singleton-side methods via `def self.foo` and `class << self; def foo; end`. A plain top-level `def` is
@@ -732,6 +741,8 @@ module Rigor
         class_name = prefix.join("::")
         if Inference::ModuleFunctionState.sig_gen_module_function?(module_function_active, kind)
           @module_function_methods << [class_name, node.name]
+        elsif Inference::ModuleFunctionState.sig_gen_uncertain?(module_function_active, kind)
+          @uncertain_module_function_defs << node
         end
         out << [node, class_name, kind]
       end
@@ -783,9 +794,13 @@ module Rigor
       # private methods are implementation details, not part of the type contract downstream consumers (Steep,
       # IDE, gem users) read. The default now skips private and protected methods; the `:include_private` flag
       # restores the slice-4 behaviour for callers that want every method.
+      #
+      # A module function renders as `def self?.name`, which RBS reads as a public singleton method and a private
+      # instance method, so a `private` written before the `module_function` toggle does not exclude it (#1968).
       def visibility_excludes?(def_node, class_name, kind, scope_index)
         return false if kind == :singleton
         return false if @include_private
+        return false if @module_function_methods.include?([class_name, def_node.name])
 
         scope = scope_index[def_node] || scope_index.each_value.first
         return false if scope.nil?
@@ -960,6 +975,9 @@ module Rigor
       # #1676 — a top-level `def` is collected with no class; it is reported, never typed.
       def classify_collected_def(path, def_node, class_name, kind, scope_index)
         return skipped(path, def_node, class_name, kind, :top_level_def) if class_name.nil?
+        if @uncertain_module_function_defs.include?(def_node)
+          return skipped(path, def_node, class_name, kind, :uncertain_module_function)
+        end
 
         classify_def(path, def_node, class_name, kind, scope_index)
       end
@@ -1421,12 +1439,17 @@ module Rigor
       # same position a method with no declaration at all is in. Over a declaration the author wrote, though, a
       # VALUE literal the body proves (`-> 1`, `-> "x"`, `-> :k`) is an implementation detail the `untyped` was
       # abstracting over, so it is widened to its class (`1 | 2` to `Integer`, `"S" | nil` to `(String | nil)`; #1489).
-      # `nil`, `true` and `false` are honest types and stay, as does a computed `Float`. An `untyped` that is only
-      # the inline reader's synthesis ({#synthesized_declaration?}) is no word of the author's and keeps the
-      # strictest carrier. `declared_return_rbs` carries `"untyped"` so the `[tighter, was: untyped]` print tag
-      # says a declaration existed.
+      # `true` and `false` widen to `bool` (#1891): a predicate's base `-> true` made every subclass override
+      # returning `false` a `def.override-return-widened`. A return that is only `nil` has no such widening — it is
+      # the shape of a template method a subclass fills in — so it is declined and the `untyped` stays. `nil` in a
+      # union (`T?`) and a computed `Float` are honest types and stay. An `untyped` that is only the inline reader's
+      # synthesis ({#synthesized_declaration?}) is no word of the author's and keeps the strictest carrier.
+      # `declared_return_rbs` carries `"untyped"` so the `[tighter, was: untyped]` print tag says a declaration
+      # existed.
       def declared_untyped_candidate(path, def_node, class_name, kind, inferred, method_def, rendered: nil)
         unless synthesized_declaration?(method_def)
+          return equivalent(path, def_node, class_name, kind, inferred, "untyped") if bare_nil?(inferred)
+
           widened = widen_value_literals(inferred)
           unless widened.equal?(inferred)
             # A `rendered` line was spelled from the unwidened type; there is nothing to rebuild it from.
@@ -1446,6 +1469,7 @@ module Rigor
       def widen_value_literals(type)
         case type
         when Type::Constant
+          return widen_boolean_literal if [true, false].include?(type.value)
           return type unless VALUE_LITERAL_CLASSES.any? { |klass| type.value.instance_of?(klass) }
 
           Type::Combinator.nominal_of(type.value.class.name)
@@ -1457,6 +1481,14 @@ module Rigor
         end
       end
 
+      def widen_boolean_literal
+        Type::Combinator.union(Type::Combinator.constant_of(true), Type::Combinator.constant_of(false))
+      end
+
+      def bare_nil?(type)
+        type.is_a?(Type::Constant) && type.value.nil?
+      end
+
       # A declaration only the inline reader's synthesis (a `virtual:` buffer) supplies — ADR-93 gives every `def` an
       # `untyped` member, annotated or not — is no word of the author's about the return, so it keeps the proposal
       # a method with no declaration at all gets: the strictest carrier the body proves.
@@ -1590,11 +1622,13 @@ module Rigor
       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.
+      # `nil`, an Integer, a Symbol, a String) as that literal and every other carrier as a nominal. Asking
+      # which of the two branches it took keeps the list of literal-spellable classes from forking a second
+      # copy into this file. A Range's nominal carries its element type (`Range[Integer]`, #1891), so it is
+      # excluded by class rather than by comparing the erasure with the class name: like a Float it is a
+      # nominal, not a pinned literal.
       def rbs_literal?(type)
-        type.is_a?(Type::Constant) && type.erase_to_rbs != type.value.class.name
+        type.is_a?(Type::Constant) && !type.value.is_a?(Range) && type.erase_to_rbs != type.value.class.name
       end
 
       # Heuristic added after the third-round self-dogfood: `FallbackTracer#size` body is `@events.size`, where
@@ -1837,7 +1871,8 @@ module Rigor
       # pre-pass resolved the type to `nil` or `Dynamic[top]` — typically because `@ivar = param` inside
       # `initialize` typed the param as `untyped` — the observation-derived type is substituted. This lets
       # `attr_reader :name` emit a concrete type when `ClassName.new("alice")` call sites are visible to the
-      # observation scan.
+      # observation scan. {#build_observed_ivar_map} leaves out an ivar anything else writes, so a writer-backed
+      # field is skipped (issue #1410).
       def ivar_type_lookup(scope_index, class_name, obs_ivar_map = {})
         any_scope = scope_index.each_value.first
         return ->(_) {} if any_scope.nil?
@@ -1854,12 +1889,107 @@ module Rigor
       # ivars assigned directly from `def initialize` parameters. Only populated when `@observations` is
       # non-empty (i.e. `--params=observed` was supplied). Matches the pattern `@ivar_name = param_name` where
       # `param_name` is a required / optional positional or keyword parameter of `initialize`.
+      #
+      # Issue #1410: the observed arguments describe the field only while those `@ivar = param_name` writes are
+      # all that writes it. An `attr_writer` / `attr_accessor`, a write in another instance method or block, or
+      # any other write in `initialize` lets the field hold values the observation never saw, so such an ivar is
+      # left out and its accessor is skipped as `untyped_return`, as a hand-written setter is.
       def build_observed_ivar_map(root)
         return {} if @observations.empty?
 
         result = {}
         collect_init_ivar_obs(root, [], result)
-        result
+        other_writes = Hash.new { |h, k| h[k] = Set.new }
+        collect_other_ivar_writes(root, [], false, other_writes)
+        result.to_h do |class_name, map|
+          others = other_writes[class_name]
+          [class_name, others.include?(ANY_IVAR) ? {} : map.reject { |attr_name, _| others.include?(:"@#{attr_name}") }]
+        end
+      end
+
+      IVAR_WRITE_NODES = [
+        Prism::InstanceVariableWriteNode, Prism::InstanceVariableOperatorWriteNode,
+        Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableTargetNode
+      ].freeze
+      ANY_IVAR = :*
+      private_constant :IVAR_WRITE_NODES, :ANY_IVAR
+
+      # Records into `other_writes[class_name]` every instance ivar a class writes other than through an
+      # `initialize`'s `@ivar = param_name`: the ivars an implicit-self `attr_writer` / `attr_accessor` names,
+      # and every write inside an instance `def` or a block, an `instance_variable_set` on `self` included
+      # ({#written_ivar}). `def self.x`, a `class << self` body and a bare class-body write set the class
+      # object's ivars and do not count.
+      def collect_other_ivar_writes(node, prefix, in_block, other_writes)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          child_prefix = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
+          return collect_other_ivar_writes(node.body, child_prefix, false, other_writes) if child_prefix
+        when Prism::SingletonClassNode then return
+        when Prism::DefNode then return record_def_ivar_writes(node, prefix, other_writes)
+        when Prism::BlockNode, Prism::LambdaNode then in_block = true
+        end
+        record_class_level_write(node, prefix, in_block, other_writes) unless prefix.empty?
+
+        node.rigor_each_child { |child| collect_other_ivar_writes(child, prefix, in_block, other_writes) }
+      end
+
+      # The ivars an `attr_writer` / `attr_accessor` on `self` names, or the ivar a write in a block sets.
+      def record_class_level_write(node, prefix, in_block, other_writes)
+        writes = other_writes[prefix.join("::")]
+        attr_writer_names(node).each { |name| writes << :"@#{name}" }
+        name = written_ivar(node) if in_block
+        writes << name if name
+      end
+
+      ATTR_WRITER_DECLARATIONS = %i[attr_writer attr_accessor].freeze
+      SEND_NAMES = %i[send public_send __send__].freeze
+      private_constant :ATTR_WRITER_DECLARATIONS, :SEND_NAMES
+
+      # The literal names `attr_writer :x` / `attr_accessor :x` declares when called on `self`, implicitly or as
+      # `self.`, or through `send` / `public_send` / `__send__` with the declaration's name as a literal first
+      # argument (`send(:attr_writer, :x)`). Any other call declares none this check sees.
+      def attr_writer_names(node)
+        return [] unless node.is_a?(Prism::CallNode) && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+
+        names = Source::Literals.symbol_arguments(node)
+        return names if ATTR_WRITER_DECLARATIONS.include?(node.name)
+        return [] unless SEND_NAMES.include?(node.name)
+
+        ATTR_WRITER_DECLARATIONS.include?(Source::Literals.symbol_arg(node, 0)) ? names.drop(1) : []
+      end
+
+      # Every ivar write in an instance `def` counts, except, in `initialize`, the `@ivar = param_name` write
+      # {#scan_ivar_param_assignments} keys the observation on.
+      def record_def_ivar_writes(def_node, prefix, other_writes)
+        return if def_node.body.nil? || def_node.receiver || prefix.empty?
+
+        credited = Set.new.compare_by_identity
+        if def_node.name == :initialize && def_node.parameters
+          params = build_init_param_index(def_node.parameters).keys.to_set
+          scan_ivar_param_assignments(def_node.body, params, {}, credited)
+        end
+        each_node(def_node.body) do |node|
+          name = written_ivar(node)
+          other_writes[prefix.join("::")] << name if name && !credited.include?(node)
+        end
+      end
+
+      # The ivar `node` writes: a write node's name, an `instance_variable_set` on `self`'s literal name, or
+      # `ANY_IVAR` for one whose name the analysis cannot read ({Inference::ReflectiveIvarWrite}).
+      def written_ivar(node)
+        return node.name if IVAR_WRITE_NODES.any? { |klass| node.is_a?(klass) }
+        return nil unless Inference::ReflectiveIvarWrite.self_write?(node)
+
+        Inference::ReflectiveIvarWrite.literal_name(node) || ANY_IVAR
+      end
+
+      def each_node(node, &)
+        return unless node.is_a?(Prism::Node)
+
+        yield node
+        node.rigor_each_child { |child| each_node(child, &) }
       end
 
       def collect_init_ivar_obs(node, prefix, result)
@@ -1945,21 +2075,36 @@ module Rigor
 
       # Walk a def body for direct `@ivar = local_var` assignments where `local_var` is one of the listed
       # parameter names. Records ivar_name (Symbol with `@` prefix) → param_name. Does not recurse into nested
-      # defs / classes / modules.
-      def scan_ivar_param_assignments(node, param_names, result)
+      # defs / classes / modules. A read counts only when it reaches the method's own parameter: its
+      # `LocalVariableReadNode#depth` equals the number of blocks / lambdas between it and the method, so a
+      # block parameter of the same name (`each { |count| @count = count }`) is not the constructor argument
+      # (#1410). `credited`, when given, collects every write node the result is keyed on.
+      def scan_ivar_param_assignments(node, param_names, result, credited = nil, scopes = 0)
         return unless node.is_a?(Prism::Node)
 
-        if node.is_a?(Prism::InstanceVariableWriteNode) &&
-           node.value.is_a?(Prism::LocalVariableReadNode) &&
-           param_names.include?(node.value.name)
-          result[node.name] ||= node.value.name
+        ivar, param = param_assignment(node, param_names, scopes)
+        if ivar
+          result[ivar] ||= param
+          credited << node if credited && result[ivar] == param
         end
 
         return if node.is_a?(Prism::DefNode) ||
                   node.is_a?(Prism::ClassNode) ||
                   node.is_a?(Prism::ModuleNode)
 
-        node.rigor_each_child { |c| scan_ivar_param_assignments(c, param_names, result) }
+        scopes += 1 if node.is_a?(Prism::BlockNode) || node.is_a?(Prism::LambdaNode)
+        node.rigor_each_child { |c| scan_ivar_param_assignments(c, param_names, result, credited, scopes) }
+      end
+
+      # `[ivar, param]` for `@ivar = param` whose read reaches the method's own parameter `param`, else nil.
+      def param_assignment(node, param_names, scopes)
+        return nil unless node.is_a?(Prism::InstanceVariableWriteNode)
+
+        read = node.value
+        return nil unless read.is_a?(Prism::LocalVariableReadNode) && read.depth == scopes
+        return nil unless param_names.include?(read.name)
+
+        [node.name, read.name]
       end
 
       def build_attr_candidates(call_name, class_name, attr_name, ivar_type, ctx)

data/lib/rigor/sig_gen/layout_index.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbs"
+require_relative "../rooted_glob"
 
 module Rigor
   module SigGen
@@ -27,12 +28,14 @@ module Rigor
     class LayoutIndex
       # The `[method_name, kind]` keys a member declaration answers for, `kind` being `:instance` or
       # `:singleton`. A `def self?.f` answers for both kinds; an `attr_accessor` answers for its reader and its
-      # writer. Shared with {Writer}, which asks the same question of the target file it is merging into.
+      # writer; an `alias new old` (`alias self.new self.old`) answers for its new name only, under its own kind
+      # (#1975). Shared with {Writer}, which asks the same question of the target file it is merging into.
       def self.member_keys(member)
         case member
         when RBS::AST::Members::MethodDefinition
           kinds = member.kind == :singleton_instance ? %i[instance singleton] : [member.kind]
           kinds.map { |kind| [member.name, kind] }
+        when RBS::AST::Members::Alias then [[member.new_name, member.kind]]
         when RBS::AST::Members::AttrReader then [[member.name, member.kind]]
         when RBS::AST::Members::AttrWriter then [[:"#{member.name}=", member.kind]]
         when RBS::AST::Members::AttrAccessor then [[member.name, member.kind], [:"#{member.name}=", member.kind]]
@@ -92,7 +95,7 @@ module Rigor
           base = Pathname(dir)
           next unless base.directory?
 
-          Dir.glob(File.join(base.to_s, "**/*.rbs"), sort: true).each do |rbs_file|
+          RootedGlob.glob(base, "**/*.rbs").each do |rbs_file|
             index_file(Pathname(rbs_file), accumulator)
           end
         end