rigortype 0.4.3 → 0.4.4

data/lib/rigor/inference/expression_typer.rb

@@ -321,6 +321,37 @@ module Rigor
           try_project_singleton_inference(receiver, node, arg_types, method_name: :[])
       end
 
+      # Issue #1889 — the type a block-form `inject` / `reduce` accumulator parameter holds across the block's runs,
+      # or nil when the call is not one {#try_block_inject_fold} folds. The RBS tier binds the parameter to the seed
+      # alone, so the statement pass and the ADR-56 write-back typed every run's accumulator as `0` for `inject(0)`,
+      # and a capture assigned from it (`m = a`) was written back as `0`.
+      #
+      # The fold records the answer as it types the call ({#record_inject_accumulator}): the constant arm the
+      # accumulator values the block receives (`0 | 1` for `[1, 2].inject(0) { |a, e| a + e }`), the nominal
+      # arm its seed joined with the converged accumulator. The statement pass types the call from the same scope
+      # just before it enters the block, so the recorded answer is read back rather than computed again — each
+      # computation types the body, and a nested `inject` multiplied that by its depth.
+      def inject_accumulator_type(call_node, receiver, arg_types)
+        block = call_node.block
+        return nil unless INJECT_METHODS.include?(call_node.name) && block.is_a?(Prism::BlockNode)
+
+        recorded = self.class.recorded_inject_accumulator(block, scope)
+        return recorded if recorded
+
+        try_block_inject_fold(call_node, receiver, arg_types)
+        self.class.recorded_inject_accumulator(block, scope)
+      end
+
+      INJECT_ACCUMULATOR_KEY = :__rigor_inject_accumulator__
+      private_constant :INJECT_ACCUMULATOR_KEY
+
+      # The accumulator type {#record_inject_accumulator} stored for `block` when the call was typed from `scope`
+      # itself (by identity), else nil.
+      def self.recorded_inject_accumulator(block, scope)
+        slot = Thread.current[INJECT_ACCUMULATOR_KEY]&.[](block)
+        slot && slot[0].equal?(scope) ? slot[1] : nil
+      end
+
       # ADR-89 WD2 — the current run's return memo bucket as `{ def_node => [MemoEntry, …] }` (only entries
       # that carry a call descriptor, i.e. every stored entry). Read by the incremental session right after a
       # recording run to harvest each analyzed callee's observed call keys → return descriptors. Returns an
@@ -1047,12 +1078,15 @@ module Rigor
       #
       # The `case ... in` pattern-matching form (`CaseMatchNode`) and the predicate-less form (`case; when
       # c1; ...`) bypass the `===` analysis: pattern matching has richer semantics, and a predicate-less
-      # `case` reduces to a `if c1; ...; elsif c2` chain that statement-level narrowing already handles.
+      # `case` reduces to a `if c1; ...; elsif c2` chain. Issue #1495 — like {#type_of_conditional}, that
+      # chain delegates to the statement evaluator, which narrows each arm by its conditions' edges, so
+      # `[case; when x.nil? then "n"; else x end]` reads `"n" | String` as the statement form does.
       # Issue #1429 — each arm is typed under the subject's clause narrowing (`Narrowing.case_when_scopes`), the
       # scope the statement evaluator runs the arm in: `when Symbol then n` on `n: Integer | Symbol` answers
       # `Symbol`, and the `else` arm reads the subject every earlier clause has ruled out.
       def type_of_case(node)
-        return type_of_case_simple_union(node) if node.is_a?(Prism::CaseMatchNode) || node.predicate.nil?
+        return type_of_case_simple_union(node) if node.is_a?(Prism::CaseMatchNode)
+        return scope.evaluate(node, tracer: tracer).first if node.predicate.nil?
 
         subject_type = type_of(node.predicate)
         candidates = []
@@ -3883,6 +3917,12 @@ module Rigor
       # default — or `Dynamic` when the shape is open or absent; `**kwrest`, `&block`, and destructured
       # positionals bind `Dynamic`. Binding `Dynamic` is monotone-safe (wider in → wider out), so the only
       # declines left are the shapes where positional CORRESPONDENCE itself is unknowable.
+      #
+      # The scope carries no `source_path:`: the body is re-typed for call sites in any file, so a rule that
+      # asks "did this file write it?" by comparing `scope.source_path` with census paths answers wrongly
+      # through it. Record a per-file write kind in the census instead, as {ScopeIndexer::CONSTANT_MEMO} does
+      # (#1276). Setting `source_path` here was rejected: plugins read it, and the return memo would become
+      # caller-dependent.
       def build_user_method_body_scope(def_node, receiver, arg_types, self_fold_safe: false)
         params = def_node.parameters
         locals = bind_params_from_call_types(params, arg_types)
@@ -3893,7 +3933,7 @@ module Rigor
         # allocated a fresh frozen Scope per field, run per user-method-call inference (ADR-44). The
         # discovery index is inherited whole by reference (ADR-53 Track A); the hand-copied per-field list
         # this replaces had silently dropped `data_member_layouts` and `discovered_method_visibilities`.
-        Scope.new(
+        body_scope = Scope.new(
           environment: scope.environment,
           locals: locals.freeze,
           self_type: receiver,
@@ -3911,6 +3951,7 @@ module Rigor
           # Issue #1358 — the callee runs in a frame of its own ({Scope#with_match_frame}).
           match_frame: MatchRebinding::Frame.new(def_node.body, def_node.parameters)
         )
+        body_scope.with_repeated_or_writes(RepeatedOrWrites.straight_line_sites(def_node.body, body_scope))
       end
 
       # Issue #681 / #707 — the ONE place in `lib/` that answers "what `Module.nesting` was recorded for this
@@ -5436,13 +5477,25 @@ module Rigor
         return nil if acc.nil?
 
         captured = inject_captured_bindings(block, rest.map { |value| Type::Combinator.constant_of(value) })
+        received = [acc]
         rest.each_with_index do |element_value, position|
           acc = inject_constant_step(block, acc, element_value, captured, position)
           return nil if acc.nil?
+
+          received << acc
         end
+        received.pop if received.size > 1
+        record_inject_accumulator(block, Type::Combinator.union(*received))
         acc
       end
 
+      # Records `type` as the accumulator `block` receives when typed from this typer's scope
+      # ({.recorded_inject_accumulator}). The keys are weak, so a finished file's nodes do not stay reachable, and
+      # the values strong, so a record outlives a collection while its node does. Prism nodes compare by identity.
+      def record_inject_accumulator(block, type)
+        (Thread.current[INJECT_ACCUMULATOR_KEY] ||= ObjectSpace::WeakKeyMap.new)[block] = [scope, type].freeze
+      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`,
@@ -5550,7 +5603,9 @@ module Rigor
             result.nil? ? {} : { __inject_acc__: result }
           end
         )
-        converged[:__inject_acc__] || seed_acc
+        result = converged[:__inject_acc__] || seed_acc
+        record_inject_accumulator(block, Type::Combinator.union(seed_acc, result))
+        result
       end
 
       def assemble_per_element_result(method_name, per_position, element_types)

data/lib/rigor/inference/guard_rebinding.rb

@@ -223,6 +223,12 @@ module Rigor
         end || Type::Combinator.untyped
       end
 
+      # Issue #1596 — true when `name` runs code chosen by name or by a String, or a block or String it is given
+      # ({CODE_RUNNING_NAMES}, {BLOCK_OR_CODE_NAMES}), whatever its receiver.
+      def code_running_name?(name)
+        CODE_RUNNING_NAMES.include?(name) || BLOCK_OR_CODE_NAMES.include?(name)
+      end
+
       # True when `method_name` on a value of `type` may run foreign code ({.foreign_target?}).
       def type_method_foreign?(type, method_name, scope)
         targets = ProjectMethodOwnership.targets(type)
@@ -326,8 +332,7 @@ module Rigor
       private_class_method :scan, :guarded_ivar_write?, :scan_call, :receiver_targets, :foreign_target?,
                            :universal_delegate_foreign?, :method_owner, :deferred_block_call?,
                            :compound_write_foreign?,
-                           :compound_receiver_type, :compound_accessors, :compound_read_type, :variable_type,
-                           :type_method_foreign?
+                           :compound_receiver_type, :compound_accessors, :compound_read_type, :variable_type
     end
 
     module GuardRebinding

data/lib/rigor/inference/last_line/self_evidence.rb

@@ -45,7 +45,7 @@ module Rigor
       #   `X.send(:define_method, :m, blk)`), whose body may be a block the file wrote anywhere, an eval of a
       #   String, whose code may do any of these, and a `const_set`, which may make a class a `class` body reopens;
       # - one name: a `def` of it anywhere (`def self.gets` at the top level defines it on `main`, which
-      #   {BlockCallTiming.project_defines_anywhere?} does not record), and a Symbol or String literal naming it,
+      #   {BlockCallTiming.project_defines_anywhere?} does not count), and a Symbol or String literal naming it,
       #   which a macro may define it through (`def_delegators :@io, :gets`, `attr_reader :gets`,
       #   `undef_method :gets`), other than `&:gets` and the first argument of a call that only names a method
       #   (`respond_to?(:gets)`, `send(:gets)`).

data/lib/rigor/inference/module_function_state.rb

@@ -11,8 +11,8 @@ module Rigor
     # [#1197](https://github.com/rigortype/rigor/issues/1197)). Four readers used to compute it in four
     # places. They disagree with each other and, in places, with Ruby. Each entry point below reproduces
     # one reader's answer exactly: this module gives the readings one place to live, and does not yet make
-    # them agree. A change to one reading lands here, beside the other three. Examples are #1550's
-    # named-form snapshot and the reset a bare `public`, `private` or `protected` makes.
+    # them agree. A change to one reading lands here, beside the other three. An example is the reset a bare
+    # `public`, `private` or `protected` makes.
     #
     # - The singleton def-node table (`ScopeIndexer#walk_singleton_body`) reads
     #   {.each_singleton_sibling} and {.each_singleton_copy}. A bare call covers the later direct
@@ -78,23 +78,49 @@ module Rigor
         end
       end
 
-      # The defs a named call copies onto the module's singleton, for the singleton def-node table. Yields
-      # `name, def_node` for each Symbol or String argument that names a receiverless def among the body's
-      # direct `statements`. The last def of that name wins wherever it sits. A def written after the call
-      # is therefore taken, although Ruby copies the one in effect at the call (#1550), and a name defined
-      # only after the call resolves, although Ruby raises `NameError` there. A `module_function def x`
-      # argument names nothing here.
+      # The defs a named call copies onto the module's singleton, for the singleton def-node table. Ruby
+      # copies the method in effect at the call (#1550), so a later def of the name redefines only the
+      # instance method. This reading approximates that from the body's direct `statements`: it yields
+      # `name, def_node` for each Symbol or String argument, where `def_node` is the last receiverless def
+      # of that name written as a direct statement before the call.
+      #
+      # A name declines (nothing is yielded) when no def precedes the call, where Ruby raises `NameError` or
+      # copies a def another file may load first, and when a statement after that def and before the call
+      # may rebind it in a way this reading cannot name: a def nested in control flow or a block, an `alias`,
+      # an `undef`, or a receiverless or `self.` `alias_method`, `define_method`, `attr_*`, `remove_method`
+      # or `undef_method` call. Such a call or `alias` with a non-literal name anywhere before the call, even
+      # before the def, declines every name. A `module_function def x` argument names nothing here.
+      #
+      # It does not see `send(:define_method, ...)`, a `define_method` on an explicit module receiver, a
+      # `prepend`, another file's singleton defs, or that a `rescue` clause's statements may run after an
+      # `ensure` call's (#1969).
       def each_singleton_copy(call, statements)
-        defs_by_name = statements.each_with_object({}) do |stmt, acc|
-          acc[stmt.name] = stmt if stmt.is_a?(Prism::DefNode) && stmt.receiver.nil?
+        call_start = call.location.start_offset
+        in_effect = {}
+        statements.each do |stmt|
+          next unless stmt.location.end_offset <= call_start
+
+          if stmt.is_a?(Prism::DefNode)
+            in_effect[stmt.name] = stmt if stmt.receiver.nil?
+          else
+            each_rebound_name(stmt) { |name| in_effect[name] = :unknown }
+          end
         end
         call.arguments&.arguments&.each do |arg|
           name = symbol_argument_name(arg)
-          def_node = name && defs_by_name[name]
-          yield name, def_node if def_node
+          def_node = name && !in_effect.key?(ANY_NAME) && in_effect[name]
+          yield name, def_node if def_node.is_a?(Prism::DefNode)
         end
       end
 
+      # The key {.each_singleton_copy} records when a statement may rebind a name it cannot read.
+      ANY_NAME = Object.new.freeze
+
+      # Calls that may define, alias or remove an instance method of the receiverless module.
+      REBINDING_CALLS = %i[
+        alias_method define_method attr attr_reader attr_writer attr_accessor remove_method undef_method
+      ].freeze
+
       # The deferred-ranges reading, over one class-ish body's subtree. Appends to `offsets` the start of
       # every bare call; each def that starts after one is a module function
       # ({.deferred_module_function?}). Appends to `ranges` one row per named call, in the table's
@@ -173,6 +199,46 @@ module Rigor
         active && kind == :instance
       end
 
+      # Yields each instance-method name `node` may rebind on the module whose body holds it, or
+      # {ANY_NAME} when one is not a literal. It does not enter a nested class, module or `class <<` body,
+      # whose methods belong to another module.
+      def each_rebound_name(node, &)
+        case node
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode then nil
+        when Prism::DefNode then yield node.name if node.receiver.nil?
+        else
+          each_own_rebound_name(node, &)
+          node.compact_child_nodes.each { |child| each_rebound_name(child, &) }
+        end
+      end
+
+      # The names `node` itself may rebind, apart from its children: an `alias`, an `undef` or a
+      # {REBINDING_CALLS} call on the module.
+      def each_own_rebound_name(node, &)
+        case node
+        when Prism::AliasMethodNode then yield symbol_argument_name(node.new_name) || ANY_NAME
+        when Prism::UndefNode then node.names.each { |name| yield symbol_argument_name(name) || ANY_NAME }
+        when Prism::CallNode
+          each_rebinding_call_name(node, &) if REBINDING_CALLS.include?(node.name) &&
+                                               (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+        end
+      end
+
+      # The names a {REBINDING_CALLS} call may rebind: the first argument of `alias_method` and
+      # `define_method`, every argument of the others (and its writer, for the `attr_*` family), or
+      # {ANY_NAME} for a non-literal one.
+      def each_rebinding_call_name(call)
+        arguments = call.arguments&.arguments || []
+        arguments = arguments.first(1) if %i[alias_method define_method].include?(call.name)
+        arguments.each do |arg|
+          name = symbol_argument_name(arg)
+          next yield(ANY_NAME) unless name
+
+          yield name
+          yield :"#{name}=" if call.name.start_with?("attr")
+        end
+      end
+
       # The prescan's call arm.
       def prescan_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
         if bare?(node)
@@ -208,7 +274,8 @@ module Rigor
         Source::Literals.symbol_or_string(arg)
       end
 
-      private_class_method :prescan_call, :prescan_eval_call, :symbol_argument_name
+      private_class_method :prescan_call, :prescan_eval_call, :symbol_argument_name, :each_rebound_name,
+                           :each_own_rebound_name, :each_rebinding_call_name
     end
   end
 end