rigortype 0.3.9 → 0.4.0

data/lib/rigor/inference/project_patched_scanner.rb

@@ -41,10 +41,11 @@ module Rigor
       def scan(paths, buffer: nil)
         entries = []
         diagnostics = []
-        paths.each { |path| scan_file(path, entries, diagnostics, buffer) }
+        census = Set.new
+        paths.each { |path| scan_file(path, entries, diagnostics, buffer, census) }
         diagnostics.concat(duplicate_declaration_diagnostics(entries))
         Result.new(
-          registry: ProjectPatchedMethods.new(entries: entries),
+          registry: ProjectPatchedMethods.new(entries: entries, write_census: census.freeze),
           diagnostics: diagnostics
         )
       end
@@ -77,7 +78,7 @@ module Rigor
       end
       private_class_method :duplicate_declaration_diagnostics
 
-      def scan_file(path, entries, diagnostics, buffer = nil)
+      def scan_file(path, entries, diagnostics, buffer = nil, census = Set.new)
         physical = buffer ? buffer.resolve(path) : path
         parse_result =
           if physical == path
@@ -91,6 +92,9 @@ module Rigor
         end
 
         walk_node(parse_result.value, [], false, path, entries)
+        # Issue #1367 — the file's `global.*` write facts: a patch file may alias a special or give a class the
+        # method a setter asks for, as any project file may.
+        census.merge(GlobalWriteCensus.scan(parse_result.value))
       rescue StandardError => e
         diagnostics << build_diagnostic(
           path: path, line: 1, column: 1,

data/lib/rigor/inference/receiver_alias.rb

@@ -24,10 +24,40 @@ module Rigor
     # object no binding can be attributed to and yields `[]`, which is what every receiver form
     # outside the single-read case already contributed. The walk is depth-capped so a pathological
     # nest cannot make receiver classification unbounded.
+    #
+    # The `it` parameter (Ruby 3.4) is a local like any other, but Prism reads it through
+    # `Prism::ItLocalVariableReadNode`, which carries no `name`; {.read_name} answers `:it` for it, the
+    # binding `BlockParameterBinder` installs. A consumer names a read through {.read_name}, never `#name`.
+    #
+    # A local or instance-variable write evaluates to the variable it writes, so `(buf ||= []) << x`
+    # mutates `buf` and yields a read of it ({.read_of}). Issue #1223 made that binding visible: the
+    # statement evaluator threads a write in a receiver, and without the alias `buf` kept the `[]`
+    # the `||=` stored.
     module ReceiverAlias
       # Deep enough for any hand-written selection; a nest beyond it degrades to "names no binding".
       WALK_DEPTH_CAP = 6
 
+      NON_ALIASED_READS = [Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode].freeze
+      private_constant :NON_ALIASED_READS
+
+      LOCAL_WRITE_NODES = Set[
+        Prism::LocalVariableWriteNode, Prism::LocalVariableOrWriteNode,
+        Prism::LocalVariableAndWriteNode, Prism::LocalVariableOperatorWriteNode
+      ].freeze
+      INSTANCE_WRITE_NODES = Set[
+        Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode
+      ].freeze
+      CLASS_VARIABLE_WRITE_NODES = Set[
+        Prism::ClassVariableWriteNode, Prism::ClassVariableOrWriteNode,
+        Prism::ClassVariableAndWriteNode, Prism::ClassVariableOperatorWriteNode
+      ].freeze
+      GLOBAL_WRITE_NODES = Set[
+        Prism::GlobalVariableWriteNode, Prism::GlobalVariableOrWriteNode,
+        Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode
+      ].freeze
+      private_constant :LOCAL_WRITE_NODES, :INSTANCE_WRITE_NODES, :CLASS_VARIABLE_WRITE_NODES, :GLOBAL_WRITE_NODES
+
       module_function
 
       # @param node — the receiver expression.
@@ -36,9 +66,11 @@ module Rigor
       #   read the expression can evaluate to; empty when it can evaluate to none.
       def candidates(node, depth = 0)
         return [] if node.nil? || depth > WALK_DEPTH_CAP
+        # Tested before the `case`: a `when *SET` arm would copy the set into an Array on every call.
+        return [read_of(node)] if variable_write?(node)
 
         case node
-        when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode then [node]
+        when Prism::LocalVariableReadNode, Prism::ItLocalVariableReadNode, Prism::InstanceVariableReadNode then [node]
         when Prism::ParenthesesNode then candidates(node.body, depth + 1)
         when Prism::StatementsNode then candidates(node.body.last, depth + 1)
         when Prism::ElseNode then candidates(node.statements, depth + 1)
@@ -52,6 +84,63 @@ module Rigor
       def branches(first, second, depth)
         candidates(first, depth + 1) + candidates(second, depth + 1)
       end
+
+      # The variable reads an in-place mutation of `receiver` changes: {.candidates}' locals and instance
+      # variables, or the class variable or global the receiver reads or writes directly, parenthesised or not
+      # (`(@@c ||= []) << x` mutates `@@c`, as `(buf ||= []) << x` mutates `buf`). A class variable or global counts
+      # only as the receiver itself, not through a branch that selects it. This is the
+      # one answer the straight-line widening ({MutationWidening.widen_receiver_aliases}), the block-return
+      # threading gate that predicts it (`ExpressionTyper#prefix_statement_jump_free?`) and the per-element fold's
+      # content-mutation scan ({CapturedLocals.content_mutations}) all read, so "the scan says the body changed
+      # it" and "evaluating the body changes it" cannot disagree about which kinds of variable count.
+      def mutated_reads(receiver)
+        direct = receiver
+        direct = direct.body.body.last while direct.is_a?(Prism::ParenthesesNode) && direct.body.is_a?(Prism::StatementsNode)
+        return [direct] if NON_ALIASED_READS.include?(direct.class)
+        return [read_of(direct)] if non_aliased_write?(direct)
+
+        candidates(receiver)
+      end
+
+      # True when `node` is a class-variable or global write, which {.mutated_reads} answers only as the receiver
+      # itself, as it answers a class-variable or global read.
+      def non_aliased_write?(node)
+        CLASS_VARIABLE_WRITE_NODES.include?(node.class) || GLOBAL_WRITE_NODES.include?(node.class)
+      end
+
+      # The binding a read from {.candidates} or {.mutated_reads} names.
+      def read_name(read) = read.is_a?(Prism::ItLocalVariableReadNode) ? :it : read.name
+
+      # True when `read` is a local the innermost block around it owns: one Prism resolves at `depth == 0`, or an
+      # `it` read, which is always that block's own parameter and never a capture of an enclosing scope.
+      def block_local?(read)
+        read.is_a?(Prism::ItLocalVariableReadNode) || (read.is_a?(Prism::LocalVariableReadNode) && read.depth.zero?)
+      end
+
+      # True when `node` is a local or instance-variable write, whose value is the variable it leaves.
+      def variable_write?(node)
+        LOCAL_WRITE_NODES.include?(node.class) || INSTANCE_WRITE_NODES.include?(node.class)
+      end
+
+      # A read of the variable `write` writes, at the write's name, for the analysers that key a receiver on a
+      # read node — a local, instance-variable, class-variable or global write. `Prism` 1.x constructs every node
+      # from `source, node_id, location, flags` and its fields.
+      def read_of(write)
+        source = write.send(:source)
+        if LOCAL_WRITE_NODES.include?(write.class)
+          Prism::LocalVariableReadNode.new(source, write.node_id, write.name_loc, 0, write.name, write.depth)
+        else
+          named_read_class(write.class).new(source, write.node_id, write.name_loc, 0, write.name)
+        end
+      end
+
+      # The read node class for an instance-variable, class-variable or global write class.
+      def named_read_class(write_class)
+        if INSTANCE_WRITE_NODES.include?(write_class) then Prism::InstanceVariableReadNode
+        elsif CLASS_VARIABLE_WRITE_NODES.include?(write_class) then Prism::ClassVariableReadNode
+        else Prism::GlobalVariableReadNode
+        end
+      end
     end
   end
 end

data/lib/rigor/inference/receiver_blind_block.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "block_parameter_binder"
+
+module Rigor
+  module Inference
+    # Can a block see the hash that an in-place transform is rewriting? This is the gate for the in-place forms
+    # of the HashShape per-pair fold (`ExpressionTyper#try_hash_shape_block_fold`).
+    #
+    # `transform_values!` / `transform_keys!` rewrite their receiver pair by pair while they iterate, so a block
+    # that reads the receiver sees the pairs it has already rewritten. The fold types every pair against the
+    # pre-call state held by the entry scope, so it gives a precise wrong answer: `h = { x: 1, y: 2 };
+    # h.transform_values! { |e| h[:x] + e }` folded to `{ x: 2, y: 3 }`, where Ruby answers `{ x: 2, y: 4 }`.
+    #
+    # The engine records no aliasing between bindings, and a method can return the receiver under any name.
+    # The gate therefore does not look for the receiver. It admits a block only when everything the block
+    # reads from outside itself is incapable of describing a hash's contents:
+    #
+    # - A local declared inside the block tree — a parameter or a block-local — is admitted. Prism's `depth`
+    #   decides this, so a nested parameter that shadows an outer local is still a parameter.
+    # - A captured local, instance, class or global variable, or a constant, is admitted when its entry type
+    #   carries no hash contents ({#carries_hash_contents?}). A compound write reads first, so it counts too.
+    #   A constant compound write (`F ||= …`) names no read node to type, and a constant path under a
+    #   non-constant parent (`m::T`) cannot be typed from the entry scope, so neither is admitted.
+    # - A method call is admitted only when its receiver is built from block parameters and literals alone
+    #   (`e.to_s.upcase`, `[e].map { … }`, `%i[a b].include?(k)`). This excludes an implicit-self call and a
+    #   call on `self`, a constant, a captured variable or a block-local, because the method can return the
+    #   receiver however the value it is called on is typed (`Registry.store[:x]`, `tbl[:x]` for
+    #   `def tbl = TABLE`).
+    # - `super`, `yield`, and a nested `def` / `class` / `module` / `class << x` run code the walk cannot
+    #   see, so they are never admitted.
+    # - The operand of `defined?` is not walked: it asks whether a name is defined and reads no value.
+    #
+    # What a method called on a block parameter reaches is outside the gate. Such a method can read global
+    # state, but its inferred return type can hold stale constant contents without any in-place transform,
+    # so this is the engine-wide method-effect gap rather than this fold's. The gate only costs precision on
+    # the value of the bang call itself, because the receiver's own binding is widened after any bang call.
+    module ReceiverBlindBlock
+      LOCAL_READS = [
+        Prism::LocalVariableReadNode,
+        Prism::LocalVariableOperatorWriteNode,
+        Prism::LocalVariableOrWriteNode,
+        Prism::LocalVariableAndWriteNode
+      ].freeze
+
+      # Each captured non-local read, and the `Scope` accessor holding its entry binding.
+      VARIABLE_ACCESSORS = Ractor.make_shareable({
+                                                   Prism::InstanceVariableReadNode => :ivar,
+                                                   Prism::InstanceVariableOperatorWriteNode => :ivar,
+                                                   Prism::InstanceVariableOrWriteNode => :ivar,
+                                                   Prism::InstanceVariableAndWriteNode => :ivar,
+                                                   Prism::ClassVariableReadNode => :cvar,
+                                                   Prism::ClassVariableOperatorWriteNode => :cvar,
+                                                   Prism::ClassVariableOrWriteNode => :cvar,
+                                                   Prism::ClassVariableAndWriteNode => :cvar,
+                                                   Prism::GlobalVariableReadNode => :global,
+                                                   Prism::GlobalVariableOperatorWriteNode => :global,
+                                                   Prism::GlobalVariableOrWriteNode => :global,
+                                                   Prism::GlobalVariableAndWriteNode => :global
+                                                 })
+
+      CONSTANT_READS = [Prism::ConstantReadNode, Prism::ConstantPathNode].freeze
+
+      # A constant compound write reads the constant by name, with no read node for the walk to type.
+      CONSTANT_COMPOUND_WRITES = [
+        Prism::ConstantOperatorWriteNode,
+        Prism::ConstantOrWriteNode,
+        Prism::ConstantAndWriteNode
+      ].freeze
+
+      # Every node that calls a method on a receiver.
+      RECEIVER_CALLS = [
+        Prism::CallNode,
+        Prism::CallAndWriteNode,
+        Prism::CallOperatorWriteNode,
+        Prism::CallOrWriteNode,
+        Prism::CallTargetNode,
+        Prism::IndexAndWriteNode,
+        Prism::IndexOperatorWriteNode,
+        Prism::IndexOrWriteNode,
+        Prism::IndexTargetNode
+      ].freeze
+
+      # Nodes that run code the walk cannot see, or open a scope the block's locals are invisible from.
+      OPAQUE = [
+        Prism::SuperNode,
+        Prism::ForwardingSuperNode,
+        Prism::YieldNode,
+        Prism::DefNode,
+        Prism::ClassNode,
+        Prism::ModuleNode,
+        Prism::SingletonClassNode
+      ].freeze
+
+      # Literal nodes, whose value is built from their children alone.
+      LITERALS = [
+        Prism::IntegerNode, Prism::FloatNode, Prism::RationalNode, Prism::ImaginaryNode,
+        Prism::StringNode, Prism::SymbolNode, Prism::RegularExpressionNode,
+        Prism::InterpolatedStringNode, Prism::InterpolatedSymbolNode, Prism::EmbeddedStatementsNode,
+        Prism::NilNode, Prism::TrueNode, Prism::FalseNode,
+        Prism::ArrayNode, Prism::HashNode, Prism::AssocNode, Prism::RangeNode
+      ].freeze
+
+      # A `Type` carrier is an immutable value built bottom-up, so it cannot contain itself. The cap is
+      # defensive only, and exceeding it answers "carries": declining the fold is the safe side.
+      TYPE_DEPTH_CAP = 8
+
+      module_function
+
+      # @param base_scope — the call-site scope the block closes over.
+      def blind?(block_node, base_scope)
+        scope_blind?(block_node, [], base_scope)
+      end
+
+      # `levels` holds the parameter names of each block from the transform's own block (index 0) down to
+      # the innermost block around the node, so a local read's Prism `depth` names the block that declares
+      # it, or none when the read is captured from outside.
+      def scope_blind?(block_node, levels, base_scope)
+        levels += [Set.new(BlockParameterBinder.new.bind(block_node).keys)]
+        [block_node.parameters, block_node.body].all? { |child| node_blind?(child, levels, base_scope) }
+      end
+
+      def node_blind?(node, levels, base_scope)
+        case node
+        when nil, Prism::DefinedNode then true
+        when Prism::BlockNode, Prism::LambdaNode then scope_blind?(node, levels, base_scope)
+        when *OPAQUE then false
+        else
+          admitted?(node, levels, base_scope) &&
+            node.compact_child_nodes.all? { |child| node_blind?(child, levels, base_scope) }
+        end
+      end
+
+      def admitted?(node, levels, base_scope)
+        case node
+        when *LOCAL_READS then in_block_tree?(node, levels) || !carries_hash_contents?(base_scope.local(node.name))
+        when *VARIABLE_ACCESSORS.keys
+          !carries_hash_contents?(base_scope.public_send(VARIABLE_ACCESSORS[node.class], node.name))
+        when *CONSTANT_READS then !constant_carries?(node, base_scope)
+        when *CONSTANT_COMPOUND_WRITES then false
+        when *RECEIVER_CALLS then built_from_parameters?(node.receiver, levels)
+        else true
+        end
+      end
+
+      def in_block_tree?(read, levels) = !declaring_level(read, levels).nil?
+
+      # The index into `levels` of the block that declares a local read, or `nil` for a captured read.
+      def declaring_level(read, levels)
+        level = levels.size - 1 - read.depth
+        level unless level.negative?
+      end
+
+      # Whether a call receiver's value comes from block parameters and literals alone. A call inside it is
+      # followed to its own receiver; its arguments are admitted by the walk on their own.
+      def built_from_parameters?(receiver, levels)
+        case receiver
+        when Prism::LocalVariableReadNode
+          level = declaring_level(receiver, levels)
+          !level.nil? && levels[level].include?(receiver.name)
+        when Prism::ItLocalVariableReadNode then true
+        when Prism::ParenthesesNode then built_from_parameters?(receiver.body, levels)
+        when Prism::StatementsNode then built_from_parameters?(receiver.body.last, levels)
+        when *RECEIVER_CALLS then built_from_parameters?(receiver.receiver, levels)
+        when *LITERALS then receiver.compact_child_nodes.all? { |child| built_from_parameters?(child, levels) }
+        else false
+        end
+      end
+
+      def constant_carries?(node, base_scope)
+        return true if node.is_a?(Prism::ConstantPathNode) && !constant_parent?(node.parent)
+
+        carries_hash_contents?(base_scope.type_of(node))
+      rescue StandardError
+        true
+      end
+
+      # `::T` has no parent; `A::T` and `A::B::T` have constant parents.
+      def constant_parent?(parent)
+        parent.nil? || CONSTANT_READS.include?(parent.class)
+      end
+
+      # Whether a value of `type` can tell a reader what some hash holds, key by key or as `Hash[K, V]`
+      # parameters. A read through such a value in an in-place transform's block can be stale by the next
+      # pair. `Dynamic[top]`, a bare `Hash` and a scalar cannot, and neither can a `Hash` whose parameters are
+      # untyped.
+      def carries_hash_contents?(type, depth = 0)
+        return false if type.nil?
+        return true if depth > TYPE_DEPTH_CAP || type.is_a?(Type::HashShape) || typed_hash_nominal?(type)
+
+        component_types(type).any? { |inner| carries_hash_contents?(inner, depth + 1) }
+      end
+
+      def typed_hash_nominal?(type)
+        type.is_a?(Type::Nominal) && type.class_name == "Hash" &&
+          type.type_args.any? { |arg| !arg.is_a?(Type::Dynamic) && !arg.is_a?(Type::Top) }
+      end
+
+      # The types a carrier holds. The list is empty for a carrier that cannot hold another value's type.
+      def component_types(type)
+        case type
+        when Type::Union, Type::Intersection then type.members
+        when Type::Tuple then type.elements
+        when Type::Nominal then type.type_args
+        when Type::Refined, Type::Difference then [type.base]
+        when Type::StructInstance, Type::DataInstance then type.members.values
+        when Type::Dynamic then [type.static_facet]
+        when Type::BoundMethod then [type.receiver_type]
+        when Type::Maybe then [type.value_type]
+        when Type::Result then [type.ok_type, type.err_type]
+        when Type::App then [*type.args, type.bound]
+        else []
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/refinement_mutation.rb

@@ -20,9 +20,11 @@ module Rigor
     module RefinementMutation
       # Mutators that CANNOT leave a non-empty receiver empty. Whitelists rather than a table of
       # emptiers: a name missing from these retracts the witness, which is the conservative answer
-      # every mutator got before. The listed ones either only add (`<< push …`) or only permute a
-      # fixed number of slots (`sort! map! …`); `replace`, `compact!`, `flatten!`, `uniq!` and every
-      # remover are deliberately absent, since each has an input that empties the receiver.
+      # every mutator got before. The listed ones either only add (`<< push …`) or only reorder or
+      # rewrite a fixed number of slots (`sort! map! …`); `replace`, `compact!`, `flatten!`, `uniq!`
+      # and every remover are deliberately absent, since each has an input that empties the receiver.
+      # Keeping the witness is all this table decides: what a rewrite leaves in those slots is
+      # {RewriteMutation}'s answer, so `map!` keeps `non-empty-array` but not its element.
       EMPTY_PRESERVING = {
         "Array" => %i[
           << push append prepend unshift concat insert
@@ -40,23 +42,25 @@ module Rigor
       # The block receives the refinement's BASE and answers the base with the mutator's added
       # content joined in, or a falsey value to decline (the mutator is not in that base's table).
       # A String base is answered here instead: it carries no content parameter, so the only
-      # question it has is the witness one.
-      def widen(difference, method_name)
+      # question it has is the witness one, which for `tr!` / `tr_s!` turns on `arg_types`.
+      def widen(difference, method_name, arg_types = StringMutation::NO_ARG_TYPES)
         return nil unless difference.removes_empty_witness?
 
         base = difference.base
-        joined = base.class_name == "String" ? string_base(base, method_name) : yield(base)
+        joined = base.class_name == "String" ? string_base(base, method_name, arg_types) : yield(base)
         return nil unless joined
 
         widened = preserves_witness?(base.class_name, method_name) ? refine(joined, difference) : joined
         widened == difference ? nil : widened
       end
 
-      # A `non-empty-string` survives every mutator that cannot empty the buffer, and those are
-      # exactly the ones {StringMutation} does not list as emptying — so this arm declines them
-      # and the refinement stands, rather than widening to `String` and dropping it.
-      def string_base(base, method_name)
-        StringMutation::EMPTYING_MUTATORS.include?(method_name) ? base : nil
+      # A `non-empty-string` survives every mutator call that cannot empty the buffer
+      # ({StringMutation.may_empty?}), so this arm declines those and the refinement stands, rather
+      # than widening to `String` and dropping it. A name that is not a String mutator declines too.
+      def string_base(base, method_name, arg_types)
+        return nil unless StringMutation::MUTATORS.include?(method_name)
+
+        StringMutation.may_empty?(method_name, arg_types) ? base : nil
       end
 
       def preserves_witness?(class_name, method_name)