rigortype 0.4.4 → 0.4.6

data/lib/rigor/inference/ivar_writer_census.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    # Issue #1154 — the instance-variable writers {GlobalWriteCensus} records for the declared-parameter credit
+    # ({ScopeIndexer::DeclaredParamWrites}), which must not type an ivar a writer the class-ivar census never walks may
+    # replace. The standard is parity with a literal write: `@x = 1` in `initialize` already reads `1` in every sibling
+    # method whatever an unknown object's code does, so only the writers that literal writes would also have to answer
+    # for are recorded, and an unknown-receiver writer records nothing (as `ReflectiveIvarWrite` leaves
+    # `o.instance_variable_set` alone). Three entry kinds go into the census `Set`:
+    #
+    # - `[:ivar_set, name]` — a literal `o.instance_variable_set(:@x, v)` (or the same through a `send` that spells
+    #   it) on an explicit receiver other than `self`, and an `@x` write in the literal block of an
+    #   `o.instance_eval { … }` / `instance_exec`: code that names the ivar it writes.
+    # - `[:ivar_set_class, class_name]` — an open-world writer ({#open_world?}) with an implicit or `self` receiver
+    #   inside an instance body of the class — a `def` or a `define_method` block in its class body, in the block of a
+    #   `K = Struct.new` / `Data.define` / `Class.new` constant, or in a `K.class_eval` block (the host walk passes
+    #   that class as `owner`): it may write any ivar of the class's instances. A writer in a class body, a
+    #   `def self.` or at the top level records nothing.
+    # - `[:own_write, class_name, name]` — an `@x` write inside an instance body of the class.
+    #   {ScopeIndexer#merge_constant_literal_tables} appends the file's path, so a reader can tell whether a second
+    #   file writes the same ivar of the same class.
+    class IvarWriterCensus
+      SEND_CALLS = %i[send __send__ public_send].to_set.freeze
+      # The methods a `send` reaching which is an open-world writer.
+      OPEN_WORLD_SENDS = %i[instance_variable_set instance_eval instance_exec extend
+                            define_singleton_method].to_set.freeze
+      EVAL_CALLS = %i[instance_eval instance_exec].to_set.freeze
+      # The calls on a `singleton_class` receiver that give the object methods or code the census cannot read.
+      SINGLETON_CLASS_CALLS = %i[
+        class_eval class_exec module_eval module_exec define_method include prepend extend attr attr_reader
+        attr_writer attr_accessor send public_send __send__
+      ].to_set.freeze
+      NO_ARGUMENTS = [].freeze
+
+      # The call names any rule here reads, so every other call returns at one Set probe.
+      # (`define_method` is in {SINGLETON_CLASS_CALLS}.)
+      WATCHED_CALLS = (SEND_CALLS | OPEN_WORLD_SENDS | EVAL_CALLS | SINGLETON_CLASS_CALLS).freeze
+
+      def initialize(census)
+        @census = census
+        @instance_ranges = []
+        @owner_names = {}.compare_by_identity
+        @own_writes = {}
+      end
+
+      # Fed each node of a pre-order descent. `owner` is the class whose body the node sits in, as its qualified name
+      # or as the host walk's prefix Array (joined here only when an entry needs it), or nil where no class owns an
+      # instance (`class << self`, the top level, an opaque block).
+      def visit(node, owner)
+        case node
+        when Prism::DefNode then remember(node.location, owner) if owner && node.receiver.nil?
+        when Prism::SingletonClassNode then visit_singleton_class(node)
+        when Prism::CallNode then visit_call(node, owner) if WATCHED_CALLS.include?(node.name)
+        when Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+             Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+          record_own_write(node) unless @instance_ranges.empty?
+        end
+      end
+
+      private
+
+      # One entry per class and ivar: a repeated write costs a Hash probe, not a location and an Array.
+      def record_own_write(node)
+        owner = instance_owner(node)
+        return if owner.nil?
+
+        seen = (@own_writes[owner] ||= {})
+        return if seen[node.name]
+
+        seen[node.name] = true
+        @census << [:own_write, owner_name(owner), node.name].freeze
+      end
+
+      def owner_name(owner) = owner.is_a?(Array) ? (@owner_names[owner] ||= owner.join("::")) : owner
+
+      def visit_call(node, owner)
+        remember(node.block.location, owner) if owner && define_method_block?(node)
+        if self_receiver?(node) || own_singleton_class_call?(node)
+          return if @instance_ranges.empty? || !(own_singleton_class_call?(node) || open_world?(node))
+
+          instance = instance_owner(node)
+          record_class(instance) if instance
+        else
+          visit_foreign(node)
+        end
+      end
+
+      # `class << self` inside an instance `def` opens the instance's singleton class.
+      def visit_singleton_class(node)
+        return unless node.expression.is_a?(Prism::SelfNode) && !@instance_ranges.empty?
+
+        instance = instance_owner(node)
+        record_class(instance) if instance
+      end
+
+      def record_class(owner) = @census << [:ivar_set_class, owner_name(owner)].freeze
+
+      # The self writers whose target or code the census cannot read: a `send` with a computed method name or one
+      # naming {OPEN_WORLD_SENDS}; `instance_eval` / `instance_exec` given a block argument, and `instance_eval`
+      # given a string; `extend`; `define_singleton_method` with a body; and an `instance_variable_set` whose name no
+      # literal spells. A call in {SINGLETON_CLASS_CALLS} on the object's own `singleton_class` counts as well.
+      def open_world?(node)
+        name = node.name
+        arguments = node.arguments&.arguments || NO_ARGUMENTS
+        return open_world_send?(arguments) if SEND_CALLS.include?(name)
+        return open_world_eval?(node, arguments) if EVAL_CALLS.include?(name)
+        # #1931's census already makes every ivar of the class gradual for one in the same file; this entry covers one
+        # in a reopening in another file, which that census does not see.
+        return ivar_name(arguments.first).nil? if name == :instance_variable_set
+
+        name == :extend || (name == :define_singleton_method && (!node.block.nil? || arguments.size > 1))
+      end
+
+      def open_world_send?(arguments)
+        return false if arguments.empty?
+
+        sent = literal_name(arguments.first)
+        sent.nil? || OPEN_WORLD_SENDS.include?(sent)
+      end
+
+      def open_world_eval?(node, arguments)
+        node.block.is_a?(Prism::BlockArgumentNode) || (node.name == :instance_eval && !arguments.empty?)
+      end
+
+      # A call on another receiver: a named foreign write, or `self.singleton_class.class_eval` and its kin.
+      def visit_foreign(node)
+        arguments = node.arguments&.arguments || NO_ARGUMENTS
+        name = node.name
+        if SEND_CALLS.include?(name) && arguments.first && literal_name(arguments.first) == :instance_variable_set
+          name = :instance_variable_set
+          arguments = arguments.drop(1)
+        end
+        if name == :instance_variable_set
+          ivar = ivar_name(arguments.first)
+          @census << [:ivar_set, ivar].freeze if ivar
+        elsif EVAL_CALLS.include?(name) && node.block.is_a?(Prism::BlockNode)
+          record_block_ivar_writes(node.block)
+        end
+      end
+
+      def record_block_ivar_writes(node)
+        return unless node.is_a?(Prism::Node)
+        return if node.is_a?(Prism::DefNode) || node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+
+        case node
+        when Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableAndWriteNode,
+             Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableTargetNode
+          @census << [:ivar_set, node.name].freeze
+        end
+        node.rigor_each_child { |child| record_block_ivar_writes(child) }
+      end
+
+      def define_method_block?(node)
+        node.name == :define_method && self_receiver?(node) && node.block.is_a?(Prism::BlockNode)
+      end
+
+      # An instance body (`def` or `define_method` block) and the class it belongs to. A `define_method` block's own
+      # nodes may reach the walk with no owner (the walk reads its `self` as opaque), so the class rides the range.
+      def remember(location, owner)
+        @instance_ranges << [(location.start_offset...location.end_offset), owner]
+      end
+
+      # The class of the innermost instance body covering `node` (pre-order, so the last covering range), or nil.
+      def instance_owner(node)
+        offset = node.location.start_offset
+        @instance_ranges.reverse_each { |(range, owner)| return owner if range.cover?(offset) }
+        nil
+      end
+
+      def self_receiver?(node) = node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+
+      # A call in {SINGLETON_CLASS_CALLS} on the object's own `singleton_class` (`singleton_class.class_eval { … }`).
+      def own_singleton_class_call?(node)
+        receiver = node.receiver
+        receiver.is_a?(Prism::CallNode) && receiver.name == :singleton_class && self_receiver?(receiver) &&
+          SINGLETON_CLASS_CALLS.include?(node.name)
+      end
+
+      def literal_name(argument)
+        return unless argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+
+        text = argument.unescaped
+        text.to_sym if text.valid_encoding?
+      end
+
+      def ivar_name(argument)
+        name = literal_name(argument)
+        name if name.to_s.start_with?("@")
+      end
+    end
+  end
+end

data/lib/rigor/inference/loop_value_record.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # The value the statement evaluator last gave a loop node, and the scope it evaluated the loop from, so
+    # `ExpressionTyper#type_of_loop` reads it instead of evaluating the loop again (issue #2031 review). A loop's value
+    # costs an evaluation of its body, its fixpoint and its `break` passes included, and the typer types a loop again
+    # wherever it types a node that holds one: the value of a write that wraps it (`id(z = (while …))`), a call it is
+    # the receiver of (`(while …).itself`), each narrowing and rule that types that operand. Each such typing of a
+    # loop nested in another loop re-ran the inner loop's passes, once more per level of nesting.
+    #
+    # The record is reused only for the very scope object the loop was evaluated from, so it answers exactly what an
+    # evaluation would. It is not compared with `Scope#==`, which ignores several fields (`match_frame`,
+    # `declared_refinements`, `struct_fold_safe_locals`, the opaque-block flags, `lexical_nesting`, the origins tables,
+    # `discovery`): across the cost spec's 10933 reads every match was an identity match, and `lib/` read no record at
+    # all (issue #2262). It lives in a per-thread map whose keys are held weakly, so a record goes when its parse tree
+    # does.
+    module LoopValueRecord
+      KEY = :rigor_loop_value_record
+      private_constant :KEY
+
+      module_function
+
+      COUNT_KEY = :rigor_loop_value_count
+      private_constant :COUNT_KEY
+
+      def record(node, scope, type)
+        Thread.current[COUNT_KEY] = loops_evaluated + 1
+        conditional(node, scope, type)
+      end
+
+      # How many loops this thread has evaluated, so a conditional can tell whether its evaluation held one.
+      def loops_evaluated = Thread.current[COUNT_KEY] || 0
+
+      # The same record for a conditional that evaluated a loop in a branch: `id(c ? (while …) : 0)` types the
+      # conditional again from the scope it was evaluated from, and each typing evaluated the loop again from a
+      # branch scope of its own, which multiplied the passes of every loop nested in it (issue #2262).
+      def conditional(node, scope, type)
+        (Thread.current[KEY] ||= ObjectSpace::WeakKeyMap.new)[node] = [scope, type]
+        type
+      end
+
+      # The recorded value of `node` evaluated from `scope` itself, or nil.
+      def fetch(node, scope)
+        slot = Thread.current[KEY]&.[](node)
+        return nil if slot.nil?
+
+        recorded, type = slot
+        recorded.equal?(scope) ? type : nil
+      end
+    end
+  end
+end

data/lib/rigor/inference/macro_block_self_type.rb

@@ -47,6 +47,25 @@ module Rigor
       # same call, another plugin's included, is not consulted. A `:lexical` entry (issue #1667) keeps the caller's
       # `self`, so its `self_type` is the calling scope's.
       def match_for(scope:, call_node:, receiver_type:)
+        entry = first_matching_entry(scope, call_node, receiver_type)
+        return nil if entry.nil?
+
+        receiver_name = singleton_receiver_class_name(receiver_type) || nominal_receiver_class_name(receiver_type)
+        entry_match(entry, receiver_name, scope, scope.environment)
+      end
+
+      # Whether `call_node`'s block runs as an instance method of the receiver class (issue #1768): its first matching
+      # entry binds `:receiver_instance`, so the block body's `self` is the instance {#match_for} narrows to and its
+      # `@x` writes are that instance's ivars, as a `def` body's are. A `:lexical` or named-`self_type` entry runs the
+      # block on another object, and no entry means no narrowing.
+      def runs_as_receiver_instance_method?(scope:, call_node:, receiver_type:)
+        entry = first_matching_entry(scope, call_node, receiver_type)
+        !entry.nil? && entry.self_type == Plugin::Macro::BlockAsMethod::SELF_TYPE_RECEIVER_INSTANCE
+      end
+
+      # The first registered entry that matches `call_node` on `receiver_type`, in (plugin registration, declaration)
+      # order, or nil.
+      def first_matching_entry(scope, call_node, receiver_type)
         return nil if receiver_type.nil?
 
         environment = scope&.environment
@@ -61,12 +80,7 @@ module Rigor
         # (plugin registration, declaration) order; the method-name membership is guaranteed
         # by the table key.
         entries = registry.contribution_index.block_entries_for(call_node.name)
-        entries.each do |entry|
-          next unless entry_matches?(entry, singleton_name, nominal_name, call_node, scope, environment)
-
-          return entry_match(entry, singleton_name || nominal_name, scope, environment)
-        end
-        nil
+        entries.find { |entry| entry_matches?(entry, singleton_name, nominal_name, call_node, scope, environment) }
       end
 
       # The {Match} a matching entry contributes: a `:lexical` one keeps the calling scope's `self`, unknown where the

data/lib/rigor/inference/match_rebinding/frame.rb

@@ -88,6 +88,18 @@ module Rigor
           @forwarded_block == name
         end
 
+        # Issue #1157 — whether a call's `&expr` block argument hands on the block THIS method was called with: the
+        # anonymous `&` of a method that declares an anonymous `&` parameter, or {#forwarded_block?} for `&name`.
+        # Anything else (`&:sym`, a proc made here, a rebound name) is a block of this frame's own making.
+        def forwards_block?(block_argument)
+          expression = block_argument.expression
+          case expression
+          when nil then anonymous_block_parameter?
+          when Prism::LocalVariableReadNode then forwarded_block?(expression.name)
+          else false
+          end
+        end
+
         # The scan of `node` under `scope`, kept while `scope`'s local and instance-variable tables are the same
         # objects: a lookup argument's answer reads them ({MatchRebinding.may_match?}), and a rebuild that leaves
         # them alone passes the same tables on. `kind` keeps another reading of the same node apart (issue #1365:
@@ -125,6 +137,13 @@ module Rigor
           name
         end
 
+        # True when the method declares a bare `&` parameter, which only an anonymous `&` argument can read.
+        def anonymous_block_parameter?
+          parameters = @parameters
+          block = parameters.is_a?(Prism::ParametersNode) ? parameters.block : nil
+          !block.nil? && block.name.nil?
+        end
+
         # The method's own `&block` parameter's name, or nil.
         def block_parameter_name
           parameters = @parameters