rigortype 0.4.4 → 0.4.6

data/lib/rigor/sig_gen/generator.rb

@@ -8,11 +8,13 @@ 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"
 require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/project_seed_tables"
 require_relative "../inference/module_function_state"
 require_relative "../inference/rbs_type_translator"
 require_relative "alias_index"
@@ -25,6 +27,7 @@ require_relative "inline_declarations"
 require_relative "layout_index"
 require_relative "method_candidate"
 require_relative "writer"
+require_relative "../rooted_glob"
 
 module Rigor
   module SigGen
@@ -97,7 +100,8 @@ module Rigor
         # candidates from one file don't leak into another; initialising empty here gives downstream consumers
         # (`build_candidate`, `method_def_prefix`) a never-nil invariant without per-call-site defensive guards.
         @namespace_kinds = {}
-        @module_function_methods = Set.new
+        @module_function_methods = Set.new.compare_by_identity
+        @uncertain_module_function_defs = Set.new.compare_by_identity
         @class_shells = Set.new
         @class_superclasses = {}
         @meta_layouts = {}
@@ -123,6 +127,7 @@ module Rigor
 
       def run
         resolved = resolve_paths(@paths)
+        @resolved_paths = resolved
         @environment = build_environment(resolved)
         candidates = resolved.flat_map { |path| analyse_file(path, @environment) }
         annotate_effects(
@@ -446,7 +451,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
@@ -455,25 +460,41 @@ module Rigor
         end.uniq
       end
 
+      # #1154 — the project's discovery tables, read only by the declared-parameter ivar credit: it must see the ivar
+      # writers in other files (an ancestor, another object's `instance_variable_set`, a reopening) as `rigor check`
+      # does. Built once per run over the configured project paths as well as the files sig-gen reads, so a run over
+      # one file declines what a `check` of it declines; every other part of the generator keeps its per-file scope.
+      def ivar_writer_scope(base_scope)
+        @ivar_writer_tables ||= Inference::ProjectSeedTables.for_paths(
+          ((@resolved_paths || []) + resolve_paths(Array(@configuration.paths))).uniq { |path| File.expand_path(path) }
+        )
+        base_scope.with_discovery(base_scope.discovery.with(**@ivar_writer_tables))
+      end
+
+      # #1406 — sig-gen keeps the census's own answer: a declared ivar type read back would echo the declaration.
+      def index_file(root, base_scope)
+        Inference::ScopeIndexer.index(
+          root, default_scope: base_scope, ivar_writer_scope: ivar_writer_scope(base_scope), declared_ivar_types: false
+        )
+      end
+
       def analyse_file(path, environment)
         source = File.read(path)
         parse_result = Prism.parse(source, filepath: path, version: @configuration.target_ruby)
         return [] if parse_result.errors.any?
 
-        base_scope = Scope.empty(environment: environment)
-        scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
+        scope_index = index_file(parse_result.value, Scope.empty(environment: environment))
 
-        @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)
+        definers = definer_table(parse_result.value, defs)
+        defs = live_definitions(defs, definers)
         # Candidate construction freezes the per-file maps above (see {#build_candidate}), so every registration
         # pass has to be finished before the first `build_candidate` call. Meta members lead the RETURNED order —
         # a value class's members and constructors read first, ahead of the methods its block body defines.
-        meta_candidates = collect_meta_member_candidates(path, scope_index)
+        meta_candidates = live_meta_candidates(path, scope_index, definers)
         candidates_from_defs = defs.filter_map do |def_node, class_name, kind|
           # An analyzer bug typing one def's body must cost only that def's candidate, never the whole
           # `rigor sig-gen` run. The `check` path recovers each *file* this way (worker_session.rb); sig-gen
@@ -485,7 +506,111 @@ module Rigor
         end
         obs_ivar_map = build_observed_ivar_map(parse_result.value)
         meta_candidates + candidates_from_defs +
-          collect_attr_candidates(parse_result.value, path, scope_index, obs_ivar_map)
+          collect_attr_candidates(parse_result.value, path, scope_index, obs_ivar_map, definers)
+      end
+
+      # Ruby keeps the LAST definition of a name: a `def x` followed by `attr_reader :x` (or the reverse) defines
+      # `x` once, and a second `def x` after a `module_function` reset replaces only the instance method. Writing
+      # one entry per definition gave RBS a duplicate method definition (#2008, #2023), so every definer of a
+      # `(class, kind, name)` slot is recorded with its source offset, and only the last one in a file is written.
+      # A module function defines two slots, its singleton copy and its instance method. A `Data.define` or
+      # `Struct.new` member is defined before any body that could redefine it, so it ranks first.
+      #
+      # Only a definer whose statement certainly runs can be last: a direct statement of a `class`, `module` or
+      # `class << self` body, of a `Data.define` / `Struct.new` block or of the file ({#walk_statements} records
+      # them). One under a condition, in a block or a lambda, passed to a call (`private def x`), or after an
+      # uncertain `module_function` reset may not run, as far as this reading tells. A slot such a definer could
+      # still take over from the last certain one is contested, and nothing is written for it.
+      #
+      # @return `{ [class_name, kind, method_name] => [[offset, certain], ...] }`.
+      MEMBER_OFFSET = -1
+      private_constant :MEMBER_OFFSET
+
+      def definer_table(root, defs)
+        certain = @certain_definers
+        table = Hash.new { |h, k| h[k] = [] }
+        record_def_definers(defs, certain, table)
+        meta_member_slots.each { |slot| table[slot] << [MEMBER_OFFSET, true] }
+        ctx = AttrWalkContext.new(definers: [])
+        walk_attr_calls(root, [], false, ctx)
+        ctx.definers.each do |slot, call_node|
+          table[slot] << [call_node.location.start_offset, certain.include?(call_node)]
+        end
+        table
+      end
+
+      def record_def_definers(defs, certain, table)
+        defs.each do |def_node, class_name, kind|
+          next if class_name.nil?
+
+          definer_slots(def_node, class_name, kind).each do |slot, possible_only|
+            table[slot] << [def_node.location.start_offset, !possible_only && certain.include?(def_node)]
+          end
+        end
+      end
+
+      def live_meta_candidates(path, scope_index, table)
+        collect_meta_member_candidates(path, scope_index).select do |c|
+          live_definer?(table, [c.class_name, c.kind, c.method_name], MEMBER_OFFSET)
+        end
+      end
+
+      # `[slot, possible_only]` pairs. A `def` after an uncertain `module_function` reset may or may not install a
+      # singleton copy, so it is a possible definer of that slot only.
+      def definer_slots(def_node, class_name, kind)
+        slots = [[[class_name, kind, def_node.name], false]]
+        if @module_function_methods.include?(def_node)
+          slots << [[class_name, :singleton, def_node.name], false]
+        elsif @uncertain_module_function_defs.include?(def_node)
+          slots << [[class_name, :singleton, def_node.name], true]
+        end
+        slots
+      end
+
+      def meta_member_slots
+        @meta_layouts.flat_map do |class_name, layout|
+          MetaClassShape.of(kind: layout.kind, members: layout.member_names, keyword_init: layout.keyword_init)
+                        .member_decls.map { |member| [class_name, member.kind, member.method_name] }
+        end
+      end
+
+      # Whether the definer at `offset` is the one Ruby keeps for `slot`. A slot with a single definer keeps it,
+      # certain or not, as before.
+      def live_definer?(table, slot, offset)
+        entries = table.fetch(slot, [])
+        return true if entries.size <= 1
+
+        last_certain = entries.select { |_, certain| certain }.map(&:first).max
+        return false if last_certain.nil?
+        return false if entries.any? { |entry_offset, certain| !certain && entry_offset > last_certain }
+
+        offset == last_certain
+      end
+
+      # The `defs` whose definition Ruby keeps. A module function whose instance method a later definition
+      # replaced keeps only its singleton copy (`M.label` still returns the first body), so it is written as
+      # `def self.label`. One whose singleton copy was replaced keeps only a private instance method, which
+      # sig-gen does not write, so it is dropped.
+      def live_definitions(defs, table)
+        defs.filter_map do |def_node, class_name, kind|
+          next [def_node, class_name, kind] if class_name.nil?
+
+          slots = definer_slots(def_node, class_name, kind).reject(&:last).map(&:first)
+          live = slots.select { |slot| live_definer?(table, slot, def_node.location.start_offset) }
+          next [def_node, class_name, kind] if live.size == slots.size
+          next nil unless live == [[class_name, :singleton, def_node.name]]
+
+          [def_node, class_name, :singleton]
+        end
+      end
+
+      # The per-file scratch state {#analyse_file} starts each file with.
+      def reset_file_maps
+        @namespace_kinds = {}
+        @module_function_methods = Set.new.compare_by_identity
+        @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
@@ -500,15 +625,19 @@ module Rigor
       # - `@namespace_kinds[qualified_name]` records whether each segment came from `class Foo` (`:class`) or
       #   `module Foo` (`:module`). Used by the writer's `wrap_in_modules` step to emit the right keyword for
       #   each intermediate segment AND the leaf.
-      # - `@module_function_methods` records `(class_name, method_name)` pairs where a `module_function` (no
-      #   args) call preceded the `def` inside a module body. The renderer emits `def self?.name` for these, the
-      #   RBS spelling that matches the dual instance + singleton dispatch the runtime produces.
+      # - `@module_function_methods` records the `def` nodes a `module_function` (no args) call preceded inside
+      #   a module body. The renderer emits `def self?.name` for these, the RBS spelling that matches the dual
+      #   instance + singleton dispatch the runtime produces. It is keyed by node, not by name: a later `def` of
+      #   the same name after a reset is an ordinary method (#2023).
       def collect_method_definitions(root, scope_index)
         @declared_types = scope_index[root].declared_types
         @walk_root = root
         @in_effect_refinements = nil
         out = []
         @block_depth = 0
+        @certain_bodies = Set.new.compare_by_identity
+        @certain_definers = Set.new.compare_by_identity
+        mark_certain_body(root.statements)
         walk_defs(root, [], false, false, out)
         out
       end
@@ -521,6 +650,7 @@ module Rigor
           return if descend_into_namespace?(node, prefix, out)
         when Prism::SingletonClassNode
           if node.expression.is_a?(Prism::SelfNode) && node.body
+            mark_certain_body(node.body)
             walk_defs(node.body, prefix, true, false, out)
             return
           end
@@ -530,6 +660,7 @@ module Rigor
         when Prism::ConstantWriteNode
           body = meta_block_body(node, prefix)
           if body
+            mark_certain_body(body)
             walk_defs(body, prefix + [node.name.to_s], false, false, out)
             return
           end
@@ -708,13 +839,30 @@ module Rigor
       def walk_namespace_body(namespace_node, prefix, out)
         return if namespace_node.body.nil?
 
+        mark_certain_body(namespace_node.body)
         walk_defs(namespace_node.body, prefix, false, false, out)
       end
 
+      # A body whose direct statements certainly run when it does ({#definer_table}): its statement list unless the
+      # body has a `rescue` clause, and its `ensure` clause. A `rescue` or `else` clause may not run.
+      def mark_certain_body(body)
+        return @certain_bodies << body unless body.is_a?(Prism::BeginNode)
+
+        # With a `rescue`, a statement before a definer can raise and skip it, so the main list is not certain.
+        @certain_bodies << body.statements if body.statements && body.rescue_clause.nil?
+        @certain_bodies << body.ensure_clause.statements if body.ensure_clause&.statements
+      end
+
       # The directive's reach is {Inference::ModuleFunctionState.each_sig_gen_statement}.
       def walk_statements(stmts_node, prefix, in_singleton_class, module_function_active, out)
+        certain_body = @certain_bodies.include?(stmts_node)
         Inference::ModuleFunctionState.each_sig_gen_statement(stmts_node.body,
                                                               module_function_active) do |stmt, active|
+          if certain_body
+            @certain_definers << stmt
+            # A `begin … end` statement's body (and `ensure`) runs whenever the statement does.
+            mark_certain_body(stmt) if stmt.is_a?(Prism::BeginNode)
+          end
           walk_defs(stmt, prefix, in_singleton_class, active, out)
         end
       end
@@ -731,7 +879,9 @@ module Rigor
         kind = node.receiver.is_a?(Prism::SelfNode) || in_singleton_class ? :singleton : :instance
         class_name = prefix.join("::")
         if Inference::ModuleFunctionState.sig_gen_module_function?(module_function_active, kind)
-          @module_function_methods << [class_name, node.name]
+          @module_function_methods << node
+        elsif Inference::ModuleFunctionState.sig_gen_uncertain?(module_function_active, kind)
+          @uncertain_module_function_defs << node
         end
         out << [node, class_name, kind]
       end
@@ -771,9 +921,9 @@ module Rigor
 
       # Returns "def self." (kind: :singleton), "def self?." (instance method declared inside a
       # `module_function` region — both instance + singleton dispatch at runtime), or "def " (plain instance).
-      def method_def_prefix(class_name, method_name, kind)
+      def method_def_prefix(def_node, kind)
         return "def self." if kind == :singleton
-        return "def self?." if @module_function_methods.include?([class_name, method_name])
+        return "def self?." if @module_function_methods.include?(def_node)
 
         "def "
       end
@@ -783,9 +933,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?(def_node)
 
         scope = scope_index[def_node] || scope_index.each_value.first
         return false if scope.nil?
@@ -960,6 +1114,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
@@ -1020,7 +1177,7 @@ module Rigor
 
         scope = scope_index[def_node]
         method_def = lookup_existing_method(class_name, def_node.name, kind, scope&.environment, scope)
-        head = "#{method_def_prefix(class_name, def_node.name, kind)}#{def_node.name}: "
+        head = "#{method_def_prefix(def_node, kind)}#{def_node.name}: "
         if return_defaulted
           return mixed_provenance_candidate(path, def_node, class_name, kind, scope_index, inline, method_def, head)
         end
@@ -1240,7 +1397,37 @@ module Rigor
       # different method (issue #1382). Delegates to {Rigor::Inference::DefReturnTyper} — the same body-typing +
       # explicit-return-union the `rigor annotate` def-line annotator uses.
       def infer_return_type(def_node, scope_index)
-        Inference::DefReturnTyper.call(def_node, scope_index)
+        absorb_empty_literals(Inference::DefReturnTyper.call(def_node, scope_index, keep_lookup_nil: true))
+      end
+
+      # Issue #1153 — an empty-collection early return (`return [] if table.empty?`) types its arm `[]`, which the
+      # engine's union keeps beside a sibling `Array[E]` arm on purpose (the empty tuple is a distinct shape). A
+      # signature has no use for the distinction: `[]` is an `Array[E]` for every `E`, so `Array[E] | []` is just
+      # `Array[E]`, and the leftover `[]` arm made the proposal read as if the empty literal pinned the element.
+      # Issue #1149 — the same holds for the empty closed hash shape `{}` (a frozen empty fallback,
+      # `table[key] || EMPTY`) beside a `Hash[K, V]` nominal. Each empty literal is absorbed only beside its OWN
+      # nominal: a `[]` beside a `Hash` arm, or a `{}` beside an `Array` arm, is untouched. A lone empty literal,
+      # one beside another tuple / shape (`[1, 2] | []`), an open `{ ... }` shape, and a non-empty shape are
+      # untouched too, since each of those is information the declaration should keep.
+      def absorb_empty_literals(type)
+        return type unless type.is_a?(Type::Union)
+
+        kept = type.members.reject { |member| absorbed_empty_literal?(member, type.members) }
+        kept.size == type.members.size ? type : Type::Combinator.union(*kept)
+      end
+
+      def absorbed_empty_literal?(member, members)
+        if member.is_a?(Type::Tuple) && member.elements.empty?
+          nominal_arm?(members, "Array")
+        elsif member.is_a?(Type::HashShape) && member.pairs.empty? && member.closed?
+          nominal_arm?(members, "Hash")
+        else
+          false
+        end
+      end
+
+      def nominal_arm?(members, class_name)
+        members.any? { |member| member.is_a?(Type::Nominal) && member.class_name == class_name }
       end
 
       def dynamic_top?(type)
@@ -1287,7 +1474,7 @@ module Rigor
         return equivalent(path, def_node, class_name, kind, inferred, VOID_RETURN_RBS) if declares_void?(method_def)
 
         declared = build_declared_return(method_def)
-        if declared_untyped?(declared)
+        if declared_untyped?(declared, method_def)
           return declared_untyped_candidate(path, def_node, class_name, kind, inferred, method_def, rendered: rendered)
         end
 
@@ -1354,7 +1541,7 @@ module Rigor
         returned = paren_wrap_union(elaborated_rbs(inferred, owner: class_name))
         annotations = overload.annotations.map { |a| "#{a.location&.source || "%a{#{a.string}}"} " }.join
         visibility = member.respond_to?(:visibility) && member.visibility ? "#{member.visibility} " : ""
-        "#{visibility}#{method_def_prefix(class_name, def_node.name, kind)}#{def_node.name}: " \
+        "#{visibility}#{method_def_prefix(def_node, kind)}#{def_node.name}: " \
           "#{annotations}#{spell_with_return(overload.method_type, returned)}"
       end
 
@@ -1413,20 +1600,30 @@ module Rigor
       # skips. ADR-93's inline `# @rbs param: Type` annotation (no return clause) synthesizes exactly this
       # spelling for every method it documents, so the silent drop hit the parameter-annotated, return-bare
       # shape ADR-14 exists to help.
-      def declared_untyped?(declared)
-        declared.is_a?(Type::Dynamic)
+      #
+      # The translation alone cannot say the author wrote `untyped`: an interface return (`-> _Taker[1]`,
+      # `-> _ToS`) also translates to `Dynamic`, and reading it as an absent declaration replaced it with an
+      # unrelated nominal under `--overwrite` (#2178). So every overload's return must be `untyped` as written.
+      def declared_untyped?(declared, method_def)
+        declared.is_a?(Type::Dynamic) &&
+          method_def.method_types.all? { |mt| mt.type.return_type.is_a?(RBS::Types::Bases::Any) }
       end
 
       # Proposed without {#tighter?}: a declared `untyped` return carries no information to weigh it against, the
       # 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.
@@ -1442,21 +1639,60 @@ module Rigor
       VALUE_LITERAL_CLASSES = [Integer, String, Symbol].freeze
       private_constant :VALUE_LITERAL_CLASSES
 
-      # The same object back when nothing needed widening.
+      # Core generics whose RBS parameters are all `out` or `unchecked out`, so a widened argument is a supertype of
+      # the body's type. An invariant or `in` parameter (a user `class Sink[in T]`) is not widened: `Sink[Integer]`
+      # is no supertype of `Sink[1]` there.
+      COVARIANT_CARRIERS = %w[Array Hash Set Range Enumerator].freeze
+      private_constant :COVARIANT_CARRIERS
+
+      # The same object back when nothing needed widening. A literal nested in a tuple element, a record or hash
+      # value, or a covariant generic argument (`[1, "a"]`, `{ a: 1 }`, `Hash[String, 1]`) widens the same way, while
+      # the carrier's shape and a record's keys stay: a subclass override returning `[2, "b"]` is no widening of
+      # `[Integer, String]`. A nested `nil` is an honest member there, as in a top-level union.
       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)
-        when Type::Union
-          members = type.members.map { |member| widen_value_literals(member) }
-          members.each_with_index.all? { |m, i| m.equal?(type.members[i]) } ? type : Type::Combinator.union(*members)
+        when Type::Union then widen_members(type.members, type) { |members| Type::Combinator.union(*members) }
+        when Type::Tuple then widen_members(type.elements, type) { |elements| Type::Combinator.tuple_of(*elements) }
+        when Type::HashShape then widen_hash_shape_values(type)
+        when Type::Nominal
+          return type unless COVARIANT_CARRIERS.include?(type.class_name)
+
+          widen_members(type.type_args, type) do |args|
+            Type::Combinator.nominal_of(type.class_name, type_args: args)
+          end
         else
           type
         end
       end
 
+      def widen_members(members, type)
+        widened = members.map { |member| widen_value_literals(member) }
+        widened.each_with_index.all? { |m, i| m.equal?(members[i]) } ? type : yield(widened)
+      end
+
+      def widen_hash_shape_values(shape)
+        widen_members(shape.pairs.values, shape) do |values|
+          Type::HashShape.new(
+            shape.pairs.keys.zip(values).to_h,
+            required_keys: shape.required_keys, optional_keys: shape.optional_keys,
+            read_only_keys: shape.read_only_keys, extra_keys: shape.extra_keys
+          )
+        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 +1826,14 @@ 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 and a Set's nominal carries a type argument (`Range[Integer]`, #1891;
+      # `Set[untyped]`, #2177), so they are excluded by class rather than by comparing the erasure with the class
+      # name: like a Float each 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.value.is_a?(::Set) &&
+          type.erase_to_rbs != type.value.class.name
       end
 
       # Heuristic added after the third-round self-dogfood: `FallbackTracer#size` body is `@events.size`, where
@@ -1662,7 +1901,7 @@ module Rigor
       def render_rbs_line(def_node, inferred, class_name, kind)
         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 = method_def_prefix(def_node, kind)
         "#{prefix}#{def_node.name}: #{head} -> #{paren_wrap_union(elaborated_rbs(inferred, owner: class_name))}"
       end
 
@@ -1766,12 +2005,17 @@ module Rigor
       # Per-file context the attr_* walker threads through its recursive descent. Keeps parameter lists in
       # check. `obs_ivar_map` carries the observation-derived fallback types built by
       # {#build_observed_ivar_map}; it is empty when sig-gen is invoked without `--params=observed`.
-      AttrWalkContext = Struct.new(:path, :scope_index, :obs_ivar_map, :out, keyword_init: true)
+      # `definer_table` is {#definer_table}'s map, which drops an attribute another definer replaces. A context
+      # with `definers` only records each attribute's slot and call node for that map, and builds nothing.
+      AttrWalkContext = Struct.new(:path, :scope_index, :obs_ivar_map, :out, :definer_table, :definers,
+                                   keyword_init: true)
       private_constant :AttrWalkContext
 
-      def collect_attr_candidates(root, path, scope_index, obs_ivar_map = {})
+      def collect_attr_candidates(root, path, scope_index, obs_ivar_map = {}, definer_table = {})
+        @lookup_ivars = Set.new
+        collect_lookup_ivar_writes(root, scope_index)
         ctx = AttrWalkContext.new(path: path, scope_index: scope_index,
-                                  obs_ivar_map: obs_ivar_map, out: [])
+                                  obs_ivar_map: obs_ivar_map, out: [], definer_table: definer_table)
         walk_attr_calls(root, [], false, ctx)
         ctx.out
       end
@@ -1816,11 +2060,67 @@ module Rigor
         class_name = prefix.join("::")
         symbol_names = extract_symbol_arguments(call_node)
         return if symbol_names.empty?
+        return record_attr_definers(call_node, class_name, symbol_names, ctx) if ctx.definers
 
         ivar_lookup = ivar_type_lookup(ctx.scope_index, class_name, ctx.obs_ivar_map)
+        offset = call_node.location.start_offset
+        symbol_names.each do |attr_name|
+          ivar_type = with_lookup_nil(ivar_lookup.call(attr_name), class_name, attr_name)
+          candidates = build_attr_candidates(call_node.name, class_name, attr_name, ivar_type, ctx)
+          ctx.out.concat(candidates.select do |c|
+            live_definer?(ctx.definer_table, [class_name, :instance, c.method_name], offset)
+          end)
+        end
+      end
+
+      # #2197 — an attribute whose ivar an instance method assigns from an optimistic lookup (`@x = h[k]`) reads
+      # `nil` on a miss, as such a return does ({Inference::DefReturnTyper.optimistic_value?}), so the written
+      # reader keeps the `nil` the engine's nil-free reading of the lookup drops.
+      def with_lookup_nil(type, class_name, attr_name)
+        return type if type.nil? || !@lookup_ivars.include?([class_name, :"@#{attr_name}"])
+
+        Type::Combinator.union(type, Type::Combinator.constant_of(nil))
+      end
+
+      LOOKUP_IVAR_WRITES = [
+        Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode
+      ].freeze
+      private_constant :LOOKUP_IVAR_WRITES
+
+      # Records `[class_name, ivar]` for each ivar an instance `def` assigns an optimistic lookup to. The class
+      # prefixes come from {#collect_other_ivar_writes}' walk, whose own result is not needed here.
+      def collect_lookup_ivar_writes(root, scope_index)
+        collect_other_ivar_writes(root, [], false, Hash.new { |h, k| h[k] = Set.new }) do |def_node, prefix|
+          next if def_node.receiver || prefix.empty?
+
+          scan_lookup_ivar_writes(def_node.body, prefix, scope_index)
+        end
+      end
+
+      def scan_lookup_ivar_writes(node, prefix, scope_index)
+        return unless node.is_a?(Prism::Node)
+
+        record_lookup_ivar_write(node, prefix, scope_index)
+        node.rigor_each_child { |child| scan_lookup_ivar_writes(child, prefix, scope_index) }
+      end
+
+      def record_lookup_ivar_write(node, prefix, scope_index)
+        return unless LOOKUP_IVAR_WRITES.any? { |klass| node.is_a?(klass) }
+
+        scope = scope_index[node.value] || scope_index[node]
+        return if scope.nil? || !Inference::DefReturnTyper.optimistic_value?(
+          node.value, scope, Inference::DefReturnTyper::LookupContext.new(scope_index, {}.compare_by_identity)
+        )
+
+        @lookup_ivars << [prefix.join("::"), node.name]
+      end
+
+      def record_attr_definers(call_node, class_name, symbol_names, ctx)
         symbol_names.each do |attr_name|
-          ivar_type = ivar_lookup.call(attr_name)
-          ctx.out.concat(build_attr_candidates(call_node.name, class_name, attr_name, ivar_type, ctx))
+          ATTR_KINDS.fetch(call_node.name).each do |variant|
+            method_name = variant == :writer ? :"#{attr_name}=" : attr_name
+            ctx.definers << [[class_name, :instance, method_name], call_node]
+          end
         end
       end
 
@@ -1837,7 +2137,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 +2155,112 @@ 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.
+      #
+      # `on_def`, when given, is called with each instance `def` reached and its class prefix, so another
+      # per-class reading of instance-method ivar writes shares this walk ({#collect_lookup_ivar_writes}).
+      def collect_other_ivar_writes(node, prefix, in_block, other_writes, &on_def)
+        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, &on_def) if child_prefix
+        when Prism::SingletonClassNode then return
+        when Prism::DefNode
+          on_def&.call(node, prefix)
+          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, &on_def) }
+      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 +2346,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)