rigortype 0.4.5 → 0.4.7

data/lib/rigor/inference/self_call_ivar_writes.rb

@@ -2,12 +2,14 @@
 
 require "prism"
 
+require_relative "../analysis/dependency_recorder"
 require_relative "../source/node_children"
 require_relative "../source/parameter_envelope"
 require_relative "../type"
 require_relative "guard_rebinding"
 require_relative "project_method_ownership"
 require_relative "refined_dispatch/own_method"
+require_relative "../run_scoped_slots"
 
 module Rigor
   module Inference
@@ -84,7 +86,9 @@ module Rigor
         :to_r, :to_c, :to_proc, :to_path, :to_sym, :to_io, :coerce, :exception, :divmod, :each, :respond_to?,
         :respond_to_missing?, :method_missing, :initialize_copy, :marshal_dump, :pretty_print
       ].freeze
-      private_constant :UNPROVABLE_NODES, :LITERAL_CLASSES, :SELF_SAFE_NAMES, :PROTOCOL_NAMES
+      # Issue #2203 — the classes and module every project class's instances reach past its own chain.
+      IMPLICIT_ROOTS = %w[Object Kernel BasicObject].freeze
+      private_constant :UNPROVABLE_NODES, :LITERAL_CLASSES, :SELF_SAFE_NAMES, :PROTOCOL_NAMES, :IMPLICIT_ROOTS
 
       # Raised inside a proof to abandon it.
       class Unprovable < StandardError
@@ -112,6 +116,32 @@ module Rigor
         nil
       end
 
+      DEFINITION_COUNTS_KEY = RunScopedSlots.register(:__rigor_self_call_ivar_writes_definition_counts__)
+      private_constant :DEFINITION_COUNTS_KEY
+
+      # `{[owner, name] => the number of instance `def` rows of name the project records for owner}`, over every
+      # file of `deferred_ranges` (a `discovered_deferred_ranges` table). Built once per table and kept in ONE
+      # thread slot keyed by the table's identity (#2300): the table is never written in place, a file whose rows
+      # equal the seed's keeps the seed's table, and a scan of every file's rows per query was the cost once the
+      # table held the whole project. The slot holds one table and its counts, the next table replaces them, and the
+      # run that filled it releases it when it ends ({RunScopedSlots}, #2399).
+      def definition_counts(deferred_ranges)
+        slot = Thread.current[DEFINITION_COUNTS_KEY]
+        return slot[1] if slot && slot[0].equal?(deferred_ranges)
+
+        counts = {}
+        deferred_ranges.each_value do |rows|
+          rows.each do |row|
+            next unless row[3] == :instance
+
+            key = [row[4], row[2]]
+            counts[key] = counts.fetch(key, 0) + 1
+          end
+        end
+        Thread.current[DEFINITION_COUNTS_KEY] = [deferred_ranges, counts]
+        counts
+      end
+
       # One proof's state: the instance variables read code writes, and the `def` bodies already read.
       class Proof
         attr_reader :written
@@ -127,7 +157,7 @@ module Rigor
         # Reads the method an implicit-self or `self.` call to `call_node`'s name runs.
         def self_call(call_node)
           name = call_node.name
-          unprovable! if GuardRebinding.code_running_name?(name) || refined?(name)
+          unprovable! if GuardRebinding.code_running_name?(name) || refined?(name, on_self: true)
 
           if ProjectMethodOwnership.defines?(@class_name, name, :instance, @scope)
             read_def(proven_def(name))
@@ -184,10 +214,66 @@ module Rigor
 
         private
 
-        # Whether a `refine` block anywhere in the project defines `name`, on any class: a `using` in effect where the
-        # read code sits may route the call to it (`refine Kernel do def warn …`), whatever the receiver.
-        def refined?(name)
-          @scope.discovered_refinements.any? { |_refined, methods| methods.key?(name) }
+        # Whether a `refine` block in the project defines `name` where the call may reach it: a `using` in effect
+        # where the read code sits may route the call to it (`refine Kernel do def warn …`).
+        #
+        # Issue #2163 — the answer reads every file's refinements whole, and a refined class off the chain (`Kernel`,
+        # `IO`, `String`) is no `mark:` the chain read files, so it records `refinement:<name>` and `refinement:*`
+        # whichever way it answers, as `InEffectRefinements` consumers do: a file that starts or stops refining the
+        # name re-checks the reader.
+        #
+        # Issue #2203 — for a call on `self` (`on_self:`) whose reach {#self_reach} knows, a row of the name counts only
+        # on a class key in that reach, on the wildcard class key, or on a key the walk could not name
+        # (`InEffectRefinements.class_wildcard_key?`); a names-wildcard row (a computed `define_method`,
+        # `import_methods`) counts as the name, but only on a class key in the reach. A refinement of `String` leaves
+        # a `Holder` alone: dropping the proof is no safer, since the intervening-call reset restores the class-ivar
+        # seed and a class guard's narrowing then reports. Where the reach is unknown, and for a call on another
+        # receiver, a row of the name counts on any class and a names-wildcard row never does, as before the issue.
+        def refined?(name, on_self: false)
+          wildcard = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
+          if Analysis::DependencyRecorder.active?
+            Analysis::DependencyRecorder.read_name(:refinement, name)
+            Analysis::DependencyRecorder.read_name(:refinement, wildcard)
+          end
+          reach = on_self ? self_reach : nil
+          @scope.discovered_refinements.any? do |refined, methods|
+            next methods.key?(name) if reach.nil?
+
+            if reach.include?(refined)
+              methods.key?(name) || methods.key?(wildcard)
+            else
+              methods.key?(name) && InEffectRefinements.class_wildcard_key?(@scope, refined)
+            end
+          end
+        end
+
+        # Issue #2203 — the classes and modules on the instance chain of `self`'s class and of `Object`, `Kernel` and
+        # `BasicObject` (which holds the modules the project mixes into them), with `Object`'s RBS ancestors
+        # (`PP::ObjectMixin`); nil when a chain is cut, mixes in a module the tables cannot name, ends in a superclass
+        # they do not know (`class Holder < Struct.new(:a)`), or holds an external entry. A project subclass's chain
+        # needs no read: {#no_protocol_override} gives the proof up on a refined class or module anywhere on it. The
+        # implicit roots' chains are recorded, so a file that mixes a module into `Object` re-checks the reader;
+        # `self`'s own chain is recorded by {#no_protocol_override}'s read.
+        def self_reach
+          return @self_reach if defined?(@self_reach)
+
+          @self_reach = read_self_reach
+        end
+
+        def read_self_reach
+          names = Set.new
+          [@class_name.to_s, *IMPLICIT_ROOTS].each do |class_name|
+            chain = Scope::ResolutionChain.for(@scope, class_name, :instance, :methods)
+            chain.record(@scope) if Analysis::DependencyRecorder.active?
+            return nil if chain.truncated? || chain.wildcard_mixin? || chain.opaque_tail?(@scope)
+            return nil if chain.entries.any?(&:external?)
+
+            chain.entries.each { |entry| names << entry.name }
+          end
+          loader = @scope.environment&.rbs_loader
+          return nil if loader.nil?
+
+          names.merge(loader.ancestor_names_for("Object"))
         end
 
         def call_receiver(node) = node.is_a?(Prism::CallNode) ? node.receiver : nil
@@ -240,12 +326,11 @@ module Rigor
         # one file, with one `def` of the name there (a reopening or a `class_eval` body in the same file is a second
         # one), and no `define_method`, `attr_*` or alias of it, nor a rewrite no literal names (`T.define_method`,
         # `T.send(:define_method, …)`, `T.class_eval` with a computed name), nor a definition the walk could not prove
-        # runs (a possible or contested one, as `DefinerResolution` reads them). The class edge files every declaring
-        # file.
+        # runs (a possible or contested one, as `DefinerResolution` reads them). `Scope#parameter_envelopes_of` files
+        # the class edge to every declaring file and, issue #2137, the `mark:` edge for a file that only marks it.
         def single_definition(owner, name)
-          Scope::ResolutionChain.record_class(@scope, owner) if Analysis::DependencyRecorder.active?
+          bucket = @scope.parameter_envelopes_of(owner)
           unprovable! if possible_definition?(owner, name)
-          bucket = @scope.discovered_parameter_envelopes[owner] || {}
           unprovable! if bucket[[:instance, name]] == Source::ParameterEnvelope::OPAQUE
           unprovable! if (@scope.discovered_class_sources[owner]&.size || 0) > 1
           unprovable! if definition_count(owner, name) > 1
@@ -259,11 +344,7 @@ module Rigor
         end
 
         def definition_count(owner, name)
-          count = 0
-          @scope.discovered_deferred_ranges.each_value do |rows|
-            count += rows.count { |row| row[2] == name && row[3] == :instance && row[4] == owner }
-          end
-          count
+          SelfCallIvarWrites.definition_counts(@scope.discovered_deferred_ranges).fetch([owner, name], 0)
         end
 
         # Whether `chain`'s own order stands with no second world: no order mark and no fork. `ResolutionChain#settle`
@@ -279,9 +360,12 @@ module Rigor
         end
 
         # Whether the project rewrites `class_name`'s method table beyond the names it spells, or refines it.
+        #
+        # Issue #2137 — read through `Scope#parameter_envelopes_of`, which files the `mark:` edge: a `refine` of the
+        # class from a file whose declared classes do not change fires no class key, and adding or removing it must
+        # re-check the reader.
         def rewritten?(class_name)
-          bucket = @scope.discovered_parameter_envelopes[class_name]
-          !bucket.nil? && Scope::DiscoveryIndex.rewritten_surface?(bucket)
+          Scope::DiscoveryIndex.rewritten_surface?(@scope.parameter_envelopes_of(class_name))
         end
 
         # The first project class or module on `class_name`'s settled instance chain that defines `name`, stopping

data/lib/rigor/inference/set_mutation.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+require_relative "content_join"
+require_relative "mutation_rejoin"
+require_relative "rewrite_mutation"
+
+module Rigor
+  module Inference
+    # The Set half of {MutationWidening}'s seams (issue #2294), beside {StringMutation}.
+    #
+    # `f = Set["a"]; f.clear; f << 1; f.map { |v| v.fdiv(2) }` reported `undefined method 'fdiv' for String`
+    # on code that prints `[0.5]`: the mutation seams answered `Tuple`, `HashShape`, `Constant[String]` and the
+    # re-openable `Array` / `Hash` nominals, so a `Set` kept the elements it was built with through every
+    # `<<`, `add`, `merge` and `replace`.
+    #
+    # A Set has no slots and no arity, so the only thing a mutation falsifies is the element set. Both carriers
+    # this module answers end at the typed Set #2290 builds for a non-constant literal — `Set[E | Dynamic[top]]`:
+    #
+    # - a constant-folded `Constant[Set]` widens to that carrier, its members' value pins dropped
+    #   ({MethodDispatcher.array_new_element}) and joined with the `Dynamic[top]` floor;
+    # - a typed `Set` whose element already carries a gradual arm re-grows the way
+    #   {MutationRejoin.regrowable_carrier?} lets an `Array` / `Hash` re-grow;
+    # - a PRECISE `Set[String]` (an RBS return such as `Array#to_set`) re-grows too (issue #2361), as a precise
+    #   `Array[String]` does ({MutationRejoin.widen_precise_array}): `f = ARGV.to_set; f.clear; f << 1` is
+    #   `Set[Dynamic[top] | String]`.
+    #
+    # A gradual seed admits every added member as itself: the seed-admissibility gate has nothing to contradict on
+    # it. A precise seed admits only a member its element accepts ({MutationRejoin.precise_admitted}), any other
+    # taking the floor, and takes no {RewriteMutation} arm: `replace` joins its elements onto the seed, and `map!`
+    # leaves it as it was. Every join carries the `Dynamic[top]` floor, as the Array re-join's does. An adder whose
+    # arguments the block-capture seam did not type joins only that floor: the store happened, and a Set has no
+    # block content join to add it afterwards. An adder called with no arguments changes nothing.
+    module SetMutation
+      # Receiver-mutating Set methods. The non-bang siblings (`map` vs `map!`, `select` vs `select!`) and the
+      # algebra (`|`, `+`, `-`, `&`, `^`) return a new Set and stay precise.
+      MUTATORS = %i[
+        << add add? merge replace
+        map! collect! flatten!
+        clear delete delete? delete_if keep_if select! filter! reject! subtract
+      ].to_set.freeze
+
+      # The {MUTATORS} that put elements in. `<<` / `add` / `add?` store their argument; `merge` stores every
+      # argument's elements; `replace` its argument's elements, after {RewriteMutation} has dropped the old ones.
+      CONTENT_ADDERS = %i[<< add add? merge replace].to_set.freeze
+
+      module_function
+
+      def constant?(type)
+        type.is_a?(Type::Constant) && type.value.is_a?(::Set)
+      end
+
+      # True when `type` is a `Set` carrier of either kind, which {#widen} answers for alone.
+      def set?(type)
+        constant?(type) || (type.is_a?(Type::Nominal) && type.class_name == "Set")
+      end
+
+      # True when `type` is a `Set` the seams may grow: a constant-folded one, or a typed one carrying a gradual
+      # element arm.
+      def carrier?(type)
+        constant?(type) || (type.is_a?(Type::Nominal) && regrowable?(type))
+      end
+
+      # True when `type`, or a member of it, is a {#carrier?}: the only types a Set-only adder's floor can change.
+      def carrier_in?(type)
+        type.is_a?(Type::Union) ? type.members.any? { |member| carrier?(member) } : carrier?(type)
+      end
+
+      # Every typed `Set[E]`, a precise one included since issue #2361.
+      def regrowable?(nominal)
+        nominal.class_name == "Set" && nominal.type_args.size == 1
+      end
+
+      # The carrier `type` holds after `method_name` with argument types `arg_types`, or `nil` when the call is not
+      # a Set mutator or `type` is not a carrier this seam grows. `nil` also answers a re-join that changed nothing,
+      # so a remover on an already-widened Set does not rebind it. That is a guard, not a behaviour: a Set has no
+      # `receiver[key] ||=` slot narrowings for a rebind to drop, so the identical carrier would read the same either
+      # way, and declining only saves rebuilding the scope.
+      #
+      # Issue #2555 L3 — `synthesised` says the binding carries the `:synthesised` construction fact: the engine built
+      # the Set itself (`s = Set[1]`, `Set.new(...)`), so no declaration made a claim about its elements, and the
+      # carrier stays re-growable for as long as the binding keeps the fact. Such a Set joins without the floor
+      # ({#floored}'s and {#join}'s) and without the precise seed's admissibility gate: `s = Set[1]; s << 2` reads
+      # `Set[Integer]`, and a read of its member reports what an Integer does not answer.
+      def widen(type, method_name, arg_types, unread_arguments: false, synthesised: false)
+        return nil unless MUTATORS.include?(method_name)
+
+        if constant?(type)
+          members = type.value.map { |v| Type::Combinator.constant_of(v) }
+          seed = synthesised && !members.empty? ? exact(members) : floored(members)
+          join(seed, method_name, arg_types, unread_arguments, synthesised:)
+        elsif type.is_a?(Type::Nominal) && regrowable?(type)
+          joined = join(type, method_name, arg_types, unread_arguments, synthesised:)
+          joined == type ? nil : joined
+        end
+      end
+
+      # Every join carries the `Dynamic[top]` floor, a precise seed's included (issue #2361): a later remover or
+      # rewriter (`subtract`, `delete`, `map!`) can take the stored members out again, and nothing narrows the
+      # carrier back, so a closed `Set[Integer | String]` would reject a declared `Set[String]` the program meets.
+      # A synthesised carrier (issue #2555) takes the rewrite arm a gradual one takes, admits every added member, and
+      # joins no floor: an untyped store joins `Dynamic[top]` as the one unknown member it is.
+      def join(carrier, method_name, arg_types, unread_arguments, synthesised: false)
+        seed = carrier.type_args.first
+        # A precise seed takes no rewrite arm, as a precise `Array` does not ({MutationRejoin.widen_precise_array}).
+        carrier = RewriteMutation.arm(carrier, method_name) if synthesised || MutationRejoin.gradual_parameter?(seed)
+        return carrier unless CONTENT_ADDERS.include?(method_name)
+
+        stored = added_elements(method_name, arg_types)
+        if stored.empty?
+          # An adder called with no arguments (`s.merge`) is a no-op; one whose arguments went untyped is a store.
+          return carrier unless unread_arguments
+
+          added = []
+        else
+          return carrier if !MutationRejoin.gradual_parameter?(seed) && MutationRejoin.already_held?(seed, stored)
+
+          added = admitted(seed, stored.map { |t| widened_member(t) }, synthesised:)
+        end
+        floor = synthesised && !added.empty? ? [] : [Type::Combinator.untyped]
+        element = Type::Combinator.union(carrier.type_args.first, *added, *floor)
+        Type::Combinator.nominal_of("Set", type_args: [element])
+      end
+
+      # `added` as {MutationRejoin.precise_admitted} admits it into a precise seed; a gradual or synthesised seed
+      # admits all.
+      def admitted(seed, added, synthesised: false)
+        return added if synthesised || MutationRejoin.gradual_parameter?(seed)
+
+        MutationRejoin.precise_admitted(seed, added)
+      end
+
+      # The element types one content-adder call puts in, from the call's argument types.
+      def added_elements(method_name, arg_types)
+        return [] if arg_types.empty?
+
+        case method_name
+        when :merge, :replace then arg_types.flat_map { |t| element_types(t) }
+        else [arg_types.first || Type::Combinator.untyped]
+        end
+      end
+
+      # `Set[E]` over `members`, value pins dropped: a constant Set a synthesised binding holds (issue #2555).
+      def exact(members)
+        Type::Combinator.nominal_of("Set", type_args: [Type::Combinator.union(*members.map { |m| widened_member(m) })])
+      end
+
+      # `Set[E | Dynamic[top]]` over `members`, the #2290 typed-Set floor. An empty seed (`Set.new`) is
+      # `Set[Dynamic[top]]`.
+      def floored(members)
+        widened = members.map { |m| widened_member(m) }
+        Type::Combinator.nominal_of("Set", type_args: [Type::Combinator.union(*widened, Type::Combinator.untyped)])
+      end
+
+      # The element types an enumerable argument (`merge`'s, `replace`'s, the algebra's `_Each[A]`) yields: a
+      # `Tuple`'s elements, an `Array` / `Set` / `Range` nominal's element parameter, a constant Set's or Range's
+      # members. Anything else yields elements this seam cannot name, which are unknown rather than none.
+      def element_types(type)
+        case type
+        when Type::Union then type.members.flat_map { |m| element_types(m) }
+        when Type::Tuple then type.elements
+        when Type::Nominal
+          if %w[Array Set Range].include?(type.class_name) && type.type_args.size == 1
+            type.type_args
+          else
+            [Type::Combinator.untyped]
+          end
+        when Type::Constant then constant_elements(type)
+        else [Type::Combinator.untyped]
+        end
+      end
+
+      def constant_elements(constant)
+        value = constant.value
+        if value.is_a?(::Set) then value.map { |v| Type::Combinator.constant_of(v) }
+        elsif value.is_a?(::Range) && value.begin.is_a?(Integer)
+          [Type::Combinator.nominal_of("Integer")]
+        else [Type::Combinator.untyped]
+        end
+      end
+
+      # A stored member's value pin and literal shape are dropped, as an `Array.new` fill's are: the set holds the
+      # object, and the program keeps a reference to it.
+      def widened_member(type)
+        MethodDispatcher.array_new_element(type)
+      end
+    end
+  end
+end

data/lib/rigor/inference/singleton_hook_decline.rb

@@ -105,8 +105,7 @@ module Rigor
         node = scope.singleton_def_for(owner, method_name)
         return nil if node.nil?
 
-        nesting = scope.discovery.discovered_def_nestings[node] || DefNodeResolver.rehydrated_nesting(node)
-        nesting&.first
+        scope.discovery.recorded_def_nesting(node)&.first
       end
 
       # Issue #1722 — the hook-capable test for one chain entry, asked by `call.undefined-method` of a project module