rigortype 0.3.8 → 0.3.9

data/lib/rigor/inference/mutation_widening.rb

@@ -5,7 +5,10 @@ require "prism"
 require_relative "../type"
 require_relative "../source/node_children"
 require_relative "content_join"
+require_relative "mutation_rejoin"
 require_relative "receiver_alias"
+require_relative "refinement_mutation"
+require_relative "string_mutation"
 
 module Rigor
   module Inference
@@ -98,7 +101,7 @@ module Rigor
       # in-place call on this name change its binding?" against (issue #587: the block-return
       # threading gate). Derived from the two tables above rather than spelled out, so the scan and
       # the widening it predicts cannot drift apart.
-      SHAPE_MUTATORS = (ARRAY_MUTATORS | HASH_MUTATORS).freeze
+      SHAPE_MUTATORS = (ARRAY_MUTATORS | HASH_MUTATORS | StringMutation::MUTATORS).freeze
 
       # Methods that return the receiver (or a shallow copy) and cannot mutate it. They must not
       # trigger widening or any other receiver-fact invalidation. The list is intentionally
@@ -126,10 +129,6 @@ module Rigor
       # pre-join behaviour exactly.
       NO_ARG_TYPES = [].freeze
 
-      # @param call_node     [Prism::CallNode]
-      # @param current_scope [Rigor::Scope]
-      # @param arg_types     [Array<Rigor::Type::Base>]
-      # @return              [Rigor::Scope]
       def widen_after_call(call_node:, current_scope:, arg_types: NO_ARG_TYPES)
         return current_scope if pure_self_returner?(call_node.name)
 
@@ -138,8 +137,7 @@ module Rigor
 
       # True when `receiver` names at least one variable whose CURRENT binding is a literal-shape
       # carrier — the only pre-state {#widen_for_mutator} joins into. Callers use it to skip typing a
-      # mutator's arguments when nothing will consume them: `buf << x` on a String and `arr << x` on an
-      # already-nominal Array are the common cases, and `Scope#type_of` memoizes nothing.
+      # mutator's arguments when nothing will consume them, and `Scope#type_of` memoizes nothing.
       def joinable_receiver?(receiver, scope)
         return false if receiver.nil?
 
@@ -149,7 +147,28 @@ module Rigor
             when Prism::LocalVariableReadNode then scope.local(read.name)
             when Prism::InstanceVariableReadNode then scope.ivar(read.name)
             end
-          current.is_a?(Type::Tuple) || current.is_a?(Type::HashShape)
+          shape_carrier?(current)
+        end
+      end
+
+      # A union carrying a shape member is joinable too (issue #645): {#widen_union} widens that
+      # member through the same join, so the arguments the caller would skip are the evidence it
+      # needs.
+      # A `Constant[String]` counts too since issue #617 residue (4): the gate exists to skip typing arguments
+      # nothing will consume, and this carrier IS consumed now — `buf << x` on a `+"ab"` rewrites the binding.
+      # An empty-witness `Difference` counts too (issue #936): the `non-empty-array[T]` arm joins the
+      # mutator's added element now, so its arguments are evidence this seam consumes rather than
+      # arguments nothing will read.
+      def shape_carrier?(type)
+        case type
+        when Type::Tuple, Type::HashShape then true
+        when Type::Constant then StringMutation.constant?(type)
+        # A re-openable nominal counts since issue #580: skipping it made the one-way door
+        # self-fulfilling, since the arm never saw the arg types it grows from.
+        when Type::Nominal then MutationRejoin.regrowable_carrier?(type)
+        when Type::Difference then type.removes_empty_witness?
+        when Type::Union then type.members.any? { |m| shape_carrier?(m) }
+        else false
         end
       end
 
@@ -224,30 +243,24 @@ module Rigor
         end
       end
 
-      def widen_alias_read(method_name, read, scope, values: :widen, arg_types: NO_ARG_TYPES)
-        case read
-        when Prism::LocalVariableReadNode
-          widen_local(method_name, read.name, scope, values: values, arg_types: arg_types)
-        when Prism::InstanceVariableReadNode
-          widen_ivar(method_name, read.name, scope, values: values, arg_types: arg_types)
-        else scope
-        end
-      end
-
-      def widen_local(method_name, var_name, current_scope, values: :widen, arg_types: NO_ARG_TYPES)
-        current = current_scope.local(var_name)
-        widened = widen_for_mutator(current, method_name, values: values, arg_types: arg_types)
-        return current_scope if widened.nil?
+      # The local and ivar arms differ only in which pair of `Scope` accessors they use, so they are read out
+      # of one table rather than written twice: a carrier the widening responds to must not be widened on one
+      # kind of binding and left on the other.
+      ALIAS_ACCESSORS = {
+        Prism::LocalVariableReadNode => %i[local with_local],
+        Prism::InstanceVariableReadNode => %i[ivar with_ivar]
+      }.freeze
+      private_constant :ALIAS_ACCESSORS
 
-        current_scope.with_local(var_name, widened)
-      end
+      def widen_alias_read(method_name, read, scope, values: :widen, arg_types: NO_ARG_TYPES)
+        getter, builder = ALIAS_ACCESSORS[read.class]
+        return scope if getter.nil?
 
-      def widen_ivar(method_name, var_name, current_scope, values: :widen, arg_types: NO_ARG_TYPES)
-        current = current_scope.ivar(var_name)
+        current = scope.public_send(getter, read.name)
         widened = widen_for_mutator(current, method_name, values: values, arg_types: arg_types)
-        return current_scope if widened.nil?
+        return scope if widened.nil?
 
-        current_scope.with_ivar(var_name, widened)
+        MutationRejoin.rebind(scope, builder, read.name, widened, pre_state: current, kind: getter)
       end
 
       # Mutators that can land a NEW value in an EXISTING slot, falsifying that slot's value pinning
@@ -259,15 +272,16 @@ module Rigor
       private_constant :VALUE_REWRITING_MUTATORS
 
       # Returns the widened type for a binding whose receiver is about to be mutated by
-      # `method_name`, or `nil` when no widening applies (binding is not a literal-shape
-      # carrier, OR the method is not a mutator for that shape, OR the binding is already a
-      # nominal — no precision to lose).
+      # `method_name`, or `nil` when no widening applies (binding is not a carrier the mutation
+      # stands for, OR the method is not a mutator for that shape, OR the carrier is a PRECISE
+      # nominal, whose element set is a claim this seam may not grow — see {MutationRejoin.regrowable_carrier?}).
       def widen_for_mutator(type, method_name, values: :widen, arg_types: NO_ARG_TYPES)
         values = :keep unless VALUE_REWRITING_MUTATORS.include?(method_name)
 
         return nil if type.nil?
 
         case type
+        when Type::Nominal then MutationRejoin.widen_nominal(type, method_name, values:, arg_types:)
         when Type::Tuple
           return nil unless ARRAY_MUTATORS.include?(method_name)
 
@@ -277,11 +291,52 @@ module Rigor
 
           join_added_pairs(widen_hash_shape(type, values: values), method_name, arg_types,
                            ContentJoin.hash_shape_key_values(type))
+        when Type::Constant then StringMutation.widen_constant(type, method_name)
         when Type::Difference
-          widen_difference(type, method_name)
+          widen_difference(type, method_name, arg_types: arg_types)
+        when Type::Union
+          widen_union(type, method_name, values: values, arg_types: arg_types)
         end
       end
 
+      # A `Union` seed is widened MEMBERWISE (issue #645). Declining it outright left a straight-line
+      # mutation on a union binding recording nothing at all — `out = flag ? 5 : [2]; out << 2` kept
+      # the `[2]` Tuple's arity after the mutation falsified it, so a later `out.size == 1` folds on a
+      # value the program never holds.
+      #
+      # Which members the mutation stands for is {ContentJoin}'s residue partition read from this
+      # side, so the straight-line seam and the block seam (#631) agree about a union: a member the
+      # mutator's class carries widens through the ordinary non-union path above, every other member
+      # survives whole. The two tables are consulted per member rather than once for the union, which
+      # is what a name in BOTH of them (`clear`, `delete`, `replace`) needs on a mixed
+      # `Array | Hash` seed.
+      #
+      # `nil` when no member widened — a union with no carrier member, or one whose carriers are
+      # already nominal, is untouched exactly as the scalar path leaves them.
+      def widen_union(union, method_name, values: :widen, arg_types: NO_ARG_TYPES)
+        widened_any = false
+        members = union.members.map do |member|
+          next member unless mutation_carrier?(member, method_name)
+
+          widened = widen_for_mutator(member, method_name, values: values, arg_types: arg_types)
+          next member if widened.nil?
+
+          widened_any = true
+          widened
+        end
+        return nil unless widened_any
+
+        Type::Combinator.union(*members)
+      end
+
+      # True when the mutator's own class stands for `member` — the absorbed side of
+      # {ContentJoin.array_residue} / {ContentJoin.hash_residue}, whichever table names the call.
+      def mutation_carrier?(member, method_name)
+        (ARRAY_MUTATORS.include?(method_name) && ContentJoin.array_residue(member).empty?) ||
+          (HASH_MUTATORS.include?(method_name) && ContentJoin.hash_residue(member).empty?) ||
+          (StringMutation::MUTATORS.include?(method_name) && StringMutation.constant?(member))
+      end
+
       # Joins the element evidence the mutator's own ARGUMENTS introduce into the already-widened
       # Array carrier (issue #560). Without it the widening keeps only the SEED's elements, which
       # under-covers precisely the value the mutation added: `u = [1, 2]; u.push(6)` left
@@ -433,25 +488,19 @@ module Rigor
         end
       end
 
-      # `non-empty-array[T]` / `non-empty-hash[K, V]` → the bare base nominal. These refinement
-      # carriers are what `empty?` / `any?` narrowing writes (ADR-47 §4-4), and they are just as
-      # invalidated by an in-place mutator as a `Tuple` is: `arr.clear` makes `arr` empty, so a
-      # surviving `Difference[Array[T], Tuple[]]` would project `arr.size` to `positive-int` and
-      # fold `arr.size == 0` to `Constant[false]` — a false `flow.always-falsey-condition` on
-      # correct code.
-      #
-      # Only the EMPTY-witness differences over Array / Hash are widened, and only for that
-      # base's mutator table. The other catalogued refinements are unreachable from these tables
-      # by construction: `non-empty-string` and `non-zero-int` bind String / Integer receivers,
-      # whose mutators (`String#<<` and friends) appear in neither `ARRAY_MUTATORS` nor
-      # `HASH_MUTATORS` — and none of them can empty a non-empty string anyway.
-      def widen_difference(difference, method_name)
-        return nil unless difference.removes_empty_witness?
-
-        base = difference.base
-        case base.class_name
-        when "Array" then ARRAY_MUTATORS.include?(method_name) ? base : nil
-        when "Hash" then HASH_MUTATORS.include?(method_name) ? base : nil
+      # The empty-witness refinement arm. {RefinementMutation} owns the witness half — whether
+      # `xs` is still provably non-empty after `method_name` — and takes the content half from
+      # here, so a refinement joins the mutator's added content on exactly the terms the `Tuple` /
+      # `HashShape` arms above do (issue #936, ADR-56 WD2.9's deferred branch).
+      def widen_difference(difference, method_name, arg_types: NO_ARG_TYPES)
+        RefinementMutation.widen(difference, method_name) do |base|
+          if base.class_name == "Array"
+            ARRAY_MUTATORS.include?(method_name) &&
+              join_added_elements(base, method_name, arg_types, ContentJoin.collection_element_types(base))
+          else
+            HASH_MUTATORS.include?(method_name) &&
+              join_added_pairs(base, method_name, arg_types, ContentJoin.hash_shape_key_values(base))
+          end
         end
       end