rigortype 0.4.1 → 0.4.2

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

@@ -53,16 +53,37 @@ 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`).
+    def build(configuration:, source_files:, feature_sources: {})
+      features = required_features(configuration, source_files, sources: feature_sources)
       Environment.for_project(
         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
+
+    # 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 +137,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

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

data/lib/rigor/scope/discovery_index.rb

@@ -51,6 +51,7 @@ module Rigor
       :clears_last_status,
       :defines_case_equality,
       :implicit_self_evidence,
+      :in_effect_refinements,
       :possible_discovered_methods,
       :possible_discovered_deferred_ranges,
       :contested_discovered_def_nodes,
@@ -155,6 +156,7 @@ module Rigor
           patched_line_readers: "the gets / readline names the file defines through the define_method family",
           clears_last_status: "whether the analysed file holds a call that may set $? to nil",
           defines_case_equality: "whether the analysed file holds a define_method naming ===",
+          in_effect_refinements: "the file's ordered in-effect refinements; built lazily from its tree, never seeded",
           implicit_self_evidence: "where the file's implicit-self readers sit; built lazily from its tree, never seeded"
         }.freeze,
         run_state: {
@@ -217,12 +219,36 @@ module Rigor
       # - {ENVELOPE_REFINED_MARK}: a `refine` block refines the class, which redefines its methods wherever a `using`
       #   is in effect. Issue #1367 splits it from {ENVELOPE_DYNAMIC_MARK}, which it used to share: an implicit
       #   conversion (`to_str`, `to_int`) ignores a refinement, so the `global.*` rules must tell the two apart.
-      #   Every reader that asks whether a surface is rewritten reads both ({.rewritten_surface?}).
+      #   The readers that ask whether a surface is rewritten read both ({.rewritten_surface?}), except
+      #   `call.wrong-arity`'s source envelope (`CheckRules::SourceArity`), which leaves a refinement to the per-call
+      #   decline that knows the name and the `using` (issue #1797).
+      # Issue #1820 — the kind of a `[ENVELOPE_REMOVED_KIND, method_name]` bucket entry: the project removes the name
+      # from the class with a literal `undef`, `remove_method` or `undef_method`, whichever side. A removal is not
+      # otherwise distinguishable from an `attr_*` or `define_method`, whose envelope is opaque too, and the
+      # refinement own-definer proof must not take a removed method as the one Ruby finds.
+      ENVELOPE_REMOVED_KIND = :removed
+      # Issue #1820 — a `K = Class.new(Parent)` constant write: the class's superclass is not in the superclass table
+      # (the meta-new walk does not route `Parent` through ancestor discovery), so a reader that must place `K` in a
+      # hierarchy reads its superclass as unknown, as it reads the `nil` the table records for `class K < <expr>`.
+      ENVELOPE_META_SUPERCLASS_MARK = :"<meta-superclass>"
       ENVELOPE_MODULE_MARK = :"<module>"
       ENVELOPE_DYNAMIC_MARK = :"<dynamic>"
       ENVELOPE_OBJECT_EXTENDED_MARK = :"<object-extended>"
       ENVELOPE_REFINED_MARK = :"<refined>"
 
+      # Issue #1820 — whether an envelope bucket says the project declares, or rewrites, the name's method table: a
+      # per-method entry, the {ENVELOPE_MODULE_MARK} a `module` declaration records, or the {ENVELOPE_DYNAMIC_MARK}
+      # (`Comparable.module_eval { define_method(computed) }` gives a module a method no table names, so a reader
+      # must keep it on its chain rather than read RBS's surface for it). A bucket that holds only the refined,
+      # object-extended or meta-superclass marks is evidence about a name the project may only mention, such as
+      # `Comparable` in `x.singleton_class.prepend(Comparable)`.
+      DECLARING_MARKS = [ENVELOPE_MODULE_MARK, ENVELOPE_DYNAMIC_MARK].freeze
+      private_constant :DECLARING_MARKS
+
+      def self.declares_surface?(bucket)
+        !bucket.nil? && bucket.any? { |key, _| !key.is_a?(Symbol) || DECLARING_MARKS.include?(key) }
+      end
+
       # Whether an envelope bucket says the project rewrites the class's method table beyond its literal names: a
       # dynamic rewrite, or a refinement.
       def self.rewritten_surface?(bucket)
@@ -236,6 +262,14 @@ module Rigor
       # present. Not a constant character, so no class can be named it.
       ENVELOPE_PROJECT_WIDE = "<project-wide>"
 
+      # ADR-121 WD7 (issues #1796, #1799) — the wildcard of `discovered_refinements`, standing for what the walk could
+      # not read. As a refined-class key it is a class the walk cannot name (`refine(k)`, `refine(self)`); as a method
+      # key, names a refine body defines that the walk cannot enumerate (`import_methods`, a computed
+      # `define_method`); as a refining module, a module the walk cannot name (a `refine` in an instance method,
+      # which any module extending it may run). `{"*" => {"*" => [M]}}` makes `M` opaque: some `refine` of `M` is
+      # unreadable. No constant can be named `*`, and method keys are Symbols, so neither axis collides.
+      REFINEMENT_WILDCARD = "*"
+
       # The shared all-empty index `Scope.empty` (and every scope that never sees a seeding pass) points at — one
       # allocation per process.
       EMPTY = new(
@@ -417,6 +451,11 @@ module Rigor
         # them by. Filled by `Inference::ScopeIndexer.index` from the file's own tree only; nil, where no file was
         # indexed, declines every such reader.
         implicit_self_evidence: nil,
+        # Issue #1673 (ADR-121 WD1) — the file's in-effect refinements (`Inference::InEffectRefinements`, walked on the
+        # first ask), which `Scope#in_effect_refinements` reads for the typer and the check rules read off the root's
+        # scope. Filled by `Inference::ScopeIndexer.index` from the file's own tree only; nil, where no file was
+        # indexed, answers no lexical refinement.
+        in_effect_refinements: nil,
         # ADR-119 WD1 — the siblings of the members {SIBLINGS} pairs, empty until a producer admits a possible fact.
         possible_discovered_methods: EMPTY_TABLE,
         possible_discovered_deferred_ranges: EMPTY_TABLE,