rigortype 0.4.6 → 0.4.8

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

@@ -15,22 +15,108 @@ module Rigor
     #   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 (#2277) would test it.
+    #   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.
     #
-    # Neither replays an addition or a body-changing edit. A skeleton identical to the file, or with no declaration
-    # (the emptied file again, or a file that does not parse), is not replayed.
+    # 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)
-        return [emptied] if reduced.empty? || reduced == 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
 
-        [emptied, Edit.new(label: "reducing to its class/module skeleton", source: reduced)]
+      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
@@ -61,7 +147,8 @@ module Rigor
         superclass = node.superclass
         superclass ? "class #{node.constant_path.slice} < #{superclass.slice}" : "class #{node.constant_path.slice}"
       end
-      private_class_method :declarations, :header_of
+      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

@@ -256,9 +256,19 @@ module Rigor
       end
 
       def class_mark?(key)
-        key.is_a?(Symbol) || (key.is_a?(Array) && key.first == Scope::DiscoveryIndex::ENVELOPE_REMOVED_KIND)
+        key.is_a?(Symbol) || (key.is_a?(Array) && ENTRY_MARK_KINDS.include?(key.first))
       end
 
+      # Issue #2901 — a class-body macro call or computed definer can be filed on a class another file declares
+      # (`X.class_eval { my_attr :a }`), so they diff as marks too. Issue #2998 — a singleton prepend diffs as one so a
+      # new file that prepends to a class object's singleton fires the `mark:` edge a singleton chain search files.
+      ENTRY_MARK_KINDS = [Scope::DiscoveryIndex::ENVELOPE_REMOVED_KIND, Scope::DiscoveryIndex::ENVELOPE_BODY_CALL_KIND,
+                          Scope::DiscoveryIndex::ENVELOPE_COMPUTED_DEFINER_KIND,
+                          Scope::DiscoveryIndex::ENVELOPE_HOOK_EXTEND_KIND,
+                          Scope::DiscoveryIndex::ENVELOPE_SAME_CLASS_KIND,
+                          Scope::DiscoveryIndex::ENVELOPE_SINGLETON_PREPEND_KIND].freeze
+      private_constant :ENTRY_MARK_KINDS
+
       # Issue #1661 — the names of the classes and modules whose unpositioned mixin edges
       # (`Scope::DiscoveryIndex#unpositioned_mixins`, `"*"` included) appeared or vanished in the files an edit
       # touched. A file can taint a module it does not otherwise change the chain of (`module Comparable;

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

@@ -78,7 +78,8 @@ module Rigor
                             fingerprint
 
           lockfiles = lockfile_paths(configuration)
-          named = Array(roots) + configuration.pre_eval + (configuration.signature_paths || ["sig"])
+          named = Array(roots) + configuration.pre_eval +
+                  Environment.project_signature_root_candidates(configuration.signature_paths)
           presence = (lockfiles + named.map { |path| File.absolute_path(path.to_s) }).to_h do |path|
             [path, Cache::Descriptor::FileEntry.kind_of(path)]
           end
@@ -261,8 +262,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