rigortype 0.4.3 → 0.4.5

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
@@ -20,7 +21,28 @@ module Rigor
     # First-found wins on duplicate declarations across files; RBS itself allows the same class to be declared
     # in multiple files for additive member contributions, but the writer only needs one canonical target per
     # class.
+    #
+    # ADR-122 WD2 adds the member level: `(class_name, method_name, kind) → sig_file_path`, so a member the project
+    # already declares in one file is updated there rather than inserted a second time into the class's
+    # first-found file (#1488).
     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; 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]]
+        else []
+        end
+      end
+
       # @param signature_paths —
       #   the `.rigor.yml`-configured signature directories.
       #   When `nil` or empty, falls back to `<project_root>/sig`
@@ -29,6 +51,7 @@ module Rigor
       def initialize(signature_paths:, project_root: Dir.pwd)
         @signature_paths = resolve_paths(signature_paths, project_root)
         @index = nil
+        @members = nil
       end
 
       # @param class_name — fully-qualified Ruby class
@@ -40,6 +63,13 @@ module Rigor
         index[class_name]
       end
 
+      # @return absolute path of the first sig file (in the same order as {#file_for}) that declares
+      #   `method_name` of `kind` on `class_name`, or `nil` when no file does.
+      def member_file_for(class_name, method_name, kind)
+        index
+        @members[[class_name, method_name, kind]]
+      end
+
       def empty?
         index.empty?
       end
@@ -60,14 +90,16 @@ module Rigor
 
       def build_index
         accumulator = {}
+        @members = {}
         Array(@signature_paths).each do |dir|
           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
+        @members.freeze
         accumulator.freeze
       end
 
@@ -97,6 +129,13 @@ module Rigor
         local_name = decl.name.to_s.sub(/\A::/, "")
         full = prefix.empty? ? local_name : "#{prefix.join('::')}::#{local_name}"
         accumulator[full] ||= rbs_path
+        decl.members.each do |member|
+          # An `overloading?` member (`def f: ... | ...`) adds to a declaration elsewhere; routing a candidate to
+          # it would replace the user's overload.
+          next if member.is_a?(RBS::AST::Members::MethodDefinition) && member.overloading?
+
+          self.class.member_keys(member).each { |name, kind| @members[[full, name, kind]] ||= rbs_path }
+        end
 
         record_decls(decl.members, prefix + [local_name], rbs_path, accumulator)
       end

data/lib/rigor/sig_gen/method_candidate.rb

@@ -68,6 +68,14 @@ module Rigor
         @declared_annotations + @annotations + [@rbs].compact
       end
 
+      # The RBS member kind `rbs` declares: `:singleton_instance` for a `def self?.` line (a `module_function`
+      # method, whose `kind` stays `:instance`), `kind` otherwise. The writer replaces only a member of this
+      # kind, so an overwrite neither drops a `self?.` member's singleton half nor adds one beside a split
+      # `def self.f` / `def f` pair (#1488).
+      def rbs_kind
+        kind == :instance && rbs.to_s.start_with?("def self?.") ? :singleton_instance : kind
+      end
+
       # A copy carrying a different annotation decision. The generator's effect pass rebuilds rather than
       # mutates, because a candidate is frozen the moment it is built.
       def with_effect_annotation(annotations, reason)

data/lib/rigor/sig_gen/observation_collector.rb

@@ -10,6 +10,7 @@ require_relative "../source/constant_path"
 require_relative "../source/literals"
 require_relative "../source/node_children"
 require_relative "../inference/scope_indexer"
+require_relative "../rooted_glob"
 
 module Rigor
   module SigGen
@@ -32,6 +33,7 @@ module Rigor
     #   `let` / `subject` bindings ride on slice 5's optional `rigor-rspec` integration.
     # - Calls whose receiver does not type as a `Type::Nominal` (e.g. `(some_dynamic).bar(...)`) are skipped —
     #   the collector cannot attribute them to a specific class.
+    # - A `T | nil` receiver with one `Nominal` / `Singleton` non-nil member counts as that member (#1389).
     # - Zero-argument calls give no observation; methods are matched by `(class_name, method_name)` only.
     class ObservationCollector # rubocop:disable Metrics/ClassLength
       # @param paths — observe paths (files /
@@ -62,6 +64,12 @@ module Rigor
         observations.transform_values(&:freeze).freeze
       end
 
+      # Whether `arg` names something {#collect} reads: a directory, or a `.rb` file. The CLI's
+      # `observation` report splits roots on this, so "observed" means what the collector does (#1398).
+      def self.readable_root?(arg)
+        File.directory?(arg) || (File.file?(arg) && arg.end_with?(".rb"))
+      end
+
       private
 
       # Issue #821 — same universe as the generator and as `rigor check`; see
@@ -74,8 +82,8 @@ module Rigor
       def resolve_paths(args)
         args.flat_map do |arg|
           if File.directory?(arg)
-            Dir.glob(File.join(arg, "**/*.rb"), sort: true)
-          elsif File.file?(arg) && arg.end_with?(".rb")
+            RootedGlob.glob(arg, "**/*.rb")
+          elsif self.class.readable_root?(arg)
             [arg]
           else
             []
@@ -92,8 +100,9 @@ module Rigor
         base_scope = base_scope.with_discovery(base_scope.discovery.with(discovered_classes: discovered_classes))
         scope_index = Inference::ScopeIndexer.index(parse_result.value, default_scope: base_scope)
         bindings = collect_rspec_bindings(parse_result.value, scope_index)
+        @before_ivars = collect_before_ivars(parse_result.value, scope_index)
 
-        walk_calls(parse_result.value, scope_index, bindings, observations)
+        walk_calls(parse_result.value, scope_index, bindings, observations, [])
       end
 
       # Pre-walks `@source_paths` to collect every qualified class / module declaration. The result seeds the
@@ -145,22 +154,64 @@ module Rigor
         end
       end
 
-      def walk_calls(node, scope_index, bindings, observations)
+      # `blocks` is the chain of enclosing RSpec group / example / hook blocks, innermost last — the blocks a
+      # `before` ivar can reach the call from ({#before_ivar_type}). See {#enclosing_blocks} for where it is cut.
+      def walk_calls(node, scope_index, bindings, observations, blocks)
         return unless node.is_a?(Prism::Node)
 
-        record_call(node, scope_index, bindings, observations) if node.is_a?(Prism::CallNode)
-        node.rigor_each_child { |child| walk_calls(child, scope_index, bindings, observations) }
+        record_call(node, scope_index, bindings, observations, blocks) if node.is_a?(Prism::CallNode)
+        node.rigor_each_child do |child|
+          walk_calls(child, scope_index, bindings, observations, enclosing_blocks(node, child, blocks))
+        end
+      end
+
+      # Group, example and hook calls whose block runs with the example's ivars. `RSpec.` may prefix a group call.
+      RSPEC_GROUP_CALLS = %i[
+        describe context feature shared_examples shared_examples_for shared_context
+      ].freeze
+      RSPEC_EXAMPLE_OR_HOOK_CALLS = %i[
+        it specify example scenario its before prepend_before append_before
+      ].freeze
+      private_constant :RSPEC_GROUP_CALLS, :RSPEC_EXAMPLE_OR_HOOK_CALLS
+
+      # The chain `child` of `parent` sees. A group / example / hook call's block extends it; every other block or
+      # lambda (`Class.new { … }`, `instance_eval { … }`, `define_method(:m) { … }`, `each { … }`), a class / module /
+      # singleton-class body, and a `def` that is not a direct statement of a group block cut it, since their `self`
+      # may be another object.
+      def enclosing_blocks(parent, child, blocks)
+        case child
+        when Prism::BlockNode then rspec_scope_call?(parent) ? [*blocks, child] : []
+        when Prism::LambdaNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode then []
+        when Prism::DefNode then group_statement?(child, blocks.last) ? blocks : []
+        else blocks
+        end
+      end
+
+      def rspec_scope_call?(node)
+        return false unless node.is_a?(Prism::CallNode)
+        return rspec_group_receiver?(node.receiver) if RSPEC_GROUP_CALLS.include?(node.name)
+
+        node.receiver.nil? && RSPEC_EXAMPLE_OR_HOOK_CALLS.include?(node.name)
       end
 
-      def record_call(call_node, scope_index, bindings, observations)
+      def rspec_group_receiver?(receiver)
+        receiver.nil? || (receiver.is_a?(Prism::ConstantReadNode) && receiver.name == :RSpec)
+      end
+
+      def group_statement?(node, block)
+        body = block&.body
+        body.is_a?(Prism::StatementsNode) && body.body.any? { |statement| statement.equal?(node) }
+      end
+
+      def record_call(call_node, scope_index, bindings, observations, blocks)
         receiver = call_node.receiver
         return if receiver.nil?
 
         scope = scope_index[call_node] || scope_index[receiver]
         return if scope.nil?
 
-        receiver_type = resolve_receiver_type(receiver, scope, bindings)
-        key = observation_key(call_node, receiver_type)
+        receiver_type = resolve_receiver_type(receiver, scope, bindings, blocks)
+        key = observation_key(call_node, observed_receiver(receiver_type, call_node, scope))
         return if key.nil?
 
         observation = collect_args(call_node, scope)
@@ -181,6 +232,36 @@ module Rigor
         end
       end
 
+      # Issue #1389 — a receiver typed `T | nil` whose one non-nil member is a `Nominal` or `Singleton` is observed as
+      # that member. A Minitest `setup` ivar read in a test method types as `Foo?` (setup is not `initialize`), and a
+      # call of a method `nil` does not answer can only have reached `Foo#bar` with its arguments: on `nil` it raises
+      # `NoMethodError`, and `&.` skips the call. A method `NilClass`'s RBS declares (`==`, `respond_to?`, `is_a?`)
+      # may have run on `nil` instead, so a plain `.` call of one keeps the union unobserved. The sole member still
+      # has to pass {#observation_key}'s `Nominal` / `Singleton` checks, so `untyped | nil` stays unobserved, and a
+      # union with two non-nil members (`Foo | Bar | nil`) passes through unchanged. Observation only: the
+      # receiver's inferred type elsewhere is untouched.
+      def observed_receiver(receiver_type, call_node, scope)
+        return receiver_type unless receiver_type.is_a?(Type::Union)
+
+        non_nil = receiver_type.members.reject { |member| nil_type?(member) }
+        return receiver_type unless non_nil.size == 1
+        return receiver_type if !call_node.safe_navigation? && nil_answers?(call_node.name, scope)
+
+        non_nil.first
+      end
+
+      # Whether `nil` may answer `method_name`: `NilClass`'s RBS declares it, or that RBS is not available to ask.
+      def nil_answers?(method_name, scope)
+        loader = scope.environment.rbs_loader
+        return true if loader.nil? || loader.instance_definition("NilClass").nil?
+
+        !loader.instance_method(class_name: "NilClass", method_name: method_name).nil?
+      end
+
+      def nil_type?(type)
+        (type.is_a?(Type::Constant) && type.value.nil?) || (type.is_a?(Type::Nominal) && type.class_name == "NilClass")
+      end
+
       # ADR-14 slice 5 — RSpec-aware receiver typing. Resolves a CallNode receiver against the collected
       # `bindings` map (built by {#collect_rspec_bindings}) before falling back to ordinary `scope.type_of`. The
       # three RSpec-shaped receivers we recognise:
@@ -190,11 +271,23 @@ module Rigor
       # - `described_class.new(...)` chain — when the surrounding `describe Foo do … end` resolved `Foo`,
       #   return `Type::Nominal[Foo]`.
       # - Anything else — pass through to `scope.type_of`, matching slice-3 behaviour.
-      def resolve_receiver_type(receiver, scope, bindings)
+      def resolve_receiver_type(receiver, scope, bindings, blocks)
         return resolve_described_class_new(bindings) if described_class_new?(receiver)
         return bindings[receiver.name] if bound_call?(receiver, bindings)
 
-        safe_type_of(scope, receiver)
+        type = safe_type_of(scope, receiver)
+        return type unless receiver.is_a?(Prism::InstanceVariableReadNode) && (type.nil? || type.is_a?(Type::Dynamic))
+
+        before_ivar_type(receiver.name, blocks) || type
+      end
+
+      # Issue #1389 — an ivar read inside an `it` block types as `Dynamic` (the block's ivars are not a class's), so
+      # a `before { @foo = Foo.new }` write stands in for it. Only a `before` whose example-group block encloses the
+      # read counts — a sibling `describe`, an un-included `shared_context` or a class body never reaches it — and
+      # when those `before`s write the name with more than one type, no type is answered.
+      def before_ivar_type(name, blocks)
+        types = blocks.flat_map { |block| @before_ivars.dig(block, name) || [] }.uniq
+        types.size == 1 ? types.first : nil
       end
 
       def bound_call?(receiver, bindings)
@@ -279,6 +372,39 @@ module Rigor
         bindings[name] = body_type if body_type
       end
 
+      # `before { @foo = Foo.new }` / `before(:each) do … end` inside an example-group block: records each ivar the
+      # `before` block's top-level statements write, with the written value's type, under that enclosing group
+      # block — `{ BlockNode => { :@foo => [Type] } }`, keyed by node identity. A `before` outside every group
+      # block ({#enclosing_blocks}), and `config.before`, record nothing.
+      def collect_before_ivars(root, scope_index)
+        index = {}.compare_by_identity
+        walk_before_ivars(root, [], index, scope_index)
+        index
+      end
+
+      def walk_before_ivars(node, blocks, index, scope_index)
+        return unless node.is_a?(Prism::Node)
+
+        record_before_ivars(node, blocks.last, index, scope_index) if blocks.last
+        node.rigor_each_child do |child|
+          walk_before_ivars(child, enclosing_blocks(node, child, blocks), index, scope_index)
+        end
+      end
+
+      def record_before_ivars(node, group, index, scope_index)
+        return unless node.is_a?(Prism::CallNode) && node.name == :before && node.receiver.nil?
+
+        body = block_body_node(node.block)
+        statements = body.is_a?(Prism::StatementsNode) ? body.body : [body].compact
+        statements.each do |statement|
+          next unless statement.is_a?(Prism::InstanceVariableWriteNode)
+
+          scope = scope_index[statement.value] || scope_index[statement]
+          type = scope && safe_type_of(scope, statement.value)
+          ((index[group] ||= {})[statement.name] ||= []) << type if type
+        end
+      end
+
       def binding_name_for(call_node)
         first_arg = call_node.arguments&.arguments&.first
         return call_node.name == :subject ? :subject : nil if first_arg.nil?