rigortype 0.4.4 → 0.4.6

data/lib/rigor/configuration.rb

@@ -8,6 +8,7 @@ require_relative "configuration/dependencies"
 require_relative "configuration/severity_profile"
 require_relative "config_path"
 require_relative "configuration_error"
+require_relative "rooted_glob"
 require_relative "effects/entry_points"
 require_relative "effects/label"
 require_relative "effects/method_key"
@@ -320,12 +321,22 @@ module Rigor
 
     # The test roots a run uses: the declared `test_paths:` as written (already resolved against the
     # config file's directory by {.load}), or — when the key is unset — whichever of
-    # {CONVENTIONAL_TEST_PATHS} is a directory under `root`, as absolute paths. `root` is the directory
-    # the run treats as the project root (the CLI's CWD), as for `signature_paths:` auto-detection.
-    def resolved_test_paths(root: Dir.pwd)
+    # {CONVENTIONAL_TEST_PATHS} is a directory under a root, as absolute paths. The roots, unless `root` names
+    # one, are the directory of the config file in use, the one `paths:` and a declared `test_paths:` resolve
+    # against, and then the working directory, read only when the first holds neither. Auto-detecting against
+    # the working directory alone found nothing for a run from a subdirectory, or for the MCP server started
+    # elsewhere, though both name the config file (#2078); a config file kept in a subdirectory
+    # (`--config=config/rigor.yml`) still finds the project's `spec/` from the project root.
+    def resolved_test_paths(root: nil)
       return test_paths unless test_paths.nil?
 
-      CONVENTIONAL_TEST_PATHS.map { |dir| File.absolute_path(dir, root) }.select { |dir| File.directory?(dir) }
+      roots = root ? [root] : [exclude_base, Dir.pwd].uniq
+      roots.each do |dir|
+        found = CONVENTIONAL_TEST_PATHS.map { |test_dir| File.absolute_path(test_dir, dir) }
+                                       .select { File.directory?(it) }
+        return found unless found.empty?
+      end
+      []
     end
 
     # Loads a configuration file.
@@ -995,9 +1006,34 @@ module Rigor
     # this entry" so a templated `**` pattern in a fresh project doesn't generate an error per match-less
     # pattern.
     def expand_pre_eval_entries(entries)
-      entries.flat_map do |entry|
-        glob_pattern?(entry) ? Dir.glob(entry, sort: true) : [entry]
-      end.uniq.freeze
+      entries.flat_map { |entry| expand_pre_eval_entry(entry) }.uniq.freeze
+    end
+
+    # #1956 — a relative entry arrives joined onto the config file's directory, so the metacharacters the
+    # check above sees may be that directory's own (`ds [x]/`). The leading run of segments that name existing
+    # directories is read literally and only the rest is globbed under it: a literal entry under such a
+    # directory stays a literal path, and a pattern matches what it matches under a plain directory.
+    def expand_pre_eval_entry(entry)
+      return [entry] unless glob_pattern?(entry)
+
+      base, pattern = literal_directory_prefix(entry)
+      return [entry] unless glob_pattern?(pattern)
+
+      base ? RootedGlob.glob(base, pattern) : Dir.glob(entry, sort: true)
+    end
+
+    def literal_directory_prefix(entry)
+      segments = entry.split("/")
+      count = (1...segments.size).take_while { |n| File.directory?(join_segments(segments.take(n))) }.size
+      return [nil, entry] if count.zero?
+
+      [join_segments(segments.take(count)), segments.drop(count).join("/")]
+    end
+
+    # `"/a".split("/")` leads with an empty segment, which spells the filesystem root.
+    def join_segments(segments)
+      path = segments.join("/")
+      path.empty? ? "/" : path
     end
 
     def glob_pattern?(path)

data/lib/rigor/effects/signature_sources.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../rooted_glob"
+
 module Rigor
   module Effects
     # Everything an effect envelope may be written in, as `[buffer name, RBS source]` pairs
@@ -55,7 +57,7 @@ module Rigor
       # @param signature_paths — the configured roots; empty / nil takes the default.
       # @param virtual_rbs — the loader's virtual entries.
       def collect(signature_paths:, virtual_rbs: nil)
-        files = roots(signature_paths).flat_map { |root| Dir.glob(File.join(root.to_s, "**", "*.rbs")).sort }
+        files = roots(signature_paths).flat_map { |root| RootedGlob.glob(root, "**/*.rbs").sort }
         sources = files.filter_map do |path|
           [path, File.read(path)]
         rescue StandardError

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -3,6 +3,7 @@
 require "yaml"
 
 require_relative "../config_path"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -91,8 +92,8 @@ module Rigor
         # all (`Bundler::Source::Path#path` is the user's own `path:` directory, used in place), so there is
         # no bundle-relative location to walk. A `path:`-sourced gem's `sig/` is only reachable by adding it
         # directly to the project's `signature_paths:` — which already works today and needs no discovery.
-        all = (Dir.glob(resolved.join("ruby", "*", "gems", "*", "sig")) +
-               Dir.glob(resolved.join("ruby", "*", "bundler", "gems", "*", "sig"))).map { |d| Pathname.new(d) }
+        all = (RootedGlob.glob(resolved, "ruby/*/gems/*/sig") +
+               RootedGlob.glob(resolved, "ruby/*/bundler/gems/*/sig")).map { |d| Pathname.new(d) }
         filtered = all.reject { |sig_dir| skip_gems.include?(gem_name_from_sig_path(sig_dir)) }
         return filtered if locked_gems.nil? || locked_gems.empty?
 

data/lib/rigor/environment/gated_signature_guard.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbs"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -15,7 +16,7 @@ module Rigor
       # @param dir — the vendored directory (Pathname).
       # @return the absolute-less names (`"Prime::PseudoPrimeGenerator"`) of every class and module it declares.
       def type_names(dir)
-        Dir.glob(File.join(dir.to_s, "*.rbs")).flat_map do |file|
+        RootedGlob.glob(dir, "*.rbs").flat_map do |file|
           _, _, decls = RBS::Parser.parse_signature(File.read(file))
           names(decls, nil)
         rescue RBS::BaseError, SystemCallError

data/lib/rigor/environment/gated_signature_plan.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbs"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -132,7 +133,7 @@ module Rigor
       end
 
       def signature_files(roots)
-        roots.flat_map { |root| Dir.glob(File.join(root.to_s, "*.rbs")).sort }
+        roots.flat_map { |root| RootedGlob.glob(root, "*.rbs").sort }
       end
 
       def shell_buffer

data/lib/rigor/environment/installed_gem_set.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "lockfile_resolver"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -47,7 +48,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/gems/*").each_with_object({}) do |dir, acc|
           name, version, platform = split_install_dirname(File.basename(dir))
           next unless name
 

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -71,7 +72,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/gems/*").each_with_object({}) do |dir, acc|
           acc[File.basename(dir)] ||= dir
         end
       end
@@ -114,7 +115,7 @@ module Rigor
         base = Pathname.new(bundle_path)
         return {} unless base.directory?
 
-        Dir.glob(base.join("ruby", "*", "bundler", "gems", "*")).each_with_object({}) do |dir, acc|
+        RootedGlob.glob(base, "ruby/*/bundler/gems/*").each_with_object({}) do |dir, acc|
           name = gemspec_gem_name(dir)
           acc[name] ||= dir if name
         end
@@ -124,7 +125,7 @@ module Rigor
       # exactly one. Bundler requires a git-sourced gem to ship one, so "not exactly one" means this is not
       # the shape we think it is — and a guess from the directory basename is what this exists to avoid.
       def gemspec_gem_name(dir)
-        specs = Dir.glob(File.join(dir, "*.gemspec"))
+        specs = RootedGlob.glob(dir, "*.gemspec")
         return nil unless specs.size == 1
 
         File.basename(specs.first, ".gemspec")

data/lib/rigor/environment/rbs_loader.rb

@@ -10,6 +10,8 @@ require_relative "member_consistency"
 require_relative "required_features"
 require_relative "gated_signature_guard"
 require_relative "gated_signature_plan"
+require_relative "ruby_library_roots"
+require_relative "../rooted_glob"
 
 module Rigor
   class Environment
@@ -549,7 +551,7 @@ module Rigor
             path = Pathname(path) unless path.is_a?(Pathname)
             next [] unless path.directory?
 
-            Dir.glob(path.join("**", "*.rbs")).map { |p| File.expand_path(p) }
+            RootedGlob.glob(path, "**/*.rbs").map { |p| File.expand_path(p) }
           end.to_set
         end
 
@@ -1652,9 +1654,10 @@ module Rigor
       #   arity. Read back by the env-cache producer, which rebuilds the env from the loader's readers on
       #   a miss — a list it cannot read is a stand-down that runs only on a `--no-cache` build.
       def initialize(libraries: [], signature_paths: [], cache_store: nil, virtual_rbs: [],
-                     deferred_signature_paths: [])
+                     deferred_signature_paths: [], project_signature_paths: [], required_features: [])
         @libraries = libraries.map(&:to_s).freeze
         @signature_paths = signature_paths.map { |p| Pathname(p) }.freeze
+        assign_reopen_inputs(project_signature_paths, required_features)
         # Issue #610 — the subset of `signature_paths:` a bundled PLUGIN contributed. Loaded last and
         # allowed to stand down against a colliding generic arity ({.add_deferred_signatures}). Every entry
         # is also in `@signature_paths`, so the env cache descriptor already digests these files.
@@ -1763,6 +1766,9 @@ module Rigor
       # a partial sidecar as authoritative made `sig-gen --write` on redmine report 5.9x more
       # `call.undefined-method` than the same project with no `sig/` at all.
       #
+      # A class declared only by RBS synthesized from the project's own source joins the set too
+      # ({#inline_only_entry?}, issue #1934).
+      #
       # Memoised per loader: one pass over `class_decls` (~1-2k entries), and every consumer is a check
       # rule on the analysis hot path. Attribution is by buffer NAME, which survives the ADR-54 environment
       # cache since #725 — an environment blob written before that carries the `<cached>` sentinel instead,
@@ -1776,10 +1782,14 @@ module Rigor
         return Set.new.freeze if environment.nil?
 
         project_files = self.class.project_sig_files(@signature_paths)
-        return Set.new.freeze if project_files.empty?
+        virtual_names = @virtual_rbs.to_set(&:first)
+        return Set.new.freeze if project_files.empty? && virtual_names.empty?
 
         names = environment.class_decls.each_with_object(Set.new) do |(rbs_name, entry), acc|
-          acc << rbs_name.to_s.delete_prefix("::") if self.class.project_entry?(entry, project_files)
+          next unless self.class.project_entry?(entry, project_files) ||
+                      inline_only_entry?(entry, virtual_names, project_files)
+
+          acc << rbs_name.to_s.delete_prefix("::")
         end
         names.freeze
       rescue ::RBS::BaseError
@@ -1787,6 +1797,92 @@ module Rigor
       end
       private :build_project_declared_classes
 
+      # Issue #1934 — a class whose every declaration a source RBS synthesizer (`rigor-rbs-inline`) wrote from
+      # the project's own `.rb` files is the project's as much as a `sig/` sidecar is: the declaration is the
+      # inline comments of the source under analysis, so a method another project file adds to the class (a
+      # plain `def`, or an `alias_method` whose target the inline declaration names) is the second file of an
+      # ordinary class, not an ADR-17 monkey-patch. Reading the synthesized RBS as bundled reported
+      # `alias_method :title, :label` from another file while the `alias` keyword, which upstream translates,
+      # read clean.
+      #
+      # EVERY declaration, not only the primary one, and only virtual or `sig/` buffers: a core, stdlib or gem
+      # class an inline-annotated file reopens (`class String` with a `#:` method) keeps its bundled
+      # declaration, and a project `def` on it stays the monkey-patch ADR-17 reports. A declaration whose
+      # buffer cannot be attributed (the pre-#725 `<cached>` sentinel) fails the test, which keeps the
+      # pre-#1934 reading.
+      def inline_only_entry?(entry, virtual_names, project_files)
+        return false if virtual_names.empty?
+
+        project_authored_entry?(entry, virtual_names, project_files)
+      end
+      private :inline_only_entry?
+
+      # Every declaration of `entry` sits in a project `sig/` file or in RBS synthesized from the project's
+      # source; a declaration whose buffer cannot be attributed fails the test.
+      def project_authored_entry?(entry, virtual_names, project_files)
+        buffers = self.class.entry_declarations(entry).map { |decl| self.class.declaration_buffer_name(decl) }
+        return false if buffers.empty? || buffers.any?(&:nil?)
+
+        buffers.all? { |name| virtual_names.include?(name) || project_files.include?(File.absolute_path(name)) }
+      end
+      private :project_authored_entry?
+
+      # Issue #2174 — true when every RBS declaration of `class_name` is the project's own (rbs-inline `#:`
+      # annotations, or a file under the configured `signature_paths:`) and its root constant belongs to a library
+      # Ruby ships ({RubyLibraryRoots}) that the project's source requires ({RequiredFeatures.features_of}). Such
+      # a declaration reopens a library class whose real signatures did not load (`class Matrix` with one
+      # annotated method beside `require "matrix"`, and no `matrix` RBS), so it lists only the methods the
+      # project added: the class's surface is not enumerable from it, and a call it omits is not evidence of an
+      # undefined method. A library whose RBS did load contributes a declaration of its own (core, stdlib, a gem's
+      # `sig/`, an rbs collection, a plugin's `sig/`), which takes the class out of this predicate. A project
+      # class that shares a required library's root name declines too; that is the accepted cost.
+      def ruby_library_reopen?(class_name)
+        name = class_name.to_s.delete_prefix("::")
+        return false if @required_features.empty? || !project_authored_classes.include?(name)
+
+        segments = ruby_library_roots[name.split("::").first]
+        !segments.nil? && @required_features.any? { |feature| segments.include?(feature.split("/").first) }
+      end
+
+      def ruby_library_roots
+        @state[:ruby_library_roots] ||= RubyLibraryRoots.shared
+      end
+
+      # Issue #2174 — the subset of `signature_paths:` the user configured (every entry is also in
+      # `@signature_paths`), and the features the project's source requires: read only by
+      # {#ruby_library_reopen?}.
+      def assign_reopen_inputs(project_signature_paths, required_features)
+        @project_signature_paths = project_signature_paths.map { |p| Pathname(p) }.freeze
+        @required_features = required_features.map { |feature| feature.to_s.dup.freeze }.freeze
+      end
+      private :assign_reopen_inputs
+      private :ruby_library_roots
+
+      # The class / module names every one of whose declarations is the project's own
+      # ({#project_authored_entry?}, which {#inline_only_entry?} asks behind its inline-only gate).
+      def project_authored_classes
+        @state[:project_authored_classes] ||= build_project_authored_classes
+      end
+      private :project_authored_classes
+
+      def build_project_authored_classes
+        environment = env
+        return Set.new.freeze if environment.nil?
+
+        # Only the user's configured `signature_paths:`: `@signature_paths` also holds plugin, gem-shipped,
+        # rbs-collection and overlay directories, whose declarations are a library's own.
+        project_files = self.class.project_sig_files(@project_signature_paths)
+        virtual_names = @virtual_rbs.to_set(&:first)
+        return Set.new.freeze if project_files.empty? && virtual_names.empty?
+
+        environment.class_decls.each_with_object(Set.new) do |(rbs_name, entry), acc|
+          acc << rbs_name.to_s.delete_prefix("::") if project_authored_entry?(entry, virtual_names, project_files)
+        end.freeze
+      rescue ::RBS::BaseError
+        Set.new.freeze
+      end
+      private :build_project_authored_classes
+
       # Issue #527 — the class / module names whose PRIMARY declaration lives in the `rbs` gem's own
       # `core/` or `stdlib/` tree, top-level prefix stripped.
       #
@@ -1807,9 +1903,23 @@ module Rigor
         @state[:core_stdlib_classes] ||= build_core_stdlib_classes
       end
 
-      def build_core_stdlib_classes
+      # Issue #1154 — the subset of {#core_stdlib_classes} whose primary declaration is in `core/` alone: the classes
+      # the interpreter implements, as opposed to a stdlib library written in Ruby (`Logger` rewrites `@level` in
+      # its `initialize`). Same attribution, same cache behaviour.
+      def core_class?(class_name)
+        (@state[:core_classes] ||= build_core_stdlib_classes(CORE_ROOTS)).include?(class_name.to_s.delete_prefix("::"))
+      end
+
+      CORE_ROOTS = begin
+        [::RBS::EnvironmentLoader::DEFAULT_CORE_ROOT].compact.map { |root| "#{root}/".freeze }.freeze
+      rescue StandardError
+        [].freeze
+      end
+      private_constant :CORE_ROOTS
+
+      def build_core_stdlib_classes(roots = CORE_STDLIB_ROOTS)
         environment = env
-        return Set.new.freeze if environment.nil? || CORE_STDLIB_ROOTS.empty?
+        return Set.new.freeze if environment.nil? || roots.empty?
 
         names = environment.class_decls.each_with_object(Set.new) do |(rbs_name, entry), acc|
           decl = self.class.primary_decl_for(entry)
@@ -1818,7 +1928,7 @@ module Rigor
           path = self.class.declaration_buffer_name(decl)
           next if path.nil?
 
-          acc << rbs_name.to_s.delete_prefix("::") if CORE_STDLIB_ROOTS.any? { |root| path.start_with?(root) }
+          acc << rbs_name.to_s.delete_prefix("::") if roots.any? { |root| path.start_with?(root) }
         end
         names.freeze
       rescue ::RBS::BaseError
@@ -1916,6 +2026,25 @@ module Rigor
         (@state[:definition_build_failures] || []).dup.freeze
       end
 
+      # Issue #1929 — re-ask for `class_name`'s definition on behalf of a PREVIOUS run's analysis, which
+      # demanded it and found it failing. An `--incremental` recheck replays that run's failures, and one
+      # whose conflicting buffer is a file the recheck re-synthesized cannot be replayed as it stands (the
+      # edit may have fixed it), while the file that demanded the class may sit outside the recheck's
+      # closure and never ask again. Re-asking here re-derives the answer over the current signatures: a
+      # class that still fails is reported with its current tuple, one that now builds is not.
+      #
+      # A real demand, not {#during_internal_demand}: it stands in for the analysis's own, which is what
+      # #696 binds the reported set to. Both sides are asked, since the replayed tuple does not record which
+      # side the analysis demanded ({#report_definition_build_failure} builds both anyway).
+      #
+      # @return the class's current tuple, or nil when it now builds.
+      def redemand_definition(class_name)
+        key = class_name.to_s.delete_prefix("::")
+        instance_definition(key)
+        singleton_definition(key)
+        definition_build_failures.find { |failure| failure.first == key }
+      end
+
       # Virtual (inline-synthesized) contributions dropped by the collision quarantine
       # ({.resolve_quarantining_virtual_collisions}): buffer names absent from the built env even though the
       # entry's content is non-empty and parses (a parse failure is the synthesizer's own WD6 skip, reported