rigortype 0.4.5 → 0.4.7

data/lib/rigor/analysis/dependency_source_inference/gem_resolver.rb

@@ -44,7 +44,7 @@ module Rigor
           Resolved.new(
             gem_name: entry.gem,
             version: spec.version.to_s,
-            gem_dir: spec.full_gem_path, # rigor:disable undefined-method
+            gem_dir: spec.full_gem_path,
             mode: entry.mode,
             roots: entry.roots
           )

data/lib/rigor/analysis/dependency_source_inference/index.rb

@@ -15,10 +15,9 @@ module Rigor
                     :class_to_gem, :budget_overrun_strategy, :gem_modes, :refinements, :bound_constants,
                     :bound_segments
 
-        # @param method_catalog — => Symbol}] the flat
-        #   `(class_name, method_name) → :instance | :singleton` table produced by {Walker.walk}, aggregated
-        #   across every resolved gem in the run. The Index itself stays gem-agnostic — the per-gem
-        #   attribution that slice 3's cache descriptor needs lives on `Resolved`, not here.
+        # @param method_catalog — the flat `(class_name, method_name) → CatalogEntry` table produced by
+        #   {Walker.walk}, aggregated across every resolved gem in the run. The Index itself stays gem-agnostic —
+        #   the per-gem attribution that slice 3's cache descriptor needs lives on `Resolved`, not here.
         # @param budget_exceeded — gem names whose {Walker} run hit the per-gem catalog cap
         #   (slice 4). The Runner consumes this list to emit one `dynamic.dependency-source.budget-exceeded`
         #   warning per gem.
@@ -110,10 +109,9 @@ module Rigor
           mode_for(class_name) == :full
         end
 
-        # Looks up the recorded method kind for a `(class_name, method_name)` pair. Returns `:instance` /
-        # `:singleton` when the walker observed a definition under one of the resolved gems' `roots:`, or
-        # `nil` otherwise. Slice 2b-ii enriches this with the inferred return type so the dispatcher tier can
-        # build a `Type::Dynamic` directly from the lookup result.
+        # Looks up the `CatalogEntry` (kind, and the heuristic return type) for a `(class_name, method_name)` pair.
+        # Returns it when the walker observed a definition under one of the resolved gems' `roots:`, or `nil`
+        # otherwise.
         def contribution_for(class_name:, method_name:)
           @method_catalog[[class_name, method_name]]
         end

data/lib/rigor/analysis/dependency_source_inference/walker.rb

@@ -99,10 +99,10 @@ module Rigor
         #   `Configuration::Dependencies::Entry`).
         # @param budget — per-gem catalog cap (method-definition count). When unset, defaults
         #   to `UNBOUNDED` for backwards-compatible test paths.
-        # @return frozen wrapper carrying the catalog (`Hash{[class_name, method_name] =>
-        #   :instance | :singleton}`) and a `truncated?` flag set when the walker stopped harvesting because
-        #   the budget was reached. Methods of identical name on the same class with different kinds (rare;
-        #   private API mostly) carry the kind that wins the per-class first walk.
+        # @return frozen wrapper carrying the catalog (keyed by `[class_name, method_name]`, valued by
+        #   {CatalogEntry}) and a `truncated?` flag set when the walker stopped harvesting because the budget was
+        #   reached. Methods of identical name on the same class with different kinds (rare; private API mostly)
+        #   carry the kind that wins the per-class first walk.
         def walk(gem_dir:, roots:, budget: UNBOUNDED)
           harvest = Harvest.new({}, {}, nil, nil, Set.new, Set.new)
           truncated = false

data/lib/rigor/analysis/edit_replay.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Analysis
+    # Issue #1967 — the edits `rigor check --verify-incremental-edits` replays on each sampled file, as the text an
+    # editor buffer stands in for it with ({IncrementalSession#replay_edit}).
+    #
+    # - `emptied` — the file with nothing in it. Every declaration and definition it makes disappears, so the replay
+    #   exercises the edges a removed declaration fires.
+    # - `skeleton` — the file's `class` / `module` declarations, nested as written, with every body statement dropped
+    #   (methods, `refine` blocks, visibility calls, mixins, constants). The declarations stay, so the class-level keys
+    #   a removed declaration fires stay quiet, and a finer edge such as #2163's `refinement:` is what puts a reader
+    #   into the closure. Emptying alone does not exercise that one: the broader key it fires re-checks the reader
+    #   anyway. Not every finer edge is reached: dropping a body still moves a broader key for some of them. A
+    #   `visibility:` edge is one (#2161's `module_function :two` to `private :two` swap passes both edits with the
+    #   edge removed), and only an edit that changes a body while keeping it would test it.
+    # - `dropped` (#2277) — the file with ONE statement of a `class` / `module` body removed and everything else kept,
+    #   so the declarations, the other definitions and every broader key stay as they were and a finer edge is the
+    #   only thing that re-checks a reader. At most {MAX_DROPS} statements per file: the visibility-changing calls
+    #   (`private`, `module_function`, ... {VISIBILITY_CALLS}) first, a body's own statements before those of the bodies
+    #   nested in it, since those are what finer edges such as #2161's `visibility:` read; then the other statements,
+    #   spread evenly over the file. A drop whose remainder does not parse (a heredoc body left behind) gives way to the
+    #   next candidate. Statements of a `class << self` body are never candidates.
+    #
+    # No edit is an addition. An edit identical to the file or to an earlier edit, or a file that does not parse
+    # (or, for the skeleton, declares nothing), is not replayed.
+    module EditReplay
+      Edit = Data.define(:label, :source)
+
+      # The most body-statement drops replayed per file; each is a recheck plus a full analysis.
+      MAX_DROPS = 2
+
+      VISIBILITY_CALLS = %i[
+        private public protected module_function private_class_method public_class_method
+        private_constant public_constant
+      ].freeze
+
+      module_function
+
+      # The edits to replay for `source`, in order.
+      def edits(source)
+        emptied = Edit.new(label: "emptying", source: "")
+        reduced = skeleton(source)
+        edits = [emptied]
+        edits << Edit.new(label: "reducing to its class/module skeleton", source: reduced) unless reduced.empty?
+        edits.concat(drops(source))
+        edits.reject { |edit| edit.source == source }.uniq(&:source)
+      end
+
+      # Up to {MAX_DROPS} edits, each `source` less one statement of a class / module body, in source order. A drop that
+      # leaves text that does not parse is never returned: the next candidate takes its place.
+      def drops(source)
+        result = Prism.parse(source)
+        return [] unless result.success?
+
+        picked = []
+        preferred(drop_candidates(result.value.statements.body)).each do |node|
+          edit = drop_edit(source, node)
+          picked << [node, edit] if edit
+          break if picked.size == MAX_DROPS
+        end
+        picked.sort_by { |node, _| node.location.start_offset }.map(&:last)
+      end
+
+      # `source` less `node`, or nil when what is left does not parse. The range runs to the furthest heredoc body
+      # inside the node, which sits after the node's own location.
+      def drop_edit(source, node)
+        location = node.location
+        from, to = whole_lines(source, location.start_offset, [location.end_offset, heredoc_end(node)].max)
+        dropped = source.byteslice(0, from) + source.byteslice(to..)
+        return nil unless Prism.parse(dropped).success?
+
+        Edit.new(label: "dropping the statement at line #{location.start_line} of", source: dropped)
+      end
+
+      # The end offset of the furthest heredoc terminator inside `node` (0 when it holds none).
+      def heredoc_end(node)
+        own = node.respond_to?(:closing_loc) && node.respond_to?(:opening_loc) &&
+              node.opening_loc&.slice&.start_with?("<<")
+        ends = node.compact_child_nodes.map { |child| heredoc_end(child) }
+        ends << node.closing_loc.end_offset if own && node.closing_loc
+        ends.max || 0
+      end
+
+      # The byte range of `start...finish` widened to the lines it alone occupies, so no blank line is left behind.
+      def whole_lines(source, start, finish)
+        head = source.byteslice(0, start)[/(?<=\A|\n)[ \t]*\z/]
+        tail = finish.positive? && source.getbyte(finish - 1) == 10 ? "" : source.byteslice(finish..)[/\A[ \t]*\n/]
+        head.nil? || tail.nil? ? [start, finish] : [start - head.bytesize, finish + tail.bytesize]
+      end
+
+      # Every statement directly in a `class` / `module` body of `nodes`, nested bodies included, in the order a body's
+      # own statements come before those of the bodies nested in it (a nested declaration is itself a candidate,
+      # dropped whole). A `class << self` body is never searched: its statements are not candidates.
+      def drop_candidates(nodes)
+        nodes.flat_map do |node|
+          next [] unless (node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)) &&
+                         node.body.is_a?(Prism::StatementsNode)
+
+          body = node.body.body
+          [*body, *drop_candidates(body)]
+        end
+      end
+
+      # The candidates in the order to try them: the visibility calls, then the other statements from the evenly spread
+      # picks outward, then the rest of the other statements.
+      def preferred(candidates)
+        visibility, others = candidates.partition { |node| visibility_call?(node) }
+        spread = Array.new(others.empty? ? 0 : MAX_DROPS) do |index|
+          others[(((index * 2) + 1) * others.size) / (MAX_DROPS * 2)]
+        end
+        [*visibility, *spread, *others].uniq(&:object_id)
+      end
+
+      def visibility_call?(node)
+        node.is_a?(Prism::CallNode) && VISIBILITY_CALLS.include?(node.name) &&
+          (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+      end
+
+      # `source`'s `class` / `module` declarations, nested, with their bodies dropped; "" when it does not parse or
+      # declares nothing.
+      def skeleton(source)
+        result = Prism.parse(source)
+        return "" unless result.success?
+
+        lines = declarations(result.value.statements, 0)
+        lines.empty? ? "" : "#{lines.join("\n")}\n"
+      end
+
+      # The skeleton lines of the declarations directly in `statements`, indented `depth` levels.
+      def declarations(statements, depth)
+        return [] unless statements.is_a?(Prism::StatementsNode)
+
+        statements.body.flat_map do |node|
+          next [] unless node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
+
+          indent = "  " * depth
+          ["#{indent}#{header_of(node)}", *declarations(node.body, depth + 1), "#{indent}end"]
+        end
+      end
+
+      def header_of(node)
+        return "module #{node.constant_path.slice}" if node.is_a?(Prism::ModuleNode)
+
+        superclass = node.superclass
+        superclass ? "class #{node.constant_path.slice} < #{superclass.slice}" : "class #{node.constant_path.slice}"
+      end
+      private_class_method :declarations, :header_of, :drop_candidates, :whole_lines, :drop_edit, :heredoc_end,
+                           :preferred, :visibility_call?
+    end
+  end
+end

data/lib/rigor/analysis/fact_store.rb

@@ -139,9 +139,9 @@ module Rigor
         unique.freeze
       end
 
-      # `fact.target` is `Target | Array[Target]` per the carrier contract. Branching with an early return on
-      # the `Array` arm lets type narrowing collapse the post-return value to the bare `Target` case, so the
-      # wrapped tuple is `[Target]` and the union of return paths is exactly `Array[Target]`.
+      # `fact.target` is a Target or an Array of them, per the carrier contract. The early return on the Array arm
+      # lets type narrowing collapse the post-return value to the bare Target case, so the wrapped one-element
+      # Array is what the return paths join into.
       def fact_targets(fact)
         target = fact.target
         return target if target.is_a?(Array)

data/lib/rigor/analysis/incremental.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../inference/global_write_census"
+
 module Rigor
   module Analysis
     # ADR-46 slice 2 — the pure set-algebra core of the incremental step, kept side-effect-free and
@@ -132,6 +134,41 @@ module Rigor
         moved.freeze
       end
 
+      # Issue #2158 — the `global_census:` keys whose entries moved in this edit: one for every entry that appeared in
+      # or vanished from a file's `global_write_census` ({Inference::GlobalWriteCensus.dependency_key}). `paths` MUST
+      # include removed files, whose whole census vanished. `before` / `after` map a path to that file's census Set (nil
+      # when it records nothing).
+      def changed_global_census_keys(paths, before, after)
+        moved = Set.new
+        paths.each do |path|
+          ((before[path] || Set.new) ^ (after[path] || Set.new)).each do |entry|
+            moved << "global_census:#{Inference::GlobalWriteCensus.dependency_key(entry)}"
+          end
+        end
+        moved.freeze
+      end
+
+      # The {Inference::ScopeIndexer.visibility_entries} entries that carry a leading marker before `class, slot`.
+      MARKED_VISIBILITY_ENTRIES = %i[contested module_function].freeze
+
+      # Issue #2134 — the `<class>#<method>` slots whose visibility entries or contests moved in this edit: one for
+      # every entry that appeared in or vanished from a file's {Inference::ScopeIndexer.visibility_entries}, a
+      # singleton slot's `[:singleton, name]` read as `name` (the wildcard slot as `*`), plus `*#<method>`, which the
+      # "is the name private anywhere" readers record. That key fires for an entry of any visibility: the merge is
+      # last-writer-wins, so dropping a `public :foo` can uncover another file's `private :foo`. `paths` MUST include
+      # removed files. Issue #2161 — a `[:module_function, owner, name]` entry fires `<owner>#<name>` the same way.
+      def changed_visibility_slots(paths, before, after)
+        moved = Set.new
+        paths.each do |path|
+          ((before[path] || Set.new) ^ (after[path] || Set.new)).each do |entry|
+            class_name, slot = MARKED_VISIBILITY_ENTRIES.include?(entry.first) ? entry.drop(1) : entry
+            name = slot.is_a?(Array) ? slot.last : slot
+            moved << "#{class_name}##{name}" << "*##{name}"
+          end
+        end
+        moved.freeze
+      end
+
       # Issue #1120 — the method names whose refinements moved in this edit. A consumer whose answer consulted the
       # refinement table recorded a `refinement:<method>` edge whichever way it answered, because the answer is a
       # function of the whole project's refinements of that name. `paths` MUST include removed files, whose whole

data/lib/rigor/analysis/incremental_run_slot/write_guard.rb

@@ -261,8 +261,8 @@ module Rigor
           end
         end
 
-        # A lockfile is read for its bytes: one absent at the mark must still be absent, one present must still be
-        # there with its change time before the mark.
+        # A lockfile is compared by its presence and change time: one absent at the mark must still be absent, one
+        # present must still be there with a change time before the mark.
         def lockfile_changed?(path)
           return File.exist?(path) unless present_at_mark?(path)
 

data/lib/rigor/analysis/incremental_run_slot.rb

@@ -54,8 +54,8 @@ module Rigor
       # a compaction pass — the incremental path never runs one.
       GENERATION_CAP = RunCacheKey::GENERATION_CAP
 
-      # The stored value. `baseline` and `pinned` (each a {Cache::Descriptor}) and `reads` (`{path =>
-      # Cache::Descriptor}`) are the chain the next writer carries forward, kept apart from the rest of the
+      # The stored value. `baseline` and `pinned` (each a {Cache::Descriptor}) and `reads` (keyed by
+      # path) are the chain the next writer carries forward, kept apart from the rest of the
       # dependency descriptor so it knows which rows are which; their entries are the same objects the descriptor
       # holds, so `Marshal` writes them once. `baseline` and `pinned` hold the rows the last full run recorded for
       # inputs the incremental path does not re-derive on a recheck (the signature tree, the