rigortype 0.4.6 → 0.4.8

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -4,6 +4,7 @@ require "yaml"
 
 require_relative "../config_path"
 require_relative "../rooted_glob"
+require_relative "lockfile_resolver"
 
 module Rigor
   class Environment
@@ -31,7 +32,7 @@ module Rigor
       # The list is hard-coded for the MVP because it tracks rigor's bundled coverage 1:1. When a new gem is
       # vendored under `data/vendored_gem_sigs/` or added to `DEFAULT_LIBRARIES`, add its name here.
       SKIPPED_GEMS_BY_DEFAULT = Set[
-        # DEFAULT_LIBRARIES (lib/rigor/environment.rb)
+        # DEFAULT_LIBRARIES (lib/rigor/environment/default_libraries.rb)
         "pathname", "optparse", "json", "yaml", "fileutils",
         "tempfile", "tmpdir", "stringio", "forwardable",
         "digest", "securerandom", "uri", "logger", "date",
@@ -49,6 +50,10 @@ module Rigor
         "bundler", "rubygems"
       ].freeze
 
+      # The two bundle layouts {.discover} walks, relative to the resolved bundle root. Also the listing rows the
+      # run cache records (issue #2987), so a gem gaining or losing `sig/` invalidates it.
+      SIG_GLOBS = %w[ruby/*/gems/*/sig ruby/*/bundler/gems/*/sig].freeze
+
       # @param bundle_path — explicit path to the bundler install root. When `nil`,
       #   falls back to `auto_detect` if `auto_detect:` is true.
       # @param project_root — resolution base for relative `bundle_path:` and the auto-detect search.
@@ -92,49 +97,75 @@ 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 = (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?
+        all = SIG_GLOBS.flat_map { |pattern| RootedGlob.glob(resolved, pattern) }.map { |d| Pathname.new(d) }
+        if locked_gems.nil? || locked_gems.empty?
+          return all.reject { |sig_dir| skip_gems.include?(gem_name_from_sig_path(sig_dir)) }
+        end
 
-        expected_dirs = expected_gem_dirs(locked_gems)
-        filtered.select do |sig_dir|
-          if git_sourced_layout?(sig_dir)
-            # A git install's directory name carries no resolvable version (see above), so the lockfile
-            # filter can only check the gem NAME, not `(name, version)` — but name alone is not enough: a
-            # gem that used to be `git:`-sourced and has since moved to a released version keeps its old
-            # `bundler/gems/<repo>-<sha>/` directory sitting in the bundle tree until a `bundle clean`, and
-            # its NAME is still present in the lockfile (now via the rubygems entry). Matching on name only
-            # would silently readmit that stale git install — this repo's own `vendor/bundle` had exactly
-            # this after `binpacker` moved from `git:` to a released gem. `locked_gems` must say this name is
-            # CURRENTLY git-sourced, not merely present.
-            locked = locked_gems[gem_name_from_sig_path(sig_dir)]
-            !!locked&.git_source
-          else
-            expected_dirs.include?(sig_dir.parent.basename.to_s)
-          end
+        # Issue #2978 — with a lockfile, a directory's gem name is the locked entry it matches, not a parse of the
+        # directory name, which reads `foo-2fa-1.0` as `foo`.
+        names = locked_dir_names(locked_gems)
+        all.select do |sig_dir|
+          name = locked_name_of(sig_dir, locked_gems, names)
+          name && !skip_gems.include?(name)
+        end
+      end
+
+      # The locked gem name `sig_dir` belongs to, or nil when it matches no locked entry. A git install's directory
+      # carries no version, so only the gem NAME can be checked. Name alone is not enough: a gem that moved from
+      # `git:` to a released version keeps its stale `bundler/gems/` checkout until `bundle clean`, under a name the
+      # lockfile still lists, so `locked_gems` must say this name is CURRENTLY git-sourced, not merely present.
+      #
+      # @param names — {.locked_dir_names} of `locked_gems`.
+      def self.locked_name_of(sig_dir, locked_gems, names)
+        if git_sourced_layout?(sig_dir)
+          name = gem_name_from_sig_path(sig_dir)
+          locked_gems[name]&.git_source ? name : nil
+        else
+          names[sig_dir.parent.basename.to_s]
         end
       end
+      private_class_method :locked_name_of
+
+      # Issue #2971 — the locked gem names `sig_dirs` (a {.discover} result) belong to, keyed the way {.discover}
+      # filters: a rubygems-layout directory by `<name>-<version>[-<platform>]` against the locked variants, a git
+      # layout by a git-sourced locked entry of that name. Unlike {.gem_name_from_sig_path} it never truncates a
+      # name that holds a `-<digit>` (`foo-2fa-1.0` is `foo-2fa`, not `foo`).
+      def self.locked_names_of(sig_dirs, locked_gems)
+        return [] if locked_gems.nil? || locked_gems.empty?
+
+        names = locked_dir_names(locked_gems)
+        sig_dirs.filter_map { |dir| locked_name_of(dir, locked_gems, names) }.uniq
+      end
+
+      # Issue #2987 — the locked gem names whose own `sig/` {.discover} loads for a configuration's bundle and
+      # lockfile: a pure file read ({LockfileResolver}), so the `libraries:` audit can ask without loading `rbs`.
+      def self.loaded_names(configuration, project_root)
+        auto_detect = configuration.bundler_auto_detect
+        locked = LockfileResolver.locked_gems(lockfile_path: configuration.bundler_lockfile,
+                                              project_root: project_root, auto_detect: auto_detect)
+        dirs = discover(bundle_path: configuration.bundler_bundle_path, project_root: project_root,
+                        auto_detect: auto_detect, locked_gems: locked.empty? ? nil : locked)
+        locked_names_of(dirs, locked)
+      end
 
-      # `{name => LockedGem}` → set of canonical bundler gem directory basenames. Pure-Ruby gems install as
+      # `{name => LockedGem}` → `{canonical bundler gem directory basename => name}`. Pure-Ruby gems install as
       # `<name>-<version>`; platform-specific gems install as `<name>-<version>-<platform>` (e.g.
       # `ffi-1.17.4-aarch64-linux-gnu`). Lockfile platform `"ruby"` is the pure-Ruby case; any other value is
       # treated as a platform tag. Every locked variant contributes a directory (#1844): the set only selects
       # among directories that are actually installed, so admitting another platform's name costs nothing,
-      # while dropping the host's would discard its `sig/`.
-      def self.expected_gem_dirs(locked_gems)
-        locked_gems.each_value.with_object(Set.new) do |locked, set|
+      # while dropping the host's would discard its `sig/`. Issue #2978 — the name comes from the lockfile, so a name
+      # holding `-<digit>` is read whole.
+      def self.locked_dir_names(locked_gems)
+        locked_gems.each_value.with_object({}) do |locked, names|
           locked.variants.each do |version, platform|
             base = "#{locked.name}-#{version}"
-            set << if platform == "ruby" || platform.empty?
-                     base
-                   else
-                     "#{base}-#{platform}"
-                   end
+            dir = platform == "ruby" || platform.empty? ? base : "#{base}-#{platform}"
+            names[dir] = locked.name
           end
         end
       end
-      private_class_method :expected_gem_dirs
+      private_class_method :locked_dir_names
 
       # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`, or
       # `<bundle>/ruby/X.Y.Z/bundler/gems/<repo>-<12-hex-revision>/sig` → `<repo>`. The two bundler-install
@@ -149,8 +180,8 @@ module Rigor
       #   different repo name, a monorepo). Strip the fixed-width hex suffix instead; best-effort only, since
       #   the true gem name isn't recoverable from the filesystem without running Bundler.
       #
-      # Public so the O4 Layer 3 slice-3 coverage report (`RbsCoverageReport`) can classify discovered bundle
-      # sigs against locked gem names without re-running discovery.
+      # Only for a directory no lockfile names: with one, {.locked_names_of} reads the name off the locked entry
+      # instead (issue #2978), since a name holding `-<digit>` (`foo-2fa-1.0`) truncates here to `foo`.
       def self.gem_name_from_sig_path(sig_dir)
         gem_dir = sig_dir.parent.basename.to_s
         if git_sourced_layout?(sig_dir)

data/lib/rigor/environment/class_registry.rb

@@ -9,8 +9,8 @@ module Rigor
     # This is the static fast path for built-ins; `Environment` falls through to `RbsLoader` for all other
     # names — the two tiers are complementary.
     #
-    # See docs/internal-spec/inference-engine.md for the binding contract (every entry below MUST always be
-    # recognised).
+    # See docs/internal-spec/inference-engine.md for the binding contract (the classes in
+    # `SLICE_1_BUILT_INS` MUST always be recognised).
     class ClassRegistry
       SLICE_1_BUILT_INS = [
         Integer,
@@ -27,7 +27,7 @@ module Rigor
       # Common Ruby core classes that user code routinely names by constant reference. Adding them to the
       # registry lets `nominal_for_name` resolve `Array`, `Hash`, etc. without each call site re-listing
       # them. The static registry is the cheap fast path; `RbsLoader` extends coverage to all other
-      # RBS-declared names (Slice 4, landed).
+      # RBS-declared names.
       SLICE_2_BUILT_INS = [
         Array,
         Hash,

data/lib/rigor/environment/constant_type_cache_holder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   class Environment
     # Per-key memoization container for {Environment#constant_for_name}. Held by {Environment} so the
@@ -22,6 +24,9 @@ module Rigor
     # reader path. If a future caller introduces a multi-threaded reader against one Environment, the
     # synchronisation belongs at that caller's seam, not here.
     class ConstantTypeCacheHolder
+      TypingState.memo_field(self, :@cache, reason: "keyed on the constant name; a pure function of the name for " \
+                                                    "the environment's lifetime (Environment#constant_for_name)")
+
       def initialize
         @cache = {}
       end

data/lib/rigor/environment/core_root.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../configuration_error"
+require_relative "../rooted_glob"
+
+module Rigor
+  class Environment
+    # Issue #2517 — a core signature directory chosen IN PLACE OF the `rbs` gem's own `core/` (`core_root:` in
+    # `.rigor.yml`). The caller is a provider such as rbs-shifter, which rewrites upstream core for an older
+    # CRuby (`Array#rfind` gone, `String#strip` without arguments); Rigor accepts the directory and passes it to
+    # `RBS::EnvironmentLoader.new(core_root:)`, so the default core is never loaded beside it.
+    #
+    # An explicit choice is never second-guessed by a fallback: a directory that is missing, unreadable or holds
+    # no signature, and an environment that fails to build from it, raise {CoreRootError} instead of analysing
+    # against the default core or against a degraded `Dynamic[top]` environment. Both would report a project as
+    # clean for the very APIs the selection exists to reject.
+    module CoreRoot
+      module_function
+
+      # @param path — the configured directory, already resolved against the config file's directory.
+      # @return the absolute directory as a frozen String (`Ractor.shareable?`, so a frozen loader stays shareable).
+      # @raise CoreRootError — the directory cannot serve as a core.
+      def validate!(path)
+        absolute = File.expand_path(path.to_s)
+        reason = invalid_reason(absolute)
+        raise CoreRootError, "core_root: #{absolute.inspect} #{reason}" if reason
+
+        absolute.dup.freeze
+      end
+
+      # A selected core inside a signature root, or one containing it, loads its files twice — once as core and once
+      # as project signatures — and every class it declares then fails to build on its duplicated methods.
+      #
+      # @param core_root — a {.validate!}d directory.
+      # @param signature_paths — the project's own signature roots.
+      # @raise CoreRootError — the two overlap.
+      def reject_overlap!(core_root, signature_paths)
+        core = File.join(real_path(core_root), "")
+        Array(signature_paths).each do |path|
+          root = File.join(real_path(path), "")
+          next unless core.start_with?(root) || root.start_with?(core)
+
+          raise CoreRootError, "core_root: #{core_root.inspect} overlaps the signature path #{path.to_s.inspect}, so " \
+                               "its signatures would load twice; move the core outside the project's signature paths"
+        end
+      end
+
+      # Compared resolved, because the project-signature walk does not follow a symlinked directory: a `sig/core`
+      # link to a core kept elsewhere loads once, as core, and must not be rejected. A path that does not exist yet
+      # resolves through its nearest existing ancestor, so the two sides of a comparison are spelled alike.
+      def real_path(path)
+        absolute = File.expand_path(path.to_s)
+        missing = []
+        until File.exist?(absolute) || File.dirname(absolute) == absolute
+          missing.unshift(File.basename(absolute))
+          absolute = File.dirname(absolute)
+        end
+        File.join(File.realpath(absolute), *missing)
+      rescue SystemCallError
+        File.expand_path(path.to_s)
+      end
+
+      def invalid_reason(absolute)
+        return "does not exist" unless File.exist?(absolute)
+        return "is not a directory" unless File.directory?(absolute)
+        return "is not readable" unless File.readable?(absolute)
+
+        "contains no .rbs signature file" if RootedGlob.glob(absolute, "**/*.rbs").empty?
+      end
+    end
+
+    # The selected core cannot be used. A {ConfigurationError}, so the CLI reports it as one `rigor:` line with
+    # the usage exit code rather than as a crash.
+    class CoreRootError < ConfigurationError
+    end
+  end
+end

data/lib/rigor/environment/default_libraries.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "rbs_collection_discovery"
+
 module Rigor
   class Environment
-    # Slice A stdlib expansion. Stdlib libraries that `Environment.for_project` loads on top of RBS core
+    # Stdlib libraries that `Environment.for_project` loads on top of RBS core
     # unless the caller passes an explicit `libraries:` array. Each entry MUST be a stdlib library name
     # accepted by `RBS::EnvironmentLoader#has_library?`; unknown libraries MUST fail-soft
     # (`RbsLoader#build_env` already filters through `has_library?`). The default set covers the common
@@ -32,5 +34,20 @@ module Rigor
       strscan
       prism rbs
     ].freeze
+
+    # The library list a run loads before its `RequiredFeatures` tokens: {DEFAULT_LIBRARIES}, then the
+    # configured `libraries:`, then — issue #2946 — the `source: { type: stdlib }` entries of the run's
+    # `rbs_collection.lock.yaml` ({RbsCollectionDiscovery.stdlib_library_names}), de-duplicated in that order.
+    # `Environment.for_project` and the boot-slimming probe's `RunCacheKey.libraries_config_entries` both build
+    # it here, so the cache key's `rbs.libraries` slot names the lockfile's libraries on both paths. A module of
+    # its own, not an `Environment` class method, so the plugin-facing `Environment` surface does not grow.
+    module BaseLibraries
+      def self.resolve(libraries, rbs_collection_lockfile:, rbs_collection_auto_detect:, root: Dir.pwd)
+        collection_stdlib = RbsCollectionDiscovery.stdlib_library_names(
+          lockfile_path: rbs_collection_lockfile, project_root: root, auto_detect: rbs_collection_auto_detect
+        )
+        (DEFAULT_LIBRARIES + libraries.map(&:to_s) + collection_stdlib).uniq
+      end
+    end
   end
 end