rigortype 0.4.5 → 0.4.7

data/lib/rigor/inference/def_return_typer.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "../type"
 require_relative "../source/node_children"
 require_relative "return_barrier"
+require_relative "optimistic_origin"
 
 module Rigor
   module Inference
@@ -21,14 +22,20 @@ module Rigor
     #
     # Extracted from `Rigor::SigGen::Generator#infer_return_type` so `LineTypeCollector` (`rigor annotate`'s
     # def-line annotator) and the sig-generator share one source of truth.
+    #
+    # `keep_lookup_nil: true` is the reading a signature needs (#2197). The engine reads a lookup that can miss
+    # (`Hash#[]`, `Array#first`, the {OptimisticOrigin} family) as nil-free on purpose, so `if h[k]` stays
+    # silent, but a `-> V` written into `sig/` is a contract that every caller's `nil` check is dead code. Each
+    # returned expression whose value is such a lookup therefore contributes `nil` beside its type. Only the
+    # value positions a lookup's `nil` reaches the return through are followed ({#optimistic_value?}).
     module DefReturnTyper
       module_function
 
-      def call(def_node, scope_index)
+      def call(def_node, scope_index, keep_lookup_nil: false)
         body = def_node.body
         return nil if body.nil?
 
-        last = body_last_expression(body)
+        last = primary_value_expression(body)
         return nil if last.nil?
 
         inner_scope = scope_index[last] || scope_index[body] || scope_index[def_node]
@@ -37,11 +44,195 @@ module Rigor
         last_type = safe_type_of(inner_scope, last)
         return nil if last_type.nil?
 
-        union_with_explicit_returns(body, last_type, scope_index)
+        lookup_context = keep_lookup_nil ? LookupContext.new(scope_index, truthy_guards(body)) : nil
+        last_type = with_lookup_nil(last_type, last, inner_scope, lookup_context) if lookup_context
+        arm_types = rescue_arm_types(body, inner_scope, scope_index, lookup_context)
+        return nil if arm_types.nil?
+
+        union_with_explicit_returns(body, Type::Combinator.union(last_type, *arm_types), scope_index,
+                                    lookup_context: lookup_context)
       rescue StandardError
         nil
       end
 
+      # Issue #2410 — the value a def body ends on when no exception escapes its primary path. A def-level
+      # `rescue … else … end` body is a `BeginNode` whose else-clause, when present, replaces the body's value (the
+      # ensure-clause's value is discarded, so it never counts).
+      def primary_value_expression(body)
+        return body_last_expression(body) unless body.is_a?(Prism::BeginNode) && body.else_clause
+
+        body_last_expression(body.else_clause.statements)
+      end
+
+      # Issue #2410 — the value of each arm of a def-level rescue chain, which the method returns when that arm
+      # completes. An empty arm returns `nil`; an arm ending in `raise`, `retry` or `return` types as bottom and so
+      # adds nothing here (a `return`'s value is collected with the other explicit returns). Nil when an arm cannot
+      # be typed: the body's value alone would be a narrower, wrong contract.
+      def rescue_arm_types(body, inner_scope, scope_index, lookup_context)
+        return [] unless body.is_a?(Prism::BeginNode)
+
+        types = []
+        arm = body.rescue_clause
+        while arm
+          type = rescue_arm_type(arm, inner_scope, scope_index, lookup_context)
+          return nil if type.nil?
+
+          types << type
+          arm = arm.subsequent
+        end
+        types
+      end
+
+      def rescue_arm_type(arm, inner_scope, scope_index, lookup_context)
+        value = body_last_expression(arm.statements)
+        return Type::Combinator.constant_of(nil) if value.nil?
+
+        scope = scope_index[value] || scope_index[arm] || inner_scope
+        type = safe_type_of(scope, value)
+        return nil if type.nil?
+
+        lookup_context ? with_lookup_nil(type, value, scope, lookup_context) : type
+      end
+
+      # What {#optimistic_value?} reads beside a node's scope: the engine's per-node scopes, and for each lookup
+      # under a guard the source of the guarding predicates ({#truthy_guards}).
+      LookupContext = Data.define(:scope_index, :guards)
+
+      def with_lookup_nil(type, node, scope, context = nil)
+        return type unless optimistic_value?(node, scope, context)
+
+        Type::Combinator.union(type, Type::Combinator.constant_of(nil))
+      end
+
+      # Whether `node`'s value can be the `nil` an optimistic lookup's miss returns: the lookup itself (a call
+      # the dispatcher marked, or `recv&.m` over one), a local or ivar bound to one, or a branch or operand that
+      # hands its value on. `a && b` hands on either operand (a falsy `a`, a missed lookup's `nil` included, is
+      # the result); `a || b` hands on `b` only, since `a` is returned only when truthy, so `h[k] || 0` stays
+      # nil-free. `x ||= v` and `x &&= v` hand on `v` and, for `&&=`, the binding. A call ON the lookup
+      # (`h[k].to_s`) is a different value.
+      #
+      # Each child is read under the scope the engine recorded for it (`scope_index`), so a branch a guard narrows
+      # (`v ? v : "d"`, `return "z" unless v`) reads the binding the narrowing left, not the enclosing one.
+      def optimistic_value?(node, scope, context = nil)
+        scope = context&.scope_index&.[](node) || scope
+        case node
+        when Prism::CallNode then optimistic_call?(node, scope, context)
+        when Prism::LocalVariableReadNode then !scope.optimistic_local(node.name).nil?
+        when Prism::InstanceVariableReadNode then !scope.optimistic_ivar(node.name).nil?
+        when Prism::AndNode then [node.left, node.right].any? { optimistic_value?(it, scope, context) }
+        when Prism::OrNode then optimistic_value?(node.right, scope, context)
+        else optimistic_write?(node, scope, context) || optimistic_branch?(node, scope, context)
+        end
+      end
+
+      def optimistic_call?(node, scope, context)
+        if scope.optimistic_origins[node]
+          return false if guarded_lookup?(node, context) || non_empty_end?(node, scope)
+
+          return true
+        end
+        node.safe_navigation? && optimistic_value?(node.receiver, scope, context)
+      end
+
+      # `return h[k] if h[k]`, `h[k] ? h[k] : d`: the same lookup, read again under a predicate that just found it
+      # truthy. Only a lookup whose receiver and arguments are plain reads or literals counts, so the second read
+      # sees what the first did.
+      GUARDABLE_LOOKUPS = %i[[] first last dig].freeze
+      private_constant :GUARDABLE_LOOKUPS
+
+      def guarded_lookup?(node, context)
+        return false if context.nil? || !GUARDABLE_LOOKUPS.include?(node.name)
+        return false unless [node.receiver, *node.arguments&.arguments].all? { stable_operand?(it) }
+
+        context.guards.fetch(node, EMPTY_GUARDS).include?(node.slice)
+      end
+
+      EMPTY_GUARDS = [].freeze
+      private_constant :EMPTY_GUARDS
+
+      def stable_operand?(node)
+        case node
+        when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::SymbolNode, Prism::StringNode,
+             Prism::IntegerNode, Prism::SelfNode, Prism::ConstantReadNode then true
+        else false
+        end
+      end
+
+      # `a.first` / `a.last` on a receiver the engine has narrowed to a non-empty array (`a.empty? ? d : a.first`)
+      # cannot miss.
+      def non_empty_end?(node, scope)
+        return false unless %i[first last].include?(node.name) && node.arguments.nil? && node.receiver
+
+        receiver = scope.type_of(node.receiver)
+        receiver.is_a?(Type::Difference) && receiver.removed == Type::Combinator.tuple_of
+      rescue StandardError
+        false
+      end
+
+      def optimistic_write?(node, scope, context)
+        case node
+        when Prism::LocalVariableWriteNode, Prism::InstanceVariableWriteNode,
+             Prism::LocalVariableOrWriteNode, Prism::InstanceVariableOrWriteNode
+          optimistic_value?(node.value, scope, context)
+        when Prism::LocalVariableAndWriteNode
+          !scope.optimistic_local(node.name).nil? || optimistic_value?(node.value, scope, context)
+        when Prism::InstanceVariableAndWriteNode
+          !scope.optimistic_ivar(node.name).nil? || optimistic_value?(node.value, scope, context)
+        else false
+        end
+      end
+
+      # The value-carrying children of a statement list or a conditional: any of them can be the value returned.
+      def optimistic_branch?(node, scope, context)
+        value_branches(node).any? { |branch| !branch.nil? && optimistic_value?(branch, scope, context) }
+      end
+
+      # The lookup a truthy arm (the body of an `if` or ternary, the `else` of an `unless`) reads FIRST, mapped to
+      # the source of the predicate that just tested it, for {#guarded_lookup?}. Only the first expression, or the
+      # value of a first `return`, counts: anything run between the test and the re-read (`h.delete(k)`, a
+      # reassignment, a block, `yield`, another call that mutates the receiver) can make the re-read miss.
+      def truthy_guards(body)
+        guards = {}.compare_by_identity
+        collect_truthy_guards(body, guards)
+        guards
+      end
+
+      def collect_truthy_guards(node, guards)
+        return unless node.is_a?(Prism::Node)
+
+        predicate, arm = truthy_arm(node)
+        first = first_value(arm)
+        guards[first] = [predicate.slice] if first
+        node.rigor_each_child { collect_truthy_guards(it, guards) }
+      end
+
+      def first_value(arm)
+        return nil unless arm.is_a?(Prism::StatementsNode)
+
+        first = arm.body.first
+        args = first.is_a?(Prism::ReturnNode) ? first.arguments&.arguments : nil
+        args&.size == 1 ? args.first : first
+      end
+
+      def truthy_arm(node)
+        case node
+        when Prism::IfNode then [node.predicate, node.statements]
+        when Prism::UnlessNode then [node.predicate, node.else_clause&.statements]
+        end
+      end
+
+      def value_branches(node)
+        case node
+        when Prism::ParenthesesNode then [node.body && body_last_expression(node.body)]
+        when Prism::StatementsNode, Prism::BeginNode then [body_last_expression(node)]
+        when Prism::IfNode then [node.statements, node.subsequent]
+        when Prism::UnlessNode then [node.statements, node.else_clause]
+        when Prism::ElseNode, Prism::WhenNode, Prism::InNode then [node.statements]
+        when Prism::CaseNode, Prism::CaseMatchNode then [*node.conditions, node.else_clause]
+        else []
+        end
+      end
+
       def body_last_expression(body)
         case body
         when Prism::StatementsNode then body.body.last
@@ -50,27 +241,27 @@ module Rigor
         end
       end
 
-      def union_with_explicit_returns(body, last_type, scope_index)
+      def union_with_explicit_returns(body, last_type, scope_index, lookup_context: nil)
         return_types = []
-        collect_return_types(body, scope_index, return_types)
+        collect_return_types(body, scope_index, return_types, lookup_context: lookup_context)
         return last_type if return_types.empty?
 
         Type::Combinator.union(last_type, *return_types)
       end
 
-      def collect_return_types(node, scope_index, out)
+      def collect_return_types(node, scope_index, out, lookup_context: nil)
         return unless node.is_a?(Prism::Node)
         return if ReturnBarrier.node?(node)
 
-        type_return_node(node, scope_index, out) if node.is_a?(Prism::ReturnNode)
+        type_return_node(node, scope_index, out, lookup_context: lookup_context) if node.is_a?(Prism::ReturnNode)
         # A barrier call's receiver and arguments still run in the method; only its block is cut off.
         barrier_block = node.block if node.is_a?(Prism::CallNode) && ReturnBarrier.block_call?(node)
         node.rigor_each_child do |c|
-          collect_return_types(c, scope_index, out) unless c.equal?(barrier_block)
+          collect_return_types(c, scope_index, out, lookup_context: lookup_context) unless c.equal?(barrier_block)
         end
       end
 
-      def type_return_node(return_node, scope_index, out)
+      def type_return_node(return_node, scope_index, out, lookup_context: nil)
         args = return_node.arguments&.arguments || []
         if args.empty?
           out << Type::Combinator.constant_of(nil)
@@ -79,12 +270,13 @@ module Rigor
 
         scope = scope_index[return_node] || scope_index[args.first]
         return if scope.nil?
-        # `return a, b` packs into a Tuple at runtime; the MVP only handles the single-value form. Multi-arg
-        # returns contribute no type to keep the implementation focused.
+        # `return a, b` packs into a Tuple at runtime; only the single-value form is typed.
         return unless args.size == 1
 
         type = safe_type_of(scope, args.first)
-        out << type unless type.nil?
+        return if type.nil?
+
+        out << (lookup_context ? with_lookup_nil(type, args.first, scope, lookup_context) : type)
       end
 
       def safe_type_of(scope, node)

data/lib/rigor/inference/definer_resolution.rb

@@ -25,8 +25,10 @@ module Rigor
     # truth-tested: {UNKNOWN} and {ABSENT} are both truthy, so any other use folds a decline into a firing arm.
     # `spec/rigor/inference/definer_resolution_case_in_spec.rb` fails on a call site of any other shape.
     #
-    # It migrates one question at a time: `SourceArity` (C1b) and the relationship lints (C1c) read the instance
-    # side; no production reader reads the singleton side yet (C2-a landed it for C2's typing sites).
+    # It migrates one question at a time: `SourceArity` (C1b, C2-c) asks for the receiver's own side, instance or
+    # singleton; the override lints (C1c) and the C2 typing sites (`ExpressionTyper#resolve_typing_def_with_owner`,
+    # `StatementEvaluator#own_definer_node`) read the instance side; `RefinedDispatch::OwnMethod.certain_owner?` and
+    # `CheckRules#reached_definer_visibility` pass the side they hold.
     module DefinerResolution
       Known = Data.define(:answer, :owner)
       UnknownResult = Data.define
@@ -221,11 +223,15 @@ module Rigor
       # alone where a later `attr_*` replaced the `def`: the attr writes the name's visibility slot, so the reader's
       # visibility is certain. A `define_method` or alias that replaced it contests the visibility slot as well, which
       # this question does read.
+      #
+      # Issue #2134 — the contest is a read of the slot, so a question that reads it files `visibility:<owner>#<name>`:
+      # an answer block may answer from RBS without reading the slot itself (`nearest_ancestor_method_def`).
       def possible?(scope, hit, method_name, reads_visibility)
         discovery = scope.discovery
         owner = hit.owner
         kind = hit.side == :singleton ? :singleton : :instance
         nodes = kind == :singleton ? :discovered_singleton_def_nodes : :discovered_def_nodes
+        Analysis::DependencyRecorder.read_visibility(owner, method_name) if reads_visibility
         discovery.possible_method?(owner, method_name, kind) ||
           (!(reads_visibility == :visibility && kind == :instance) &&
            discovery.contested?(nodes, [owner, method_name.to_sym])) ||
@@ -277,7 +283,7 @@ module Rigor
 
       def side_visibility(scope, owner, method_name, kind)
         if kind == :singleton
-          scope.discovered_method_visibilities.dig(owner.to_s, visibility_slot(method_name, :singleton)) ||
+          scope.discovered_method_visibility(owner, method_name, singleton: true) ||
             self_extended_copy_visibility(scope, owner, method_name)
         else
           scope.discovered_method_visibility(owner, method_name)
@@ -301,11 +307,21 @@ module Rigor
 
       # Whether any file's deferred ranges carry a `module_function` row (`:both` or `:singleton`) for the name on
       # `owner` (`ModuleFunctionState`).
+      #
+      # Issue #2161 — the answer reads every file's rows, so it records `visibility:<owner>#<name>` whichever way it
+      # answers: `ScopeIndexer.visibility_entries` carries each file's rows of this shape, so a file that starts or
+      # stops writing one fires the key. A swap from `private :x` to `module_function :x` in a reopening leaves the
+      # file's visibility table and declared classes as they were, and fires nothing else. The caller's own
+      # visibility reads record the same key today; this one keeps the reader's edge where it reads.
+      #
+      # Issue #2209 — a row named {ModuleFunctionState::ANY_ROW_NAME} (a `module_function` spelling whose names the
+      # prescan cannot read) stands for every name of its owner, so it counts too, and its key is read as well
+      # ({ModuleFunctionState.row_names}).
       def module_function_row?(scope, owner, method_name)
-        name = method_name.to_sym
+        names = ModuleFunctionState.row_names(method_name).each { Analysis::DependencyRecorder.read_visibility(owner, it) }
         scope.discovered_deferred_ranges.each_value.any? do |rows|
           rows.any? do |(_start, _finish, row_name, kind, row_owner)|
-            row_name == name && row_owner == owner.to_s && kind != :instance
+            names.include?(row_name) && row_owner == owner.to_s && kind != :instance
           end
         end
       end

data/lib/rigor/inference/definers_index.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "../run_scoped_slots"
+
+module Rigor
+  module Inference
+    # The `method_name (Symbol) → [owner names]` inverted index the override gate reads
+    # (`ExpressionTyper#method_definers_index`), over one instance or singleton def table.
+    #
+    # Issue #2300 — a file's def table is its own `def`s merged over the cross-file seed
+    # (`ScopeIndexer#merge_def_node_tables`, `#merge_singleton_def_nodes`, then the #526 extend fold), a new Hash per
+    # file. Inverting it whole scanned every project `def` once per analysed file. {.record_layers} remembers the
+    # seed a final merged table was built over, and {.for} then inverts the seed ONCE per seed table and, per file,
+    # only the owners whose inner table is not the seed's own object ({Layered}).
+    #
+    # The two answers hold the same owners: an owner the merge left alone shares the seed's inner table, so its
+    # names are the seed's, and every other owner is read from the merged table itself. That holds only while the
+    # seed cannot change under the cached index, so a seed whose tables are not all frozen, or a merged table
+    # missing one of the seed's owners, is inverted whole, as is a table {.record_layers} was not told about. Only
+    # the order of a name's owners can differ, and the gate asks `any?` of the list.
+    module DefinersIndex
+      # These thread slots are bounded, like `ExpressionTyper#method_definers_index`'s two ways. Each is a fixed
+      # number of entries, replaced rather than accumulated: two `[merged, seed]` pairs (the last file's two def
+      # tables) and two seed indexes. The run that filled them releases them when it ends ({RunScopedSlots}, #2399),
+      # so a finished run keeps none of its seed tables or their indexes alive.
+      LAYERS_KEY = RunScopedSlots.register(:__rigor_definers_index_layers__)
+      SEED_INDEX_KEY = RunScopedSlots.register(:__rigor_definers_index_seed__)
+      SEED_INDEX_ALT_KEY = RunScopedSlots.register(:__rigor_definers_index_seed_alt__)
+      private_constant :LAYERS_KEY, :SEED_INDEX_KEY, :SEED_INDEX_ALT_KEY
+
+      # A name's owners: the seed's, less the owners the file replaced, plus the replaced owners' own.
+      class Layered
+        def initialize(seed_index, replaced, replaced_index)
+          @seed_index = seed_index
+          @replaced = replaced
+          @replaced_index = replaced_index
+          @answers = {}
+        end
+
+        def [](method_name)
+          return @answers[method_name] if @answers.key?(method_name)
+
+          from_seed = @seed_index[method_name]
+          from_seed = from_seed.reject { |owner| @replaced.key?(owner) } if from_seed && !@replaced.empty?
+          from_file = @replaced_index[method_name]
+          owners = from_file.nil? ? from_seed : (from_seed || []) + from_file
+          @answers[method_name] = owners.nil? || owners.empty? ? nil : owners
+        end
+      end
+
+      module_function
+
+      # Records that the final `merged` table was built over `seed`. The last two are kept (a file merges an
+      # instance and a singleton table), replaced rather than accumulated.
+      def record_layers(merged, seed)
+        previous = Thread.current[LAYERS_KEY]
+        Thread.current[LAYERS_KEY] = [[merged, seed], previous&.first].compact
+      end
+
+      # The definers index over `table`.
+      def for(table)
+        seed = Thread.current[LAYERS_KEY]&.find { |entry| entry[0].equal?(table) }&.last
+        return build(table) if seed.nil? || !deeply_frozen?(seed)
+
+        replaced = {}
+        kept = 0
+        table.each do |owner, methods|
+          if methods.equal?(seed[owner])
+            kept += 1
+          else
+            replaced[owner] = methods
+          end
+        end
+        return build(table) unless kept + replaced.count { |owner, _| seed.key?(owner) } == seed.size
+
+        Layered.new(seed_index(seed), replaced, build(replaced))
+      end
+
+      def deeply_frozen?(seed)
+        seed.frozen? && seed.each_value.all?(&:frozen?)
+      end
+
+      # The seed's index, built once per seed table. Two ways, an instance and a singleton seed table.
+      def seed_index(seed)
+        [SEED_INDEX_KEY, SEED_INDEX_ALT_KEY].each do |key|
+          slot = Thread.current[key]
+          return slot[1] if slot && slot[0].equal?(seed)
+        end
+        index = build(seed)
+        Thread.current[SEED_INDEX_ALT_KEY] = Thread.current[SEED_INDEX_KEY]
+        Thread.current[SEED_INDEX_KEY] = [seed, index]
+        index
+      end
+
+      def build(table)
+        index = {}
+        table.each do |class_name, methods|
+          next if class_name == ScopeIndexer::TOP_LEVEL_DEF_KEY
+
+          methods.each_key { |method_name| (index[method_name] ||= []) << class_name }
+        end
+        index
+      end
+    end
+  end
+end