rigortype 0.4.2 → 0.4.4

data/lib/rigor/inference/refined_dispatch.rb

@@ -20,10 +20,18 @@ module Rigor
     #
     # Issue #1740 — {OwnMethod} shares {.levels} with the walk below and asks the opposite question for the two
     # argument checks: does the receiver's own method answer ahead of every refinement in effect?
+    #
+    # Issue #1752 — a class object is walked through its own lookup ({ClassObject}): its singleton class and each
+    # superclass's, then `Class`, `Module`, `Object`, `Kernel` and `BasicObject`, so a refinement of `Object` answers
+    # `Integer.oo` while `Integer.sqrt` keeps answering ahead of one.
     module RefinedDispatch
       # The refinement that answers: `module_name` refines `refined_class` (a class or module on the walk).
       Winner = Data.define(:module_name, :refined_class)
 
+      # Issue #1752 — the singleton class `#<Class:of>` as an entry of a class object's walk ({ClassObject}): it
+      # defines the name through `of`'s own singleton methods, and no refinement table key names it.
+      SingletonClass = Data.define(:of)
+
       # The answer when the in-effect list carries {InEffectRefinements::UNKNOWN} and some refinement defines the
       # name on a class the walk reaches: any of them may answer.
       UNKNOWN = :unknown
@@ -37,14 +45,16 @@ module Rigor
       def wildcard = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
 
       # A {Winner}, {UNKNOWN}, or nil when no in-effect refinement answers `method_name` on an instance of
-      # `class_name` (the class's own lookup does). `list` is the call site's in-effect refinements.
+      # `class_name` (the class's own lookup does), or with `kind: :singleton` on the class object `class_name`
+      # itself (issue #1752). `list` is the call site's in-effect refinements.
       #
       # ADR-121 WD7 — a row the walk could not read never yields a {Winner}: an in-effect module's row for the name
       # whose class the walk could not name reaches every receiver, and a names-wildcard row of a level the walk
       # reaches before a definer may define the name, so both answer {UNKNOWN}. So does a winner whose module shares
       # its last segment with another listed module (A1): which of a `using`'s declared candidates Ruby finds can
-      # depend on load order.
-      def winner(scope, class_name, method_name, list)
+      # depend on load order. A class object's walk always ends at `Object`, so where it cannot be read a row that
+      # may sit on it answers {UNKNOWN} too.
+      def winner(scope, class_name, method_name, list, kind: :instance)
         refinements = scope.discovered_refinements
         return UNKNOWN if class_unknown_row?(scope, refinements, method_name, list)
 
@@ -53,13 +63,26 @@ module Rigor
         unknown = list.include?(InEffectRefinements::UNKNOWN)
         return nil if targets.nil? && unread.nil? && !unknown
 
-        levels = levels(scope, class_name)
+        levels = levels(scope, class_name, kind: kind)
+        return unread_class_object(scope, refinements, method_name, list) if levels.nil? && kind == :singleton
         return nil if levels.nil?
         return UNKNOWN if unknown && unknown_reaches?(scope, refinements, method_name, levels)
 
         walk_targets(scope, levels, method_name, [targets, unread], list)
       end
 
+      # {UNKNOWN} when some row for `method_name` (or a names-wildcard row) that `list` puts in effect, or any row
+      # under the unknown marker, names a class or module a class object may reach ({ClassObject.reachable?}).
+      def unread_class_object(scope, refinements, method_name, list)
+        unknown = list.include?(InEffectRefinements::UNKNOWN)
+        reaches = refinements.any? do |refined, methods|
+          rows = [methods[method_name], methods[wildcard]].compact
+          !rows.empty? && (unknown || rows.any? { |modules| in_effect?(modules, list) }) &&
+            ClassObject.reachable?(scope, refined)
+        end
+        reaches ? UNKNOWN : nil
+      end
+
       def walk_targets(scope, levels, method_name, (targets, unread), list)
         return nil if targets.nil? && unread.nil?
 
@@ -165,20 +188,40 @@ module Rigor
       # refinement first, as any level is; past that, the mixin may define the name, so a refinement further up the
       # walk may or may not win and the answer is {UNKNOWN}, never the replaced method's. ADR-121 WD7: a level an
       # in-effect module has a names-wildcard row for (`unread`) may define the name too, so it answers {UNKNOWN}.
+      #
+      # Issue #1752 — on a class object's walk a singleton level that only an entry no table names may answer
+      # (`:continue_unsure`) makes a refinement reached past it {UNKNOWN}: that entry may define the name.
       def walk(scope, levels, method_name, targets, unread)
-        levels.each_with_index do |(level_class, entries, mixed), index|
-          return UNKNOWN if level_class && unread.key?(level_class)
-
-          refining = level_class && targets[level_class]
-          return Winner.new(module_name: refining, refined_class: level_class) if refining
-          return targeted_after?(levels, index, targets, unread) ? UNKNOWN : nil if mixed
+        unsure = false
+        levels.each_index do |index|
+          answer = level_answer(scope, levels, index, method_name, [targets, unread])
+          next unsure = true if answer == :continue_unsure
+          next if answer == :continue
 
-          answer = walk_entries(scope, entries, level_class, method_name, targets, unread)
-          return answer unless answer == :continue
+          return unsure && answer.is_a?(Winner) ? UNKNOWN : answer
         end
         nil
       end
 
+      def level_answer(scope, levels, index, method_name, (targets, unread))
+        level_class, entries, mixed, every = levels[index]
+        return UNKNOWN if level_class && unread.key?(level_class)
+
+        refining = level_class && targets[level_class]
+        return Winner.new(module_name: refining, refined_class: level_class) if refining
+        return targeted_after?(levels, index, targets, unread) ? UNKNOWN : nil if mixed
+
+        walk_level(scope, [entries, every], level_class, method_name, [targets, unread])
+      end
+
+      def walk_level(scope, (entries, every), level_class, method_name, (targets, unread))
+        if level_class.is_a?(SingletonClass)
+          return ClassObject.walk_level(scope, every || entries, method_name, targets, unread)
+        end
+
+        walk_entries(scope, entries, level_class, method_name, targets, unread)
+      end
+
       # A level's prepended modules, its own method and its included modules, in that order: `:continue` when none
       # answers, so the walk moves on.
       def walk_entries(scope, entries, level_class, method_name, targets, unread)
@@ -205,7 +248,10 @@ module Rigor
       # name. `every entry` (project levels only) is the level's entries in lookup order with each one that
       # neither the project's resolver nor RBS can name kept as its candidate names (an Array) where `entries`
       # leaves it out: the typer never reads it, and {OwnMethod} declines where a refinement may name one.
-      def levels(scope, class_name)
+      # `kind: :singleton` answers the class object `class_name` instead ({ClassObject.levels}, issue #1752).
+      def levels(scope, class_name, kind: :instance)
+        return ClassObject.levels(scope, class_name) if kind == :singleton
+
         environment = scope.environment
         return rbs_levels(scope, class_name) if environment&.class_known?(class_name)
 
@@ -257,8 +303,9 @@ module Rigor
 
       # Does `name` define `method_name` on its instance side itself: a project `def` (its dependency edge recorded
       # through `Scope#user_def_for`), another project definer (`attr_*`, `define_method`), or an RBS declaration
-      # written on `name` rather than on an ancestor?
+      # written on `name` rather than on an ancestor? A {SingletonClass} asks its own singleton methods.
       def defines?(scope, name, method_name)
+        return ClassObject.defines?(scope, name.of, method_name) if name.is_a?(SingletonClass)
         return true if scope.user_def_for(name, method_name)
         return true if scope.discovered_method?(name, method_name, :instance)
 
@@ -269,4 +316,5 @@ module Rigor
   end
 end
 
+require_relative "refined_dispatch/class_object"
 require_relative "refined_dispatch/own_method"

data/lib/rigor/inference/reflective_ivar_write.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Issue #1889 — `instance_variable_set` called on `self` writes an instance variable that no write node shows.
+    # Left unseen, the binding the call site holds outlived it: `@n = 0; instance_variable_set(:@n, 5)` kept `@n`
+    # on `0`, and a block that wrote `@n` only this way never entered the captured-binding name set, so
+    # `[1, 2].inject(0) { |a, e| instance_variable_set(:@n, @n + 1); a + @n }` folded to a constant.
+    #
+    # A call counts when its receiver is implicit or `self` and it passes any argument ({.self_write?}). With
+    # exactly two plain positional arguments, the first a Symbol or String literal naming an instance variable
+    # (`:@n`, `"@n"`; Ruby accepts both), it is a write of that variable ({.literal_name}). Any other argument list
+    # — a computed name, a splat (`instance_variable_set(*args)`), a keyword hash, or a literal Ruby rejects with
+    # `NameError` (`:n`) — names an ivar the analysis cannot see, so every ivar the scope binds may have been
+    # written ({.apply}; for a rejected literal this over-approximates, which only widens).
+    # `obj.instance_variable_set` writes another object's ivar and does not count; neither does the reflective
+    # `send(:instance_variable_set, …)`.
+    module ReflectiveIvarWrite
+      METHOD_NAME = :instance_variable_set
+      private_constant :METHOD_NAME
+
+      IVAR_NAME = /\A@[A-Za-z_]\w*\z/
+      private_constant :IVAR_NAME
+
+      REPEATING_KEY = :__rigor_reflective_ivar_write_repeating__
+      private_constant :REPEATING_KEY
+
+      module_function
+
+      # True when `node` is an `instance_variable_set` on `self` with at least one argument.
+      def self_write?(node)
+        return false unless node.is_a?(Prism::CallNode) && node.name == METHOD_NAME
+        return false unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+
+        arguments = node.arguments&.arguments
+        !arguments.nil? && !arguments.empty?
+      end
+
+      # `:@n` for `instance_variable_set(:@n, v)` or `instance_variable_set("@n", v)` on `self`, else nil.
+      def literal_name(node)
+        return nil unless self_write?(node)
+
+        arguments = node.arguments.arguments
+        return nil unless arguments.size == 2 && arguments.none? { |arg| splat_or_keywords?(arg) }
+
+        name = arguments.first
+        text =
+          case name
+          when Prism::SymbolNode, Prism::StringNode then name.unescaped
+          end
+        text && IVAR_NAME.match?(text) ? text.to_sym : nil
+      end
+
+      # True for a call {.self_write?} takes whose target {.literal_name} cannot name: it may write any ivar.
+      def unknown_target?(node)
+        self_write?(node) && literal_name(node).nil?
+      end
+
+      # The value argument of a call {.literal_name} names.
+      def value_node(node)
+        node.arguments.arguments[1]
+      end
+
+      # Runs the block with the evaluator inside a `while` / `until` / `for` body. The loop's rebind fixpoint widens
+      # locals only, so a literal-name write there must not replace the binding with one pass's value
+      # ({.apply}).
+      def in_repeating_body
+        depth = Thread.current[REPEATING_KEY] || 0
+        Thread.current[REPEATING_KEY] = depth + 1
+        begin
+          yield
+        ensure
+          Thread.current[REPEATING_KEY] = depth
+        end
+      end
+
+      def repeating_body?
+        (Thread.current[REPEATING_KEY] || 0).positive?
+      end
+
+      # `scope` after `node` runs. A literal name binds that ivar to the value's type (yielded), as `@n = v` does.
+      # Inside a loop body ({.in_repeating_body}) the value and `Dynamic[top]` are joined into the current binding
+      # instead: the loop's fixpoint widens locals only, so its single pass over an ivar types the value from one
+      # iteration's locals (`instance_variable_set(:@n, i + 1)` stored `1`) and would leave that. Any other call joins
+      # `Dynamic[top]` into every ivar `scope` binds: any one of them may now hold the value, and joining the
+      # value's own type would report a method the old value has and the new one lacks. An ivar on its ADR-58
+      # declaration seed keeps its mark, which stops a nil in the seed from fuelling a nil-receiver diagnostic.
+      def apply(node, scope)
+        return scope unless self_write?(node)
+
+        name = literal_name(node)
+        return bind_literal(scope, name, yield) if name
+
+        floor = Type::Combinator.untyped
+        scope.ivars.reduce(scope) do |acc, (ivar, type)|
+          widened = Type::Combinator.union(type, floor)
+          rebound = acc.with_ivar(ivar, widened).without_ivar_guard(ivar)
+          scope.declaration_sourced?(:ivar, ivar) ? rebound.seed_declaration_sourced_ivar(ivar, widened) : rebound
+        end
+      end
+
+      def bind_literal(scope, name, value)
+        type = repeating_body? ? Type::Combinator.union(*scope.ivar(name), value, Type::Combinator.untyped) : value
+        scope.with_ivar(name, type).without_ivar_guard(name)
+      end
+
+      def splat_or_keywords?(arg)
+        arg.is_a?(Prism::SplatNode) || arg.is_a?(Prism::KeywordHashNode) || arg.is_a?(Prism::BlockArgumentNode)
+      end
+    end
+  end
+end