rigortype 0.4.4 → 0.4.6

data/lib/rigor/protection/mutation_cache.rb

@@ -209,7 +209,13 @@ module Rigor
         def table_digest(project_scan)
           payload = {
             "synthetic" => project_scan.synthetic_method_index.to_h,
-            "patched" => patched_rows(project_scan.project_patched_methods)
+            "patched" => patched_rows(project_scan.project_patched_methods),
+            "patched_mixins" => project_scan.project_patched_methods.mixins.map do |mixin|
+              mixin.to_h.values.map(&:to_s)
+            end,
+            "patched_overrides" => project_scan.project_patched_methods.overrides.map do |key, visibility|
+              [*key, visibility].map(&:to_s)
+            end
           }
           Digest::SHA256.hexdigest(JSON.generate(payload))
         rescue StandardError
@@ -221,7 +227,7 @@ module Rigor
         def patched_rows(patched)
           patched.by_key.map do |(class_name, method_name, kind), entry|
             [class_name.to_s, method_name.to_s, kind.to_s, entry.source_path.to_s, entry.source_line,
-             entry.return_type&.describe(:short).to_s, entry.alias_of.to_s]
+             entry.return_type&.describe(:short).to_s, entry.alias_of.to_s, entry.visibility.to_s]
           end.sort
         end
 

data/lib/rigor/rooted_glob.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rigor
+  # `Dir.glob(File.join(root, pattern))` with `root` read as a literal path (#1956, #1959).
+  #
+  # Joining a directory into the pattern makes `Dir.glob` read the directory's own characters as glob syntax:
+  # a project at `ds [x]` or `ds{a}` matches nothing, `ds*` matches its siblings, `fx[1]` matches `fx1`, and
+  # a directory literally named `{..,zz}` expands into the parent tree. Each glob metacharacter of `root` is
+  # backslash-escaped before the join, so `root` matches only itself while `pattern` keeps exactly the meaning the
+  # joined spelling gave it: a leading `/` collapses into the join (`/etc/*` reads `root/etc/*`), and so does one
+  # inside a brace alternative (`{/etc,lib}/*` reads `root/etc/*` and `root/lib/*`). `Dir.glob(pattern, base:)`
+  # would not do that: it reads an absolute pattern, or an absolute alternative, outside `base`. A root without
+  # metacharacters is joined unchanged, so the results are the joined glob's strings in its order, `root` kept as
+  # given (relative, symlinked or with a trailing `/`).
+  #
+  # `literal(name)` is the same escape for a single name (a file's basename, a configured path) that is joined into
+  # a pattern as a literal: `literal("a[1].rb")` matches `a[1].rb` and not `a1.rb`.
+  module RootedGlob
+    METACHARACTERS = /[\[\]{}*?\\]/
+
+    module_function
+
+    # @param root — a directory path (String or Pathname), taken literally
+    # @param pattern — a `Dir.glob` pattern relative to `root`
+    # @return the matches spelled under `root`, in `Dir.glob` order; empty when `root` is not a directory
+    def glob(root, pattern)
+      Dir.glob(File.join(literal(root), pattern.to_s))
+    end
+
+    # @param name — a file or directory name, taken literally
+    # @return the pattern that matches exactly `name` under `Dir.glob`, with its metacharacters escaped
+    def literal(name)
+      name.to_s.gsub(METACHARACTERS, "\\\\\\0")
+    end
+  end
+end

data/lib/rigor/scope/discovery_index.rb

@@ -231,6 +231,11 @@ module Rigor
       # (the meta-new walk does not route `Parent` through ancestor discovery), so a reader that must place `K` in a
       # hierarchy reads its superclass as unknown, as it reads the `nil` the table records for `class K < <expr>`.
       ENVELOPE_META_SUPERCLASS_MARK = :"<meta-superclass>"
+      # Issue #1979 — the kind of a `[ENVELOPE_CONSTRUCTED_KIND, constant_name]` bucket entry: `class K < <expr>` whose
+      # superclass expression is a core constructor call (`Data.define(...)`, `Struct.new(...)`, `Class.new(...)`)
+      # naming that constant, as the receiver or as `Class.new`'s single bare-constant argument (`Object` for none).
+      # Read only by the #1596 proof's subclass walk (`RefinedDispatch::OwnMethod.each_subclass`).
+      ENVELOPE_CONSTRUCTED_KIND = :constructed_from
       ENVELOPE_MODULE_MARK = :"<module>"
       ENVELOPE_DYNAMIC_MARK = :"<dynamic>"
       ENVELOPE_OBJECT_EXTENDED_MARK = :"<object-extended>"

data/lib/rigor/scope/resolution_chain/relevance.rb

@@ -84,6 +84,20 @@ module Rigor
           false
         end
 
+        # {.external_lacks?} on the side an entry stands for: an external superclass on a singleton chain
+        # (`:singleton`, its whole tail) is asked for a singleton method, an extended module (`:instance`) and every
+        # instance-side entry for an instance method.
+        def external_lacks_on?(scope, candidates, side, name)
+          return external_lacks?(scope, candidates, name) if side == :instance
+
+          known = candidates.find { |candidate| Rigor::Reflection.rbs_class_known?(candidate, scope: scope) }
+          return false if known.nil?
+
+          Rigor::Reflection.singleton_method_definition(known, name, scope: scope).nil?
+        rescue StandardError
+          false
+        end
+
         # One verdict's working state: the scope, the resolver, and the edges the tests read.
         class Context
           attr_reader :mark, :edges

data/lib/rigor/scope/resolution_chain.rb

@@ -300,17 +300,24 @@ module Rigor
       # `Kernel` or `Enumerable` on any reopening. So each candidate name files the negative method edge of every
       # {Relevance::HOOKS} name on its singleton side (`method:Comparable.included`, the key a new `def
       # self.included` satisfies); a file adding any other method to the module re-checks nothing, and once the
-      # module is declared its sites carry later edits and the removal. The edges are a function of the chain alone,
-      # so a consumer files them once per chain ({Analysis::DependencyRecorder.file_chain_once}, #1590). A hook
-      # written another way — an instance `def included` in a module extended onto the external, a
-      # `define_singleton_method(:included)` — satisfies no such key and is not seen.
+      # module is declared its sites carry later edits and the removal. #1661 — each name also files `mixin:<name>`,
+      # which `IncrementalSession#mark_affected` fires when the module's unpositioned mixin edges move: a new file
+      # that taints it (`module Comparable; include(*MODS); end`) without a hook. The key is the qualified candidate,
+      # the spelling the chain resolves a project entry by. The unpositioned table may key the owner by a relative
+      # spelling (`Constants` inside `class File`), so the producer also fires every recorded `mixin:` key ending in
+      # `::<owner>` (`IncrementalSession#mixin_keys`); a taint on a project `Foo::Base` still re-checks no reader of
+      # an external `Lib::Base`. An ambiguous spelling has no candidate and files none: no project module can resolve
+      # it, so no taint can mark it. The edges are a function of the chain alone, so a consumer files them once per
+      # chain ({Analysis::DependencyRecorder.file_chain_once}, #1590). A hook written another way — an instance `def
+      # included` in a module extended onto the external, a `define_singleton_method(:included)` — satisfies no such
+      # key and is not seen.
       def record_hooks(scope)
         externals = (@memo[:externals] ||= @entries.select(&:external?).freeze)
         return if externals.empty?
 
         Analysis::DependencyRecorder.file_chain_once(self, :hooks, scope.discovery) do
           externals.each do |entry|
-            entry.candidates.each { |name| Analysis::DependencyRecorder.read_keys(ResolutionChain.hook_keys(name)) }
+            entry.candidates.each { |name| Analysis::DependencyRecorder.read_keys(ResolutionChain.external_keys(name)) }
           end
         end
       end
@@ -393,12 +400,18 @@ module Rigor
       end
 
       @hook_keys = {}
+      @external_keys = {}
 
       # The frozen `method:Name.hook` negative keys of `name`'s {Relevance::HOOKS}, built once per name.
       def self.hook_keys(name)
         @hook_keys[name] ||= Relevance::HOOKS.map { |hook| "method:#{name}.#{hook}".freeze }.freeze
       end
 
+      # {hook_keys} plus the `mixin:<name>` key an external entry files for its unpositioned mixins (#1661).
+      def self.external_keys(name)
+        @external_keys[name] ||= (hook_keys(name) + ["mixin:#{name}".freeze]).freeze
+      end
+
       def record_head(scope, start, side)
         ResolutionChain.record_class(scope, @root) unless start.zero? && @entries.first&.name == @root
         start.times { |index| ResolutionChain.record_entry(scope, @entries[index], side) }
@@ -440,6 +453,28 @@ module Rigor
         @entries[@level_starts[index]...finish]
       end
 
+      # Issue #1624 — whether the chain's last class has a superclass the tables cannot name, so ancestors the chain
+      # does not list follow it where a chain otherwise ends in the implicit `Object`: a superclass written as an
+      # expression (`class K < Struct.new(:a)`, `< Data.define(:a)`, `< Class.new(Base)`, `< pick_base`), which the
+      # superclass table records as `nil`, or a class a constant write creates (`K = Class.new(Base)`,
+      # `K = Struct.new(:a)`, `K = Data.define(:a)`), which has no superclass entry. The constructor's methods
+      # (`members`, the member readers, a block's `def`s) and everything it inherits live in that unlisted part.
+      # Every fact read here is filed under the last class's class edge, which a read reaching the tail has passed.
+      def opaque_tail?(scope)
+        @memo.fetch(:opaque_tail) do
+          last = level_count.positive? ? @level_classes[level_count - 1] : nil
+          @memo[:opaque_tail] = !last.nil? && ResolutionChain.opaque_superclass?(scope, last)
+        end
+      end
+
+      def self.opaque_superclass?(scope, name)
+        superclasses = scope.discovery.discovered_superclasses
+        return superclasses[name].nil? if superclasses.key?(name)
+
+        scope.discovery.discovered_parameter_envelopes[name]&.key?(DiscoveryIndex::ENVELOPE_META_SUPERCLASS_MARK) ||
+          !(scope.struct_member_layout(name) || scope.data_member_layout(name)).nil?
+      end
+
       # Each complete level up to the first superclass the project does not declare, as `[class_name,
       # modules, externals]`: the level's class, the project modules around it (each once), and the candidate
       # lists of the ancestors in it the project does not declare — the shape `call.wrong-arity` reads.

data/lib/rigor/scope.rb

@@ -1213,13 +1213,28 @@ module Rigor
     # wrong-arity rules consult this map to suppress diagnostics for methods the user has defined dynamically,
     # even when no RBS sig describes them.
     # A name defined on both sides of one class records {DiscoveryIndex::METHOD_KIND_BOTH} and matches either kind.
+    #
+    # Issue #2121 — a hit is an ADR-46 read. The table carries what no `def` symbol edge covers — an `attr_*`, an
+    # `alias` or a `define_method` (a cross-file `def` is withheld from it) — so an answer that read a hit records
+    # the class edge to the files declaring `class_name` and the name edge `defines:<method_name>`: deleting the
+    # `attr_accessor` re-checks the caller it silenced, whether or not the deleting file declares the class. A miss
+    # records nothing here; the readers that act on one record their own negative edges.
     def discovered_method?(class_name, method_name, kind)
       table = @discovery.discovered_methods[class_name.to_s]
       return false unless table
 
       recorded = table[method_name.to_sym]
-      recorded == kind || recorded == DiscoveryIndex::METHOD_KIND_BOTH
+      return false unless recorded == kind || recorded == DiscoveryIndex::METHOD_KIND_BOTH
+
+      record_discovered_method(class_name, method_name) if Analysis::DependencyRecorder.active?
+      true
+    end
+
+    def record_discovered_method(class_name, method_name)
+      record_class_dependency(class_name)
+      Analysis::DependencyRecorder.read_name(:defines, method_name)
     end
+    private :record_discovered_method
 
     # ADR-34 § "Decision" — predicate identifying a toplevel-shaped scope (no enclosing `class` / `module` body).
     # True at the top of a file AND inside a top-level `def` body (since toplevel defs leave `self_type` nil per
@@ -1410,6 +1425,27 @@ module Rigor
                         call_node)
     end
 
+    # Issue #1569 — whether `def_node`, written in this file, is a module function of `class_name`: a `:both`
+    # deferred-range row over the def (a bare `module_function` before it, or `module_function def x`;
+    # `ModuleFunctionState.prescan_deferred`), or a `:singleton` row for the name after the def
+    # (`module_function :x`) whose singleton copy is this def (`ModuleFunctionState.each_singleton_copy`).
+    def module_function_def?(class_name, def_node)
+      path = source_path
+      return false if path.nil?
+
+      ranges = discovered_deferred_ranges[path]
+      return false if ranges.nil?
+
+      start = def_node.location.start_offset
+      ranges.any? do |(row_start, _finish, name, kind, owner)|
+        next false unless name == def_node.name && owner == class_name.to_s
+
+        (kind == :both && row_start == start) ||
+          (kind == :singleton && row_start > start &&
+           singleton_def_for(class_name, name)&.location&.start_offset == start)
+      end
+    end
+
     # Shared ordering half of the two `*_def_shadows_call?` predicates, over this file's
     # `discovered_deferred_ranges` (issue #1097). `exists` — a recorded `"path:line"` site or the
     # method-existence table — says a def of `method_name`/`kind` on `class_name` is known at all; a
@@ -1527,7 +1563,8 @@ module Rigor
     #
     # This is EVIDENCE FOR a singleton ancestor, never against one: the walk sees only what a constant
     # argument to a receiverless `extend` (or, since #915, a receiverless `include` / `prepend` inside a
-    # `class << self` body) written inside a declaration body spells, so a runtime `Widget.extend(m)` and an
+    # `class << self` body) written inside a declaration body spells, or, since #2094, `Widget.extend(M)` and
+    # `Widget.singleton_class.include(M)` with a constant receiver, so a runtime `Widget.extend(m)` and an
     # `extend` in a file outside the analysed set are both absent from it, as is an `extend` declared only
     # in RBS — that one reaches the same consumer through `Environment#singleton_extended_modules` instead.
     # Its one consumer ({Inference::Narrowing.narrow_class}) therefore reads it
@@ -1905,8 +1942,9 @@ module Rigor
     # declaration-level fact of the whole file, which is also the granularity
     # `ScopeIndexer#append_constant_signature` moves the declaration signature at.
     #
-    # `constant_sources` is seeded only when dependency recording is on, so on every ordinary run the table
-    # is empty and this is one Hash miss; the caller additionally gates on the recorder being active.
+    # `constant_sources` is seeded when dependency recording is on and in the editor publish's discovery seed
+    # (ADR-124), where the recorder is inactive; elsewhere the table is empty and this is one Hash miss. The caller
+    # gates on the recorder being active.
     def record_constant_dependency(name)
       sites = @discovery.constant_sources[name]
       return if sites.nil?
@@ -1917,8 +1955,15 @@ module Rigor
     # Issue #992 — one class's `discovered_parameter_envelopes` bucket (`{[kind, method_name] => envelope}` plus
     # the class-wide marks), or an empty Hash. Records the ADR-46 class edge first: a verdict read off the
     # bucket depends on every file that declares the class, and a `memoize :f` added to one of them moves it.
+    #
+    # Issue #1833 — and the name edge `mark:<last segment>`: a file that does not declare the class may still mark it
+    # (`x.singleton_class.prepend(Comparable)`, `o.extend(Helper)` in a method body, a `refine` block), and
+    # `IncrementalSession#mark_affected` fires the key when such a mark appears or vanishes.
     def parameter_envelopes_of(class_name)
-      record_class_dependency(class_name) if Analysis::DependencyRecorder.active?
+      if Analysis::DependencyRecorder.active?
+        record_class_dependency(class_name)
+        Analysis::DependencyRecorder.read_last_segment(:mark, class_name.to_s)
+      end
       @discovery.discovered_parameter_envelopes[class_name.to_s] || EMPTY_PARAMETER_ENVELOPES
     end
 
@@ -1930,11 +1975,18 @@ module Rigor
     # a wrapping `private def` / `private attr_reader` call, else the surrounding `private` / `protected` / `public`
     # modifier state, plus any post-hoc `private :name, ...` named-argument calls. Consumed by the
     # `def.method-visibility-mismatch` rule so explicit-non-self calls to a private method surface a diagnostic.
-    def discovered_method_visibility(class_name, method_name)
+    # `singleton: true` reads the class's singleton slot for the name (`[:singleton, name]`).
+    #
+    # Issue #2134 — every answer is an ADR-46 read of the slot, so it records `visibility:<class>#<method_name>`
+    # whichever way it answers ({Analysis::DependencyRecorder.read_visibility}). A `private :foo` can be written from
+    # a reopening or a `class_eval` block in a file the reader has no other edge to, and adding or removing it must
+    # re-check the reader.
+    def discovered_method_visibility(class_name, method_name, singleton: false)
+      Analysis::DependencyRecorder.read_visibility(class_name, method_name) if Analysis::DependencyRecorder.active?
       table = @discovery.discovered_method_visibilities[class_name.to_s]
       return nil unless table
 
-      table[method_name.to_sym]
+      table[singleton ? [:singleton, method_name.to_sym] : method_name.to_sym]
     end
 
     # Closes the "`params[:f] ||= []; params[:f] << x`" precision gap (ROADMAP § Type-language / engine —

data/lib/rigor/sig_gen/alias_index.rb

@@ -2,6 +2,7 @@
 
 require_relative "../inference/rbs_type_translator"
 require_relative "type_elaborator"
+require_relative "../rooted_glob"
 
 module Rigor
   module SigGen
@@ -101,7 +102,7 @@ module Rigor
           dir = path.is_a?(Pathname) ? path : Pathname(path.to_s)
           next [] unless dir.directory?
 
-          Dir.glob(dir.join("**", "*.rbs").to_s).map { |p| File.expand_path(p) }
+          RootedGlob.glob(dir, "**/*.rbs").map { |p| File.expand_path(p) }
         end.to_set
       end
 

data/lib/rigor/sig_gen/classification.rb

@@ -60,7 +60,10 @@ module Rigor
         inline_differs: "sig.skipped.inline-differs",
         # #1676 — a plain top-level `def` defines a private `Object` method and has no class to write a
         # declaration under, so it is reported rather than silently dropped. Whether to emit it stays open.
-        top_level_def: "sig.skipped.top-level-def"
+        top_level_def: "sig.skipped.top-level-def",
+        # #1968 — a bare `public` / `private` / `protected` that may not run (in control flow or a block) sits
+        # between a bare `module_function` and the def, so whether the def is a module function is unknown.
+        uncertain_module_function: "sig.skipped.uncertain-module-function"
       }.freeze
     end
   end