rigortype 0.4.5 → 0.4.6

data/lib/rigor/inference/method_dispatcher.rb

@@ -535,10 +535,9 @@ module Rigor
       # The question is asked HERE, of the same two tiers `resolve` consults and in the same order, rather
       # than reconstructed in the veto: a name this reports as answered is a name the dispatch really would
       # resolve, and no plugin knowledge moves into the engine's veto. The tiers are the gated
-      # `dynamic_return` walk and the ADR-16 synthetic-method index (Tier C `heredoc_templates` emissions
-      # today; the Tier B `Plugin::Macro::TraitRegistry` explosions share that table but cannot populate it
-      # until #476 threads a real environment into the pre-pass that builds it, so no trait member reaches
-      # this predicate in production yet — it will when #476 lands, with no change here).
+      # `dynamic_return` walk and the ADR-16 synthetic-method index (Tier C `heredoc_templates` emissions and
+      # the Tier B `Plugin::Macro::TraitRegistry` explosions, which share that table; since #476 the pre-pass
+      # explodes a trait module whenever the project's RBS declares it).
       #
       # It is a predicate, not a type: the veto's job is to stop the top-level bind, after which the call
       # falls through to the ordinary dispatch chain and the tier that answered here answers there too. The
@@ -1031,6 +1030,7 @@ module Rigor
 
         fallback_receiver = user_class_fallback_receiver(receiver_type, environment)
         return nil if fallback_receiver.nil?
+        return nil if declared_by_external_ancestor?(receiver_type, environment, context)
 
         # Preserve the ORIGINAL receiver type as the `self` substitution so `Kernel#dup: () ->
         # self` and other `self`-returning methods route through Object's RBS while still
@@ -1055,6 +1055,45 @@ module Rigor
         )
       end
 
+      # Issue #2196 — a project class whose ancestry reaches a core or stdlib class before `Object` (`class FL <
+      # Array`) answers a name that class declares from that class, not from `Object` / `Kernel`: Ruby dispatches
+      # `select { … }` on an `FL` to `Array#select`, never to the private `Kernel#select` (`-> Array[String]`). The
+      # ancestor tiers decline such a name where they cannot type it (`RbsDispatch#returns_the_walked_ancestry?`),
+      # and the `Object` fallback then fabricated `Kernel#select`'s answer, so `fields.detect { |f| f.errors }` read
+      # `f` as `String`. The fallback declines the name instead, which leaves the call `Dynamic[top]`.
+      # {ExternalAncestorResolution.resolve} answers nil for a name only `Object`, `Kernel` or `BasicObject` declares,
+      # so `puts` and `raise` keep resolving.
+      def declared_by_external_ancestor?(receiver_type, environment, context)
+        return false unless receiver_type.is_a?(Type::Nominal)
+
+        scope = context.scope
+        return false if scope.nil?
+
+        memo = external_ancestor_memo(scope, environment)
+        key = [receiver_type.class_name, context.method_name]
+        return memo[key] if memo.key?(key)
+
+        memo[key] = !ExternalAncestorResolution.resolve(receiver_type.class_name, context.method_name, :instance,
+                                                        scope: scope, environment: environment,
+                                                        record_dependencies: false).nil?
+      end
+
+      EXTERNAL_ANCESTOR_MEMO_KEY = :__rigor_user_class_fallback_external_ancestor__
+      private_constant :EXTERNAL_ANCESTOR_MEMO_KEY
+
+      # One slot per discovery index and environment, as `RbsDispatch#ancestor_memo_slot` keeps its own: the answer
+      # reads only the frozen discovery tables and the RBS environment, and its walk is withheld from dependency
+      # recording, so it may be served again for the same pair.
+      def external_ancestor_memo(scope, environment)
+        discovery = scope.discovery
+        slot = Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY]
+        unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
+          slot = [discovery, environment, {}]
+          Thread.current[EXTERNAL_ANCESTOR_MEMO_KEY] = slot
+        end
+        slot[2]
+      end
+
       # True when the call node carries an explicit receiver that is not the literal `self`.
       # Such a call cannot legally dispatch to a private method, so the user-class fallback must
       # skip private signatures rather than return a confidently-wrong type. Returns false for
@@ -1257,7 +1296,7 @@ module Rigor
         range_lift = range_new_lift(receiver_type.class_name, arg_types)
         return range_lift if range_lift
 
-        set_lift = set_new_lift(receiver_type.class_name, arg_types)
+        set_lift = set_new_lift(receiver_type.class_name, arg_types, context)
         return set_lift if set_lift
 
         hash_lift = hash_new_lift(receiver_type.class_name, arg_types, context&.call_node)
@@ -1613,19 +1652,10 @@ module Rigor
       # are given or the single argument is a `Tuple` whose every element is a `Constant[T]`.
       # Mirrors `SetFolding#fold_new` but lives here so the `:new` path in
       # `try_meta_introspection` can reach it before the RBS tier answers `Nominal[Set]`.
-      def set_new_lift(class_name, arg_types)
+      def set_new_lift(class_name, arg_types, context = nil)
         return nil unless class_name == "Set"
-        return Type::Combinator.constant_of(::Set.new) if arg_types.empty?
-        return nil if arg_types.size > 1
 
-        arg = arg_types.first
-        return nil unless arg.is_a?(Type::Tuple)
-        return nil unless arg.elements.all?(Type::Constant)
-
-        values = arg.elements.map(&:value)
-        Type::Combinator.constant_of(::Set.new(values))
-      rescue StandardError
-        nil
+        SetFolding.fold_new(arg_types, context&.call_node, context&.block_type)
       end
 
       # `Regexp.new(pattern)` / `Regexp.new(pattern, opts)` — folds to `Constant[Regexp]` when

data/lib/rigor/inference/module_function_state/spellings.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../../source/literals"
+
+module Rigor
+  module Inference
+    module ModuleFunctionState
+      # Issue #2209 — the `module_function` spellings other than the receiverless call that the deferred-ranges
+      # prescan ({ModuleFunctionState.prescan_deferred}) reads: `self.module_function(...)`, and
+      # `send(:module_function, ...)` or `__send__(:module_function, ...)` on no receiver or `self`, which Ruby runs
+      # as the receiverless call. `public_send` raises on a private method such as `module_function`, so it is not
+      # one.
+      #
+      # A literal name gives the `:singleton` row and a `def` argument the `:both` or `:singleton` row a receiverless
+      # call gives. The bare form, and an argument that is neither (`*names`, a local), gives an {ANY_ROW_NAME} row
+      # over the call: the prescan reads neither the toggle these spellings set nor such a name, so every singleton
+      # copy of the owner is uncertain (`DefinerResolution.module_function_row?`).
+      module Spellings
+        SEND_CALLS = %i[send __send__].freeze
+        private_constant :SEND_CALLS
+
+        module_function
+
+        # The arguments the spelling `node` passes `module_function`, or nil for any other call.
+        def arguments(node)
+          arguments = node.arguments&.arguments || []
+          return arguments if node.name == :module_function && node.receiver.is_a?(Prism::SelfNode)
+          return nil unless SEND_CALLS.include?(node.name)
+          return nil unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+          return nil unless Source::Literals.symbol_or_string(arguments.first) == :module_function
+
+          arguments.drop(1)
+        end
+
+        # Appends the rows of the spelling `node` with `arguments` ({.arguments}) to `ranges`, and prescans the rest
+        # as {ModuleFunctionState.prescan_deferred} prescans a receiverless call's.
+        def prescan(node, arguments, qualified_prefix, in_singleton_class, offsets, ranges)
+          owner = qualified_prefix.empty? ? nil : qualified_prefix.join("::")
+          call_span = [node.location.start_offset, node.location.end_offset]
+          any = arguments.empty?
+          arguments.each do |arg|
+            if arg.is_a?(Prism::DefNode)
+              kind = ScopeIndexer.def_singleton?(arg, qualified_prefix, in_singleton_class) ? :singleton : :both
+              ranges << [arg.location.start_offset, arg.location.end_offset, arg.name, kind, owner]
+            elsif (name = Source::Literals.symbol_or_string(arg))
+              ranges << [*call_span, name, :singleton, owner]
+            else
+              any = true
+              nested_prescan(arg, qualified_prefix, in_singleton_class, offsets, ranges)
+            end
+          end
+          ranges << [*call_span, ANY_ROW_NAME, :singleton, owner] if any
+          nested_prescan(node.block, qualified_prefix, in_singleton_class, offsets, ranges) if node.block
+        end
+
+        def nested_prescan(node, qualified_prefix, in_singleton_class, offsets, ranges)
+          ModuleFunctionState.prescan_deferred(node, qualified_prefix, in_singleton_class, offsets, ranges,
+                                               nested: true)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/module_function_state.rb

@@ -318,10 +318,20 @@ module Rigor
         end
       end
 
+      # Issue #2209 — the row name of a deferred-ranges row that stands for every name of its owner
+      # ({Spellings}).
+      ANY_ROW_NAME = :*
+
+      # Issue #2209 — the deferred-ranges row names that make `method_name` a module function on their owner: its
+      # own and {ANY_ROW_NAME}.
+      def row_names(method_name) = [method_name.to_sym, ANY_ROW_NAME]
+
       # The prescan's arms for a call; true when the arm took the call and its subtree.
       def prescanned_call?(node, qualified_prefix, in_singleton_class, offsets, ranges, nested)
         if call?(node)
           prescan_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
+        elsif (arguments = Spellings.arguments(node))
+          Spellings.prescan(node, arguments, qualified_prefix, in_singleton_class, offsets, ranges)
         elsif visibility_reset?(node)
           offsets << [node.location.start_offset, nested ? :maybe_off : :off]
         elsif ScopeIndexer.receiver_eval_call?(node) || (node.block && ScopeIndexer.meta_new_constant_rvalue?(node))
@@ -374,3 +384,5 @@ module Rigor
     end
   end
 end
+
+require_relative "module_function_state/spellings"

data/lib/rigor/inference/mutation_widening.rb

@@ -7,6 +7,7 @@ require_relative "../source/node_children"
 require_relative "content_join"
 require_relative "hash_lookup_mutation"
 require_relative "mutation_rejoin"
+require_relative "deep_erasure"
 require_relative "receiver_alias"
 require_relative "refinement_mutation"
 require_relative "rewrite_mutation"
@@ -200,12 +201,15 @@ module Rigor
       # `Prism::BlockNode`s — each block is processed by its own `eval_call`.
       def widen_after_block(call_node:, outer_scope:)
         block = call_node.block
+        return DeepErasure.widen_symbol_proc(call_node, outer_scope) if DeepErasure.symbol_proc_mutation?(block)
         return outer_scope unless block.is_a?(Prism::BlockNode)
 
         body = block.body
         return outer_scope if body.nil?
 
-        walk_for_outer_mutations(body, outer_scope)
+        scope = walk_for_outer_mutations(body, outer_scope)
+        names = DeepErasure.parameter_names(block.parameters)
+        DeepErasure.widen_element_aliases(call_node.receiver, block.body, names, scope)
       end
 
       def walk_for_outer_mutations(node, scope)
@@ -257,7 +261,6 @@ module Rigor
                                                 Prism::ClassVariableReadNode => %i[cvar with_cvar],
                                                 Prism::GlobalVariableReadNode => %i[global with_global]
                                               })
-      private_constant :ALIAS_ACCESSORS
 
       def widen_alias_read(method_name, read, scope, values: :widen, arg_types: NO_ARG_TYPES)
         getter, builder = ALIAS_ACCESSORS[read.class]

data/lib/rigor/inference/narrowing.rb

@@ -524,7 +524,7 @@ module Rigor
 
         # Issue #1429 — a global or constant subject (`case $stdout when StringIO`) narrows as a local does, and so
         # does an instance variable (#1446).
-        slot = receiver_slot(subject, scope, kinds: CASE_SUBJECT_KINDS)
+        slot = case_subject_slot(subject, scope)
         return [body_scope, scope] if slot.nil?
 
         truthy_type, falsey_type = case_when_types(scope, slot.current, conditions)
@@ -538,6 +538,32 @@ module Rigor
       CASE_SUBJECT_KINDS = %i[local ivar global constant].freeze
       private_constant :CASE_SUBJECT_KINDS
 
+      # The slot a `case` subject narrows. Issue #2211 — a subject that writes a local or instance variable
+      # (`case (x = v)`, `case x = v`) tests the value it stores, which the variable holds in every clause, so the
+      # clauses narrow the variable as they narrow a bare read of it: `case (x = s ? String(s) : nil) when String then
+      # x.upcase end` reads `x` as `String`. A single-statement `(…)` is unwrapped.
+      def case_subject_slot(subject, scope)
+        subject = unwrap_case_subject(subject)
+        case subject
+        when Prism::LocalVariableWriteNode
+          variable_slot(:local, subject.name, scope.local(subject.name), CASE_SUBJECT_KINDS)
+        when Prism::InstanceVariableWriteNode
+          variable_slot(:ivar, subject.name, scope.ivar(subject.name), CASE_SUBJECT_KINDS)
+        else receiver_slot(subject, scope, kinds: CASE_SUBJECT_KINDS)
+        end
+      end
+      private_class_method :case_subject_slot
+
+      # `subject` with each single-statement `(…)` around it removed: the node {.case_subject_slot} narrows through,
+      # which `StatementEvaluator#when_test_rebinds_subject?` reads the same way.
+      def unwrap_case_subject(subject)
+        while subject.is_a?(Prism::ParenthesesNode) && subject.body.is_a?(Prism::StatementsNode) &&
+              subject.body.body.size == 1
+          subject = subject.body.body.first
+        end
+        subject
+      end
+
       # Returns `[body_scope, falsey_scope]` for one clause of a `case` with a subject: a `when` clause narrows
       # through {.case_when_scopes}, and an `in` clause only for a bare class pattern ({.bare_class_pattern_node}),
       # which matches exactly when `subject.is_a?(C)`. Every other pattern can fail to match where a class test
@@ -2762,10 +2788,14 @@ module Rigor
 
         # Issue #1955 — the subject on the match edge of `/re/ === x` (and of `case x when /re/`). `Regexp#===`
         # matches a String, a Symbol by its name, and an object that converts with `to_str`, and answers false for
-        # anything else. Each member narrows to its String and Symbol parts: a `String | nil` subject reads `String`, a
-        # Symbol one stays `Symbol`. The `to_str` conversion is not modelled, so a member that defines `to_str` and is
-        # neither drops out of the edge. A `Dynamic` member is left as it is, since it may be a Symbol at run time. The
-        # no-match edge keeps the entry type: a String that does not match reaches it too.
+        # anything else. A member is kept whole when its class defines `to_str` (#2002) — a String and its
+        # subclasses, a class whose signature, ancestry or project source declares it — or when no signature
+        # declares the class, and a `Dynamic` member is kept, since it may also be a Symbol at run time. Any other
+        # member narrows to its String and Symbol parts, which are only what can match: a `String | nil` subject
+        # reads `String`, a Symbol one stays `Symbol`, an Integer one drops out. An `Object`, `BasicObject` or
+        # module member narrows too (to `String | Symbol`): its instances may be anything, and reading the edge as
+        # the String it most often is keeps `s.length` on it from reporting. The no-match edge keeps the entry type:
+        # a String that does not match reaches it too.
         def regexp_case_equality_type(current, scope)
           members = current.is_a?(Type::Union) ? current.members : [current]
           Type::Combinator.union(*members.map { |member| regexp_case_equality_member(member, scope) })
@@ -2773,6 +2803,7 @@ module Rigor
 
         def regexp_case_equality_member(member, scope)
           return member if member.is_a?(Type::Dynamic)
+          return member if converts_with_to_str?(member, scope)
 
           parts = %w[String Symbol].map do |class_name|
             narrow_class(member, class_name, exact: false, environment: scope.environment, scope: scope)
@@ -2780,6 +2811,36 @@ module Rigor
           Type::Combinator.union(*parts)
         end
 
+        # True when a class `member` dispatches through declares `to_str`, or is declared by no signature
+        # ({#class_lacks_method?} answers false for it). `Object`, `BasicObject` and a module String or Symbol
+        # includes (`Kernel`, `Comparable`) are read as their String and Symbol parts instead: their instances may be
+        # anything, and the String they most often are keeps a String method on the arm from reporting. Any other
+        # module is kept whole, since a matching value may include it; so is one of those that declares `to_str`.
+        def converts_with_to_str?(member, scope)
+          targets = ProjectMethodOwnership.targets(member)
+          return false if targets.nil? || targets.empty?
+
+          targets.any? { |class_name, kind| class_converts_with_to_str?(class_name, kind, scope) }
+        end
+
+        # The modules String's or Symbol's own ancestry includes, read from the running Ruby.
+        STRING_SYMBOL_MODULES = (String.ancestors + Symbol.ancestors).grep_v(Class).filter_map(&:name).uniq.freeze
+        private_constant :STRING_SYMBOL_MODULES
+
+        def class_converts_with_to_str?(class_name, kind, scope)
+          return false if kind == :instance && OPEN_SURFACE_CLASSES.include?(class_name)
+          if kind == :instance && scope.environment.rbs_module?(class_name)
+            return module_declares_to_str?(class_name, scope) || !STRING_SYMBOL_MODULES.include?(class_name)
+          end
+
+          !class_lacks_method?(class_name, :to_str, kind, scope)
+        end
+
+        def module_declares_to_str?(module_name, scope)
+          ProjectMethodOwnership.defines?(module_name, :to_str, :instance, scope) ||
+            !ExternalAncestorResolution.method_definition(module_name, :to_str, :instance, scope: scope).nil?
+        end
+
         def unwrap_parens(node)
           while node.is_a?(Prism::ParenthesesNode) && node.body.is_a?(Prism::StatementsNode) &&
                 node.body.body.size == 1

data/lib/rigor/inference/object_mixins.rb

@@ -123,9 +123,14 @@ module Rigor
       # all.
       def answer_for_entry(scope, entry, method_name)
         unless entry.external?
-          return source_defines?(scope, entry.name, method_name) ? [:source, entry.name] : nil
+          defines = source_defines?(scope, entry.name, method_name) || macro_named?(scope, entry.name, method_name)
+          return defines ? [:source, entry.name] : nil
         end
 
+        # Issue #2094 — a project module with no `def` is held as an external; a macro of its body may name it.
+        named = entry.candidates.find { |candidate| macro_named?(scope, candidate, method_name) }
+        return [:source, named] if named
+
         entry.candidates.each do |candidate|
           definition = Rigor::Reflection.instance_method_definition(candidate, method_name, scope: scope)
           return [private_definition?(definition) ? :private_rbs : :rbs, candidate, definition] if definition
@@ -137,6 +142,13 @@ module Rigor
       end
       private_class_method :answer_for_entry
 
+      # Issue #2094 — whether a class-body macro of `owner` was handed `method_name` as a literal
+      # (`dsl_method :xdyn`, `def_delegators :@target, :xdyn`). The indexer files every such name as an opaque
+      # envelope, since what the macro defines under it is unknown, so the module may define the name.
+      def macro_named?(scope, owner, method_name)
+        scope.parameter_envelopes_of(owner).key?([:instance, method_name.to_sym])
+      end
+
       def private_definition?(definition)
         definition.respond_to?(:accessibility) && definition.accessibility == :private
       end

data/lib/rigor/inference/project_seed_tables.rb

@@ -39,7 +39,8 @@ module Rigor
       # `dependencies.source_inference:`), and no `discovery_seed:` base is merged in (the runner can start from one).
       NOT_SEEDED = {
         run_generation: "the identity token of a check run's return memo; these paths run no check",
-        constant_sources: "read only by dependency recording, which only an incremental check run turns on",
+        constant_sources: "read by dependency recording and the #663 pre_eval retraction; a seed carries it only " \
+                          "when asked (DiscoverySeed.tables_for_buffer(constant_sources: true), the editor publish)",
         param_inferred_types: "the parameter-inference output itself; each caller adds its own " \
                               "(DiscoverySeed.build, coverage under parameter_inference:, the collector's last round)"
       }.freeze

data/lib/rigor/inference/project_yielder.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Issue #2127 — whether a call to a PROJECT method may run the block it passes more than once, read off the
+    # callee's body. {BlockRepetition.may_repeat?} answers only for the core iterators {ClosureEscapeAnalyzer}
+    # catalogues, so `def yielder = (yield; yield)` or the idiomatic wrapper `def each = @items.each { |i| yield i }`
+    # counted as running the block once, and a `return` in the block that only a later run reaches (`each { return
+    # false if (seen += 1) > 3 }`) never joined the method's return type.
+    #
+    # Only the later-run `return` pass asks this (`StatementEvaluator#collect_repeated_block_returns`); the block's
+    # entry scopes and the ADR-56 write-back keep {BlockRepetition}'s rule. That pass only widens the method's
+    # return type, so the rule here errs toward "repeats". The callee repeats when its body, outside a nested `def`
+    # (a `yield` in a class body is a syntax error inside a method):
+    #
+    # - holds two or more sites that run the block (`yield`, or `call` / `yield` / `===` / `[]` on the `&blk`
+    #   parameter), or one inside a loop, a block or a lambda, which may run it many times; or
+    # - hands the block on (`each(&blk)`, `each(&)`, `...` forwarding) or reads the `&blk` parameter any other way
+    #   (stores it, passes it as an argument), so code the walk does not see may run it any number of times.
+    #
+    # A callee the analysis cannot resolve to a project `def` (an unknown receiver, a method defined by
+    # metaprogramming) answers false, as before.
+    module ProjectYielder
+      module_function
+
+      BLOCK_RUN_CALLS = Set[:call, :yield, :===, :[]].freeze
+      REPEATING_NODES = Set[Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::BlockNode,
+                            Prism::LambdaNode].freeze
+      private_constant :BLOCK_RUN_CALLS, :REPEATING_NODES
+
+      def may_run_block_repeatedly?(call_node, receiver_type, scope)
+        def_node = callee_def(call_node, receiver_type, scope)
+        return false unless def_node.is_a?(Prism::DefNode) && def_node.body
+
+        repeats?(def_node)
+      rescue StandardError
+        false
+      end
+
+      # Issue #2301 — whether the callee hands the block it is called with on to another call (`g(x, &)`,
+      # `g(x, &blk)`), outside a nested `def`. The block-return pass types such a forward's target `yield` as the
+      # caller's block ({ExpressionTyper#forwarded_block_return_type}), and the target may run it any number of
+      # times, so the caller's block is typed as one that may repeat. Answers false where the callee does not resolve.
+      def hands_block_on?(call_node, receiver_type, scope)
+        def_node = callee_def(call_node, receiver_type, scope)
+        return false unless def_node.is_a?(Prism::DefNode) && def_node.body
+
+        hand_off_in?(def_node.body, def_node.parameters&.block&.name)
+      rescue StandardError
+        false
+      end
+
+      def hand_off_in?(node, block_name)
+        return false if node.is_a?(Prism::DefNode)
+        return true if node.is_a?(Prism::BlockArgumentNode) && forwards_block?(node, block_name)
+
+        node.compact_child_nodes.any? { |child| hand_off_in?(child, block_name) }
+      end
+
+      # The `def` an instance call on a project class, a singleton call on one, or an implicit-self call to a
+      # top-level method resolves to.
+      def callee_def(call_node, receiver_type, scope)
+        name = call_node.name
+        found =
+          case receiver_type
+          when Type::Nominal then scope.user_def_through_ancestors(receiver_type.class_name, name).first
+          when Type::Singleton then scope.singleton_def_for(receiver_type.class_name, name)
+          end
+        found || (call_node.receiver.nil? ? scope.top_level_def_for(name) : nil)
+      end
+
+      def repeats?(def_node)
+        block_param = def_node.parameters&.block
+        counter = { sites: 0, repeats: false }
+        walk(def_node.body, block_param&.name, false, counter)
+        counter[:repeats] || counter[:sites] >= 2
+      end
+
+      def walk(node, block_name, repeating, counter)
+        return if counter[:repeats] || node.is_a?(Prism::DefNode)
+
+        skipped = visit(node, block_name, repeating, counter)
+        inner = repeating || REPEATING_NODES.include?(node.class)
+        node.compact_child_nodes.each do |child|
+          walk(child, block_name, inner, counter) unless child.equal?(skipped)
+        end
+      end
+
+      # Counts `node` and answers the child the walk must not visit: the `blk` receiver of a `blk.call`, which is a
+      # run, not a hand-off.
+      def visit(node, block_name, repeating, counter)
+        case node
+        when Prism::YieldNode then run_site(repeating, counter)
+        when Prism::ForwardingArgumentsNode then counter[:repeats] = true
+        when Prism::BlockArgumentNode then counter[:repeats] = true if forwards_block?(node, block_name)
+        when Prism::CallNode
+          return unless block_run_call?(node, block_name)
+
+          run_site(repeating, counter)
+          node.receiver
+        when Prism::LocalVariableReadNode then counter[:repeats] = true if block_name && node.name == block_name
+        end
+      end
+
+      def run_site(repeating, counter)
+        counter[:sites] += 1
+        counter[:repeats] = true if repeating
+      end
+
+      # `blk.call` and its spellings.
+      def block_run_call?(node, block_name)
+        receiver = node.receiver
+        !block_name.nil? && receiver.is_a?(Prism::LocalVariableReadNode) && receiver.name == block_name &&
+          BLOCK_RUN_CALLS.include?(node.name)
+      end
+
+      # `&blk` or an anonymous `&` handed to another call.
+      def forwards_block?(node, block_name)
+        expression = node.expression
+        expression.nil? || (expression.is_a?(Prism::LocalVariableReadNode) && expression.name == block_name)
+      end
+    end
+  end
+end

data/lib/rigor/inference/scope_indexer/certainty.rb

@@ -66,6 +66,15 @@ module Rigor
           classifier.result
         end
 
+        # Issue #2021 — every contribution of the tree under `root`, for a file discovery reached only through a
+        # `require_relative` walk: another file the walk does not see may redefine what it defines, so none of its
+        # contributions is certain.
+        def every_contribution(root)
+          classifier = Classifier.new
+          classifier.possible(root)
+          classifier.result
+        end
+
         # Whether `node` was classified possible in `possible` (a {possible_nodes} answer).
         def possible?(possible, node)
           !possible.empty? && possible.include?(node)

data/lib/rigor/inference/scope_indexer/declared_ivar_types.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../../reflection"
+require_relative "../rbs_type_translator"
+
+module Rigor
+  module Inference
+    module ScopeIndexer
+      # Issue #1406 — an ivar the class's RBS declares, as `@x: T` or through an `attr_reader x: T` /
+      # `attr_writer` / `attr_accessor` member (in `sig/`, or inline `attr_reader :x #: T`), reads the declared type
+      # in place of the census's join of the writes. The declaration is the author's contract for the field, so it
+      # wins over every write the census saw, #541's untyped `attr_writer` write included; whether the writes
+      # honour it is ADR-112 WD5's question (#1075), not this one's. It serves
+      # checking only: `rigor sig-gen` indexes with `declared_ivar_types: false` and keeps the census's answer.
+      #
+      # Only an ivar the census already holds is replaced, so a declaration adds no entry the file's writes did not.
+      # A declaration is not taken when it is `untyped` (what rbs-inline supplies for a bare `attr_reader :x`, which
+      # the type specification reads as a placeholder) or mentions a type variable (`@x: T` in `class Box[T]` is
+      # unsolved at a read), and the census entry stands.
+      module DeclaredIvarTypes
+        module_function
+
+        def apply!(accumulator, scope)
+          environment = scope&.environment
+          return if environment.nil?
+
+          accumulator.each do |class_name, entries|
+            next unless class_name.is_a?(String) # a guard: the side-table keys are deleted before this runs
+
+            declared = declared_ivars(class_name, environment)
+            next if declared.empty?
+
+            accumulator[class_name] = entries.to_h do |ivar, type|
+              [ivar, declared.fetch(ivar, type)]
+            end
+          end
+        end
+
+        # `{ivar name => Rigor::Type}` for the ivars `class_name`'s RBS instance definition declares with a usable
+        # type, or `{}`.
+        def declared_ivars(class_name, environment)
+          definition = Reflection.instance_definition(class_name, environment: environment)
+          return {} if definition.nil?
+
+          instance = Type::Combinator.nominal_of(class_name)
+          definition.instance_variables.each_with_object({}) do |(name, variable), acc|
+            type = translate(variable.type, instance, environment)
+            acc[name] = type if type
+          end
+        rescue StandardError # a guard: a definition that fails to build declares nothing
+          {}
+        end
+
+        def translate(rbs_type, instance, environment)
+          return nil unless rbs_type.free_variables.empty?
+
+          type = RbsTypeTranslator.translate(rbs_type, self_type: instance, instance_type: instance,
+                                                       alias_expander: environment.rbs_loader)
+          type.is_a?(Type::Dynamic) ? nil : type
+        end
+      end
+    end
+  end
+end