rigortype 0.4.6 → 0.4.7

data/lib/rigor/effects/mutation_classifier.rb

@@ -32,13 +32,10 @@ module Rigor
       # `foo=`, and deliberately not `==` / `<=` / `!=` / `===`.
       ATTRIBUTE_WRITER = /\A[a-z_][A-Za-z0-9_]*=\z/
 
-      # Every Hash method that mutates its receiver. The widening keeps two tables because they answer two different
-      # questions of a `HashShape` — `MutationWidening::HASH_MUTATORS` changes the pair set,
-      # `HashLookupMutation::MUTATORS` changes what a read of the pairs answers — but either is a write to the
-      # receiver, and that is all this asks: `h.compare_by_identity` raises `FrozenError` on a frozen hash as
-      # `h.clear` does (unless the hash already compares by identity, when it returns before the check), and a
-      # method whose one effect was `@h.compare_by_identity` did not read as mutating while this cited the first
-      # table alone.
+      # Every Hash method that mutates its receiver: the union of two widening tables that answer different
+      # questions of a `HashShape` (the pair set; what a read of the pairs answers). Either is a write to the
+      # receiver, so either counts. `compare_by_identity` lives only in the second, and it raises `FrozenError`
+      # on a frozen hash as `h.clear` does, so a method whose one effect is that call must still read as mutating.
       #
       # `rehash` is in neither table because it changes no read a shape can state: a shape's keys are literals, which
       # a rebuild never merges. It still rebuilds the receiver's table in place, and it is the one name spelt here.

data/lib/rigor/effects/propagator.rb

@@ -363,7 +363,7 @@ module Rigor
         # dispatch target is spelled under a different key, and this is the rewrite: the same ancestor walk
         # {#resolve_owner} performs, on the instance side, for `initialize`.
         #
-        # Three boundaries, and each of them can only narrow:
+        # Four boundaries, and each of them can only narrow:
         #
         # - a project `def self.new` **wins**. It is the definition `Const.new` actually reaches, and a
         #   constructor that overrides `new` is the case where `#initialize` is not the answer. Resolved

data/lib/rigor/effects/registry.rb

@@ -35,8 +35,8 @@ module Rigor
       # without proposing an unrelated label for a genuinely new spelling.
       SUGGESTION_DISTANCE_CAP = 2
 
-      # The shared registry as shipped. Memoised: the YAML parse is a once-per-process cost, and
-      # nothing consumes the registry yet, so it stays lazy rather than paying at `require "rigor"`.
+      # The shared registry as shipped. Memoised: the YAML parse is a once-per-process cost, so it stays
+      # lazy rather than paying at `require "rigor"`.
       def self.default
         @default ||= load_file(DATA_PATH)
       end

data/lib/rigor/effects/snapshot.rb

@@ -55,7 +55,7 @@ module Rigor
       #
       # A count rather than the causes themselves (#434). On redmine the cause renderings were 144,771 of
       # the file's 293,276 bytes, on lines up to 821 characters — simultaneously the half a reviewer
-      # cannot read and the half that churns when an unrelated call moves. This file already makes that
+      # cannot read and the half that churns when an unrelated call moves. {SnapshotDiff} already makes that
       # argument about origins ("a record keyed by them would churn on every refactor"); the causes are
       # the same class of thing and were the one place it was not applied. What a reviewer needs from the
       # record is the stable fact that the row is not exhaustive and by how much, which is what a count

data/lib/rigor/effects/taint_cause.rb

@@ -8,8 +8,6 @@ module Rigor
     # A tainted summary reads "these effects, and possibly more": the cause says which knowledge the
     # analyzer could not have. Taint never produces a finding — diagnostics read the proven lane
     # only — so this enum is a reporting vocabulary, not a diagnostic one.
-    #
-    # Nothing produces causes yet; the collector of #379 is the first writer.
     module TaintCause
       # Closed and ordered by how it arises: dispatch the analyzer could not resolve first, then
       # attribution it had to take on trust, then the collector's own limits.

data/lib/rigor/effects/unit_scan.rb

@@ -586,9 +586,9 @@ module Rigor
       # #1071 widens the answer per `respond_to` arm: a unit that spelled a dispatcher renders one
       # conventional `<action>.<fmt>` template per arm rather than one `<action>.html`, so the row is
       # applied once per arm the walk read, each answered outright (a `responds:` row at the arm's own
-      # top level) or degenerate (`any` / `all`) standing its arm's edge down. The `<action>.html`
-      # answer survives only for a dispatcher the walk could not name arms on, or one nested under a
-      # branch — the plain fall-through still exists on the path that skips it.
+      # top level) or degenerate (`any` / `all`) standing its arm's edge down. The `<action>.html` answer
+      # is kept where no arm was read, and beside the arms when the dispatcher is nested under a branch,
+      # because the plain fall-through still exists on the path that skips it.
       def apply_unit_callees
         return if @responded || @singleton || @non_public
         return if @owner_class.nil? || @method_name.nil?
@@ -811,11 +811,9 @@ module Rigor
       #
       # **Unless the syntax named the class** (#463). The `Dynamic` exclusion exists because a projected
       # receiver class is a guess; a written constant path is not one, and {#catalog_target} already
-      # trusts it for the row lookup. Refusing the posture there made the catalogue's reach a function of
-      # whether the bundled rbs happens to ship a signature for the constant: `Net::HTTP.get` proves
-      # `io.net.http` and `Net::IMAP.new` proved nothing, because rbs ships `net-http` and not
-      # `net-imap`. That is why the `Net::FTP` row has never once fired, and why Redmine's IMAP and POP3
-      # pollers proved no network at all.
+      # trusts it for the row lookup. Refusing the posture there made the catalogue's reach depend on
+      # whether the bundled rbs ships a signature for the constant: `Net::HTTP.get` proved `io.net.http`,
+      # while `Net::IMAP.new` proved nothing, because rbs ships `net-http` and not `net-imap`.
       #
       # The site is then **claimed**, and so discharges, like every other catalogue answer. That is not a
       # softening of the `dynamic-receiver` rule but its premise failing: the taint says the class the
@@ -974,12 +972,10 @@ module Rigor
         positional_arity(node).positive?
       end
 
-      # The class the catalogue would look this call up under, as `[owner, singleton, implicit_self]`.
+      # The class the catalogue would look this call up under, as `[owner, singleton, implicit, named]`.
       # Spelled from the syntax where the syntax settles it and from the typer's receiver otherwise;
-      # `[nil, …]` when neither does.
-      # `[owner, singleton, implicit, named]`. `named` says the owner came from a **constant path the
-      # author wrote**, which is what licenses the posture on a receiver the typer could not resolve
-      # ({#posture_allowed?}).
+      # `[nil, …]` when neither does. `named` says the owner came from a **constant path the author wrote**,
+      # which is what licenses the posture on a receiver the typer could not resolve ({#posture_allowed?}).
       def catalog_target(node, record)
         receiver = node.receiver
         return ["Kernel", false, true, false] if receiver.nil? || receiver.is_a?(Prism::SelfNode)

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -31,7 +31,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",
@@ -100,14 +100,10 @@ module Rigor
         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.
+            # A git install's directory carries no version, so the lockfile filter can only check the gem NAME.
+            # 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. `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

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/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

@@ -2,7 +2,7 @@
 
 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

data/lib/rigor/environment/deferred_signature_plan.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require "rbs"
+
+module Rigor
+  class Environment
+    # Issue #2422 — what a bundled plugin's deferred signature file loads as, against the environment every other
+    # signature source has already built. The #610 arity check stands a file down whole first
+    # (`RbsLoader.generic_arity_conflict`); {.plan} decides the rest declaration by declaration and member by
+    # member, with {GatedSignaturePlan}'s #1713 helpers:
+    #
+    # - a method another source declares (a `def`, an attribute or an alias), where that source is NOT the project's own
+    #   (an `rbs collection install`, a gem's `sig/`, a vendored or another plugin's file), is *composed*: the plugin's
+    #   `def` becomes an overload continuation, `def m: <plugin overloads> | ...`, so RBS puts the plugin's overloads
+    #   first and keeps the other source's as the fallback. The plugin's signatures are often written wider on purpose
+    #   (`Object#html_safe?: () -> bool` where the collection says `-> false`), and standing them down would let the
+    #   narrower one fold correct code into dead branches;
+    # - any other method, attribute or alias another source declares stands down: the project's own `sig/` or
+    #   inline RBS binds by #610's rule, and an attribute, an alias or one side of a `def self?.m` cannot be
+    #   continued ({GatedSignaturePlan.untaken} narrows an `attr_accessor` or `self?` to its untaken half);
+    # - a constant, global, type alias, interface or class alias another source already declares, and a type
+    #   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.
+    #
+    # 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
+    # cache reports what the cold run decided.
+    module DeferredSignaturePlan
+      module_function
+
+      # @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) }
+        same?(planned, decls) ? decls : planned
+      end
+
+      def plan_declaration(decl, env, own, namespace)
+        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)
+        end
+        declared_elsewhere(env, decl, name) ? nil : decl
+      end
+
+      def plan_type(decl, env, own, name)
+        others = GatedSignaturePlan.other_declarations(env, name)
+        taken = GatedSignaturePlan.declared_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 member if taken.empty?
+
+          composed(member, defined) || GatedSignaturePlan.untaken(member, taken)
+        end
+        drop = superclass_given?(decl, others)
+        return decl if same?(members, decl.members) && !drop
+
+        GatedSignaturePlan.rebuild(decl, members: members, drop_super_class: drop)
+      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
+      # two names are not compared: they are not resolved yet, and the other source's superclass binds either way.
+      def superclass_given?(decl, others)
+        super_class?(decl) && others.any? { |other| super_class?(other) }
+      end
+
+      # `member` as an overload continuation, or nil when it cannot be one: only a plain one-sided `def` can, and
+      # only onto a method — a `def`, an attribute or an alias, all of which RBS continues — that a source other
+      # than the project's own declares.
+      def composed(member, defined)
+        return nil unless member.is_a?(::RBS::AST::Members::MethodDefinition) && !member.overloading?
+        return nil if member.kind == :singleton_instance
+
+        key = [member.name, member.kind]
+        return nil unless defined.include?(key)
+
+        member.update(overloading: true)
+      end
+
+      # The `[name, kind]` keys a plain or continued `def` in `decls` declares — what a continuation can extend.
+      def definition_keys(decls)
+        decls.each_with_object(Set.new) do |decl, keys|
+          decl.members.each do |member|
+            next unless member.is_a?(::RBS::AST::Members::MethodDefinition)
+
+            sides = member.kind == :singleton_instance ? %i[instance singleton] : [member.kind]
+            sides.each { |side| keys << [member.name, side] }
+          end
+        end
+      end
+
+      def kind_clash?(env, decl, name)
+        type_name = ::RBS::TypeName.parse("::#{name}")
+        return true if env.class_alias_decls.key?(type_name)
+
+        first = GatedSignaturePlan.other_declarations(env, name).first
+        !first.nil? && !first.instance_of?(decl.class)
+      end
+
+      # The buffer of the declaration another source already makes under `decl`'s name, or nil.
+      def declared_elsewhere(env, decl, name)
+        entry = declaration_entry(env, decl, name)
+        entry && (RbsLoader.declaration_buffer_name(entry.decl) || "")
+      end
+
+      def declaration_entry(env, decl, name)
+        type_name = -> { ::RBS::TypeName.parse("::#{name}") }
+        case decl
+        when ::RBS::AST::Declarations::Constant then env.constant_decls[type_name.call]
+        when ::RBS::AST::Declarations::Global then env.global_decls[decl.name]
+        when ::RBS::AST::Declarations::TypeAlias then env.type_alias_decls[type_name.call]
+        when ::RBS::AST::Declarations::Interface then env.interface_decls[type_name.call]
+        when ::RBS::AST::Declarations::ClassAlias, ::RBS::AST::Declarations::ModuleAlias
+          env.class_alias_decls[type_name.call] || env.class_decls[type_name.call]
+        end
+      end
+
+      # A class or module alias names itself as `new_name`; every other declaration as `name`.
+      def declared_name(decl)
+        decl.respond_to?(:new_name) ? decl.new_name : decl.name
+      end
+
+      def declaration?(member)
+        member.is_a?(::RBS::AST::Declarations::Base)
+      end
+
+      def same?(planned, original)
+        planned.size == original.size && planned.zip(original).all? { |a, b| a.equal?(b) }
+      end
+
+      def buffer_of(decl)
+        RbsLoader.declaration_buffer_name(decl)
+      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
+        attr_reader :env, :file, :rows
+
+        def initialize(env, file)
+          @env = env
+          @file = file
+          @rows = []
+        end
+
+        # rbs 4.x builds the resolver with `TypeNameResolver.build(env)`; rbs 3.x's constructor takes the env, which
+        # the 4.x signature Rigor reads (`new(all_names, aliases)`) does not describe.
+        def resolver
+          @resolver ||= begin
+            klass = ::RBS::Resolver::TypeNameResolver
+            if klass.respond_to?(:build)
+              klass.build(env)
+            else
+              klass.new(env) # rigor:disable call.wrong-arity
+            end
+          end
+        end
+      end
+
+      # What {.plan} left out of the deferred `file` (its parsed `decls`) in the built `env`, as `[declaration,
+      # cause_file]` rows — `Object#acts_like?`, `Time.at`, `FFI::Pointer::NULL`, `Foo < Bar`, or a type name — with
+      # the buffer of the other source's declaration, or nil when it cannot be named. A composed method is not a row:
+      # the plugin's overloads still bind.
+      def standdown_rows(env, file, decls)
+        walk = Walk.new(env, file)
+        decls.each { |decl| declaration_rows(walk, decl, nil) }
+        walk.rows.uniq
+      end
+
+      # `context` is RBS's resolver context for where `decl` is written: nil at the top level, else `[outer,
+      # absolute name of the enclosing declaration]`, as `RBS::Environment#append_context` builds it.
+      def declaration_rows(walk, decl, context)
+        name = GatedSignaturePlan.qualify(namespace_of(context), declared_name(decl))
+        return type_rows(walk, decl, name, context) if GatedSignaturePlan.type_declaration?(decl)
+
+        cause = displaced_by(walk.env, decl, name, walk.file)
+        walk.rows << [decl.is_a?(::RBS::AST::Declarations::Global) ? decl.name.to_s : name, cause] if cause
+      end
+
+      def namespace_of(context)
+        context && context.last.to_s.delete_prefix("::")
+      end
+
+      # A non-nil buffer name (possibly empty) when another source's declaration of `decl` is the one loaded.
+      def displaced_by(env, decl, name, file)
+        entry = declaration_entry(env, decl, name)
+        return nil if entry.nil?
+
+        buffer = RbsLoader.declaration_buffer_name(entry.decl)
+        buffer == file ? nil : buffer
+      end
+
+      def type_rows(walk, decl, name, context)
+        loaded, others = loaded_and_others(walk, name)
+        if loaded.empty?
+          cause = others.empty? ? alias_cause(walk.env, name) : buffer_of(others.first)
+          walk.rows << [name, cause] if cause
+          return
+        end
+
+        walk.rows.concat(superclass_rows(walk, decl, name, context, others))
+        walk.rows.concat(member_rows(decl, name, loaded, others))
+        inner = [context, ::RBS::TypeName.parse("::#{name}")]
+        decl.members.each { |member| declaration_rows(walk, member, inner) if declaration?(member) }
+      end
+
+      # The declarations of `name` the walked file loaded, and the ones other sources made (synthesized stubs left out).
+      def loaded_and_others(walk, name)
+        entry = walk.env.class_decls[::RBS::TypeName.parse("::#{name}")]
+        declarations = entry.nil? ? [] : RbsLoader.entry_declarations(entry)
+        loaded = declarations.select { |other| buffer_of(other) == walk.file }
+        [loaded, declarations.reject { |other| loaded.include?(other) || GatedSignaturePlan.synthetic?(other) }]
+      end
+
+      # The buffer of a class or module alias declaring `name` (empty when it cannot be named), or nil.
+      def alias_cause(env, name)
+        entry = env.class_alias_decls[::RBS::TypeName.parse("::#{name}")]
+        entry && (RbsLoader.declaration_buffer_name(entry.decl) || "")
+      end
+
+      # The plugin's superclass clause as a row (`ActiveRecord::StatementInvalid < ActiveRecordError`) when the plan
+      # dropped it for another source's ({.superclass_given?}) and that source's names a different class or type
+      # arguments. The plan drops an identical clause too, but nothing is lost, so no row.
+      def superclass_rows(walk, decl, name, context, others)
+        return [] unless superclass_given?(decl, others)
+
+        cause = others.find { |other| super_class?(other) }
+        return [] if same_super_class?(walk, decl.super_class, context, cause.super_class)
+
+        written = decl.super_class
+        args = written.args.empty? ? "" : "[#{written.args.join(', ')}]"
+        [["#{name} < #{written.name}#{args}", buffer_of(cause)]]
+      end
+
+      # Whether the plugin's clause `written`, resolved as RBS resolves a superclass (in the context the class is
+      # written in, not its own), names the class and type arguments of `other`, the built env's already-absolute
+      # clause, class aliases normalised on both sides. An unresolvable name differs.
+      def same_super_class?(walk, written, context, other)
+        name = absolute_name(walk, written.name, context)
+        return false if name.nil? || normalized(walk.env, name) != normalized(walk.env, other.name)
+
+        written.args.map { |arg| normalized_type(walk, arg, context) } ==
+          other.args.map { |arg| normalized_type(walk, arg, nil) }
+      end
+
+      def absolute_name(walk, name, context)
+        name.absolute? ? name : walk.resolver.resolve(name, context: context)
+      end
+
+      def normalized(env, name)
+        name.class? ? env.normalize_module_name(name) : name
+      end
+
+      def normalized_type(walk, type, context)
+        return type.to_s unless type.respond_to?(:map_type_name)
+
+        type.map_type_name { |name, _, _| normalized(walk.env, absolute_name(walk, name, context) || name) }.to_s
+      end
+
+      def super_class?(decl)
+        decl.is_a?(::RBS::AST::Declarations::Class) && !decl.super_class.nil?
+      end
+
+      def member_rows(decl, name, loaded, others)
+        present = GatedSignaturePlan.declared_keys(loaded) | definition_keys(loaded)
+        decl.members.flat_map do |member|
+          RbsLoader.member_method_keys(member).reject { |key| present.include?(key) }.filter_map do |key|
+            cause = others.find { |other| other.members.any? { |m| RbsLoader.member_method_keys(m).include?(key) } }
+            cause && [GatedSignaturePlan.member_label(name, key), buffer_of(cause)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/environment/gated_signature_guard.rb

@@ -13,7 +13,7 @@ module Rigor
     module GatedSignatureGuard
       module_function
 
-      # @param dir — the vendored directory (Pathname).
+      # @param dir — the vendored directory.
       # @return the absolute-less names (`"Prime::PseudoPrimeGenerator"`) of every class and module it declares.
       def type_names(dir)
         RootedGlob.glob(dir, "*.rbs").flat_map do |file|

data/lib/rigor/environment/gated_signature_plan.rb

@@ -213,10 +213,13 @@ module Rigor
         end
       end
 
-      def rebuild(decl, members:)
+      # `decl` with `members` in place of its own. A class keeps its superclass unless `drop_super_class` (#2439: a
+      # plugin's class header another source already gives a superclass reopens the class without one).
+      def rebuild(decl, members:, drop_super_class: false)
         if decl.is_a?(::RBS::AST::Declarations::Class)
           ::RBS::AST::Declarations::Class.new(
-            name: decl.name, type_params: decl.type_params, super_class: decl.super_class, members: members,
+            name: decl.name, type_params: decl.type_params, super_class: drop_super_class ? nil : decl.super_class,
+            members: members,
             annotations: decl.annotations, location: decl.location, comment: decl.comment
           )
         else

data/lib/rigor/environment/lockfile_resolver.rb

@@ -7,7 +7,7 @@ module Rigor
     # Gemfile.lock parser for target-project bundler awareness (O4 Layer 3, implemented).
     #
     # Parses a target project's `Gemfile.lock` via Bundler's `LockfileParser` and exposes the locked gem set
-    # as a frozen `Hash[String, LockfileResolver::LockedGem]` keyed by gem name. Used by
+    # as a frozen map from gem name to `LockedGem`. Used by
     # {Rigor::Environment::BundleSigDiscovery} as a filter so the discovered `sig/` directories under the
     # bundler install root are limited to gems the project actually declares (and at the version it declared
     # them).
@@ -38,8 +38,12 @@ module Rigor
       # variant for the readers that want a single version (coverage report, doctor): the `ruby` one when the
       # lockfile has it, otherwise the last parsed. Defaults to the single `[version, platform]` pair, and the
       # pair must be one of `variants`.
-      LockedGem = Data.define(:name, :version, :platform, :git_source, :variants) do
-        def initialize(name:, version:, platform:, git_source: false, variants: nil)
+      #
+      # `path_source` is the absolute directory a lockfile `PATH` stanza resolved this gem from (its `remote:`
+      # expanded against the lockfile's directory), and `nil` for every other source, `GIT` included. Issue
+      # #2441 reads it to tell the project's own path gems apart from the rest of the bundle. Defaults `nil`.
+      LockedGem = Data.define(:name, :version, :platform, :git_source, :variants, :path_source) do
+        def initialize(name:, version:, platform:, git_source: false, variants: nil, path_source: nil)
           version = -version.to_s
           platform = -platform.to_s
           variants = (variants || [[version, platform]]).map { |v, p| [-v.to_s, -p.to_s].freeze }.uniq.freeze
@@ -52,7 +56,8 @@ module Rigor
             version: version,
             platform: platform,
             git_source: git_source ? true : false,
-            variants: variants
+            variants: variants,
+            path_source: path_source && -path_source.to_s
           )
         end
       end
@@ -115,9 +120,9 @@ module Rigor
       def self.do_parse_dependency_names(path)
         parser = Bundler::LockfileParser.new(File.read(path.to_s))
         # `#dependencies` is the parsed `DEPENDENCIES` section keyed by gem name, so the version constraint
-        # and the pinned-source `!` suffix are already stripped for us. The upstream bundler RBS shim does
-        # not declare it.
-        parser.dependencies.keys.to_set { |name| -name.to_s }.freeze # rigor:disable undefined-method
+        # and the pinned-source `!` suffix are already stripped for us. Rigor's vendored bundler
+        # signature declares it as a Hash keyed by gem name.
+        parser.dependencies.keys.to_set { |name| -name.to_s }.freeze
       rescue ::Ractor::IsolationError => e
         warn_isolated(path, e)
         EMPTY_NAMES
@@ -171,10 +176,9 @@ module Rigor
         parser = Bundler::LockfileParser.new(body)
         locked = parser.specs.each_with_object({}) do |spec, h|
           # `Bundler::LazySpecification` carries name, version, platform. Platform is `Gem::Platform` or the
-          # symbol `:ruby`; both stringify cleanly. The upstream bundler RBS shim
-          # (references/rbs/sig/shims/bundler.rbs) does NOT declare `LazySpecification#platform` so the call
-          # site needs a suppression marker.
-          platform = spec.platform.to_s # rigor:disable undefined-method
+          # symbol `:ruby`; both stringify cleanly. Rigor's vendored bundler signature declares
+          # `LazySpecification#platform`, so the call needs no suppression.
+          platform = spec.platform.to_s
           # `#source` is the `Bundler::Source::*` this spec resolved from — `Git` for a `GIT` lockfile
           # stanza, `Rubygems` for a `GEM` one, `Path`/`Gemspec` for `path:`. Only `Git` sources land under
           # {BundleSigDiscovery}'s `bundler/gems/` walk.
@@ -182,7 +186,8 @@ module Rigor
           # instead of letting the last one overwrite the rest (#1844).
           entry = LockedGem.new(
             name: spec.name, version: spec.version.to_s, platform: platform,
-            git_source: spec.source.is_a?(Bundler::Source::Git)
+            git_source: spec.source.is_a?(Bundler::Source::Git),
+            path_source: path_source_dir(spec.source, path)
           )
           h[entry.name] = (prior = h[entry.name]) ? merge_variant(prior, entry) : entry
         end
@@ -196,6 +201,17 @@ module Rigor
       end
       private_class_method :do_parse
 
+      # The absolute directory a `PATH` stanza names, resolved against the lockfile's own directory — never
+      # against `Bundler.root`, which is Rigor's process and not the analysed project. `Bundler::Source::Git`
+      # subclasses `Path`, so a `GIT` stanza is excluded by name.
+      def self.path_source_dir(source, lockfile_path)
+        return nil unless source.is_a?(Bundler::Source::Path)
+        return nil if source.is_a?(Bundler::Source::Git)
+
+        File.expand_path(source.path.to_s, File.dirname(File.expand_path(lockfile_path.to_s)))
+      end
+      private_class_method :path_source_dir
+
       # Folds a further platform variant of an already-parsed name into it. The representative keeps a `ruby`
       # variant once seen; otherwise the last variant wins, as it did before variants were kept.
       def self.merge_variant(prior, entry)