rigortype 0.4.0 → 0.4.2

data/lib/rigor/inference/external_ancestor_resolution.rb

@@ -30,10 +30,11 @@ module Rigor
     #
     # There is deliberately NO memo here. The dispatch consumer this module is being extracted FOR does
     # not exist yet, and a memo keyed on the tables this slice happens to name would be keyed on less
-    # than the walk reads — `Scope#resolve_ancestor_class_name` consults `discovered_def_nodes` and
-    # `discovered_methods` through `known_user_class?`, and `ancestor_name_candidates` reads
-    # `discovered_header_nestings`. The slice that brings the hot path brings the memo, keyed on what
-    # that consumer actually reads.
+    # than the walk reads — the ancestor chain resolves names through `known_user_class?`
+    # (`discovered_def_nodes`, `discovered_methods`) and `ancestor_name_candidates`
+    # (`discovered_header_nestings`). The chain itself is memoised per discovery index
+    # ({Scope::ResolutionChain}); the slice that brings the hot path brings this module's memo, keyed on
+    # what that consumer actually reads.
     module ExternalAncestorResolution
       # The owner a name must PRECEDE for its declaration to win an MRO. See {declared_before_object?}.
       OBJECT_OWNER = "Object"
@@ -67,13 +68,12 @@ module Rigor
       # `include Enumerable` so that slice 2's measurement stays its own, and the narrowing belongs to
       # the CALLER rather than to this module: the implicit-self veto must keep walking both edges,
       # because Ruby reaches an included module's methods too.
-      # rubocop:disable-next Metrics/ParameterLists
-      def resolve(class_name, method_name, kind = :instance, scope:, environment: nil, name_memo: nil,
-                  record_dependencies: true, mixins: true)
+      def resolve(class_name, method_name, kind = :instance, scope:, environment: nil, record_dependencies: true,
+                  mixins: true)
         return nil if class_name.nil? || scope.nil?
         return nil unless kind == :instance
 
-        compute(class_name, method_name, scope, environment, name_memo, record_dependencies, mixins)
+        compute(class_name, method_name, scope, environment, record_dependencies, mixins)
       end
 
       # The RBS method definition for `class_name`, or nil for a class the environment does not know, a
@@ -133,7 +133,7 @@ module Rigor
         []
       end
 
-      def compute(class_name, method_name, scope, environment, name_memo, record_dependencies, mixins)
+      def compute(class_name, method_name, scope, environment, record_dependencies, mixins)
         kind = :instance
         own = method_definition(class_name, method_name, kind, scope: scope, environment: environment)
         if own
@@ -144,7 +144,7 @@ module Rigor
           end
         end
 
-        groups = ancestor_candidate_groups(scope, class_name, name_memo, record_dependencies, mixins)
+        groups = ancestor_candidate_groups(scope, class_name, record_dependencies, mixins)
         farther_ancestors = {}
         groups.each_with_index do |candidates, index|
           answer = first_known_candidate_answer(candidates, method_name, kind, scope, environment)
@@ -244,14 +244,11 @@ module Rigor
       # The walk, with its ADR-46 reads attached or detached. `withhold` returns `[result, read_set]`
       # and the read set is dropped: a caller that suppresses is saying these reads are not a dependency
       # of its answer, not that they should be replayed somewhere else.
-      def ancestor_candidate_groups(scope, class_name, name_memo, record_dependencies, mixins)
-        memo = name_memo || {}
-        if record_dependencies
-          return scope.external_ancestor_name_candidates(class_name, name_memo: memo, mixins: mixins)
-        end
+      def ancestor_candidate_groups(scope, class_name, record_dependencies, mixins)
+        return scope.external_ancestor_name_candidates(class_name, mixins: mixins) if record_dependencies
 
         Analysis::DependencyRecorder.withhold do
-          scope.external_ancestor_name_candidates(class_name, name_memo: memo, mixins: mixins)
+          scope.external_ancestor_name_candidates(class_name, mixins: mixins)
         end.first
       end
       private_class_method :ancestor_candidate_groups

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

@@ -33,12 +33,19 @@ module Rigor
     # The accepted gap is implicit conversion: a core method that calls back into a project method the program
     # does not spell (`puts obj` runs `obj.to_s`, `hash[obj]` runs `obj.hash`, `a.sort` runs `<=>`) is read as the
     # core method alone.
+    #
+    # Issue #1446 — a class guard's narrowing of an instance variable is restored at the same code, since code that
+    # may rebind a global may reach `self` and rebind the variable too, and at two more: `instance_variable_set` and
+    # `remove_instance_variable` on any receiver, and a write to the narrowed variable in code the scan reads (a
+    # block that may run again, a loop's next pass).
     module GuardRebinding
       # Calls that run code chosen by name or by a String.
       CODE_RUNNING_NAMES = Set[
         :send, :__send__, :public_send, :eval, :require, :require_relative, :load,
         # These rebind a constant on any receiver (`Object.const_set(:SEP, nil)`).
-        :const_set, :remove_const
+        :const_set, :remove_const,
+        # These rebind an instance variable of a receiver that may be `self` (#1446).
+        :instance_variable_set, :remove_instance_variable
       ].freeze
       # These run their literal block, which the scan reads as any block, or a String of code, which it cannot read.
       BLOCK_OR_CODE_NAMES = Set[
@@ -109,10 +116,11 @@ module Rigor
           (call_node.block.is_a?(Prism::BlockArgumentNode) && may_rebind?(call_node.block, scope))
       end
 
-      # True when running `node` may rebind one: it writes a global or constant, yields, calls `super`, or holds a
-      # call, spelled or implicit ({.implicit_call_may_rebind?}), whose method may run foreign code. A `def` and a
-      # lambda literal run nothing where they are written. Each node is visited once: a call's literal block is
-      # reached as one of its children, so a nested block chain costs its size, not its depth's power.
+      # True when running `node` may rebind one: it writes a global, a constant or an instance variable a class guard
+      # narrowed, yields, calls `super`, or holds a call, spelled or implicit ({.implicit_call_may_rebind?}), whose
+      # method may run foreign code. A `def` and a lambda literal run nothing where they are written. Each node is
+      # visited once: a call's literal block is reached as one of its children, so a nested block chain costs its
+      # size, not its depth's power.
       #
       # A local the scanned code writes has no binding in `scope` yet, so the scan reads it as the code writes it
       # ({ScanScope.with_scanned_locals}): `copy = $sep; copy.length` is a `String` call. A literal block's parameters
@@ -126,6 +134,7 @@ module Rigor
       def scan(node, scope)
         return false unless node.is_a?(Prism::Node)
         return true if REBINDING_NODES.include?(node.class)
+        return true if guarded_ivar_write?(node, scope)
         return false if node.is_a?(Prism::DefNode) || node.is_a?(Prism::LambdaNode)
         return scan_call(node, scope) if node.is_a?(Prism::CallNode)
         return true if IMPLICIT_CALL_NODES.include?(node.class) && implicit_call_may_rebind?(node, scope)
@@ -135,6 +144,18 @@ module Rigor
         found
       end
 
+      # Issue #1446 — true when `node` writes an instance variable a class guard narrowed
+      # ({Scope#guard_narrowed_ivar?}). A write to any other instance variable rebinds nothing a guard recorded.
+      def guarded_ivar_write?(node, scope)
+        case node
+        when Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+             Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+          scope.guard_narrowed_ivar?(node.name)
+        else
+          false
+        end
+      end
+
       def scan_call(node, scope)
         return true if call_runs_foreign_code?(node, scope)
         return true if scan(node.receiver, scope) || scan(node.arguments, scope)
@@ -156,7 +177,9 @@ module Rigor
       def implicit_call_may_rebind?(node, scope)
         kind = VARIABLE_OPERATOR_WRITES[node.class]
         return type_method_foreign?(variable_type(kind, node.name, scope), node.binary_operator, scope) if kind
-        return type_method_foreign?(scope.type_of(node.collection), :each, scope) if node.is_a?(Prism::ForNode)
+        if node.is_a?(Prism::ForNode)
+          return type_method_foreign?(ScanScope.dispatch_type(node.collection, scope), :each, scope)
+        end
 
         compound_write_foreign?(node, scope)
       rescue StandardError
@@ -174,7 +197,7 @@ module Rigor
       end
 
       def compound_receiver_type(node, scope)
-        return scope.type_of(node.receiver) if node.receiver
+        return ScanScope.dispatch_type(node.receiver, scope) if node.receiver
 
         scope.self_type || Type::Combinator.nominal_of("Object")
       end
@@ -264,7 +287,7 @@ module Rigor
           return ProjectMethodOwnership.targets(self_type)
         end
 
-        ProjectMethodOwnership.targets(scope.type_of(receiver))
+        ProjectMethodOwnership.targets(ScanScope.dispatch_type(receiver, scope))
       end
 
       def foreign_target?(class_name, method_name, kind, scope)
@@ -300,8 +323,8 @@ module Rigor
         owner = definition.respond_to?(:defined_in) ? definition.defined_in : nil
         owner&.to_s&.delete_prefix("::")
       end
-      private_class_method :scan, :scan_call, :receiver_targets, :foreign_target?, :universal_delegate_foreign?,
-                           :method_owner, :deferred_block_call?,
+      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?
@@ -376,18 +399,36 @@ module Rigor
           bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
         end
 
-        # What the method `call_node` calls yields its block, by position, or `[]` when that cannot be read.
+        # What the method `call_node` calls yields its block, by position, or `[]` when that cannot be read. A receiver
+        # a class guard left `bot` yields what the guarded class does ({.dispatch_type}, #1446).
         def yielded_types(call_node, scope)
-          receiver = call_node.receiver ? scope.type_of(call_node.receiver) : scope.self_type
+          receiver = call_node.receiver ? dispatch_type(call_node.receiver, scope) : scope.self_type
           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
           []
         end
 
+        # Issue #1446 — the type a call on the receiver `node` dispatches on: its type in `scope`, or, where a class
+        # guard disjoint from the receiver's binding left it `bot` (`return unless @io.is_a?(StringIO)` on an `IO`),
+        # the classes the guard named ({Narrowing.bot_guard_classes_of}), since the value that passes the guard is one
+        # of them. So `@io.rewind` reads as `StringIO#rewind` and keeps the narrowing, while `@cb.call` past
+        # `@cb.is_a?(Proc)` reads as a call on a code object, and a method a project subclass or reopening defines on
+        # the class still counts. A `bot` no class guard produced stays `bot`, which no target resolves, so a call on
+        # it counts as an unresolved callee.
+        def dispatch_type(node, scope)
+          type = scope.type_of(node)
+          return type unless type.is_a?(Type::Bot)
+
+          classes = Narrowing.bot_guard_classes_of(node, scope)
+          return type if classes.nil?
+
+          Type::Combinator.union(*classes.map { |name| Type::Combinator.nominal_of(name) })
+        end
+
         # The names a block's parameter list declares: every kind of parameter, a destructured one's parts included,
         # and a `;`-block-local. A default value is not read.
         def collect_parameter_names(node, names)

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