rigortype 0.4.0 → 0.4.2

data/lib/rigor/reflection/constant_ancestors.rb

@@ -11,18 +11,29 @@ module Rigor
     ANCESTOR_SCOPES_KEY = :__rigor_ancestor_constant_scopes__
     private_constant :ANCESTOR_SCOPES_KEY
 
+    # The recording run's slot. See {.recorded_ancestor_constant_scopes}.
+    RECORDED_ANCESTOR_SCOPES_KEY = :__rigor_recorded_ancestor_constant_scopes__
+    private_constant :RECORDED_ANCESTOR_SCOPES_KEY
+
     module_function
 
     # #354 — the project classes and modules whose own constants `class_name` inherits, in Ruby's
-    # ancestor order: included / prepended modules before the superclass (Ruby places mixins nearer),
-    # transitively, breadth-first. `class_name` itself is excluded — step 1 already covered it.
+    # ancestor order: the entries of `class_name`'s `Scope::ResolutionChain` — prepended modules, then
+    # included ones, then the superclass's chain likewise — each once. `class_name` itself is excluded:
+    # step 1 already covered it.
+    #
+    # Issue #1571 — this was a breadth-first walk of its own, which is not Ruby's order: `class C < Base;
+    # include A` with `A` including `M` reached `Base::X` (depth 1) before `M::X` (depth 2), while Ruby's
+    # 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. `Scope#superclass_of` / `#includes_of` carry as-written names
-    # from the discovery pre-pass, and an as-written name that resolves to no discovered class or
-    # module is dropped — so a `class Foo < ActiveRecord::Base` contributes nothing 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
@@ -30,11 +41,49 @@ module Rigor
     # back to the per-file discovery table for runner-less scopes, so a re-run in one process (LSP,
     # ADR-62 warm loop) cannot hit stale entries.
     def ancestor_constant_scopes(class_name, scope)
-      # ADR-46: `superclass_of` / `includes_of` record a cross-file class dependency per consumer
-      # file, and the memo is run-scoped rather than file-scoped — a hit would skip the recording and
-      # under-record the edge for every later file. Recording runs are rare (incremental only), so
-      # they simply bypass the memo rather than complicate its key.
-      return compute_ancestor_constant_scopes(class_name, scope) if Analysis::DependencyRecorder.active?
+      ancestor_constant_worlds(class_name, scope).first
+    end
+    private_class_method :ancestor_constant_scopes
+
+    # ADR-24 / #1570 — the first ancestor that owns a constant, asked as {.ancestor_constant_scopes} orders
+    # them and settled by `Scope::ResolutionChain#settle`: the block's first truthy answer where the chain
+    # stands, and otherwise the answer of the breadth-first order this rung used before the chain
+    # (`Scope::ResolutionChain::MasterOrder`) — where a skipped `include` would put a different owner first,
+    # which constant Ruby reads depends on the order the bodies ran.
+    def agreed_ancestor_hit(class_name, scope, &)
+      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, scope), &)&.first
+      end
+      return hit if verdict == :chain
+
+      first_ancestor_hit(master_constant_scopes(class_name, scope), &)&.last
+    end
+    private_class_method :agreed_ancestor_hit
+
+    def master_constant_scopes(class_name, scope)
+      Scope::ResolutionChain::MasterOrder.breadth_first(scope, class_name.to_s, :constants)
+    end
+    private_class_method :master_constant_scopes
+
+    def first_ancestor_hit(entries)
+      entries.each do |entry|
+        hit = yield entry
+        return [entry, hit] if hit
+      end
+      nil
+    end
+    private_class_method :first_ancestor_hit
+
+    # `[scopes, chain]` — {.ancestor_constant_scopes} and the chain they were read from, which settles the
+    # answer.
+    def ancestor_constant_worlds(class_name, scope)
+      # ADR-46: the answer depends on every class on the chain, and the memo is run-scoped rather than
+      # file-scoped — a hit would skip the recording and under-record the edge for every later file. A
+      # recording run reads the chain, which is memoised per discovery index, and files its edges on
+      # every call.
+      return recorded_ancestor_constant_scopes(class_name, scope) if Analysis::DependencyRecorder.active?
 
       generation = scope.run_generation || scope.discovered_superclasses
       slot = Thread.current[ANCESTOR_SCOPES_KEY]
@@ -45,48 +94,164 @@ module Rigor
       bucket = slot[1]
       bucket.fetch(class_name) { bucket[class_name] = compute_ancestor_constant_scopes(class_name, scope) }
     end
-    private_class_method :ancestor_constant_scopes
+    private_class_method :ancestor_constant_worlds
+
+    # The recording run's memo. The answer is every project entry of the chain, so its edges are the
+    # root's and every entry's — what `Scope::ResolutionChain#record` files, which a computation does and a
+    # hit replays, in the same order. One slot keyed on the discovery index: the answer and the edges are
+    # both read from it, so the key is exact, and the slot never pins more than the index it serves.
+    def recorded_ancestor_constant_scopes(class_name, scope)
+      discovery = scope.discovery
+      slot = Thread.current[RECORDED_ANCESTOR_SCOPES_KEY]
+      unless slot && slot[0].equal?(discovery)
+        slot = [discovery, {}]
+        Thread.current[RECORDED_ANCESTOR_SCOPES_KEY] = slot
+      end
+      bucket = slot[1]
+      worlds = bucket[class_name]
+      return bucket[class_name] = compute_ancestor_constant_scopes(class_name, scope) if worlds.nil?
+
+      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
 
+    # Reads the chain whole, so a recording run files every class on it (a no-op otherwise).
     def compute_ancestor_constant_scopes(class_name, scope)
-      queue = [class_name]
-      seen = { class_name => true }
+      chain = Scope::ResolutionChain.for(scope, class_name.to_s, :instance, :constants)
+      chain.record(scope)
+      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, 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 = []
-      until queue.empty?
-        current = queue.shift
-        # Mixins first, then the superclass — Ruby's ancestor order.
-        scope.includes_of(current).each do |raw|
-          resolved = resolve_ancestor_name(current, raw, scope)
-          next if resolved.nil? || seen[resolved]
-
-          seen[resolved] = true
-          out << resolved
-          queue << resolved
-        end
-        raw_super = scope.superclass_of(current)
-        next if raw_super.nil?
-
-        resolved_super = resolve_ancestor_name(current, raw_super, scope)
-        next if resolved_super.nil? || seen[resolved_super]
-
-        seen[resolved_super] = true
-        out << resolved_super
-        queue << resolved_super
+      chain.entries.each do |entry|
+        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 :compute_ancestor_constant_scopes
+    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
 
-    # Resolves an ancestor name AS WRITTEN (`"Base"`, or a qualified `"A::B"`) against the nesting in
-    # force where the subclass's header is written — `Scope#ancestor_name_candidates`, the single
-    # owner of that order, which `Scope#enqueue_ancestors` reads for method lookup and the
-    # override-visibility rule reads for its own walk. Returns nil when no candidate names a
-    # discovered project class or module.
-    def resolve_ancestor_name(subclass_qualified, raw, scope)
-      scope.ancestor_name_candidates(subclass_qualified, raw)
-           .find { |candidate| known_project_namespace?(candidate, scope) }
+    # 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 :resolve_ancestor_name
+    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)
       scope.discovered_superclasses.key?(name) ||
         scope.discovered_includes.key?(name) ||

data/lib/rigor/reflection/constant_path.rb

@@ -81,7 +81,10 @@ module Rigor
 
       prefix = caller_derived ? enclosing_class_path(scope) : nil
       unless prefix.nil? || prefix.empty?
-        hit = first_namespace_hit(bounded_ancestor_scopes(prefix, scope), head, scope)
+        hit = bounded_agreed_hit(prefix, scope) do |entry|
+          candidate = "#{entry}::#{head}"
+          candidate if namespace_known?(candidate, scope)
+        end
         return hit if hit
       end
 
@@ -106,28 +109,51 @@ module Rigor
       candidate = "#{owner}::#{segment}"
       return candidate if yield(candidate)
 
-      bounded_ancestor_scopes(owner, scope).each do |ancestor|
+      bounded_agreed_hit(owner, scope) do |ancestor|
         inherited = "#{ancestor}::#{segment}"
-        return inherited if yield(inherited)
+        inherited if yield(inherited)
       end
-      nil
     end
     private_class_method :constant_in_namespace
 
+    # {.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(project_scopes(scopes, scope)), &)
+      verdict = chain.settle(scope, owner, owner: owner) do |retro|
+        first_ancestor_hit(bounded(project_scopes(constant_scopes_of(retro, class_name, scope), scope)), &)&.first
+      end
+      return hit if verdict == :chain
+
+      first_ancestor_hit(bounded(master_constant_scopes(class_name, scope)), &)&.last
+    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
     # itself is the memoised one step 2 builds, so this bounds the per-segment consultation the walk
     # adds and not the graph. Reported through the shared counter, so a truncated walk is visible in a
     # budget trace instead of looking like a plain miss.
-    def bounded_ancestor_scopes(class_name, scope)
-      scopes = ancestor_constant_scopes(class_name, scope)
+    def bounded(scopes)
       return scopes if scopes.size <= Scope::ANCESTOR_WALK_LIMIT
 
       Inference::BudgetTrace.hit(Inference::BudgetTrace::ANCESTOR_WALK_LIMIT)
       scopes.first(Scope::ANCESTOR_WALK_LIMIT)
     end
-    private_class_method :bounded_ancestor_scopes
+    private_class_method :bounded
 
     # Whether `name` can OWN a constant. `class_known?` covers the RBS and registry classes and modules;
     # the project tables cover a namespace the project declares with no RBS for it.

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?
 
-      first_constant_hit(ancestor_constant_scopes(prefix, scope), 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
 
@@ -322,8 +354,7 @@ module Rigor
     # ({Analysis::Incremental.changed_constant_publications}). Gated by the caller on the recorder being
     # active, so an ordinary run pays one integer read.
     def record_constant_reference(name)
-      segment = name.delete_prefix("::").split("::").last
-      Analysis::DependencyRecorder.read_name(:constant, segment) if segment
+      Analysis::DependencyRecorder.read_last_segment(:constant, name)
     end
     private_class_method :record_constant_reference