rigortype 0.4.1 → 0.4.3

data/lib/rigor/plugin/inflector.rb

@@ -54,7 +54,7 @@ module Rigor
       # by `rigor plugins` (ADR-90) to probe {available?} at activation time — so a standalone install
       # where inflection silently degrades reports the degradation instead of an unqualified `[OK]`. When
       # a new plugin adopts the helper, add its manifest id here.
-      CONSUMER_PLUGIN_IDS = %w[actionmailer actionpack activerecord factorybot rails-routes].freeze
+      CONSUMER_PLUGIN_IDS = %w[actionmailer actionpack activerecord alba factorybot rails-routes].freeze
 
       # Raised when `ActiveSupport::Inflector` is required for an inflection but cannot be loaded. Caught by
       # the per-plugin isolation boundary, so it surfaces as "this plugin produced no diagnostics" rather than

data/lib/rigor/plugin/io_boundary.rb

@@ -199,6 +199,44 @@ module Rigor
         entries
       end
 
+      # Issue #1652 — the MEMBERSHIP fingerprint of a `Dir.glob` pattern under `root`, `**` included. Returns the
+      # matching paths and records one `:names` {Cache::Descriptor::GlobEntry} over `root` and `pattern`: the row
+      # reads stale when a match appears or disappears, in a subdirectory created after the read too, and NOT
+      # when a match's bytes or stat tuple move. A caller whose answer depends on a match's content MUST
+      # {#read_file} each match it reads; that row carries the edit. A stat signature here would read stale on
+      # every `touch`, checkout or restored CI cache, though the content the caller read is unchanged (#979's
+      # reasoning). {#list_directory} keeps its `:stat` listing row.
+      #
+      # The pattern must stay under `root`, since the policy is checked against `root` alone: a `..` segment, a
+      # brace (`{..,x}`) or a backslash escape (`.\\./`) raises {AccessDeniedError} (`:read_outside_scope`).
+      # The last two are refused outright because `Dir.glob` can spell `..` with them. Out of policy, `root` is
+      # globbed truthfully and contributes no row, as in {#list_directory}.
+      #
+      # @param root — project directory; relative paths expand against the working directory
+      # @param pattern — a `Dir.glob` pattern relative to `root`, such as `"ext/**/extconf.rb"`
+      # @return the absolute matching paths in `Dir.glob` order
+      def glob(root, pattern)
+        absolute = File.absolute_path(root.to_s)
+        pattern = pattern.to_s
+        if pattern.match?(/[{\\]/) || pattern.split("/").include?("..")
+          raise AccessDeniedError.new(
+            "plugin #{@plugin_id.inspect} cannot glob #{pattern.inspect} under #{absolute.inspect}: " \
+            "a `..` segment, a brace or a backslash can leave the root the trusted-read scope was checked against",
+            reason: :read_outside_scope,
+            resource: File.join(absolute, pattern)
+          )
+        end
+
+        entries = Dir.glob(File.join(absolute, pattern))
+        unless @policy.allow_read?(absolute)
+          record_refusal(absolute)
+          return entries
+        end
+
+        record_glob_entry(absolute, pattern, mode: :names)
+        entries
+      end
+
       # Fetches the URL when the policy permits it. Returns the response body. Raises {AccessDeniedError} when
       # the policy is `:disabled`, the URL scheme is not `https`, the host is not on the allowlist, the
       # response is non-2xx, the body exceeds {URL_MAX_BYTES}, or the request times out
@@ -352,11 +390,12 @@ module Rigor
         self.class.attribute(entry)
       end
 
-      # ADR-45 WD1c (#629) — the listing row for {#list_directory}, deduplicated per (root, pattern) slot.
+      # ADR-45 WD1c (#629) — the listing row for {#list_directory} (and the `:names` row for {#glob}),
+      # deduplicated per (root, pattern, mode) slot.
       # Recomputed on each call rather than `||=`d, so a directory listed again after a mid-run mutation
       # carries the signature of the state the LAST reader saw.
-      def record_glob_entry(root, pattern)
-        entry = Cache::Descriptor::GlobEntry.compute(root: root, pattern: pattern)
+      def record_glob_entry(root, pattern, mode: :stat)
+        entry = Cache::Descriptor::GlobEntry.compute(root: root, pattern: pattern, mode: mode)
         @mutex.synchronize { @glob_entries[entry.slot_key] = entry }
         self.class.attribute(entry)
       end

data/lib/rigor/plugin/macro/block_as_method.rb

@@ -42,8 +42,20 @@ module Rigor
       #   `Nominal[Grape::Endpoint]` (the block is `instance_eval`'d on an instance of that class, e.g. a
       #   route body on `Grape::Endpoint`), and `"singleton(Grape::API::Instance)"` binds
       #   `Singleton[Grape::API::Instance]` (the block is `instance_eval`'d on that *class object*, e.g.
-      #   a `namespace` body on `Grape::API::Instance`). Reserved Symbol names (`:receiver_singleton`,
-      #   `:dsl_recorder`) remain unaccepted.
+      #   a `namespace` body on `Grape::API::Instance`). `:lexical` (issue #1667) leaves `self` as the caller's:
+      #   the method runs the block where it was written (`block.refined(M).call`), so the entry only declares
+      #   `refinements:`. Reserved Symbol names (`:receiver_singleton`, `:dsl_recorder`) remain unaccepted.
+      # - `refinements` — Array of fully-qualified module-name Strings (default `[]`, issue #1667, ADR-121 WD5).
+      #   The method runs the block under `Proc#refined` with these modules (`instance_exec(&block.refined(M))`),
+      #   so they are appended to the block body's in-effect refinements after its lexical list, in the declared
+      #   order (the last one wins). Nested blocks inherit them. A module that refines nothing the project or a
+      #   gem's source inference makes visible contributes nothing.
+      #
+      # ## Matching
+      #
+      # A `:receiver_instance` or `singleton(...)` entry matches `Singleton[X]` receivers only (a class-level DSL
+      # call). A named instance binding (`"Foo::Bar"`) and a `:lexical` entry also match `Nominal[X]` receivers:
+      # a `:lexical` method is as often an instance method (`ActiveRecord::Relation#where`) as a class-level one.
       #
       # ## Ractor-shareability
       #
@@ -51,7 +63,8 @@ module Rigor
       # mutable array does not leak into the value. `Ractor.shareable?` returns true after `#initialize`.
       class BlockAsMethod
         SELF_TYPE_RECEIVER_INSTANCE = :receiver_instance
-        VALID_SELF_TYPES = [SELF_TYPE_RECEIVER_INSTANCE].freeze
+        SELF_TYPE_LEXICAL = :lexical
+        VALID_SELF_TYPES = [SELF_TYPE_RECEIVER_INSTANCE, SELF_TYPE_LEXICAL].freeze
 
         CLASS_NAME_PATTERN = /[A-Z]\w*(?:::[A-Z]\w*)*/
         # `self_type: "Foo::Bar"` — the block is `instance_eval`'d on an instance of `Foo::Bar`.
@@ -60,16 +73,18 @@ module Rigor
         # object itself (Grape's `namespace`/`route_param` bodies run on `Grape::API::Instance`).
         SINGLETON_SELF_TYPE_PATTERN = /\Asingleton\((#{CLASS_NAME_PATTERN})\)\z/
 
-        attr_reader :receiver_constraint, :method_names, :self_type
+        attr_reader :receiver_constraint, :method_names, :self_type, :refinements
 
-        def initialize(receiver_constraint:, method_names:, self_type: SELF_TYPE_RECEIVER_INSTANCE)
+        def initialize(receiver_constraint:, method_names:, self_type: SELF_TYPE_RECEIVER_INSTANCE, refinements: [])
           validate_receiver_constraint!(receiver_constraint)
           validate_method_names!(method_names)
           validate_self_type!(self_type)
+          validate_refinements!(refinements)
 
           @receiver_constraint = receiver_constraint.dup.freeze
           @method_names = method_names.map(&:to_sym).freeze
           @self_type = self_type.is_a?(String) ? self_type.dup.freeze : self_type
+          @refinements = refinements.map { |name| name.dup.freeze }.freeze
           freeze
         end
 
@@ -77,7 +92,8 @@ module Rigor
           {
             "receiver_constraint" => receiver_constraint,
             "method_names" => method_names.map(&:to_s),
-            "self_type" => self_type.to_s
+            "self_type" => self_type.to_s,
+            "refinements" => refinements
           }
         end
 
@@ -85,12 +101,18 @@ module Rigor
           other.is_a?(BlockAsMethod) &&
             receiver_constraint == other.receiver_constraint &&
             method_names == other.method_names &&
-            self_type == other.self_type
+            self_type == other.self_type &&
+            refinements == other.refinements
         end
         alias eql? ==
 
         def hash
-          [receiver_constraint, method_names, self_type].hash
+          [receiver_constraint, method_names, self_type, refinements].hash
+        end
+
+        # Whether the block keeps the caller's `self` (`self_type: :lexical`).
+        def lexical_self?
+          self_type == SELF_TYPE_LEXICAL
         end
 
         # The class name a String `self_type` binds `self` to — `"Foo::Bar"` for both the plain and the
@@ -118,6 +140,12 @@ module Rigor
           self_type.is_a?(String) && !singleton_binding?
         end
 
+        # Whether `Nominal[X]` receivers match, beside `Singleton[X]` ones: a named instance binding, or a
+        # `:lexical` entry.
+        def matches_instance_receivers?
+          named_instance_binding? || lexical_self?
+        end
+
         private
 
         def validate_receiver_constraint!(value)
@@ -143,6 +171,21 @@ module Rigor
           end
         end
 
+        def validate_refinements!(refinements)
+          unless refinements.is_a?(Array)
+            raise ArgumentError,
+                  "Plugin::Macro::BlockAsMethod#refinements must be an Array, got #{refinements.inspect}"
+          end
+
+          refinements.each do |name|
+            next if name.is_a?(String) && name.match?(NAMED_SELF_TYPE_PATTERN)
+
+            raise ArgumentError,
+                  "Plugin::Macro::BlockAsMethod#refinements entries must be module-name Strings ('Foo::Bar'), " \
+                  "got #{name.inspect}"
+          end
+        end
+
         def validate_self_type!(self_type)
           return if VALID_SELF_TYPES.include?(self_type)
           return if self_type.is_a?(String) &&

data/lib/rigor/project_environment.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "environment"
+require_relative "inference/project_patched_scanner"
 require_relative "plugin"
 require_relative "plugin/loader"
 require_relative "plugin/services"
@@ -53,16 +54,55 @@ module Rigor
     #   ADR-93 auto-wired `rigor-rbs-inline` entry when the library is resolvable).
     # @param source_files — the file(s) the command inspects. Threaded so each loaded plugin's
     #   `source_rbs_synthesizer` runs over them at env-build time; an empty list contributes no synthesized RBS.
-    def build(configuration:, source_files:)
+    # @param feature_sources — path => source text the required-feature scan reads in place of that file (an
+    #   editor buffer bound with `--tmp-file` / `--instead-of`).
+    # @param project_patched_methods — the `pre_eval:` registry (see {.project_patched_methods}); nil keeps
+    #   the unpatched universe.
+    def build(configuration:, source_files:, feature_sources: {}, project_patched_methods: nil)
+      features = required_features(configuration, source_files, sources: feature_sources)
       Environment.for_project(
+        project_patched_methods: project_patched_methods,
         libraries: configuration.libraries,
         signature_paths: configuration.signature_paths,
         plugin_registry: load_plugin_registry(configuration),
         source_files: source_files,
+        required_features: features,
         **dependency_discovery_options(configuration)
       )
     rescue StandardError
-      bare(configuration)
+      bare(configuration, features)
+    end
+
+    # The patched-method registry `rigor check` types against for the project's `pre_eval:` files. It depends
+    # on those files alone, so it is built by the same {Inference::ProjectPatchedScanner} the Runner's project
+    # pre-pass calls, over the same resolved `configuration.pre_eval` entries (glob-expanded at config load,
+    # missing files skipped), without the pre-pass's plugin load / `#prepare` / dependency-source work. An
+    # editor `buffer` is honoured, so a `--tmp-file` edit of a pre_eval file is read in flight. Nil when the
+    # project lists no `pre_eval:` entry, so a project without one stays byte-identical. Fail-soft.
+    def project_patched_methods(configuration, buffer: nil)
+      return nil if configuration.pre_eval.empty?
+
+      existing = configuration.pre_eval.select { |path| File.file?(path) }
+      Inference::ProjectPatchedScanner.scan(existing, buffer: buffer).registry
+    rescue StandardError
+      nil
+    end
+
+    # Issue #1700 — the {Environment::RequiredFeatures} the environment gates on: the configured paths plus
+    # `extra_files` (the file a probe inspects, which may lie outside them), the same set `rigor check` scans
+    # whichever files it is given, so a position types as `rigor check` types it.
+    def required_features(configuration, extra_files = [], sources: {})
+      Environment::RequiredFeatures.for_configuration(configuration, extra_files, sources: sources)
+    end
+
+    # The required-feature scan's view of an editor buffer (`--tmp-file` / `--instead-of`): its logical path
+    # read from its physical file. Empty without a buffer or when the file cannot be read.
+    def buffer_sources(buffer)
+      return {} if buffer.nil?
+
+      { buffer.logical_path => File.binread(buffer.physical_path) }
+    rescue SystemCallError
+      {}
     end
 
     # The dependency-discovery axes `check` reads off the configuration, as a keyword hash. Extracted so the
@@ -116,22 +156,24 @@ module Rigor
 
     # The first fail-soft floor: no plugin tier and no synthesized RBS, but still the project's own dependency
     # sources — dropping those is what issue #821 was, so a plugin-loading failure must not cost them.
-    def bare(configuration)
+    def bare(configuration, features = required_features(configuration))
       Environment.for_project(
         libraries: configuration.libraries,
         signature_paths: configuration.signature_paths,
+        required_features: features,
         **dependency_discovery_options(configuration)
       )
     rescue StandardError
-      minimal(configuration)
+      minimal(configuration, features)
     end
 
     # The last floor: RBS core plus the project's own signature paths, which cannot fail on anything outside
     # the project itself.
-    def minimal(configuration)
+    def minimal(configuration, features = [])
       Environment.for_project(
         libraries: configuration.libraries,
-        signature_paths: configuration.signature_paths
+        signature_paths: configuration.signature_paths,
+        required_features: features
       )
     end
   end

data/lib/rigor/protection/mutation_cache.rb

@@ -84,7 +84,8 @@ module Rigor
 
       # Human-readable reasons the caller prints. Each names something the operator can act on.
       NO_SNAPSHOT = "no reusable `rigor check --incremental` snapshot"
-      OPAQUE_PLUGIN = "a plugin contributes types with no incremental fingerprint surface"
+      OPAQUE_PLUGIN = "a plugin is opaque to the incremental fingerprint " \
+                      "(no fingerprint surface, or a value it cannot digest)"
       UNDIGESTIBLE = "the project-scan tables could not be digested"
       UNIDENTIFIED_ENGINE = "the engine's own source tree could not be digested"
 
@@ -220,7 +221,7 @@ module Rigor
         def patched_rows(patched)
           patched.by_key.map do |(class_name, method_name, kind), entry|
             [class_name.to_s, method_name.to_s, kind.to_s, entry.source_path.to_s, entry.source_line,
-             entry.return_type&.describe(:short).to_s]
+             entry.return_type&.describe(:short).to_s, entry.alias_of.to_s]
           end.sort
         end
 

data/lib/rigor/protection/mutator.rb

@@ -366,7 +366,7 @@ module Rigor
       end
 
       def snippet(loc)
-        text = loc.slice.gsub(/\s+/, " ")
+        text = loc.slice.scrub.gsub(/\s+/, " ")
         text.length > 30 ? "#{text[0, 27]}..." : text
       end
     end

data/lib/rigor/reflection/constant_ancestors.rb

@@ -27,11 +27,13 @@ module Rigor
     # ancestors are `[C, A, M, Base]`. It reads the chain's `:constants` flavor, whose predicate for a
     # project class also admits a module that holds only constants.
     #
-    # Only PROJECT ancestors appear: an as-written name that resolves to no discovered class or module
-    # is an external entry on the chain and contributes nothing here, so a `class Foo <
-    # ActiveRecord::Base` adds no candidate and a constant owned by an RBS-known ancestor still resolves
-    # only if the bare name reaches it at step 3. That gap is deliberate for this slice: widening to the
-    # RBS ancestor graph is a separate question with its own FP surface.
+    # Project ancestors appear, and (issue #1698) a module the class body `include`s or `prepend`s that
+    # only RBS or the class registry declares: `include AcLibraryRb` puts `AcLibraryRb` at its Ruby
+    # position, so `Segtree` inside the class reads `AcLibraryRb::Segtree` as Ruby does. Such an entry
+    # contributes its OWN constants only; the RBS ancestry behind it is not expanded, as for every external
+    # entry. An external SUPERCLASS (`class Foo < ActiveRecord::Base`) still contributes nothing, and a
+    # constant it owns resolves only if the bare name reaches it at step 3: widening to the superclass's
+    # RBS graph is a separate question with its own FP surface. See {.external_constant_owner}.
     #
     # Memoised per run because step 2 runs on every constant reference whose lexical candidates all
     # miss — which is the common case for a core-class reference (`String` inside `class Foo`). The
@@ -52,7 +54,7 @@ module Rigor
       scopes, chain = ancestor_constant_worlds(class_name, scope)
       owner, hit = first_ancestor_hit(scopes, &)
       verdict = chain.settle(scope, owner, owner: owner) do |retro|
-        first_ancestor_hit(constant_scopes_of(retro, class_name), &)&.first
+        first_ancestor_hit(constant_scopes_of(retro, class_name, scope), &)&.first
       end
       return hit if verdict == :chain
 
@@ -109,7 +111,9 @@ module Rigor
       worlds = bucket[class_name]
       return bucket[class_name] = compute_ancestor_constant_scopes(class_name, scope) if worlds.nil?
 
-      Scope::ResolutionChain.for(scope, class_name.to_s, :instance, :constants).record(scope)
+      chain = Scope::ResolutionChain.for(scope, class_name.to_s, :instance, :constants)
+      chain.record(scope)
+      record_external_owner_edges(chain)
       worlds
     end
     private_class_method :recorded_ancestor_constant_scopes
@@ -118,22 +122,134 @@ module Rigor
     def compute_ancestor_constant_scopes(class_name, scope)
       chain = Scope::ResolutionChain.for(scope, class_name.to_s, :instance, :constants)
       chain.record(scope)
-      scopes = constant_scopes_of(chain, class_name)
+      record_external_owner_edges(chain)
+      scopes = constant_scopes_of(chain, class_name, scope)
       [scopes, chain].freeze
     end
     private_class_method :compute_ancestor_constant_scopes
 
-    # The chain's project entries in order, each once, without `class_name` itself.
-    def constant_scopes_of(chain, class_name)
+    # The chain's project entries in order, each once, without `class_name` itself, with each mixin entry
+    # the project does not declare standing as the module {.external_constant_owner} names.
+    def constant_scopes_of(chain, class_name, scope)
       out = []
       chain.entries.each do |entry|
-        name = entry.name
+        name = entry.external? ? external_constant_owner(entry, scope) : entry.name
         out << name unless name.nil? || name == class_name || out.include?(name)
       end
       out.freeze
     end
     private_class_method :constant_scopes_of
 
+    # Issue #1698 — the module an external `include` / `prepend` entry names, when the constant ladder may
+    # read its constants, or nil. Ruby resolved the spelling at the `include` lexically, so the first of the
+    # entry's candidates (most qualified first) that exists is the module. The answer is the first candidate
+    # RBS or the class registry knows, and nil when a nearer candidate is a constant the project binds
+    # ({.project_written_candidate?}): Ruby's module is then that constant, whose constants nothing here
+    # describes. The candidates are the entry's own, behind the namespace of the body that wrote the edge
+    # (`entry.owner`), which Ruby searches first and the chain's resolver does not consult. An ambiguous
+    # spelling has no candidates and answers nil. A superclass edge answers nil (see
+    # {.ancestor_constant_scopes}).
+    def external_constant_owner(entry, scope)
+      return nil if entry.superclass_edge || entry.candidates.empty?
+
+      env = scope.environment
+      external_owner_candidates(entry).each do |candidate|
+        return nil if project_written_candidate?(candidate, scope)
+        return candidate if env.class_known?(candidate)
+      end
+      nil
+    end
+    private_class_method :external_constant_owner
+
+    def external_owner_candidates(entry)
+      return entry.candidates if entry.owner.nil? || entry.raw.start_with?("::")
+
+      ["#{entry.owner}::#{entry.raw}", *entry.candidates]
+    end
+    private_class_method :external_owner_candidates
+
+    # ADR-46 — the name edges of {.external_constant_owner}'s guard, for every mixin entry it read: a file that
+    # starts writing or declaring a nearer spelling of the module's name (`User::AcLibraryRb = …` in a file the
+    # reader has no other edge to) moves the answer. Keyed on the spelling's last segment, as the ladder's own
+    # `constant:` and `class:` edges are. A memo hit replays them beside the chain's own edges.
+    def record_external_owner_edges(chain)
+      return unless Analysis::DependencyRecorder.active?
+
+      chain.entries.each do |entry|
+        next unless entry.external? && !entry.superclass_edge
+
+        Analysis::DependencyRecorder.read_last_segment(:constant, entry.raw)
+        Analysis::DependencyRecorder.read_last_segment(:class, entry.raw)
+      end
+    end
+    private_class_method :record_external_owner_edges
+
+    # Issue #1698 — whether the walk must stop at `owner` because a module its RBS ancestry holds may own the name
+    # (`candidate` answers for it). Ruby searches that ancestry right after `owner`, before any later entry of
+    # the chain and before the top level, and the chain does not expand it. Where no module of it owns the
+    # name, where they sit does not matter to this name and the walk goes on.
+    #
+    # `owner` is an RBS-only mixin (`external`), or a project entry RBS also declares: a project file that
+    # reopens an RBS module without restating its `include`s makes it a project entry whose chain lists only
+    # the edges the project writes, so its ancestry is read less what that chain lists. The ancestry comes from
+    # the declarations (`RbsLoader#declared_ancestry`), so a definition that fails to build still yields what
+    # it declares. Where it cannot be read whole, {.ancestry_unknown?} keeps the later RBS-only mixins out
+    # instead of stopping here.
+    def mixin_ancestry_stop?(owner, scope, external)
+      loader = rbs_loader_for(scope, nil)
+      return false if loader.nil? || (!external && !loader.class_known?(owner))
+
+      names, = loader.declared_ancestry(owner)
+      listed = nil
+      names.any? do |ancestor|
+        next false if IMPLICIT_ANCESTORS.include?(ancestor)
+
+        listed ||= external ? EMPTY_NAMES : project_chain_names(owner, scope)
+        !listed.include?(ancestor) && yield(ancestor)
+      end
+    end
+    private_class_method :mixin_ancestry_stop?
+
+    # Issue #1698 — whether an entry ahead of `entry` on `class_name`'s list has an RBS ancestry that cannot be
+    # read whole ({.mixin_ancestry_stop?}): a module it hides may own the name, so `entry`, an RBS-only mixin,
+    # MUST NOT answer. Only those entries are kept out; project entries, the superclass chain and the top level
+    # answer as they did before #1698.
+    def ancestry_unknown_before?(class_name, entry, scope)
+      loader = rbs_loader_for(scope, nil)
+      return true if loader.nil?
+
+      ancestor_constant_scopes(class_name, scope).each do |earlier|
+        break if earlier == entry
+        next unless loader.class_known?(earlier)
+
+        return true unless loader.declared_ancestry(earlier)[1]
+      end
+      false
+    end
+    private_class_method :ancestry_unknown_before?
+
+    # Ruby places these after every entry of a chain, so a constant they own is the top level's (step 4).
+    IMPLICIT_ANCESTORS = %w[Object Kernel BasicObject].freeze
+    private_constant :IMPLICIT_ANCESTORS
+
+    EMPTY_NAMES = [].freeze
+    private_constant :EMPTY_NAMES
+
+    # Every name `owner`'s own instance chain lists: its project entries and each external entry's candidates.
+    def project_chain_names(owner, scope)
+      Scope::ResolutionChain.for(scope, owner, :instance, :constants).entries.flat_map do |entry|
+        entry.external? ? entry.candidates : [entry.name]
+      end
+    end
+    private_class_method :project_chain_names
+
+    # Whether the project binds `candidate` itself: a namespace under the `:constants` flavor's tables, or a
+    # constant write the census records (#1290), typed or not.
+    def project_written_candidate?(candidate, scope)
+      known_project_namespace?(candidate, scope) || scope.shadowing_constant_names(candidate).include?(candidate)
+    end
+    private_class_method :project_written_candidate?
+
     # Whether `name` is a namespace the project declares — the predicate the chain's `:constants` flavor
     # resolves ancestor names with, and the path walk's (`reflection/constant_path.rb`) test for a head.
     def known_project_namespace?(name, scope)

data/lib/rigor/reflection/constant_path.rb

@@ -118,11 +118,15 @@ module Rigor
 
     # {.agreed_ancestor_hit} over the budget-bounded scope lists: the first answer where
     # `Scope::ResolutionChain#settle` lets the chain stand, and otherwise the breadth-first order's.
+    #
+    # Issue #1698 — the path walk reads the project entries only: an RBS-only mixin's own ancestry is not on the
+    # chain, so the rung that reads such a mixin also stops behind it ({.mixin_ancestry_stop?}), and this
+    # walk keeps the answer it gave before.
     def bounded_agreed_hit(class_name, scope, &)
       scopes, chain = ancestor_constant_worlds(class_name, scope)
-      owner, hit = first_ancestor_hit(bounded(scopes), &)
+      owner, hit = first_ancestor_hit(bounded(project_scopes(scopes, scope)), &)
       verdict = chain.settle(scope, owner, owner: owner) do |retro|
-        first_ancestor_hit(bounded(constant_scopes_of(retro, class_name)), &)&.first
+        first_ancestor_hit(bounded(project_scopes(constant_scopes_of(retro, class_name, scope), scope)), &)&.first
       end
       return hit if verdict == :chain
 
@@ -130,6 +134,13 @@ module Rigor
     end
     private_class_method :bounded_agreed_hit
 
+    def project_scopes(scopes, scope)
+      return scopes if scopes.all? { |name| known_project_namespace?(name, scope) }
+
+      scopes.select { |name| known_project_namespace?(name, scope) }
+    end
+    private_class_method :project_scopes
+
     # How many of {.ancestor_constant_scopes}' entries one segment may consult, under
     # `Scope::ANCESTOR_WALK_LIMIT` — the budget `Scope`'s method lookup already spends on this same
     # graph, reused rather than re-chosen so one pathological ancestry costs one bound. The list

data/lib/rigor/reflection.rb

@@ -50,6 +50,11 @@ module Rigor
     WRITTEN_CANDIDATE = Object.new.freeze
     private_constant :WRITTEN_CANDIDATE
 
+    # Issue #1698 — what the constant ladder's ancestor rung answers where an entry's RBS ancestry may
+    # own the name ({.mixin_ancestry_stop?}). Never a type: {.lexical_constant_type} replaces it.
+    MIXIN_ANCESTRY_STOP = Object.new.freeze
+    private_constant :MIXIN_ANCESTRY_STOP
+
     module_function
 
     def class_known?(class_name, scope: Scope.empty)
@@ -197,10 +202,19 @@ module Rigor
       # `P::A < P::Base` is `P::Base::B`, and step 3's `A::B` is a real but different class.
       #
       # Step 3 — the bare name (top level). It takes no `shadows`: nothing sits below it for a stop to replace.
-      first_constant_hit(lexical_nesting_chain(scope), name, scope, shadows) ||
-        ancestor_constant_type(name, scope, enclosing_class_path(scope), shadows) ||
-        constant_path_type(name, scope, shadows: shadows) ||
-        constant_type_at(name, scope)
+      #
+      # Issue #1698 — step 2 answers {MIXIN_ANCESTRY_STOP} where an RBS-only mixin's own ancestry may own the name
+      # ({.mixin_ancestry_stop?}). Ruby reads that ancestry before any later ancestor or the top level, and
+      # the chain does not list it, so a lower rung's answer is replaced by `Dynamic[top]`, as #1290's stop is.
+      lexical = first_constant_hit(lexical_nesting_chain(scope), name, scope, shadows)
+      return lexical if lexical
+
+      ancestor = ancestor_constant_type(name, scope, enclosing_class_path(scope), shadows)
+      stopped = ancestor.equal?(MIXIN_ANCESTRY_STOP)
+      return ancestor if ancestor && !stopped
+
+      below = constant_path_type(name, scope, shadows: shadows) || constant_type_at(name, scope)
+      stopped && below ? Type::Combinator.untyped : below
     end
     private_class_method :lexical_constant_type
 
@@ -216,11 +230,28 @@ module Rigor
     end
     private_class_method :first_constant_hit
 
-    # Step 2's rung on its own: nil when there is no enclosing class path to take ancestors of.
+    # Step 2's rung on its own: nil when there is no enclosing class path to take ancestors of, and
+    # {MIXIN_ANCESTRY_STOP} where an RBS-only mixin's ancestry may own the name.
+    #
+    # Issue #1698 — an entry that stands for an RBS-only mixin ({.external_constant_owner}) is skipped where `self`
+    # is a class object: a `class << self` body and a `def` in it run under the singleton class's cref, whose
+    # ancestors are not the class's ([#1305](https://github.com/rigortype/rigor/issues/1305)), and the scope does
+    # not tell such a body from a `def self.m` or the class body. Skipping keeps the answer this rung gave before
+    # #1698 there.
     def ancestor_constant_type(name, scope, prefix, shadows)
       return nil if prefix.nil? || prefix.empty?
 
-      agreed_ancestor_hit(prefix, scope) { |entry| constant_type_at("#{entry}::#{name}", scope, shadows) }
+      class_object_self = scope.self_type.is_a?(Type::Singleton)
+      agreed_ancestor_hit(prefix, scope) do |entry|
+        external = !known_project_namespace?(entry, scope)
+        next nil if external && (class_object_self || ancestry_unknown_before?(prefix, entry, scope))
+
+        candidate = ->(owner) { constant_type_at("#{owner}::#{name}", scope, shadows) }
+        hit = candidate.call(entry)
+        next hit if hit
+
+        MIXIN_ANCESTRY_STOP if mixin_ancestry_stop?(entry, scope, external, &candidate)
+      end
     end
     private_class_method :ancestor_constant_type
 
@@ -264,8 +295,9 @@ module Rigor
       prefix = enclosing_class_path(scope)
       return nil if prefix.nil? || prefix.empty?
 
-      first_constant_hit(peeled_nesting(prefix), name, scope, shadows) ||
-        ancestor_constant_type(name, scope, prefix, shadows)
+      hit = first_constant_hit(peeled_nesting(prefix), name, scope, shadows) ||
+            ancestor_constant_type(name, scope, prefix, shadows)
+      hit.equal?(MIXIN_ANCESTRY_STOP) ? nil : hit
     end
     private_class_method :caller_derived_constant_type