rigortype 0.4.1 → 0.4.2

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

@@ -4,6 +4,7 @@ require "fileutils"
 require "securerandom"
 
 require_relative "../incremental_run_slot"
+require_relative "../dependency_source_inference/gem_resolver"
 require_relative "../../cache/file_digest"
 require_relative "../../cache/incremental_snapshot"
 
@@ -61,7 +62,9 @@ module Rigor
         # signature file under the configured or auto-detected `sig/` roots, or a `pre_eval:` file, changed in
         # between would leave the snapshot the run restores keyed by one tree
         # and the run reading another. From the stamp on, the lockfiles are the guard's to watch ({#admits?}), which
-        # is also what lets the slot's key, whose only file inputs they are, be computed when the run ends.
+        # is also what lets the slot's key, whose only file inputs they are, be computed when the run ends. The
+        # opted-in gems' resolved versions, the key's one input that is neither a file nor the configuration (issue
+        # #1814), are read at the mark and watched the same way.
         #
         # The mark also records which of the paths an existence row can name are present: the lockfiles, the
         # analysis roots, the `pre_eval:` entries and the signature roots.
@@ -78,10 +81,22 @@ module Rigor
           presence = (lockfiles + named.map { |path| File.absolute_path(path.to_s) }).to_h do |path|
             [path, File.exist?(path)]
           end
+          rows = dependency_rows(configuration)
+          return nil if rows.nil?
+
           new(started_ns: started_ns, device: device, lockfiles: lockfiles, presence: presence,
-              stamp_dir: stamp_dir(cache_root))
+              stamp_dir: stamp_dir(cache_root), configuration: configuration, dependency_rows: rows)
         end
 
+        # Issue #1814 — the opted-in gems' `(name, version, mode)` rows as the key carries them; nil when they cannot
+        # be resolved, which takes no mark (the key could not be computed either).
+        def self.dependency_rows(configuration)
+          DependencySourceInference::GemResolver.dependency_entries(configuration.dependencies)
+        rescue StandardError
+          nil
+        end
+        private_class_method :dependency_rows
+
         # The mark: the change time and device of the first stamp whose change time is later than that of a
         # stamp taken before it, on the same device; nil when none is written within {TICK_WAIT_LIMIT}.
         def self.stamp(cache_root)
@@ -143,17 +158,21 @@ module Rigor
         end
         private_class_method :lockfile_paths
 
-        def initialize(started_ns:, device:, lockfiles:, presence: {}, stamp_dir: nil)
+        def initialize(started_ns:, device:, lockfiles:, presence: {}, stamp_dir: nil, configuration: nil,
+                       dependency_rows: [])
           @stamp_dir = stamp_dir
           @started_ns = started_ns
           @device = device
           @lockfiles = lockfiles
           @presence = presence
+          @configuration = configuration
+          @dependency_rows = dependency_rows
         end
 
         # True when nothing the guard watches moved since the mark:
         #
-        # - no lockfile the key or the fingerprint digests was written, created or removed;
+        # - no lockfile the key or the fingerprint digests was written, created or removed, and no opted-in gem
+        #   resolves to another version than at the mark (issue #1814);
         # - no file `rows` or `pinned` names changed. A content row's file changed if its change time moved. An
         #   existence row asks only whether its path is there, so a path the mark recorded changed if it came or
         #   went, and an editor's lock file created and removed beside it, which moves its directory's change
@@ -174,7 +193,7 @@ module Rigor
         # @param rows — a {Cache::Descriptor} of the rows the key does not pin
         # @param pinned — a {Cache::Descriptor} of the rows it does
         def admits?(rows, pinned: Cache::Descriptor.new)
-          !clock_stepped_back? && @lockfiles.none? { |path| lockfile_changed?(path) } &&
+          !clock_stepped_back? && @lockfiles.none? { |path| lockfile_changed?(path) } && dependency_rows_unchanged? &&
             files_unchanged?(rows.files, strict: true) && globs_unchanged?(rows.globs, strict: true) &&
             files_unchanged?(pinned.files, strict: false) && globs_unchanged?(pinned.globs, strict: false)
         rescue StandardError
@@ -196,6 +215,12 @@ module Rigor
 
         private
 
+        # Issue #1814 — the opted-in gems resolve to the versions they did at the mark. A guard built without a
+        # configuration (the specs' bare constructor) watches none.
+        def dependency_rows_unchanged?
+          @configuration.nil? || self.class.send(:dependency_rows, @configuration) == @dependency_rows
+        end
+
         # One more stamp: a change time earlier than the mark means the clock stepped back since it was taken, so
         # a save since then may carry a change time the guard reads as before it. A stamp that cannot be written,
         # or lands on another device, cannot vouch for the clock either.

data/lib/rigor/analysis/incremental_run_slot.rb

@@ -84,7 +84,9 @@ module Rigor
         return nil if base.nil?
 
         roots = RunCacheKey.config_entry("incremental.roots", normalize_roots(target.roots).sort.join("\n"))
-        Cache::Descriptor.new(gems: base.gems, configs: base.configs + [roots])
+        # Issue #1814 — the opted-in gems' `(name, version, mode)` rows travel with the key, as they do in the plain
+        # probe's: the gem's walked source reaches every file's answer and no analysed file records it.
+        Cache::Descriptor.new(gems: base.gems, dependencies: base.dependencies, configs: base.configs + [roots])
       end
 
       # The roots as absolute paths, which the KEY holds sorted: `lib`, `./lib` and `lib/` are one root there. A

data/lib/rigor/analysis/incremental_session.rb

@@ -1090,12 +1090,24 @@ module Rigor
           changed + removed, @constant_decls, new_constant_decls
         )
         keys = appeared_methods.map { |symbol| negative_key_for(symbol) }
-        keys.concat(moved_classes.map { |klass| "class:#{klass.split('::').last}" })
+        keys.concat(class_move_keys(moved_classes))
         keys.concat(moved_constants.map { |name| "constant:#{name.split('::').last}" })
         Incremental.negative_closure(keys, @negative_dependents) | refinement_affected(changed + removed, summary) |
           global_write_reporters
       end
 
+      # The negative keys a class-declaration diff fires: `class:<last segment>` for a class name, and (issue #1820)
+      # `subclass_of:<last segment of the superclass>` for a `[class, superclass]` pair appearing or vanishing. Any
+      # class declaration moving may move the set of classes whose superclass the tables do not know, which
+      # `subclass_of:*` stands for.
+      def class_move_keys(moved)
+        names, edges = moved.partition { |entry| entry.is_a?(String) }
+        keys = names.map { |klass| "class:#{klass.split('::').last}" }
+        keys.concat(edges.map { |(_child, parent)| "subclass_of:#{parent.split('::').last}" })
+        keys << "subclass_of:*" unless moved.empty?
+        keys
+      end
+
       # Issue #1120 — the consumers whose `call.undefined-method` answer read the refinement table for a method
       # name whose refinements moved in this edit. The before-state is each file's seed bundle (the per-file
       # table the last run recorded), the after-state the scan's per-file tables. A refine body is not a class's
@@ -1118,6 +1130,7 @@ module Rigor
         index[:class_sources].each do |class_name, files|
           files.each { |file| result[file] << class_name }
         end
+        Incremental.add_superclass_edges(result, index[:class_sources], index[:superclasses])
         result.transform_values(&:freeze).freeze
       end
 

data/lib/rigor/analysis/reachability/graph.rb

@@ -35,15 +35,21 @@ module Rigor
         #   a reopened gem or stdlib class must never be a candidate (WD6). Defaults to "nothing is foreign".
         # @param dynamic_uses — sites where a constant is reached by name at runtime.
         #   A literal-argument site contributes a real reference; a dynamic one taints a namespace (WD4).
-        def initialize(declarations:, references:, root_fqns: [], dynamic_uses: [], foreign: ->(_fqn) { false })
+        # @param shadows — declarations made in files outside the analysed paths. They are never nodes, but a
+        #   reference written in the SAME file resolves to them first, as Ruby would (#1732, see {#resolve_ref}).
+        def initialize(declarations:, references:, root_fqns: [], dynamic_uses: [], shadows: [],
+                       foreign: ->(_fqn) { false })
           @declarations = declarations
-          @dynamic_uses = dynamic_uses
           @references = references + literal_dynamic_references(dynamic_uses)
           @root_fqns = root_fqns.to_set
           @foreign = foreign
           @by_fqn = declarations.group_by(&:fqn)
+          @shadows = shadows.group_by(&:path).transform_values { |decls| decls.to_set(&:fqn) }
+          @shadows.default = Set.new.freeze
           @owned = @by_fqn.keys.reject { |fqn| @foreign.call(fqn) }.to_set
           @ancestors = {}
+          # `Foo.const_get("V#{k}")` bounds its reach by `Foo`, a reference like any other (#1734).
+          @dynamic_uses = dynamic_uses.flat_map { |use| use.anchored { |ref| resolve_ref(ref) } }
         end
 
         def report
@@ -51,21 +57,31 @@ module Rigor
           production = walk(edges, seeds: production_seeds, roles: %i[production task config])
           reachable = walk(edges, seeds: production_seeds | test_seeds, roles: %i[production task config test])
           unreached = @owned - reachable
-          namespaces = namespace_only(unreached, reachable)
+          # A namespace is excused by a member PRODUCTION reaches. One whose members only tests reach is dead
+          # production code like them, so it joins them under test-only rather than vanishing from every
+          # bucket (#1732).
+          namespaces = namespace_only(unreached, production)
+          test_only = (reachable - production) | namespace_only(unreached - namespaces, reachable)
+          unreached -= namespaces | test_only
+          # A namespace a test names (`Ns::CONST`) while production reaches a declaration under it is live in
+          # production for the same reason an unreached one is not dead (#1732).
+          live_namespaces = namespace_only(test_only, production)
+          test_only -= live_namespaces
           # The data-file demotion applies to BOTH buckets it can speak to, which is what the tier
           # contract says and what the implementation had narrowed (#370). See {#tainted}.
-          test_only = reachable - production
-          undecidable = tainted(unreached - namespaces).merge(tainted(test_only))
-          build_report(edges: edges, reachable: reachable, unreached: unreached, namespaces: namespaces,
-                       test_only: test_only, undecidable: undecidable)
+          undecidable = tainted(unreached).merge(tainted(test_only))
+          undecidable = spread_undecidable(edges, undecidable, unreached | test_only,
+                                           through: namespaces | live_namespaces)
+          build_report(edges:, reachable:, unreached:, namespaces:, test_only:, undecidable:)
         end
 
         private
 
         def build_report(edges:, reachable:, unreached:, namespaces:, test_only:, undecidable:)
           demoted = undecidable.keys.to_set
-          Report.new(declared: @owned.size, reachable: reachable.size,
-                     candidates: rows(unreached - namespaces - demoted),
+          # A test-only namespace counts as reachable, like the members it is listed with.
+          Report.new(declared: @owned.size, reachable: (reachable | test_only).size,
+                     candidates: rows(unreached - demoted),
                      undecidable: undecidable.map { |fqn, reason| undecidable_row(fqn, reason) }.freeze,
                      test_only: rows(test_only - demoted),
                      namespaces: namespaces.size, roots: production_seeds.size, edges: edges.size)
@@ -109,6 +125,41 @@ module Rigor
           end
         end
 
+        # Whatever an undecidable declaration reaches is undecidable too (#1720 review). `class Sub < Base` with
+        # `Sub` reachable through `"Sub#{x}".constantize` left `Base` a DEFINITE candidate, and acting on that row
+        # deletes the base of a class that may well be live. Only declarations that would otherwise be
+        # reported — unreached or test-only — are moved; the reason names the declaration they hang from.
+        #
+        # The spread passes `through` a declaration hidden as a namespace without listing it: a service hidden
+        # only because something names a constant nested in it (`Svc::Error`) still carries the undecidable
+        # evidence on to what its body names. Stopping there left the next service down under "reachable only
+        # from tests" (#1732).
+        def spread_undecidable(edges, undecidable, reportable, through:)
+          return undecidable if undecidable.empty?
+
+          out = Hash.new { |h, k| h[k] = [] }
+          edges.each { |from, to, _role| out[from] << to }
+          result = undecidable.dup
+          passed = Set.new
+          queue = undecidable.keys
+          until queue.empty?
+            from = queue.shift
+            out[from].each do |target|
+              next if result.key?(target) || passed.include?(target)
+
+              if reportable.include?(target)
+                result[target] = "reachable from #{from}, which cannot be decided"
+              elsif through.include?(target)
+                passed << target
+              else
+                next
+              end
+              queue << target
+            end
+          end
+          result
+        end
+
         def undecidable_row(fqn, reason)
           site = @by_fqn.fetch(fqn).first
           Undecidable.new(fqn: fqn, path: site.path, line: site.line, reason: reason)
@@ -132,14 +183,32 @@ module Rigor
         # Seeds that make a declaration live in PRODUCTION: named entry points, plus anything referenced at
         # file level by a non-test file (file-level code runs on load, so its target is live).
         def production_seeds
-          @production_seeds ||= (@root_fqns & @owned) | seeds_from { |ref| ref.from.nil? && ref.role != :test }
+          @production_seeds ||= (@root_fqns & @owned) | seeds_from { |ref| source(ref).nil? && ref.role != :test }
         end
 
         # Seeds that make a declaration live only through TEST code. Kept separate from production seeds
         # rather than folded in: a spec's file-level `Foo.new` would otherwise promote `Foo` to a root and
         # erase the very distinction WD8 exists to report.
         def test_seeds
-          @test_seeds ||= seeds_from { |ref| ref.from.nil? && ref.role == :test }
+          @test_seeds ||= seeds_from { |ref| source(ref).nil? && ref.role == :test }
+        end
+
+        # The node an edge leaves: the owned declaration whose code holds the reference, with a declaration-header
+        # reference (`class Sub < Base`) credited to `Sub` (#1720). Only an owned declaration from `paths:` is a
+        # node, though. A class an initializer, `config/application.rb` or a spec helper declares, or a reopened
+        # gem class (WD6), is outside the declaration set, so the walk can never start from it and an edge
+        # leaving it would silently drop the evidence. Falling back to the enclosing nesting (#1724) did not help
+        # either: `module MyApp; class Application` and a spec's `module Outer; class Fake < OBase` fall back to a
+        # module that is never reached itself, or is not a node at all (#1732).
+        #
+        # Such a reference counts as file-level code of its file instead, in that file's role: a spec helper's
+        # reference keeps its target test-reachable, an initializer's keeps it live in production. A class header
+        # and a class body's own statements run when the file loads; a method body is read the same way because
+        # whether it runs is not decidable from a declaration this report does not own, and the other reading
+        # would report live code as dead. What the reference NAMES is still resolved against its own file's
+        # declarations first (see {#resolve_ref}).
+        def source(ref)
+          @owned.include?(ref.from) ? ref.from : nil
         end
 
         def seeds_from
@@ -147,7 +216,7 @@ module Rigor
           @references.each do |ref|
             next unless yield(ref)
 
-            target = resolve(ref.as_written, ref.nesting, rooted: ref.rooted)
+            target = resolve_ref(ref)
             set << target if target && @owned.include?(target)
           end
           set
@@ -156,14 +225,39 @@ module Rigor
         # `[from_fqn_or_nil, to_fqn, role]` for every reference that resolves to an owned declaration.
         def resolved_edges
           @resolved_edges ||= @references.filter_map do |ref|
-            target = resolve(ref.as_written, ref.nesting, rooted: ref.rooted)
+            target = resolve_ref(ref)
             next unless target && @owned.include?(target)
-            next if ref.from == target # a declaration referencing itself is not evidence of use
 
-            [ref.from, target, ref.role]
+            from = source(ref)
+            next if from == target # a declaration referencing itself is not evidence of use
+
+            [from, target, ref.role]
           end
         end
 
+        # A declaration-header reference never names the declaration it belongs to: `module Api; class User <
+        # User; end; end` reads `User` before `Api::User` exists, so Ruby answers `::User`. Every other reference
+        # resolves as written, and one that lands on its own declaration is dropped as a self-reference.
+        #
+        # A class its own file declares outside `paths:` shadows a same-named owned one, as Ruby's lookup does:
+        # `LegacyThing` inside a migration's local `class LegacyThing < ActiveRecord::Base` stub names the stub,
+        # not the app's model. The answer is then not an owned node and the reference is dropped. Only the
+        # referring file's own declarations count: a spec support file's stub is loaded with the specs, never
+        # with production, so letting it shadow other files could hide a production reference (#1732).
+        def resolve_ref(ref)
+          local = @shadows[ref.path]
+          target = resolve(ref.as_written, ref.nesting, rooted: ref.rooted, local: local)
+          return target unless target && target == ref.from && header?(ref)
+
+          resolve(ref.as_written, ref.nesting, rooted: ref.rooted, exclude: target, local: local)
+        end
+
+        # Only a header reference is credited to something other than the scope it is written in (see
+        # {Scan::Reference}).
+        def header?(ref)
+          ref.from != (ref.nesting.empty? ? nil : ref.nesting.join("::"))
+        end
+
         # Mark-and-sweep, not reference counting: an edge only propagates if its SOURCE is itself reachable, so
         # a cluster of mutually-referencing dead classes stays dead (ADR-102 WD2).
         #
@@ -198,18 +292,19 @@ module Rigor
         # Ruby's constant lookup at name granularity: `Module.nesting` innermost first, then the ancestors of
         # the innermost cresting scope (#354), then the bare name. When `rooted: true`, lexical nesting and
         # ancestors are skipped, answering the top-level declaration directly (#625).
-        def resolve(as_written, nesting, rooted: false)
+        # `exclude` names a declaration the answer must not be (see {#resolve_ref}).
+        def resolve(as_written, nesting, rooted: false, exclude: nil, local: nil)
           if rooted
-            return as_written if @by_fqn.key?(as_written)
+            return as_written if declared?(as_written, exclude, local)
 
             idx = as_written.rindex("::")
-            return idx ? resolve(as_written[0, idx], nesting, rooted: true) : nil
+            return idx ? resolve(as_written[0, idx], nesting, rooted: true, exclude: exclude, local: local) : nil
           end
 
           walker = nesting.dup
           until walker.empty?
             candidate = (walker + [as_written]).join("::")
-            return candidate if @by_fqn.key?(candidate)
+            return candidate if declared?(candidate, exclude, local)
 
             walker.pop
           end
@@ -217,11 +312,11 @@ module Rigor
           unless nesting.empty?
             ancestor_scopes(nesting.join("::")).each do |ancestor|
               candidate = "#{ancestor}::#{as_written}"
-              return candidate if @by_fqn.key?(candidate)
+              return candidate if declared?(candidate, exclude, local)
             end
           end
 
-          return as_written if @by_fqn.key?(as_written)
+          return as_written if declared?(as_written, exclude, local)
 
           # `Scope::DiscoveryIndex::EMPTY` names a constant INSIDE a class, and reading it is a use of that
           # class — but the leaf is not itself a declaration, so the reference would resolve to nothing and
@@ -229,7 +324,11 @@ module Rigor
           # on the first run of this report against Rigor's own `lib`). Peel the trailing segment and retry:
           # a reference to a member is a reference to its owner.
           idx = as_written.rindex("::")
-          idx ? resolve(as_written[0, idx], nesting) : nil
+          idx ? resolve(as_written[0, idx], nesting, exclude: exclude, local: local) : nil
+        end
+
+        def declared?(fqn, exclude, local)
+          fqn != exclude && (@by_fqn.key?(fqn) || local&.include?(fqn))
         end
 
         # Breadth-first over superclass + included modules, mixins first, terminating on a cycle. As-written
@@ -260,7 +359,8 @@ module Rigor
           segments = subclass_fqn.split("::")
           (segments.length - 1).downto(0) do |i|
             candidate = (segments[0, i] + [raw]).join("::")
-            return candidate if @by_fqn.key?(candidate)
+            # `class Api::User < User` cannot inherit from itself; the name was read before it existed.
+            return candidate if candidate != subclass_fqn && @by_fqn.key?(candidate)
           end
           nil
         end