rigortype 0.3.7 → 0.3.9

data/lib/rigor/inference/body_fixpoint.rb

@@ -26,12 +26,12 @@ module Rigor
 
       module_function
 
-      # @param names [Array<Symbol>] the outer locals the body can rebind.
-      # @param seed_bindings [Hash{Symbol=>Type}] pre-state binding per name.
-      # @param widen [#call] value-pinned widener (Constant -> Nominal).
-      # @param evaluate_body [#call] `bindings -> exit_bindings` — evaluates the body once from `bindings`
+      # @param names — the outer locals the body can rebind.
+      # @param seed_bindings — pre-state binding per name.
+      # @param widen — value-pinned widener (Constant -> Nominal).
+      # @param evaluate_body — `bindings -> exit_bindings` — evaluates the body once from `bindings`
       #   (the per-name current assumption) and returns the per-name exit binding it produced.
-      # @return [Hash{Symbol=>Type}] the continuation binding per name.
+      # @return the continuation binding per name.
       def converge(names:, seed_bindings:, widen:, evaluate_body:)
         return {} if names.empty?
 

data/lib/rigor/inference/budget_trace.rb

@@ -65,8 +65,6 @@ module Rigor
       #   plain `(receiver, method)` signature was already on the recursion guard stack.
       # - {MEMO_REFUSE_UNROLL} — pre-ADR-84 blanket refusal (constant-arg unroll in flight). Kept in the table
       #   as the ADR-84 WD3 gate pin: structurally unreachable, must read ~0.
-      # - {MEMO_REFUSE_CONSULT_TAINTED} — a candidate frame computed a result but an ADR-55 fixpoint summary
-      #   was *consulted* during the compute, so the result is a transient Kleene iterate and was NOT stored.
       # - {MEMO_REFUSE_TRANSIENT} — ADR-84 WD3: a candidate frame's compute bracket saw a
       #   transient-machinery event (recursion-guard hit / unroll-fuel exhaustion / ADR-55 WD1 clamp /
       #   fixpoint-cap collapse — `ExpressionTyper#note_transient_fallback`) that referenced a stack frame
@@ -79,15 +77,13 @@ module Rigor
       MEMO_BODY_EVALS = :memo_body_evals
       MEMO_REFUSE_ON_STACK = :memo_refuse_on_stack
       MEMO_REFUSE_UNROLL = :memo_refuse_unroll
-      MEMO_REFUSE_CONSULT_TAINTED = :memo_refuse_consult_tainted
       MEMO_REFUSE_TRANSIENT = :memo_refuse_transient
 
       CATEGORIES = [
         RECURSION_GUARD, ANCESTOR_WALK_LIMIT, HKT_FUEL_EXHAUSTED, RECURSION_UNROLL_FUEL,
         RECURSION_FIXPOINT_CAP, BLOCK_WRITEBACK_CAP,
         MEMO_ENTRIES, MEMO_HITS, MEMO_MISSES, MEMO_BODY_EVALS,
-        MEMO_REFUSE_ON_STACK, MEMO_REFUSE_UNROLL, MEMO_REFUSE_CONSULT_TAINTED,
-        MEMO_REFUSE_TRANSIENT
+        MEMO_REFUSE_ON_STACK, MEMO_REFUSE_UNROLL, MEMO_REFUSE_TRANSIENT
       ].freeze
 
       # Distribution (histogram) categories — read-only observations of a value's size at a site, used to

data/lib/rigor/inference/captured_locals.rb

@@ -30,9 +30,8 @@ module Rigor
 
       module_function
 
-      # @param block_node [Prism::BlockNode]
-      # @param base_scope [Rigor::Scope] the call-site scope the block closes over.
-      # @return [Array<Symbol>] the captured names the body writes, each once, in first-write order.
+      # @param base_scope — the call-site scope the block closes over.
+      # @return the captured names the body writes, each once, in first-write order.
       def writes(block_node, base_scope)
         body = block_node.body
         return [] if body.nil?

data/lib/rigor/inference/closure_escape_analyzer.rb

@@ -51,11 +51,9 @@ module Rigor
     module ClosureEscapeAnalyzer
       module_function
 
-      # @param receiver_type [Rigor::Type, nil]
-      # @param method_name [Symbol]
-      # @param environment [Rigor::Environment, nil] reserved for the future sub-phase that consults
+      # @param environment — reserved for the future sub-phase that consults
       #   `RBS::Extended` call-timing effects; sub-phase 3a ignores it.
-      # @return [Symbol] one of `:non_escaping`, `:escaping`, `:unknown`.
+      # @return one of `:non_escaping`, `:escaping`, `:unknown`.
       def classify(receiver_type:, method_name:, environment: nil) # rubocop:disable Lint/UnusedMethodArgument
         return :unknown if receiver_type.nil?
 

data/lib/rigor/inference/coverage_scanner.rb

@@ -22,17 +22,17 @@ module Rigor
     # a tracer per visited node and discards the inferred type values.
     class CoverageScanner
       class Result < Data.define(:visits, :unrecognized, :events)
-        # @return [Integer] sum of all visits across node classes.
+        # @return sum of all visits across node classes.
         def visited_count
           visits.values.sum
         end
 
-        # @return [Integer] sum of directly-unrecognized counts across classes.
+        # @return sum of directly-unrecognized counts across classes.
         def unrecognized_count
           unrecognized.values.sum
         end
 
-        # @return [Float] unrecognized_count / visited_count, or 0.0 when empty.
+        # @return unrecognized_count / visited_count, or 0.0 when empty.
         def unrecognized_ratio
           total = visited_count
           return 0.0 if total.zero?
@@ -41,13 +41,11 @@ module Rigor
         end
       end
 
-      # @param scope [Rigor::Scope] base scope used for every type_of call. Defaults to `Scope.empty`.
+      # @param scope — base scope used for every type_of call. Defaults to `Scope.empty`.
       def initialize(scope: nil)
         @scope = scope || Scope.empty
       end
 
-      # @param root [Prism::Node]
-      # @return [Result]
       def scan(root)
         visits = Hash.new(0)
         unrecognized = Hash.new(0)

data/lib/rigor/inference/dynamic_origin.rb

@@ -60,7 +60,7 @@ module Rigor
 
       module_function
 
-      # @return [Symbol, nil] the tractability category for a cause, or nil when the cause is unknown /
+      # @return the tractability category for a cause, or nil when the cause is unknown /
       #   absent.
       def tractability(cause)
         TRACTABILITY[cause]

data/lib/rigor/inference/element_read_widening.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../type"
+require_relative "mutation_widening"
+
+module Rigor
+  module Inference
+    # Widens the element a mutator call reaches THROUGH a read, when the container is a local's
+    # literal-shape carrier. {MutationWidening} widens the bindings a receiver expression NAMES;
+    # this module covers the case where it names none because the receiver is an rvalue temp.
+    module ElementReadWidening
+      # Element reads that name ONE element of a container: the only receiver shapes whose mutation
+      # is attributable to a single position inside a local's literal-shape carrier. `first` / `last`
+      # with an argument return a sub-ARRAY, not an element, so they are excluded by arity below.
+      ELEMENT_READERS = %i[[] first last dig].to_set.freeze
+
+      module_function
+
+      # Widens an element read through an index / `first` / `last` / `dig` chain rooted at a LOCAL,
+      # when that read is the RECEIVER of a content mutator (issue #643).
+      #
+      # `c = [flag ? [1] : [2]]; c[0] << 5` mutates the rvalue temp `c[0]`, so
+      # {MutationWidening.widen_after_call} — which widens exactly the bindings the receiver expression NAMES —
+      # sees no variable and records nothing. `c` keeps `Tuple[[1] | [2]]`, and the later
+      # `c[0].last == 5` folds always-falsey on a value the program does hold. The nested plain
+      # literal (`b = [[[]]]; b[0][0] << 1`) reads `b[0][0].first` as `nil` for the same reason.
+      #
+      # The fix widens the element's pin ONE STEP INSIDE the container and writes the rebuilt
+      # container back to the local: `Tuple[[1] | [2]]` becomes `Tuple[Array[Integer]]`. The outer
+      # arity survives — mutating an element cannot change how many elements the container has —
+      # so `c.size == 1` keeps folding. A non-literal index widens every position instead, since
+      # which one was mutated is not decidable.
+      #
+      # Rooted at a local only: a mutation through a method call's result (`foo[0] << 5`) has no
+      # binding to write back to, and inventing one would be unsound.
+      def widen_element_read(call_node:, current_scope:, arg_types: MutationWidening::NO_ARG_TYPES)
+        return current_scope if MutationWidening.pure_self_returner?(call_node.name)
+
+        path = element_read_path(call_node.receiver)
+        return current_scope if path.nil?
+
+        read, steps = path
+        widened = widen_through_path(current_scope.local(read.name), steps, call_node.name, arg_types)
+        return current_scope if widened.nil?
+
+        current_scope.with_local(read.name, widened)
+      end
+
+      # True when `receiver` is an element read whose target element is a literal-shape carrier —
+      # the {#joinable_receiver?} counterpart for the element path, gating whether the caller types
+      # the mutator's arguments at all.
+      def joinable_element_read?(receiver, scope)
+        path = element_read_path(receiver)
+        return false if path.nil?
+
+        read, steps = path
+        !element_at_path(scope.local(read.name), steps).nil?
+      end
+
+      # `[<local read>, [step, …]]` for a chain of element reads rooted at a local variable, or
+      # `nil` when the expression is anything else. A step is an Integer position (negative counts
+      # from the end, as Ruby's own indexing does) or `:all` when the index is not a literal.
+      def element_read_path(node)
+        steps = []
+        cursor = node
+        while cursor.is_a?(Prism::CallNode)
+          step = element_read_step(cursor)
+          return nil if step.nil?
+
+          steps.unshift(*step)
+          cursor = cursor.receiver
+        end
+        return nil unless cursor.is_a?(Prism::LocalVariableReadNode) && !steps.empty?
+
+        [cursor, steps]
+      end
+
+      # The positions one element-read call selects, or `nil` when the call is not an element read.
+      # A block makes the call something other than a plain read (`arr.first { … }` is not one), and
+      # `[]` with anything but a single argument is a slice.
+      def element_read_step(call_node)
+        return nil unless ELEMENT_READERS.include?(call_node.name)
+        return nil if call_node.receiver.nil? || call_node.block
+
+        positional_steps(call_node.name, call_node.arguments&.arguments || [])
+      end
+
+      def positional_steps(name, args)
+        case name
+        when :[] then args.size == 1 ? [index_step(args.first)] : nil
+        when :first then args.empty? ? [0] : nil
+        when :last then args.empty? ? [-1] : nil
+        when :dig then args.empty? ? nil : args.map { |arg| index_step(arg) }
+        end
+      end
+
+      # `:all` stands for "some position, not statically known" — every position is widened, which
+      # is the only answer that cannot under-approximate.
+      def index_step(node)
+        node.is_a?(Prism::IntegerNode) ? node.value : :all
+      end
+
+      # The type at `steps` inside `type`, or `nil` when the path does not resolve to a widenable
+      # literal-shape carrier.
+      def element_at_path(type, steps)
+        return MutationWidening.shape_carrier?(type) ? type : nil if steps.empty?
+
+        case type
+        when Type::Tuple
+          tuple_positions(type, steps.first).lazy
+                                            .filter_map { |i| element_at_path(type.elements[i], steps.drop(1)) }
+                                            .first
+        when Type::Union
+          type.members.lazy.filter_map { |member| element_at_path(member, steps) }.first
+        end
+      end
+
+      # Rebuilds `type` with the element at `steps` widened against `method_name`, or `nil` when
+      # nothing along the path widened.
+      def widen_through_path(type, steps, method_name, arg_types)
+        return MutationWidening.widen_for_mutator(type, method_name, arg_types: arg_types) if steps.empty?
+
+        case type
+        when Type::Tuple then widen_tuple_path(type, steps, method_name, arg_types)
+        when Type::Union then widen_union_path(type, steps, method_name, arg_types)
+        end
+      end
+
+      def widen_tuple_path(tuple, steps, method_name, arg_types)
+        elements = tuple.elements.dup
+        rest = steps.drop(1)
+        widened_any = false
+        tuple_positions(tuple, steps.first).each do |position|
+          inner = widen_through_path(elements[position], rest, method_name, arg_types)
+          next if inner.nil?
+
+          elements[position] = inner
+          widened_any = true
+        end
+        widened_any ? Type::Tuple.new(elements) : nil
+      end
+
+      def widen_union_path(union, steps, method_name, arg_types)
+        widened_any = false
+        members = union.members.map do |member|
+          widened = widen_through_path(member, steps, method_name, arg_types)
+          next member if widened.nil?
+
+          widened_any = true
+          widened
+        end
+        widened_any ? Type::Combinator.union(*members) : nil
+      end
+
+      # An out-of-range literal index selects nothing: the mutation cannot be attributed to any
+      # position of THIS tuple, so no widening is justified.
+      def tuple_positions(tuple, step)
+        size = tuple.elements.size
+        return (0...size).to_a if step == :all
+
+        position = step.negative? ? step + size : step
+        position.between?(0, size - 1) ? [position] : []
+      end
+    end
+  end
+end