rigortype 0.4.1 → 0.4.3

data/lib/rigor/inference/expression_typer.rb

@@ -28,6 +28,7 @@ require_relative "fallback"
 require_relative "flow_tracer"
 require_relative "index_write_widening"
 require_relative "indexed_narrowing"
+require_relative "key_presence_guard"
 require_relative "jump_targets"
 require_relative "define_method_block_self"
 require_relative "macro_block_self_type"
@@ -39,6 +40,7 @@ require_relative "optimistic_origin"
 require_relative "receiver_alias"
 require_relative "repeated_or_writes"
 require_relative "singleton_object_constant"
+require_relative "refined_dispatch"
 require_relative "stored_block_call"
 require_relative "struct_fold_safety"
 require_relative "unknown_store_widening"
@@ -648,7 +650,12 @@ module Rigor
       # `StatementEvaluator` at class-body and method-body boundaries) or `Dynamic[Top]` at the top level.
       # Class-body `self` is `Singleton[<class>]`; instance-method `self` is `Nominal[<class>]`;
       # singleton-method `self` is `Singleton[<class>]`.
+      #
+      # Issue #1763 — directly in a `refine X` block body `self` is the refinement module, which Rigor does not
+      # model; its `Singleton[X]` stand-in serves implicit-self calls only, so a value read of `self` is untyped.
       def type_of_self_node(_node)
+        return dynamic_top if scope.refinement_block_self?
+
         scope.self_type || dynamic_top
       end
 
@@ -1811,7 +1818,8 @@ module Rigor
       # that normal return is `untyped` — the result's declared type — so `loop { e.next }` is not `bot` and
       # `loop { x = e.next; break x if x }` keeps its arm beside it.
       def call_dispatch_type_for(node, receiver_override: nil)
-        result = loop_completion_type(node, call_result_type_for(node, receiver_override: receiver_override))
+        result = key_guarded_type(node, call_result_type_for(node, receiver_override: receiver_override))
+        result = loop_completion_type(node, result)
         arms = call_break_arm_types(node, receiver_override: receiver_override)
         if exactly_once_block_never_completes?(node, receiver_override)
           return arms.empty? ? Type::Combinator.bot : Type::Combinator.union(*arms)
@@ -1821,6 +1829,15 @@ module Rigor
         widen_optimistic_predicate_constant(node, combined)
       end
 
+      # Issue #1703 — `H[k]` under a true `H.key?(k)` with a non-literal key drops the miss `nil`
+      # ({KeyPresenceGuard.guarded_read}). Only inside the guarded re-walk `call.possible-nil-receiver` runs to
+      # decide whether to withhold a report; the analysis every other rule reads never records a guard.
+      def key_guarded_type(node, type)
+        return type unless node.name == :[]
+
+        KeyPresenceGuard.guarded_read(node, type, scope) || type
+      end
+
       # Issue #1172 — the nil-collapsing predicates (`nil?`, `!`, `x == nil`, …) answer a `Constant` that
       # encodes the receiver's nil-freeness. When that nil-freeness is only *optimistic* — an
       # `%a{implicitly-returns-nil}` read `RbsDispatch` deliberately reads past — the constant is a bet,
@@ -1896,6 +1913,9 @@ module Rigor
         # asks nothing further of dispatch. Off (the default) this is one integer read.
         Effects::Collector.record_call(node, receiver, scope) if Effects::Collector.active?
 
+        refined = try_refined_dispatch(node, receiver, arg_types, block_type)
+        return refined if refined
+
         literal_send = try_literal_send(node, receiver)
         return literal_send if literal_send
 
@@ -1927,6 +1947,173 @@ module Rigor
         dispatch_miss_result(node, receiver, arg_types, block_type)
       end
 
+      # ADR-121 WD2 (issue #1664) — a call through an in-effect Ruby refinement, typed from the winning refine body
+      # with the call's receiver as `self`, ahead of every tier below: each answers from the method the refinement
+      # replaces (a refined `String#upcase` must not fold, a refined `map` must not fold per element, a top-level
+      # `def` must not bind ahead of a refinement of `Object`, a plugin models the class's own method). An unreadable
+      # body, or a list that may hold any refinement, answers `Dynamic[top]`, never the replaced method's signature.
+      # A union receiver is decided per member; a `Dynamic` receiver and a call no refinement wins fall through. A
+      # class object walks its own lookup (issue #1752): under `refine(Object) { def oo = :o }` a refinement that wins
+      # `Integer.oo` answers `Dynamic[top]` ({#refined_class_object_result}). A call site no refinement is in effect
+      # at answers nil at once and records nothing: its answer cannot change without an edit to its own file.
+      #
+      # ADR-121 WD7 (A2) — inside the span of an activation that puts an opaque module in effect
+      # ({InEffectRefinements.opaque_module?}), any method of any object may be replaced, so every call on an instance
+      # or a class object answers `Dynamic[top]`.
+      def try_refined_dispatch(node, receiver, arg_types, block_type)
+        list = scope.in_effect_refinements(node)
+        return nil if list.empty?
+
+        InEffectRefinements.record_refinement_names(node.name)
+        return dynamic_top if refined_receiver?(receiver) && opaque_refinement_span?(node, list)
+        return nil if scope.discovered_refinements.empty?
+
+        refined_indirect_result(node, receiver, list) ||
+          refined_receiver_result(node, receiver, list, arg_types, block_type)
+      end
+
+      # ADR-121 WD4 — `send` / `__send__` / `public_send` with a literal name, `respond_to?` and `method` /
+      # `public_method` with one, and a `&:name` block argument honour refinements too (CRuby `test_refinement.rb`;
+      # probed on Ruby 4.0.5). When the name they reach is refined in effect for the receiver they answer
+      # `Dynamic[top]`: typing them through the arm is deferred, and `respond_to?` must never fold to `false`. A
+      # `&:name` block's receiver is the yielded element, which is not known here, so any in-effect refinement of the
+      # name answers. Only `methods` ignores refinements and keeps its answer.
+      def refined_indirect_result(node, receiver, list)
+        name = REFINED_NAMING_CALLS.include?(node.name) ? literal_method_name_argument(node) : nil
+        return dynamic_top if name && refined_name_for?(receiver, name, list)
+
+        block_name = symbol_block_argument(node)
+        dynamic_top if block_name && refined_anywhere?(block_name, list)
+      end
+
+      REFINED_NAMING_CALLS = Set[:send, :__send__, :public_send, :respond_to?, :method, :public_method].freeze
+      private_constant :REFINED_NAMING_CALLS
+
+      def literal_method_name_argument(node)
+        argument = node.arguments&.arguments&.first
+        name = argument.unescaped if argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+        return nil if name.nil?
+
+        name = name.to_sym
+        InEffectRefinements.record_refinement_names(name)
+        name
+      end
+
+      def symbol_block_argument(node)
+        block = node.block
+        return nil unless block.is_a?(Prism::BlockArgumentNode) && block.expression.is_a?(Prism::SymbolNode)
+
+        name = block.expression.unescaped.to_sym
+        InEffectRefinements.record_refinement_names(name)
+        name
+      end
+
+      def refined_name_for?(receiver, name, list)
+        members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+        members.any? do |member|
+          next !RefinedDispatch.winner(scope, member.class_name, name, list, kind: :singleton).nil? if
+            member.is_a?(Type::Singleton)
+
+          class_name = refined_receiver_class_name(member)
+          !class_name.nil? && !RefinedDispatch.winner(scope, class_name, name, list).nil?
+        end
+      end
+
+      # ADR-121 WD7 — a names-wildcard row counts as a refinement of every name.
+      def refined_anywhere?(name, list)
+        refinements = scope.discovered_refinements
+        wildcard = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
+        return true if list.include?(InEffectRefinements::UNKNOWN) &&
+                       refinements.any? { |_refined, methods| methods.key?(name) || methods.key?(wildcard) }
+
+        !RefinedDispatch.targets(refinements, name, list).nil? ||
+          !RefinedDispatch.targets(refinements, wildcard, list).nil?
+      end
+
+      # ADR-121 WD7 — does the call's lexical list (a plugin-declared module is the plugin's declaration and never
+      # opaque) hold an opaque module? `list` is the full list, which is the lexical one when nothing is declared.
+      def opaque_refinement_span?(node, list)
+        lexical = scope.declared_refinements.empty? ? list : scope.in_effect_refinements(node, InEffectRefinements::EMPTY)
+        InEffectRefinements.opaque_in?(scope, lexical)
+      end
+
+      # Does `receiver` (or a member of a union) have a lookup the refined arm answers for: an instance of a class,
+      # or a class object (issue #1752), not `Dynamic`?
+      def refined_receiver?(receiver)
+        members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+        members.any? { |member| member.is_a?(Type::Singleton) || !refined_receiver_class_name(member).nil? }
+      end
+
+      def refined_receiver_result(node, receiver, list, arg_types, block_type)
+        return refined_member_result(node, receiver, list, arg_types, block_type) unless receiver.is_a?(Type::Union)
+
+        answers = receiver.members.map { |member| refined_member_result(node, member, list, arg_types, block_type) }
+        return nil if answers.none?
+
+        members = receiver.members.each_with_index.map do |member, index|
+          answers[index] || call_result_type_for(node, receiver_override: member)
+        end
+        Type::Combinator.union(*members)
+      end
+
+      def refined_member_result(node, receiver, list, arg_types, block_type)
+        return refined_class_object_result(node, receiver, list, arg_types, block_type) if
+          receiver.is_a?(Type::Singleton)
+
+        class_name = refined_receiver_class_name(receiver)
+        return nil if class_name.nil?
+
+        winner = RefinedDispatch.winner(scope, class_name, node.name, list)
+        return nil if winner.nil?
+        return dynamic_top if winner == RefinedDispatch::UNKNOWN
+
+        refined_body_return(winner, node.name, Type::Combinator.nominal_of(class_name), arg_types, block_type) ||
+          dynamic_top
+      end
+
+      # Issue #1752 — a call on a class object, walked through its singleton levels. A refinement that wins answers
+      # `Dynamic[top]`, never its refine body's type: a hook on any ancestor (an RBS-declared `include Singleton`, a
+      # gem concern, `define_singleton_method(:included)`, a `Module#included` patch) can install the class object's
+      # own method where no table sees it, and the body's type then fires downstream on correct code. A walk that finds
+      # no winner keeps the class object's own answer (`Integer.sqrt(16)` stays `Integer`).
+      def refined_class_object_result(node, receiver, list, _arg_types, _block_type)
+        winner = RefinedDispatch.winner(scope, receiver.class_name, node.name, list, kind: :singleton)
+        dynamic_top unless winner.nil?
+      end
+
+      # The winning refine body's inferred return, re-typed with the receiver's class as `self` and the call's
+      # argument types bound as an undeclared method's are; nil when the body is not readable here.
+      #
+      # A body another file wrote is re-typed with that file's in-effect refinements at the `def` (its own module
+      # among them), so a sibling override it calls answers from its refine body too.
+      def refined_body_return(winner, method_name, self_type, arg_types, block_type)
+        def_node, foreign =
+          InEffectRefinements.refinement_def_with_query(scope, winner.module_name, winner.refined_class, method_name)
+        return nil if def_node.nil?
+
+        refinements = foreign&.at(def_node.location.start_offset) do |name|
+          InEffectRefinements.activated_modules(scope, name)
+        end
+        infer_user_method_return(def_node, self_type, arg_types, yield_type: block_type, refinements: refinements)
+      rescue StandardError
+        nil
+      end
+
+      # The class an instance-side receiver is an instance of, or nil for one this instance walk does not answer: a
+      # class object (it walks its own lookup, {#refined_class_object_result}), `Dynamic`, `top`, or a shape with no
+      # class.
+      def refined_receiver_class_name(receiver)
+        case receiver
+        when Type::Nominal, Type::StructInstance, Type::DataInstance then receiver.class_name
+        when Type::Constant then receiver.value.class.name
+        when Type::Tuple then "Array"
+        when Type::HashShape then "Hash"
+        when Type::IntegerRange then "Integer"
+        when Type::FloatRange then "Float"
+        when Type::Refined, Type::Difference then refined_receiver_class_name(receiver.base)
+        end
+      end
+
       # The post-dispatch tiers for a call `MethodDispatcher` could not answer, in their historical
       # order; extracted from {#call_dispatch_type_for} whole.
       def dispatch_miss_result(node, receiver, arg_types, block_type = nil)
@@ -2284,7 +2471,7 @@ module Rigor
         return every_definer_raises_type(raising, receiver, call_node, arg_types, block_type) if def_node.nil?
 
         result = infer_user_method_return(def_node, receiver, arg_types,
-                                          self_fold_safe: fold_safe_call_receiver?(call_node, receiver),
+                                          self_fold_safe: fold_safe_call_receiver?(call_node),
                                           yield_type: block_type)
         return result if result.nil?
 
@@ -2319,11 +2506,11 @@ module Rigor
       # This is only a property of the receiver expression; whether the grant is actually issued also needs
       # a `StructInstance` carrier and a body that survives the self-use scan, both decided in
       # {#build_user_method_body_scope}.
-      def fold_safe_call_receiver?(call_node, receiver)
+      def fold_safe_call_receiver?(call_node)
         return false if call_node.nil?
 
         case call_node.receiver
-        when Prism::CallNode then materialization_call?(call_node.receiver, receiver)
+        when Prism::CallNode then materialization_call?(call_node.receiver)
         when Prism::LocalVariableReadNode then scope.struct_fold_safe?(call_node.receiver.name)
         when nil, Prism::SelfNode then scope.struct_fold_safe?(:self)
         else false
@@ -2333,10 +2520,10 @@ module Rigor
       # Issue #595 — the materialisation test lives ONCE, in
       # [`struct_materialization.rb`](method_dispatcher/struct_materialization.rb), because the direct
       # member-read gate ({MethodDispatcher::StructFolding}`#fresh_receiver?`) needs the identical answer;
-      # see {MethodDispatcher::StructMaterialization.materialization_call?}. It resolves its own `.with`
-      # guard through `Scope`, so neither consumer supplies a lookup and neither can answer differently.
-      def materialization_call?(node, receiver)
-        MethodDispatcher::StructMaterialization.materialization_call?(node, receiver, scope)
+      # see {MethodDispatcher::StructMaterialization.materialization_call?}. A `.with` call is never one
+      # (`Struct` has no `#with`, #1335), so the test needs no lookup from either consumer.
+      def materialization_call?(node)
+        MethodDispatcher::StructMaterialization.materialization_call?(node, scope)
       end
 
       # Module-singleton call resolution (ADR-57 follow-up) — resolves `Foo.<name>` on a `Singleton[Foo]`
@@ -2505,7 +2692,7 @@ module Rigor
       def every_definer_raises_type(defs, receiver, call_node, arg_types, block_type)
         return nil if defs.nil?
 
-        self_fold_safe = fold_safe_call_receiver?(call_node, receiver)
+        self_fold_safe = fold_safe_call_receiver?(call_node)
         defs.each do |def_node|
           result = infer_user_method_return(def_node, receiver, arg_types,
                                             self_fold_safe: self_fold_safe, yield_type: block_type)
@@ -2959,14 +3146,37 @@ module Rigor
       # not observable on the body scope, so it does need its own memo-key slot. It is dropped for a def
       # that cannot reach a `yield` — nearly all of them — which keeps the key shape constant for the
       # methods the memo actually carries and confines the extra dimension to yielding callees.
-      def infer_user_method_return(def_node, receiver, arg_types, self_fold_safe: false, yield_type: nil)
+      # Issue #1703 — inside the guarded re-walk a callee's return summary is still computed with `key?` guards off
+      # ({KeyPresenceGuard.without_guards}): summaries are memoised for the whole run, and one computed with a guard
+      # would reach the analysis every rule reads.
+      #
+      # Issue #1664 — `refinements` are the modules in effect in a refine body another file wrote, which the body scope
+      # carries as declared refinements: its nodes are not this file's, so this file's lexical list cannot answer them.
+      # The return memo and the recursion guard do not key on them, which holds because such a node comes only from
+      # `DefNodeResolver.refinement_query`'s own parse and always carries that file's one list; a caller that types
+      # the same node under another list must add it to the key.
+      def infer_user_method_return(def_node, receiver, arg_types, self_fold_safe: false, yield_type: nil,
+                                   refinements: nil)
         return nil if def_node.body.nil?
+        unless KeyPresenceGuard.active?
+          return infer_user_method_return_unguarded(def_node, receiver, arg_types, self_fold_safe, yield_type,
+                                                    refinements)
+        end
+
+        KeyPresenceGuard.without_guards do
+          infer_user_method_return_unguarded(def_node, receiver, arg_types, self_fold_safe, yield_type, refinements)
+        end
+      end
 
+      def infer_user_method_return_unguarded(def_node, receiver, arg_types, self_fold_safe, yield_type,
+                                             refinements = nil)
         yield_type = nil unless yield_type && body_yields?(def_node)
         body_scope = build_user_method_body_scope(def_node, receiver, arg_types,
                                                   self_fold_safe: self_fold_safe)
         return nil if body_scope.nil?
 
+        body_scope = body_scope.with_declared_refinements(refinements) if refinements
+
         # Recursion-guard signature. Keyed on `(receiver, method)` only — NOT the argument types. ADR-24 WD5:
         # a method whose summary is still being computed resolves to `Dynamic[top]` for that cycle. Keying on
         # arg types would let mutual recursion through a `module_function` module (`Acceptance#accepts` →
@@ -4021,12 +4231,13 @@ module Rigor
           method_name: call_node.name,
           arg_types: arg_types,
           environment: scope.environment,
-          scope: scope
+          scope: scope,
+          call_node: call_node
         )
         block_return_for(
           block_arg, expected,
           call_node: call_node,
-          narrowed_self_type: block_body_self_narrowing(call_node, receiver_type),
+          narrowing: block_body_self_narrowing(call_node, receiver_type),
           repeats: !BLOCK_VALUE_DISCARDING.include?(call_node.name) && block_may_repeat?(call_node, receiver_type)
         )
       rescue StandardError
@@ -4093,7 +4304,7 @@ module Rigor
         block_scope = block_entry_scope(
           block_node, param_types,
           call_node: call_node,
-          narrowed_self_type: block_body_self_narrowing(call_node, receiver),
+          narrowing: block_body_self_narrowing(call_node, receiver),
           captured: repeating_captured_bindings(block_node, param_types, block_may_repeat?(call_node, receiver))
         )
         _result, collected = StatementEvaluator.with_break_value_sink do
@@ -4102,10 +4313,12 @@ module Rigor
         collected.filter_map { |jump, type| type if targets.key?(jump) }
       end
 
-      # The block body's narrowed `self_type`, or `nil` to leave the scope contract unchanged.
+      # The block body's narrowing — a {MacroBlockSelfType::Match} carrying the narrowed `self_type` and the declared
+      # refinements — or `nil` to leave the scope contract unchanged.
       #
       # ADR-16 Tier A: a registered plugin's `block_as_methods` entry matching `(receiver_type,
-      # call_node.name)` narrows to the receiver class's instance type.
+      # call_node.name)` narrows to the receiver class's instance type, and puts its `refinements:` in effect in the
+      # body (issue #1667).
       #
       # Issue #963: `define_method(:name) { ... }` installs its block as an instance method and runs it with
       # `self` bound to the receiving instance, so the block body's `self` is the INSTANCE side of a class body's
@@ -4115,9 +4328,11 @@ module Rigor
       # matters wherever the block's value is observable, e.g. a project-declared generic `define_method`
       # signature that returns the block's own type.
       def block_body_self_narrowing(call_node, receiver_type)
-        MacroBlockSelfType.narrow_self_type_for(
-          scope: scope, call_node: call_node, receiver_type: receiver_type
-        ) || DefineMethodBlockSelf.narrow_self_type_for(scope: scope, call_node: call_node)
+        match = MacroBlockSelfType.match_for(scope: scope, call_node: call_node, receiver_type: receiver_type)
+        return match if match
+
+        defined = DefineMethodBlockSelf.narrow_self_type_for(scope: scope, call_node: call_node)
+        defined && MacroBlockSelfType::Match.new(self_type: defined, refinements: InEffectRefinements::EMPTY)
       end
 
       def break_arm_param_types(call_node, receiver)
@@ -4126,16 +4341,17 @@ module Rigor
           method_name: call_node.name,
           arg_types: call_arg_types(call_node),
           environment: scope.environment,
-          scope: scope
+          scope: scope,
+          call_node: call_node
         )
       end
 
-      def block_return_for(block_arg, expected, call_node: nil, narrowed_self_type: nil, repeats: false)
+      def block_return_for(block_arg, expected, call_node: nil, narrowing: nil, repeats: false)
         case block_arg
         when Prism::BlockNode
           captured = repeating_captured_bindings(block_arg, expected, repeats)
           entry = block_entry_scope(
-            block_arg, expected, call_node: call_node, narrowed_self_type: narrowed_self_type, captured: captured
+            block_arg, expected, call_node: call_node, narrowing: narrowing, captured: captured
           )
           type_block_body(block_arg, entry, captured: captured)
         when Prism::BlockArgumentNode
@@ -4151,13 +4367,14 @@ module Rigor
       # Issue #316 — mirrors `StatementEvaluator#build_block_entry_scope`: the block body's `self` is the
       # yielding method's business, so the return-typing pass must see the same unmodelled-self mark. Issue #1358
       # — and the same match-global view ({MatchRebinding.block_entry}), which reads the owning `call_node`.
-      def block_entry_scope(block_node, expected, call_node: nil, narrowed_self_type: nil, captured: nil)
+      def block_entry_scope(block_node, expected, call_node: nil, narrowing: nil, captured: nil)
         entry = MatchRebinding.block_entry(scope.entering_opaque_block, block_node, call_node)
         entry = captured.lay(entry) if captured
         block_scope = BlockParameterBinder.new(expected_param_types: expected).bind_onto(block_node, entry)
-        return block_scope unless narrowed_self_type
+        return block_scope unless narrowing
 
-        block_scope.with_self_type(narrowed_self_type)
+        keeps_unknown = call_node ? scope.block_self_narrowing_unknown?(call_node) : false
+        MacroBlockSelfType.apply(block_scope, narrowing, keeps_unknown: keeps_unknown)
       end
 
       # The #587 (b) captured binding when the call may run the block more than once ({#block_may_repeat?}), and
@@ -5218,13 +5435,27 @@ module Rigor
         acc, rest = inject_constant_start(members, seed, has_seed)
         return nil if acc.nil?
 
-        rest.each do |element_value|
-          acc = inject_constant_step(block, acc, element_value)
+        captured = inject_captured_bindings(block, rest.map { |value| Type::Combinator.constant_of(value) })
+        rest.each_with_index do |element_value, position|
+          acc = inject_constant_step(block, acc, element_value, captured, position)
           return nil if acc.nil?
         end
         acc
       end
 
+      # Issue #1332 — the #587 (b) captured-block binding ({#captured_block_bindings}) both inject arms lay under
+      # every step, as the Tuple / Range per-element folds and the per-pair `HashShape` fold do. Without it each
+      # step reads a captured variable at its entry binding, so a body that rebinds or mutates one (`n += 1`,
+      # `log << e`, `cache[:k] ||= e`) pinned the result: `n = 0; [1, 2].inject(0) { |a, e| r = a + n; n += 1;
+      # r }` folded to `0` where Ruby answers `1`. The fixpoint binds the accumulator parameter to `Dynamic[top]`
+      # rather than to a type the inject fixpoint has not converged yet: a captured name that reads the
+      # accumulator widens rather than pins. `element_types` is the constant arm's steps, one position per block
+      # run, which {RepeatedOrWrites} reads; nil for the nominal arm, which marks every repeated site.
+      def inject_captured_bindings(block, element_types, element: nil)
+        element ||= Type::Combinator.union(*element_types)
+        captured_block_bindings(block, [Type::Combinator.untyped, element], element_types: element_types)
+      end
+
       # Extracts the receiver's foldable constant values, size-capped before enumeration, or nil to decline.
       def inject_constant_members(receiver)
         case receiver
@@ -5276,9 +5507,9 @@ module Rigor
       # Evaluates the block body once with the running constant accumulator + the next constant element
       # bound to the block params, returning the result when it is a foldable `Constant` within the
       # magnitude cap, else nil to decline the whole fold.
-      def inject_constant_step(block, acc, element_value)
+      def inject_constant_step(block, acc, element_value, captured, position)
         element = Type::Combinator.constant_of(element_value)
-        result = type_block_body_with_param(block, [acc, element])
+        result = type_block_body_with_param(block, [acc, element], captured: captured, position: position)
         return nil unless result.is_a?(Type::Constant)
         return nil unless inject_foldable?(result.value)
         return nil if inject_magnitude_too_large?(result.value)
@@ -5308,13 +5539,14 @@ module Rigor
         seed_acc = has_seed ? seed : element
         return nil if seed_acc.nil?
 
+        captured = inject_captured_bindings(block, nil, element: element)
         converged = BodyFixpoint.converge(
           names: [:__inject_acc__],
           seed_bindings: { __inject_acc__: seed_acc },
           widen: method(:widen_value_pinned),
           evaluate_body: lambda do |bindings|
             acc = bindings[:__inject_acc__]
-            result = type_block_body_with_param(block, [acc, element])
+            result = type_block_body_with_param(block, [acc, element], captured: captured)
             result.nil? ? {} : { __inject_acc__: result }
           end
         )

data/lib/rigor/inference/global_write_census.rb

@@ -82,7 +82,7 @@ module Rigor
 
       # A standalone walk, for a file no existing descent visits (a `pre_eval:` entry).
       def scan(root)
-        collector = Collector.new
+        collector = Collector.new(InEffectRefinements.new(root))
         walk(root, collector, true)
         collector.census.freeze
       end
@@ -98,13 +98,16 @@ module Rigor
 
       # Accumulates one file's census, fed each node of a pre-order descent. `top_level` says whether the node sits
       # outside every `class` / `module` body; it is the host walk's to track. `refine` blocks are remembered by
-      # offset as they are met, so a node inside one is known without the host walk tracking it.
+      # offset as they are met, so a node inside one is known without the host walk tracking it. `in_effect` is the
+      # file's {InEffectRefinements}: a `refine` it places where `self` is a class is the class's own method, so its
+      # block is not a refinement (issue #1689).
       class Collector
         attr_reader :census
 
-        def initialize
+        def initialize(in_effect)
           @census = Set.new
           @refine_ranges = []
+          @in_effect = in_effect
         end
 
         # A node the collector cannot read must not fail the analysis of its file, nor of every file the pre-pass
@@ -223,7 +226,7 @@ module Rigor
         def self_receiver?(node) = node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
 
         def remember_refine(node)
-          return unless node.name == :refine && self_receiver?(node) && node.block.is_a?(Prism::BlockNode)
+          return unless ScopeIndexer.refine_call?(node) && !@in_effect.class_body_refine?(node)
 
           location = node.block.location
           @refine_ranges << (location.start_offset...location.end_offset)

data/lib/rigor/inference/guard_rebinding.rb

@@ -406,7 +406,7 @@ module Rigor
           arguments = call_node.arguments&.arguments || []
           MethodDispatcher.expected_block_param_types(
             receiver_type: receiver, method_name: call_node.name, environment: scope.environment, scope: scope,
-            arg_types: arguments.map { |argument| scope.type_of(argument) }
+            arg_types: arguments.map { |argument| scope.type_of(argument) }, call_node: call_node
           )
         rescue StandardError
           []

data/lib/rigor/inference/in_effect_refinements/proc_literals.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    class InEffectRefinements
+      # Issue #1666 — the Proc literals whose body a `.refined` receiver call applies to, recognised from syntax.
+      module ProcLiterals
+        # The `Kernel` calls whose literal block is the Proc they return.
+        BARE_PROC_CALLS = %i[proc lambda].freeze
+        private_constant :BARE_PROC_CALLS
+
+        # Copies that keep a refined Proc's refinements (`test_refined_preserved_by_dup`): a chain reads through them.
+        COPY_CALLS = %i[dup clone].freeze
+        private_constant :COPY_CALLS
+
+        module_function
+
+        # `[literal, refined calls]` for the outermost `.refined` call `node`: the Proc literal the chain starts from
+        # ({.refinable}, or nil), and every `.refined` call of the chain, innermost (first called) first. The chain
+        # reads through parentheses and through `dup` / `clone`.
+        def refined_chain(node)
+          calls = [node]
+          receiver = unwrap(node.receiver)
+          loop do
+            if refined_call?(receiver)
+              calls << receiver
+            elsif !copy_call?(receiver)
+              break
+            end
+            receiver = unwrap(receiver.receiver)
+          end
+          [refinable(receiver), calls.reverse]
+        end
+
+        def refined_call?(node) = node.is_a?(Prism::CallNode) && node.name == :refined
+
+        def copy_call?(node)
+          node.is_a?(Prism::CallNode) && COPY_CALLS.include?(node.name) && node.arguments.nil? && node.block.nil? &&
+            !node.receiver.nil?
+        end
+
+        # `( expr )` with one statement reads as `expr`.
+        def unwrap(node)
+          while node.is_a?(Prism::ParenthesesNode) && node.body.is_a?(Prism::StatementsNode) &&
+                node.body.body.size == 1
+            node = node.body.body.first
+          end
+          node
+        end
+
+        # The node whose span is the body `node.refined(…)` applies to: `node` itself for a lambda literal, or the
+        # literal block of a `proc` / `lambda` call on no receiver or on `Kernel`, or of `Proc.new`; nil for anything
+        # else. A Proc held in a variable, or one passed as `&blk`, is not one: which block it holds is not syntax.
+        def refinable(node)
+          case node
+          when Prism::LambdaNode then node
+          when Prism::CallNode
+            block = node.block
+            return nil unless block.is_a?(Prism::BlockNode)
+
+            block if bare_proc_call?(node) || proc_new_call?(node)
+          end
+        end
+
+        def bare_proc_call?(node)
+          BARE_PROC_CALLS.include?(node.name) && (node.receiver.nil? || top_constant?(node.receiver, :Kernel))
+        end
+
+        def proc_new_call?(node)
+          node.name == :new && top_constant?(node.receiver, :Proc)
+        end
+
+        # `Name` or `::Name`.
+        def top_constant?(node, name)
+          (node.is_a?(Prism::ConstantReadNode) || (node.is_a?(Prism::ConstantPathNode) && node.parent.nil?)) &&
+            node.name == name
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/in_effect_refinements/refine_defs.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    class InEffectRefinements
+      # Issue #1664 — the `def`s one file's refine bodies define, keyed by refining module, refined class (each name
+      # the `refine` argument's spelling can denote) and method, with the `Module.nesting` each is written in. The
+      # last `def` of a name wins, as Ruby's method table keeps it.
+      class RefineDefs
+        # ADR-121 WD7 — what {#lookup} answers for a name whose last definer has no body (`define_method`, `attr_*`,
+        # `undef`): the search for a body ends there, so the typed arm answers `Dynamic[top]` rather than another
+        # file's `def`.
+        BODILESS = :bodiless
+        # Issue #1749 — what {#lookup} answers for a name whose refinement the walk cannot attribute: one from a
+        # `refine` that runs inside a method (it exists once the method has run, replacing what a refine body wrote for
+        # the name, or adding nothing if it never runs, and `using` sees it only if it runs first), or from an eval on
+        # a constant that several names denote (it runs on one of them, which another file decides, and replaces or is
+        # replaced by a `def` of the name in a refine body of the module, whichever runs first). A `def` of the name
+        # in a module-body refine, in this file or another, cannot say which one answers, so the name is never typed
+        # from any body: the lookup ends there across every file that declares the module, and unlike {BODILESS} a
+        # later record does not replace it.
+        UNDECIDED = :undecided
+
+        attr_reader :nestings
+
+        def initialize
+          @nodes = {}
+          @nestings = {}.compare_by_identity
+        end
+
+        # `owners` are the refining modules (several where an eval on a constant may run on any of its names), each
+        # filed under every class of `targets`. `name` is the method `def_node` answers for: its own name, or an
+        # alias's (ADR-121 WD7). A nil `def_node` is a later definer with no body (`define_method`, `attr_*`, `undef`),
+        # which replaces the earlier `def`. A name whose refinement the walk cannot attribute keeps no body and is
+        # {UNDECIDED}: several owners (Ruby runs the body on one of them only), or `created`, true for a `refine` that
+        # runs inside a method.
+        def record(owners, targets, name, def_node, nesting, created: false)
+          undecided = created || owners.size > 1
+          def_node = nil if undecided
+          owners.each do |owner|
+            by_class = (@nodes[owner] ||= {})
+            targets.each do |class_name|
+              by_name = (by_class[class_name] ||= {})
+              by_name[name] = undecided ? UNDECIDED : (def_node || BODILESS) unless by_name[name] == UNDECIDED
+            end
+          end
+          @nestings[def_node] = nesting if def_node
+        end
+
+        def lookup(module_name, class_name, method_name) = @nodes.dig(module_name, class_name, method_name)
+      end
+    end
+  end
+end