rigortype 0.4.4 → 0.4.6

data/lib/rigor/analysis/dependency_recorder.rb

@@ -406,6 +406,17 @@ module Rigor
         end
       end
 
+      # Issue #2134 — {read_name} for a read of `class_name`'s visibility slots for `method_name`, on either side, or
+      # of their contest: `visibility:<class>#<method>`. `IncrementalSession#visibility_name_affected` fires the key
+      # when a file's visibility entry or contest for the slot moves. A reader that asks whether ANY class records
+      # the name private passes `"*"` as the class; the key fires when any entry of the name moves. A wildcard
+      # slot (`[:singleton, :*]`) is `*` as the method name.
+      def read_visibility(class_name, method_name)
+        return if Thread.current[KEY].nil?
+
+        read_name(:visibility, "#{class_name}##{method_name}")
+      end
+
       # The miss-only spelling of {read_name}: a cross-file lookup of `name` (kind `:method` / `:class` /
       # `:toplevel` / …) that resolved to nothing. Kept as the name the internal spec's negative-edge
       # contract uses.

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

@@ -6,6 +6,7 @@ require_relative "return_type_heuristic"
 require_relative "../../source/constant_path"
 require_relative "../../source/node_children"
 require_relative "../../inference/scope_indexer"
+require_relative "../../rooted_glob"
 
 module Rigor
   module Analysis
@@ -127,7 +128,7 @@ module Rigor
         def walk_root(root_dir, harvest, budget) # rubocop:disable Naming/PredicateMethod
           return false unless File.directory?(root_dir)
 
-          Dir.glob(File.join(root_dir, "**", "*.rb")).each do |path|
+          RootedGlob.glob(root_dir, "**/*.rb").each do |path|
             harvest_file(path, harvest, budget)
             return true if harvest.catalog.size >= budget
           end

data/lib/rigor/analysis/edit_replay.rb

@@ -0,0 +1,67 @@
+# 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 (#2277) would test it.
+    #
+    # 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.
+    module EditReplay
+      Edit = Data.define(:label, :source)
+
+      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
+
+        [emptied, Edit.new(label: "reducing to its class/module skeleton", source: reduced)]
+      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
+    end
+  end
+end

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
@@ -194,6 +231,55 @@ module Rigor
         moved.freeze
       end
 
+      # Issue #1833 — the `[class name, mark]` pairs that appeared in or vanished from the class marks of the files an
+      # edit touched: a Symbol key of a `discovered_parameter_envelopes` bucket (the class-wide marks of
+      # `Scope::DiscoveryIndex`) or a `[ENVELOPE_REMOVED_KIND, name]` entry. A file may mark a class it does not declare
+      # (`x.singleton_class.prepend(Comparable)`, `o.extend(Helper)` in a method body), so neither the class-declaration
+      # diff nor a reader's edge to the declaring files sees such a mark appear or vanish.
+      #
+      # `before` and `after` are lists of envelope tables (`{class name => bucket}`): the touched files' seed-bundle
+      # tables before the edit, and the merged table of the re-parsed files after it. The diff is of their unions, which
+      # moves whenever the project's union of marks moves (the untouched files contribute the same marks to both).
+      # Returns a frozen Set of frozen `[class name, mark]` pairs.
+      def changed_class_marks(before, after)
+        (class_marks(before) ^ class_marks(after)).freeze
+      end
+
+      def class_marks(tables)
+        marks = Set.new
+        tables.each do |table|
+          table&.each do |class_name, bucket|
+            bucket.each_key { |key| marks << [class_name, key].freeze if class_mark?(key) }
+          end
+        end
+        marks
+      end
+
+      def class_mark?(key)
+        key.is_a?(Symbol) || (key.is_a?(Array) && key.first == Scope::DiscoveryIndex::ENVELOPE_REMOVED_KIND)
+      end
+
+      # 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;
+      # include(*MODS); end`, `Comparable.include(x) if c`), and an external chain entry has no declaring file
+      # for a reader's edge to name. `before` and `after` are lists of `{class => {side => [names]}}` tables,
+      # diffed as unions like {changed_class_marks}. Returns a frozen Set of class names.
+      def changed_unpositioned_owners(before, after)
+        moved = unpositioned_edges(before) ^ unpositioned_edges(after)
+        moved.to_set { |(owner, _side, _name)| owner }.freeze
+      end
+
+      def unpositioned_edges(tables)
+        edges = Set.new
+        tables.each do |table|
+          table&.each do |owner, sides|
+            sides.each { |side, names| names.each { |name| edges << [owner, side, name].freeze } }
+          end
+        end
+        edges
+      end
+
       # Issue #644 — the qualified constant names whose PUBLICATION could have moved in this edit: the names
       # whose per-file census descriptor differs between the before- and after-state of any file in `paths`.
       # The value-constant twin of {appeared_classes}, and deliberately NOT its analogue — a class either

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

@@ -7,6 +7,7 @@ require_relative "../incremental_run_slot"
 require_relative "../dependency_source_inference/gem_resolver"
 require_relative "../../cache/file_digest"
 require_relative "../../cache/incremental_snapshot"
+require_relative "../../rooted_glob"
 
 module Rigor
   module Analysis
@@ -66,8 +67,8 @@ module Rigor
         # 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.
+        # The mark also records what each path a presence row can name is ({Cache::Descriptor::FileEntry.kind_of}):
+        # the lockfiles, the analysis roots, the `pre_eval:` entries and the signature roots.
         def self.start(configuration:, roots:, cache_root:, fingerprint:)
           return nil if Gem.win_platform?
 
@@ -79,7 +80,7 @@ module Rigor
           lockfiles = lockfile_paths(configuration)
           named = Array(roots) + configuration.pre_eval + (configuration.signature_paths || ["sig"])
           presence = (lockfiles + named.map { |path| File.absolute_path(path.to_s) }).to_h do |path|
-            [path, File.exist?(path)]
+            [path, Cache::Descriptor::FileEntry.kind_of(path)]
           end
           rows = dependency_rows(configuration)
           return nil if rows.nil?
@@ -174,11 +175,12 @@ module Rigor
         # - 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
-        #   time, does not count. That needs no clock, so it holds on any filesystem; it cannot see a path that
-        #   comes and goes again within the run. Any other existence row falls back to change times: its own when
-        #   present, its nearest existing ancestor's when absent;
+        #   existence row asks only whether its path is there, and a `:kind` row what it is (#1977), so a path the
+        #   mark recorded changed if it came or went, or for a kind row turned from a directory into a file or back;
+        #   an editor's lock file created and removed beside it, which moves its directory's change time, does not
+        #   count. That needs no clock, so it holds on any filesystem; it cannot see a path that comes and goes
+        #   again within the run. Any other presence row falls back to change times: its own when present, its
+        #   nearest existing ancestor's when absent;
         # - no directory a glob row lists gained or lost an entry, nor, for a stat-mode glob, did any file it
         #   matches change.
         #
@@ -231,15 +233,20 @@ module Rigor
           ns.nil? || device != @device || ns < @started_ns
         end
 
-        # An existence row and a content row for one path are different questions (the first asks only whether it
-        # is there, the second whether it changed), so the row that comes first must not hide the other.
+        # A presence row and a content row for one path are different questions (the first asks only whether it
+        # is there, or what it is, the second whether it changed), so the row that comes first must not hide the
+        # other; nor may an existence row hide a kind row.
+        PRESENCE_COMPARATORS = %i[exists kind].freeze
+        private_constant :PRESENCE_COMPARATORS
+
         def files_unchanged?(entries, strict:)
           seen = Set.new
           entries.none? do |entry|
-            next false unless seen.add?([entry.path, entry.comparator == :exists])
+            presence = PRESENCE_COMPARATORS.include?(entry.comparator) ? entry.comparator : nil
+            next false unless seen.add?([entry.path, presence])
 
-            if entry.comparator == :exists
-              existence_changed?(entry.path, strict: strict)
+            if presence
+              presence_changed?(entry.path, presence, strict: strict)
             else
               changed?(entry.path, strict: strict)
             end
@@ -248,8 +255,8 @@ module Rigor
 
         def globs_unchanged?(entries, strict:)
           entries.none? do |entry|
-            listed = Dir.glob(File.join(entry.root, File.dirname(entry.pattern), ""))
-            matched = entry.mode == :stat ? Dir.glob(File.join(entry.root, entry.pattern)) : []
+            listed = RootedGlob.glob(entry.root, File.join(File.dirname(entry.pattern), ""))
+            matched = entry.mode == :stat ? RootedGlob.glob(entry.root, entry.pattern) : []
             (listed + matched).any? { |path| changed?(path, strict: strict) }
           end
         end
@@ -257,14 +264,25 @@ module Rigor
         # 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.
         def lockfile_changed?(path)
-          return File.exist?(path) unless @presence[path]
+          return File.exist?(path) unless present_at_mark?(path)
 
           changed?(path, strict: true, missing: true)
         end
 
-        def existence_changed?(path, strict:)
+        def present_at_mark?(path)
+          kind = @presence[path]
+          !kind.nil? && kind != Cache::Descriptor::FileEntry::KIND_ABSENT
+        end
+
+        # `comparator` is `:exists` or `:kind`: whether the path came or went, or whether it is no longer the kind
+        # of thing the mark recorded.
+        def presence_changed?(path, comparator, strict:)
           absolute = File.absolute_path(path)
-          return File.exist?(absolute) != @presence[absolute] if @presence.key?(absolute)
+          if @presence.key?(absolute)
+            return File.exist?(absolute) != present_at_mark?(absolute) if comparator == :exists
+
+            return Cache::Descriptor::FileEntry.kind_of(absolute) != @presence[absolute]
+          end
 
           nearest = absolute
           nearest = File.dirname(nearest) until File.exist?(nearest) || File.dirname(nearest) == nearest