rigortype 0.3.6 → 0.3.8

data/lib/rigor/reflection.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "type"
+require_relative "analysis/dependency_recorder"
 
 module Rigor
   # Read-side facade over Rigor's three reflection sources:
@@ -76,6 +77,21 @@ module Rigor
       loader.class_known?(class_name)
     end
 
+    # Issue #735 — true when the class's RBS declaration is the PROJECT's own (a file under
+    # `signature_paths:`) rather than bundled core / stdlib / gem RBS. The two carry different authority:
+    # a bundled signature describes a class the project does not own, so a project `def` on it is the
+    # ADR-17 monkey-patch the analyzer reports; a project sidecar describes the very source being
+    # analysed, and a `def` in another of the project's files is that class's own definition.
+    #
+    # False whenever the question cannot be answered (no loader, no environment, an environment cached
+    # before #725 preserved buffer names), which is the pre-#735 reading in every case.
+    def project_declared_class?(class_name, scope: nil, environment: nil)
+      loader = rbs_loader_for(scope, environment)
+      return false if loader.nil?
+
+      loader.project_declared_class?(class_name)
+    end
+
     # @return [Symbol] one of `:equal`, `:subclass`, `:superclass`,
     #   `:disjoint`, `:unknown`.
     def class_ordering(lhs, rhs, scope: Scope.empty)
@@ -118,22 +134,35 @@ module Rigor
     # RBS because the user's source is authoritative for its own constants. Returns the matched
     # `Rigor::Type`, or nil when no source knows the constant.
     #
+    # `rooted:` reports that the reference was written with a leading `::` (`::Foo`,
+    # `::Foo::Bar`). Ruby's absolute form names the TOP-LEVEL constant unconditionally, so the
+    # lexical ladder (steps 1 and 2) MUST be skipped and only the bare candidate consulted. The
+    # name itself stays un-rooted — every discovered-constant table is keyed that way — so the
+    # marker travels beside it rather than inside it (#614). When no top-level constant answers,
+    # the result is nil exactly as for an unknown constant: a lexically nearer shadow is never the
+    # answer to `::Foo`, and falling back to it was the bug (`::Rails` inside `module MyApp` typed
+    # as `MyApp::Rails`).
+    #
     # This is the shared owner of the lexical-constant resolution: `Inference::ExpressionTyper`
     # reads it to type a constant read, and `Inference::Narrowing` reads it to recognise a
     # value-pinned `Constant[Regexp]` match-predicate operand.
-    def resolve_constant_type(name, scope: Scope.empty)
-      prefix = enclosing_class_path(scope)
+    def resolve_constant_type(name, scope: Scope.empty, rooted: false)
+      # Issue #644 — the ADR-46 name edge, recorded ONCE PER REFERENCE and BEFORE the ladder, so it does not
+      # depend on which resolver answers. A reference that resolves through RBS (`Math::PI`) or through the
+      # class registry is exactly as dependent on the project's constant write set as one that resolves
+      # through `in_source_constants`: a project file that later assigns the name wins over the RBS answer,
+      # and without this edge the reader keeps serving the pre-assignment type. That staleness is NEW with
+      # the cross-file publication — before it, a project value write never won at a reader, so nothing could
+      # go stale. Over-recording is ADR-46's safe direction.
+      record_constant_reference(name) if Analysis::DependencyRecorder.active?
+      return constant_type_at(name, scope) if rooted
+      # Issue #716 — a body whose `Module.nesting` was RECORDED EMPTY is definitively top level, and Ruby
+      # resolves its constants there no matter which namespace calls it. Steps 1 and 2 both derive from the
+      # caller and are both wrong for it, so it takes its own ladder.
+      return toplevel_first_constant_type(name, scope) if recorded_toplevel_nesting?(scope)
 
       # Step 1 — `Module.nesting`, innermost first. Each entry contributes only its OWN constants.
-      walker = prefix
-      while walker && !walker.empty?
-        hit = constant_type_at("#{walker}::#{name}", scope)
-        return hit if hit
-
-        idx = walker.rindex("::")
-        walker = idx ? walker[0, idx] : nil
-      end
-
+      #
       # Step 2 (#354) — the ancestors of the innermost cresting scope, which Ruby consults BEFORE
       # falling back to the top level. Skipping this step did not merely lose a resolution: when the
       # same name also exists at top level, step 3 answered a lookup Ruby gives to the ancestor, so
@@ -141,16 +170,67 @@ module Rigor
       # wrong type on correct code, which outranks any worst-case reading (AGENTS.md
       # § "Implementation Guidelines"). Only project ancestors are walked; an RBS-known superclass
       # contributes no name here (see {.ancestor_constant_scopes}).
-      if prefix
-        ancestor_constant_scopes(prefix, scope).each do |ancestor|
-          hit = constant_type_at("#{ancestor}::#{name}", scope)
-          return hit if hit
-        end
+      #
+      # Step 3 — the bare name (top level).
+      first_constant_hit(lexical_nesting_chain(scope), name, scope) ||
+        ancestor_constant_type(name, scope, enclosing_class_path(scope)) ||
+        constant_type_at(name, scope)
+    end
+
+    # The first candidate `<entry>::<name>` any source knows, walking `entries` in order, or nil. The one
+    # place a qualifying prefix is joined to a name, so every rung of the ladder consults its candidates
+    # identically.
+    def first_constant_hit(entries, name, scope)
+      entries.each do |entry|
+        hit = constant_type_at("#{entry}::#{name}", scope)
+        return hit if hit
       end
+      nil
+    end
+    private_class_method :first_constant_hit
 
-      # Step 3 — the bare name (top level).
-      constant_type_at(name, scope)
+    # Step 2's rung on its own: nil when there is no enclosing class path to take ancestors of.
+    def ancestor_constant_type(name, scope, prefix)
+      return nil if prefix.nil? || prefix.empty?
+
+      first_constant_hit(ancestor_constant_scopes(prefix, scope), name, scope)
     end
+    private_class_method :ancestor_constant_type
+
+    # Issue #716 — whether the scope carries a RECORDED empty `Module.nesting`, which is the declaration
+    # walk's positive statement that the body is written at the top level (`Inference::ScopeIndexer#
+    # walk_def_nestings`). Distinct from `nil`, which still means "no declaration walk built this scope" and
+    # keeps the peel ({.lexical_nesting_chain}); the two are only distinguishable because the table is
+    # populated by that walk alone.
+    def recorded_toplevel_nesting?(scope) = scope.lexical_nesting.is_a?(Array) && scope.lexical_nesting.empty?
+    private_class_method :recorded_toplevel_nesting?
+
+    # Issue #716 — the ladder for a top-level body: the top level FIRST, then the caller-derived rungs
+    # unchanged. The candidate SET is exactly what {.resolve_constant_type}'s three steps consult for the
+    # same scope — only the order moves — so no read that resolves today stops resolving, and any read where
+    # the two disagree is one where the top level is Ruby's answer and the caller's namespace never was.
+    #
+    # Keeping the caller-derived rungs at all is deliberate and unsound against Ruby: they cover reads whose
+    # name exists ONLY under some namespace, where Ruby raises `NameError` (486 such reads on gitlab, 33 on
+    # dependabot-core — `docs/notes/20260905-toplevel-def-cref-movable-sites.md`). Rigor reports nothing
+    # about them either way, so retracting them would trade a silent wrong answer for a silent absent one at
+    # no gain. Making them FIRE is a separate question with its own false-positive budget.
+    def toplevel_first_constant_type(name, scope)
+      constant_type_at(name, scope) || caller_derived_constant_type(name, scope)
+    end
+    private_class_method :toplevel_first_constant_type
+
+    # The peel and its ancestors — {.resolve_constant_type}'s steps 1 and 2 as they answer for a scope with
+    # no recorded chain, factored out so the top-level ladder above can consult them BELOW the top level
+    # instead of above it.
+    def caller_derived_constant_type(name, scope)
+      prefix = enclosing_class_path(scope)
+      return nil if prefix.nil? || prefix.empty?
+
+      first_constant_hit(peeled_nesting(prefix), name, scope) ||
+        ancestor_constant_type(name, scope, prefix)
+    end
+    private_class_method :caller_derived_constant_type
 
     # One candidate name, consulted in source-precedence order: the class registry (yielding a
     # `Singleton[C]`), source-discovered classes, in-source value constants, then RBS-side
@@ -166,12 +246,27 @@ module Rigor
       return in_source_class if in_source_class
 
       in_source_value = scope.in_source_constants[candidate]
-      return in_source_value if in_source_value
+      if in_source_value
+        scope.record_constant_dependency(candidate) if Analysis::DependencyRecorder.active?
+        return in_source_value
+      end
 
       env.constant_for_name(candidate)
     end
     private_class_method :constant_type_at
 
+    # Issue #644 — the load-bearing ADR-46 edge for a constant reference: `constant:<last segment>`, keyed on
+    # the NAME rather than on a file. The published value is a function of the whole project's write set for
+    # the name, so it moves when a SECOND file starts or stops assigning it — a file this reader has no other
+    # relationship with, and which no positive edge could reach. Matched against the publication diff
+    # ({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
+    end
+    private_class_method :record_constant_reference
+
     # #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.
@@ -235,17 +330,14 @@ module Rigor
     end
     private_class_method :compute_ancestor_constant_scopes
 
-    # Resolves an ancestor name AS WRITTEN (`"Base"`, or a qualified `"A::B"`) against the
-    # subclass's lexical nesting, innermost first — the same walk
-    # `ExpressionTyper#compute_ancestor_class_name` performs for method lookup. Returns nil when no
-    # candidate names a discovered project class or module.
+    # 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)
-      segments = subclass_qualified.split("::")
-      (segments.length - 1).downto(0) do |i|
-        candidate = (segments[0, i] + [raw]).join("::")
-        return candidate if known_project_namespace?(candidate, scope)
-      end
-      nil
+      scope.ancestor_name_candidates(subclass_qualified, raw)
+           .find { |candidate| known_project_namespace?(candidate, scope) }
     end
     private_class_method :resolve_ancestor_name
 
@@ -266,6 +358,49 @@ module Rigor
     end
     private_class_method :enclosing_class_path
 
+    # Ruby's `Module.nesting` for the body `scope` sits in, innermost first — the chain step 1 of
+    # {.resolve_constant_type} walks, and the chain `Inference::Narrowing` walks to resolve a class-guard
+    # name. The single owner of the question, so a constant read and the `is_a?` / `case`-`when` / `===`
+    # guard over the same spelling cannot disagree about which constant it names.
+    #
+    # The chain the analyzer RECORDED at declaration time wins ({Scope#with_lexical_nesting}). It is not
+    # recoverable from `self_type`: `class Admin::UsersController` and `module Admin; class
+    # UsersController` produce the identical `class_name`, while Ruby's nesting is
+    # `[Admin::UsersController]` for the first and `[Admin::UsersController, Admin]` for the second — so a
+    # bare `User` in the compact form names `::User`, and peeling the name reached `Admin::User` and
+    # reported `undefined method` on correct code ([#652](https://github.com/rigortype/rigor/issues/652)).
+    #
+    # The peel survives only as the FALLBACK, for a scope no declaration walk built (a callee body
+    # re-entered through `Scope#evaluate`, a plugin-constructed scope). A `class << expr` body is NOT
+    # one of them — not even `class << SomeOtherConstant`, whose class-frame stack the evaluator
+    # resets: the body inherits the enclosing chain, because Ruby pushes no `Module.nesting` entry
+    # there either. Answering an empty chain there would retract resolutions the
+    # engine makes today and turn correct code into `Dynamic`; a stale-but-gradual rung costs precision
+    # only, which is the direction AGENTS.md § "Implementation Guidelines" mandates.
+    #
+    # Issue #716 — the recorded value is three-valued, and a RECORDED `[]` is not the absence of one: it is
+    # the declaration walk saying "top level", and this returns it verbatim so `Module.nesting` reads what
+    # Ruby reads. {.resolve_constant_type} keeps the peel for that case as a rung BELOW the top level rather
+    # than through this reader, because a chain is not where an out-of-order fallback belongs.
+    def lexical_nesting_chain(scope)
+      recorded = scope.lexical_nesting
+      return recorded if recorded
+
+      base = enclosing_class_path(scope)
+      return [] if base.nil? || base.empty?
+
+      peeled_nesting(base)
+    end
+
+    # The peel itself: a qualified name split into the chain the NESTED spelling would have produced
+    # (`"Admin::Users::Show"` → `["Admin::Users::Show", "Admin::Users", "Admin"]`). Shared by the fallback
+    # above and by issue #716's below-the-top-level rung, so the two cannot drift apart.
+    def peeled_nesting(base)
+      parts = base.split("::")
+      parts.each_index.map { |i| parts[0..-(i + 1)].join("::") }
+    end
+    private_class_method :peeled_nesting
+
     # Returns the RBS `RBS::Definition::Method` for the instance method, or nil when the
     # class or method is not in RBS. The source-side discovered-method facts are reachable
     # through {.discovered_method?}; a future slice will unify the two under a
@@ -340,8 +475,25 @@ module Rigor
     # @param kind [:instance, :singleton]
     # @return [Boolean] true when the ScopeIndexer recorded a `def` for the given method on
     #   the given class with the matching kind.
+    #
+    # ADR-46 — a MISS records a negative cross-file dependency, so a consumer whose analysis
+    # turned on "the project does not define this method" is re-checked once a later edit
+    # defines it. The engine's own dispatch gets that edge from
+    # `Scope#record_cross_file_method`, but this facade is what a PLUGIN gate reads, and a
+    # contribution tier answers before dispatch reaches the engine's recording accessors —
+    # rigor-railties declines its `Rails.logger` typing exactly on this probe. Without the
+    # edge a warm `--incremental` run kept serving the plugin's answer after the project
+    # added `def self.logger`. The key grammar is the one `IncrementalSession#negative_key_for`
+    # inverts against (`Class#method` instance-side, `Class.method` singleton-side), which is
+    # also what `Incremental.appeared_symbols` emits for a newly-defined method.
     def discovered_method?(class_name, method_name, kind: :instance, scope: Scope.empty)
-      scope.discovered_method?(class_name, method_name, kind)
+      return true if scope.discovered_method?(class_name, method_name, kind)
+
+      if Analysis::DependencyRecorder.active?
+        symbol = "#{class_name}#{kind == :singleton ? '.' : '#'}#{method_name}"
+        Analysis::DependencyRecorder.read_missing(:method, symbol)
+      end
+      false
     end
   end
 end

data/lib/rigor/scope/discovery_index.rb

@@ -19,13 +19,18 @@ module Rigor
       :in_source_constants,
       :discovered_methods,
       :discovered_def_nodes,
+      :discovered_def_nestings,
       :discovered_singleton_def_nodes,
       :discovered_def_sources,
       :discovered_singleton_def_sources,
       :discovered_method_visibilities,
       :discovered_superclasses,
+      :discovered_header_nestings,
       :discovered_includes,
       :discovered_class_sources,
+      :constant_sources,
+      :published_constant_names,
+      :local_constant_names,
       :data_member_layouts,
       :struct_member_layouts,
       :param_inferred_types,
@@ -35,7 +40,8 @@ module Rigor
     class DiscoveryIndex
       EMPTY_NODE_TABLE = {}.compare_by_identity.freeze
       EMPTY_TABLE = {}.freeze
-      private_constant :EMPTY_NODE_TABLE, :EMPTY_TABLE
+      EMPTY_NAME_SET = Set.new.freeze
+      private_constant :EMPTY_NODE_TABLE, :EMPTY_TABLE, :EMPTY_NAME_SET
 
       # The third value a `discovered_methods` entry can hold, beside `:instance` and `:singleton`. One name may
       # legitimately be defined on both sides of the same class (`def helper` plus a `class << self` twin), and the
@@ -57,13 +63,45 @@ module Rigor
         in_source_constants: EMPTY_TABLE,
         discovered_methods: EMPTY_TABLE,
         discovered_def_nodes: EMPTY_TABLE,
+        # Issue #681 — `{Prism::DefNode => Module.nesting}` for every `def` the declaration walk reaches,
+        # recorded by `Inference::ScopeIndexer` where the declaration is indexed. Read by
+        # `Inference::ExpressionTyper#build_user_method_body_scope`, which rebuilds a callee's body scope
+        # from the receiver's type alone and so has no prefix of its own to derive one from. Keyed by node
+        # IDENTITY, because an inherited body is re-walked with the subclass as receiver while its
+        # constants resolve under the declaration that owns it.
+        #
+        # Issue #716 — PRESENT with `[]` and ABSENT are different facts, and only this table can tell them
+        # apart: it is populated by the declaration walk alone, so `[]` means "walked, and written at the top
+        # level" (Ruby's `Module.nesting` there) while an absent entry still means "not recorded" and
+        # `Reflection.lexical_nesting_chain` keeps its peel fallback for it.
+        discovered_def_nestings: EMPTY_NODE_TABLE,
         discovered_singleton_def_nodes: EMPTY_TABLE,
         discovered_def_sources: EMPTY_TABLE,
         discovered_singleton_def_sources: EMPTY_TABLE,
         discovered_method_visibilities: EMPTY_TABLE,
         discovered_superclasses: EMPTY_TABLE,
+        # Issue #682 — `{qualified class name => Module.nesting where its declaration HEADER is written}`,
+        # innermost first and EXCLUDING the declaration's own entry. Read by `Scope#ancestor_name_candidates`,
+        # which resolves a superclass / include name in that cref instead of peeling the subclass's qualified
+        # name — the peel is the nested spelling's answer, and it searched an `Admin::Base` that a compact
+        # `class Admin::Widget < Base` written at the top level never reaches. An absent entry means "not
+        # recorded" and keeps the peel, so a scope that never saw a declaration walk is unchanged.
+        discovered_header_nestings: EMPTY_TABLE,
         discovered_includes: EMPTY_TABLE,
         discovered_class_sources: EMPTY_TABLE,
+        # Issue #644 — `{qualified constant name => Set[declaring file]}`, the write attribution behind the
+        # cross-file value-constant table. Read only by `Scope#record_constant_dependency` during ADR-46
+        # dependency recording, so the runner seeds it only on a recording run; every other run leaves it
+        # empty and the edge costs one nil check.
+        constant_sources: EMPTY_TABLE,
+        # Issue #644 — the two halves of `Scope#published_constant?`, the question
+        # {Analysis::CheckRules::PublishedConstantGuard} asks. `published_constant_names` is the LAST
+        # SEGMENTS of the project-wide published table (run-wide, seeded by the runner);
+        # `local_constant_names` is the last segments the ANALYSED FILE itself assigns (per file, seeded by
+        # `ScopeIndexer.index`). A name in the first and not the second was declared somewhere the reader's
+        # author cannot see. Both empty outside a runner-seeded scope, which makes the guard a no-op there.
+        published_constant_names: EMPTY_NAME_SET,
+        local_constant_names: EMPTY_NAME_SET,
         data_member_layouts: EMPTY_TABLE,
         struct_member_layouts: EMPTY_TABLE,
         # ADR-67 WD3 — the call-site parameter-inference table, keyed by `[class_name, method_name, kind]` (the