rigortype 0.4.7 → 0.4.8

data/lib/rigor/environment/deferred_signature_plan.rb

@@ -22,7 +22,12 @@ module Rigor
     #   whose kind (class or module) contradicts another source's, stands down on its own, where adding it would
     #   have raised `RBS::DuplicatedDeclarationError` and dropped the plugin's whole file;
     # - a class header's superclass clause another source already gives the class one stands down (#2439), where two
-    #   different clauses would have raised `RBS::SuperclassMismatchError`; the plugin's declaration reopens the class.
+    #   different clauses would have raised `RBS::SuperclassMismatchError`; the plugin's declaration reopens the class;
+    # - an `include`, `extend` or `prepend` of a module this file declares but that stood down whole, or that another
+    #   source declares as a class, stands down too (#2974), where keeping it would have raised `NoMixinFoundError` or
+    #   `MixinClassError` for the class that mixes it in (`Integer`, for the overlay's `ActiveSupport::NumericWithFormat`);
+    # - an instance, class-instance or class variable another source declares on the type stands down (#2978), where
+    #   two declarations of it would have raised `InstanceVariableDuplicationError` or its twins for the class.
     #
     # A declaration with nothing taken comes back as the same object, so a file with no collision loads as it
     # stands. {.standdown_rows} reads what stood down back off the built environment, so a warm run off the env
@@ -33,27 +38,30 @@ module Rigor
       # @param own — the buffer names that are the project's own sources: its `signature_paths:` files (not the
       #   collection or gem directories also on that list) and its inline RBS.
       def plan(decls, env, own, namespace = nil)
-        planned = decls.filter_map { |decl| plan_declaration(decl, env, own, namespace) }
+        mixins = MixinGate.new(env, decls)
+        planned = decls.filter_map { |decl| plan_declaration(decl, env, own, namespace, mixins) }
         same?(planned, decls) ? decls : planned
       end
 
-      def plan_declaration(decl, env, own, namespace)
+      def plan_declaration(decl, env, own, namespace, mixins)
         name = GatedSignaturePlan.qualify(namespace, declared_name(decl))
         if GatedSignaturePlan.type_declaration?(decl)
           return nil if kind_clash?(env, decl, name)
 
-          return plan_type(decl, env, own, name)
+          return plan_type(decl, env, own, name, mixins)
         end
         declared_elsewhere(env, decl, name) ? nil : decl
       end
 
-      def plan_type(decl, env, own, name)
+      def plan_type(decl, env, own, name, mixins)
         others = GatedSignaturePlan.other_declarations(env, name)
         taken = GatedSignaturePlan.declared_keys(others)
+        variables = variable_keys(others)
         external = others.reject { |other| own.include?(buffer_of(other)) }
         defined = GatedSignaturePlan.declared_keys(external) | definition_keys(external)
         members = decl.members.filter_map do |member|
-          next plan_declaration(member, env, own, name) if declaration?(member)
+          next plan_declaration(member, env, own, name, mixins) if declaration?(member)
+          next nil if mixins.drop?(member, name) || variables.include?(variable_key(member))
           next member if taken.empty?
 
           composed(member, defined) || GatedSignaturePlan.untaken(member, taken)
@@ -64,6 +72,40 @@ module Rigor
         GatedSignaturePlan.rebuild(decl, members: members, drop_super_class: drop)
       end
 
+      # Issue #2978 — an instance, class-instance or class variable another source declares on the type stands down:
+      # RBS raises `InstanceVariableDuplicationError` (or its class-instance and class-variable twins) for two
+      # declarations of one, and the class reads `Dynamic[top]`. Keyed by name and kind, not type: the other source's
+      # declaration binds either way.
+      VARIABLE_MEMBERS = {
+        ::RBS::AST::Members::InstanceVariable => :instance_variable,
+        ::RBS::AST::Members::ClassInstanceVariable => :class_instance_variable,
+        ::RBS::AST::Members::ClassVariable => :class_variable
+      }.freeze
+
+      # `[name, kind]` for a variable member, else nil.
+      def variable_key(member)
+        kind = VARIABLE_MEMBERS[member.class]
+        kind && [member.name, kind]
+      end
+
+      # The variable keys `decls` declare, an attribute's implied instance variable included (`attr_reader x: String`
+      # declares `@x` unless written `attr_reader x(): String`).
+      def variable_keys(decls)
+        decls.each_with_object(Set.new) do |decl, keys|
+          decl.members.each do |member|
+            key = variable_key(member) || attribute_variable_key(member)
+            keys << key if key
+          end
+        end
+      end
+
+      def attribute_variable_key(member)
+        return nil unless member.is_a?(::RBS::AST::Members::Attribute) && member.ivar_name != false
+
+        [member.ivar_name || :"@#{member.name}",
+         member.kind == :singleton ? :class_instance_variable : :instance_variable]
+      end
+
       # Issue #2439 — true when `decl` is a class with a superclass clause and another source (`others`) already
       # gives the class one. Two different clauses raise `RBS::SuperclassMismatchError` and the class and every
       # descendant read `Dynamic[top]`, so the plugin's header stands down and reopens the class without one. The
@@ -140,6 +182,62 @@ module Rigor
         RbsLoader.declaration_buffer_name(decl)
       end
 
+      # Issue #2974 — which of a deferred file's mixins name a module that will not be there as a module: one the file
+      # itself declares, inside a type that stood down whole on a kind clash (the project's `class ActiveSupport` takes
+      # the overlay's `module ActiveSupport` and the `NumericWithFormat` in it), or one another source declares as a
+      # class. A mixin of a module the file does not declare, which some other source may supply, is left alone.
+      class MixinGate
+        MIXINS = [::RBS::AST::Members::Include, ::RBS::AST::Members::Extend, ::RBS::AST::Members::Prepend].freeze
+
+        def initialize(env, decls)
+          @env = env
+          @declared = Set.new
+          @dropped = Set.new
+          decls.each { |decl| collect(decl, nil, false) }
+        end
+
+        # `namespace` is the absolute name, without the leading `::`, of the type `member` is written in.
+        def drop?(member, namespace)
+          return false unless MIXINS.any? { |klass| member.is_a?(klass) } && member.name.class?
+
+          target = resolve(member.name, namespace)
+          return false if target.nil?
+
+          first = GatedSignaturePlan.other_declarations(@env, target).first
+          return first.is_a?(::RBS::AST::Declarations::Class) unless first.nil?
+
+          @dropped.include?(target)
+        end
+
+        private
+
+        def collect(decl, namespace, inside_dropped)
+          return unless GatedSignaturePlan.type_declaration?(decl)
+
+          name = GatedSignaturePlan.qualify(namespace, decl.name)
+          dropped = inside_dropped || DeferredSignaturePlan.kind_clash?(@env, decl, name)
+          @declared << name
+          @dropped << name if dropped
+          decl.members.each { |member| collect(member, name, dropped) }
+        end
+
+        # The first lexical candidate for `type_name` written inside `namespace` that this file or the env declares,
+        # as RBS resolves a relative name outward from the innermost scope.
+        def resolve(type_name, namespace)
+          candidates(type_name, namespace).find do |name|
+            @declared.include?(name) || !GatedSignaturePlan.other_declarations(@env, name).empty?
+          end
+        end
+
+        def candidates(type_name, namespace)
+          text = type_name.to_s
+          return [text.delete_prefix("::")] if type_name.absolute?
+
+          scopes = namespace.to_s.split("::")
+          scopes.size.downto(0).map { |depth| [*scopes.first(depth), text].join("::") }
+        end
+      end
+
       # One {.standdown_rows} walk over a deferred file: the built env, the file's buffer name, the rows so far, and
       # the env's type-name resolver, built on first use (only a dropped superclass clause needs it).
       class Walk

data/lib/rigor/environment/hkt_registry_holder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   class Environment
     # ADR-20 slice 2e — mutable single-slot memoization container for the per-Environment HKT registry. Held
@@ -10,6 +12,10 @@ module Rigor
     # prevent cross-thread races. If a future caller introduces a multi-threaded reader path against a
     # shared Environment, the synchronisation belongs at that caller's seam, not here.
     class HktRegistryHolder
+      TypingState.memo_field(self, :@value, :@loaded,
+                             reason: "the one value its owner's block builds from the environment's fixed inputs, " \
+                                     "kept once built")
+
       def initialize
         @loaded = false
         @value = nil

data/lib/rigor/environment/rbs_collection_discovery.rb

@@ -19,12 +19,16 @@ module Rigor
     # access. Failure modes (missing lockfile, malformed YAML, missing collection directory) silently
     # degrade to an empty list.
     module RbsCollectionDiscovery
-      # `stdlib`-typed entries in the lockfile are loaded into the RBS environment by the standard library
-      # mechanism (rigor's `Environment::DEFAULT_LIBRARIES` already covers this surface). Including them as
-      # `signature_paths:` entries would risk `RBS::DuplicatedDeclarationError` (the same hazard O7's
-      # failure-memo handles). The other documented source types — `git` (the gem_rbs_collection repo),
-      # `rubygems` (sigs lifted from a gem's bundled `sig/`), and `local` (a user-managed RBS dir) — all
-      # produce a directory under the collection root and are admitted.
+      # `stdlib`-typed entries (`source: { type: stdlib }`) name a library rbs ships under its own `stdlib/`, and
+      # produce no directory under the collection root, so {.discover} never returns one. Issue #2946 — they are
+      # loaded all the same, as the `rbs` CLI's `EnvironmentLoader#add_collection` loads them: as RBS LIBRARIES.
+      # {.stdlib_library_names} lists them, and `Environment::BaseLibraries.resolve` appends them to the library list,
+      # which is de-duplicated, so an entry `DEFAULT_LIBRARIES` already names is not loaded twice. A collection
+      # gem that subclasses one (actionview's `NodeParser < ::Ripper`) then builds. An unknown name is dropped by
+      # the loader's `has_library?` filter, as a `libraries:` name is, and `ConfigAudit` reports it. The other
+      # documented source types — `git` (the gem_rbs_collection repo), `rubygems` (sigs lifted from a gem's
+      # bundled `sig/`), and `local` (a user-managed RBS dir) — all produce a directory under the collection root
+      # and are admitted by {.discover}.
       #
       # The `source.type` filter alone is NOT sufficient: gems that were extracted from Ruby's stdlib into
       # standalone default gems (e.g. `cgi`, `logger`, `base64`, `csv`, `bigdecimal`) are published in
@@ -77,6 +81,110 @@ module Rigor
         Rigor::ConfigPath.absolute(lockfile_path.to_s, project_root)
       end
 
+      # Issue #2946 — the `name` of every `source: { type: stdlib }` entry in the lockfile, in lockfile order and
+      # de-duplicated, whether or not rbs ships that library: the caller loads them as RBS libraries, and the
+      # loader's `has_library?` filter drops an unknown one. Unlike {.discover}, the collection directory need not
+      # exist, since a stdlib entry installs nothing there. Returns `[]` when no lockfile resolves or its YAML is
+      # unreadable. A pure YAML read, so the ADR-87 boot-slimming probe can rebuild the library list from it.
+      def self.stdlib_library_names(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+        resolved = resolve_lockfile_path(lockfile_path: lockfile_path, project_root: project_root,
+                                         auto_detect: auto_detect)
+        return [] if resolved.nil?
+
+        data = read_lockfile_yaml(resolved)
+        return [] if data.nil?
+
+        Array(data["gems"]).filter_map do |entry|
+          next unless entry.is_a?(Hash) && SKIPPED_SOURCE_TYPES.include?(source_type(entry))
+
+          name = entry["name"]
+          name.to_s if name.is_a?(String) && !name.empty?
+        end.uniq
+      end
+
+      # Issue #2971 — the `name` of every lockfile entry that is NOT a `stdlib` source and whose
+      # `<root>/<name>/<version>/` directory exists: the gems whose signatures come from the collection ({.discover}).
+      # The `libraries:` audit uses it so a name the collection provides is not reported as an unknown RBS library.
+      # A pure file read, like {.stdlib_library_names}.
+      def self.collection_gem_names(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+        resolved = resolve_lockfile_path(lockfile_path: lockfile_path, project_root: project_root,
+                                         auto_detect: auto_detect)
+        return [] if resolved.nil?
+
+        data = read_lockfile_yaml(resolved)
+        return [] if data.nil?
+
+        collection_root = resolve_collection_root(resolved, data)
+        gem_paths_from(collection_root, data, Set.new).map { |dir| dir.parent.basename.to_s }.uniq
+      end
+
+      # Issue #3030 — whether `file`, found under the collection gem directory `root`, sits below a `_`-prefixed
+      # directory (`_test/`, `_scripts/`). Such a file is not part of the gem's signatures: rbs's
+      # `EnvironmentLoader` loads a collection gem as a library, and `RBS::FileFinder.each_file(skip_hidden: true)`
+      # drops every file with a `_`-prefixed directory between it and the library root. A `git` source never
+      # copies them into the collection (`Sources::Git#cp_r` prunes them), but a `local` source symlinks the whole
+      # `<name>/<version>/` directory, so gem_rbs_collection's own `bin/test` setup brings each gem's `_test/`
+      # fixtures along. Only the directories count, as in rbs: a `_`-prefixed file name is loaded.
+      def self.hidden_file?(root, file)
+        relative = Pathname(file.to_s).relative_path_from(Pathname(root.to_s))
+        relative.ascend.drop(1).any? { |part| part.basename.to_s.start_with?("_") }
+      end
+
+      # Issue #3030 — `collection_paths` ({.discover}) without each gem directory a `signature_paths:` root already
+      # loads a copy of. A root is a copy of the entry `<collection>/<name>/<version>` when its real path is the
+      # entry's real path (a `local` source symlinks the working tree in), or when it is a gem_rbs_collection working
+      # tree for the same gem and version, `.../gems/<name>/<version>` (a `git` source installs a copy of it). That is
+      # what an author editing the tree points `signature_paths:` at from its `_test/` directory while the lockfile
+      # installs the same gem, and loading both declares every member twice. The `signature_paths:` copy is kept, as
+      # it is the one being edited. Any other root, such as a partial override `sig/overrides/foo/1.0`, leaves the
+      # collection copy loaded. Real paths are read so `..` and a symlinked spelling answer the same; a root that
+      # does not exist matches nothing.
+      def self.without_signature_path_copies(collection_paths, signature_roots)
+        reals = signature_roots.filter_map { |root| real_path(root) }
+        return collection_paths if reals.empty?
+
+        trees = reals.filter_map do |real|
+          real = Pathname(real)
+          [real.parent.basename.to_s, real.basename.to_s] if real.parent.parent.basename.to_s == "gems"
+        end.to_set
+        reals = reals.to_set
+        collection_paths.reject do |path|
+          path = Pathname(path.to_s)
+          trees.include?([path.parent.basename.to_s, path.basename.to_s]) || reals.include?(real_path(path))
+        end
+      end
+
+      def self.real_path(path)
+        File.realpath(path.to_s)
+      rescue SystemCallError
+        nil
+      end
+      private_class_method :real_path
+
+      # Issue #3030 — why a run with no collection lockfile looks like it was meant to have one: `:collection_test_dir`
+      # when `project_root` is a gem_rbs_collection test directory (`gems/<name>/<version>/_test/`, whose lockfile
+      # gem_rbs_collection's `bin/test` setup writes), `:collection_config` when it holds an `rbs_collection.yaml`
+      # (`rbs collection install` has not run), and nil otherwise, or when a lockfile resolves or the lookup is off.
+      # Rigor resolves no `manifest.yaml` or gemspec dependency itself, so without the lockfile the dependency RBS
+      # is absent. Two `stat`s and no read.
+      def self.missing_lockfile_hint(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+        return nil if lockfile_path.nil? && !auto_detect
+        return nil if resolve_lockfile_path(lockfile_path: lockfile_path, project_root: project_root,
+                                            auto_detect: auto_detect)
+
+        root = Pathname(File.expand_path(project_root.to_s))
+        return :collection_test_dir if collection_test_dir?(root)
+        return :collection_config if root.join("rbs_collection.yaml").file?
+
+        nil
+      end
+
+      # `gems/<name>/<version>/_test/`, the layout of a gem_rbs_collection working tree.
+      def self.collection_test_dir?(root)
+        root.basename.to_s == "_test" && root.parent.parent.parent.basename.to_s == "gems"
+      end
+      private_class_method :collection_test_dir?
+
       # Returns the resolved lockfile path (`Pathname`) or `nil` when neither explicit nor auto-detect
       # produces one. Public so the stats banner can surface what rigor found.
       def self.resolve_lockfile_path(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
@@ -110,12 +218,19 @@ module Rigor
       end
       private_class_method :resolve_collection_root
 
+      # An entry's `source.type`, or "" when `source:` is absent or not a mapping (`source: stdlib`): a malformed
+      # entry fails soft (ADR-5) instead of raising out of the run.
+      def self.source_type(entry)
+        source = entry["source"]
+        source.is_a?(Hash) ? source["type"].to_s : ""
+      end
+      private_class_method :source_type
+
       def self.gem_paths_from(collection_root, data, skip_gem_names)
         Array(data["gems"]).filter_map do |entry|
           next unless entry.is_a?(Hash)
 
-          source_type = entry.dig("source", "type").to_s
-          next if SKIPPED_SOURCE_TYPES.include?(source_type)
+          next if SKIPPED_SOURCE_TYPES.include?(source_type(entry))
 
           name = entry["name"]
           version = entry["version"]

data/lib/rigor/environment/rbs_coverage_report.rb

@@ -5,8 +5,9 @@ module Rigor
     # Open item O4 Layer 3 slice 3 — graceful-degradation coverage report.
     #
     # When the user has a `Gemfile.lock` (via slice 1) and rigor has resolved its target-project RBS sources
-    # (DEFAULT_LIBRARIES, `data/vendored_gem_sigs/`, slice-1 bundle-shipped `sig/`, slice-2
-    # `rbs_collection.lock.yaml` paths), this module classifies each locked gem by RBS provenance and
+    # (the resolved library list — `Environment::BaseLibraries.resolve`, `data/vendored_gem_sigs/`,
+    # slice-1 bundle-shipped `sig/`, slice-2 `rbs_collection.lock.yaml` paths), this module classifies each
+    # locked gem by RBS provenance and
     # surfaces the "no RBS available" set so the run-start diagnostic in {Rigor::Analysis::Runner} can
     # suggest `rbs collection install` or `dependencies.source_inference:` for the uncovered gems.
     #
@@ -37,9 +38,9 @@ module Rigor
 
       # @param locked_gems — The lockfile-resolved gem set. Empty
       #   hash → no coverage analysis to do.
-      # @param default_libraries — gem names rigor auto-loads through
-      #   `RBS::EnvironmentLoader#add(library:)`. Pass `Rigor::Environment::DEFAULT_LIBRARIES` from callers
-      #   running in a project context.
+      # @param default_libraries — the resolved list of names rigor loads as RBS libraries
+      #   (`Environment::BaseLibraries.resolve`: `DEFAULT_LIBRARIES` + `libraries:` + the collection
+      #   lockfile's stdlib entries). Pass it from callers running in a project context.
       # @param bundle_sig_paths — the discovered `<bundle>/.../gems/<name>-<ver>/sig`
       #   paths from {BundleSigDiscovery.discover}.
       # @param rbs_collection_paths — the discovered `<collection>/<name>/<version>/`
@@ -48,7 +49,7 @@ module Rigor
       def self.classify(locked_gems:, default_libraries:,
                         bundle_sig_paths:, rbs_collection_paths:)
         default_set = default_libraries.to_set
-        bundle_names = extract_gem_names_from_bundle_paths(bundle_sig_paths)
+        bundle_names = extract_gem_names_from_bundle_paths(bundle_sig_paths, locked_gems)
         collection_names = extract_gem_names_from_collection_paths(rbs_collection_paths)
 
         locked_gems.each_value.map do |locked|
@@ -73,11 +74,11 @@ module Rigor
         coverage_rows.select { |row| row.source == :missing }
       end
 
-      def self.extract_gem_names_from_bundle_paths(paths)
-        paths.each_with_object(Set.new) do |path, set|
-          pathname = path.is_a?(Pathname) ? path : Pathname.new(path)
-          set << BundleSigDiscovery.gem_name_from_sig_path(pathname)
-        end
+      # Issue #2978 — each path's gem name as the locked entry it matches ({BundleSigDiscovery.locked_names_of}), not
+      # a parse of its directory name, which reads `foo-2fa-1.0` as `foo` and reported `foo-2fa` as missing RBS.
+      def self.extract_gem_names_from_bundle_paths(paths, locked_gems)
+        pathnames = paths.map { |path| path.is_a?(Pathname) ? path : Pathname.new(path) }
+        BundleSigDiscovery.locked_names_of(pathnames, locked_gems).to_set
       end
       private_class_method :extract_gem_names_from_bundle_paths
 

data/lib/rigor/environment/rbs_hierarchy.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   class Environment
     # Small hierarchy oracle backed by RBS instance definitions.
     class RbsHierarchy
+      TypingState.memo_field(self, :@ancestor_names_cache, :@class_ordering_cache,
+                             reason: "keyed on the class names; answered from the loader's RBS environment, fixed " \
+                                     "for the loader's lifetime")
+
       def initialize(loader)
         @loader = loader
         @ancestor_names_cache = {}