rigortype 0.4.0 → 0.4.2

data/lib/rigor/analysis/check_rules/source_arity.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../reflection"
+require_relative "../../inference/definer_resolution"
 require_relative "../../source/parameter_envelope"
 
 module Rigor
@@ -14,9 +15,10 @@ module Rigor
       # Asked in two stages, because every condition past the first can only WITHHOLD a firing:
       #
       # 1. {#owner_envelope} walks the receiver's superclass chain to the first class whose own body, or one of
-      #    whose project mixins, records the name. Every record at that level must agree — `include` and
-      #    `prepend` share one table, so a mixin's definition may shadow the class's own — and none may be
-      #    opaque. A call that fits this envelope is silent, and nothing below is consulted.
+      #    whose project mixins, records the name. Every record at that level must agree — deliberately wider
+      #    than Ruby's order, so a mixin whose definition may shadow the class's own, or a load-order-dependent
+      #    pair (#986), declines instead of answering — and none may be opaque. A call that fits this envelope
+      #    is silent, and nothing below is consulted.
       # 2. {#authoritative?} runs only for a call that would fire. It declines when a `method_missing` /
       #    `respond_to_missing?` hook or a dynamic-surface mark sits anywhere in the chain; when a mixin the
       #    project does not declare is not a known RBS module that lacks the name; when a `pre_eval:` patch or
@@ -24,20 +26,45 @@ module Rigor
       #    project subclass of the receiver — whose instances the receiver's type admits — records a different
       #    or opaque envelope for it.
       #
+      # ADR-119 C1b / C2-c — on both sides stage 1 and the subclass check ask `Inference::DefinerResolution`, and a
+      # chain it declines (`UNKNOWN`) answers no envelope: where Ruby's order depends on a fact the tables cannot
+      # prove, the rule is silent instead of checking the call against master's order (#1570, #1607).
+      #
       # Deliberately NOT in scope: a constructor reached through `Class#new` (nothing records `initialize` as
       # `[:singleton, :new]`, so `.new` finds no owner unless the class writes `def self.new` itself); keyword
       # arity (the envelope's required-keyword flag declines, as `compute_arity_envelope` declines an RBS
       # function with required keywords); and a `class_eval` whose receiver is not a constant, which the
       # discovery walk cannot name.
-      class SourceArity
+      class SourceArity # rubocop:disable Metrics/ClassLength
         MISSING_HOOKS = %i[method_missing respond_to_missing?].freeze
         private_constant :MISSING_HOOKS
 
         # One class on the walk: its own name, the project modules its mixins resolve to (transitively through
         # their own `include`s), and the candidate-name lists of the mixins that resolve to no project module.
+        #
+        # Issue #1570 — the level is a SEGMENT of the receiver's `Scope::ResolutionChain` (`:arity` flavor): the
+        # class with the modules Ruby inserts around it before the superclass's entries begin. Ruby skips an
+        # `include` of a module the superclass chain already carries, so `class C < Base; include M` where
+        # `Base` includes `M` leaves `M` at `Base`'s level; collecting every module a class's own `include`s
+        # name put it at `C`'s level instead, where its `def` answered a call `Base#foo` receives.
         Level = Data.define(:class_name, :modules, :externals)
         private_constant :Level
 
+        # ADR-119 C1b — the answer of a level whose records are not one non-opaque envelope. It equals itself in
+        # every world, so two worlds that both reach such a level agree, and no envelope equals it.
+        AMBIGUOUS = Object.new.freeze
+        private_constant :AMBIGUOUS
+
+        # What `Inference::DefinerResolution` reads off a candidate: the answer, the entry that gave it, its
+        # position on the chain and its side. The same four readers as `DefinerResolution::Hit`, which a call site
+        # may not name (the case/in contract spec allows no other reference to the module).
+        ArityHit = Data.define(:answer, :owner, :index, :side)
+        private_constant :ArityHit
+
+        # A subclass level the walk cannot read: `subclasses_agree?` reads the nil as a decline.
+        NO_LEVELS = [nil].freeze
+        private_constant :NO_LEVELS
+
         def initialize(scope, method_name, kind)
           @scope = scope
           @method_name = method_name.to_sym
@@ -53,6 +80,7 @@ module Rigor
         def owner_envelope(class_name)
           @owner_entries = []
           @ambiguous = false
+          @unknown = false
           envelope, @withheld = Analysis::DependencyRecorder.withhold { walk_to_owner(class_name) }
           envelope
         end
@@ -67,6 +95,11 @@ module Rigor
         # withhold, so none of these needs the file-level class edge the bucket reads would otherwise record.
         def settle_by_definitions
           return if @withheld.nil?
+          # ADR-119 C1b — a declined chain (`@unknown`) that some level records the name on is silent only until
+          # another file's edit lifts the decline, so its verdict depends on everything the walk read, as an opaque
+          # level's does. A decline over a name no project level records is not `@unknown` (see
+          # {#decline_unless_recorded_nowhere}): it settles by definitions, as an `ABSENT` read does.
+          return settle_by_walk if @unknown
 
           @owner_entries.each do |name, kind|
             if kind == :singleton
@@ -95,20 +128,88 @@ module Rigor
 
         private
 
+        # ADR-119 C1b / C2-c, #1570 / #1607 — the nearest level is asked of {Inference::DefinerResolution}, on the
+        # receiver's own side: the chain stands only where every candidate level gives one envelope in every
+        # world Ruby may have run (a fork, an unproven mixin order, a `possible`-only definer, and on the
+        # singleton side a hook that could have put a definer ahead). Where it does not, the answer is NO
+        # envelope and `@unknown` — the rule stays silent — instead of master's order, which is what #1570 and
+        # #1607 fired on. The levels the walk keeps for {#authoritative?} are the chain's.
         def walk_to_owner(class_name)
           @levels = []
           @passed = []
-          walked_whole_chain?(class_name) do |current|
-            level = level_for(current)
+          @recorded = false
+
+          case Inference::DefinerResolution.resolve(@scope, class_name, @method_name, side,
+                                                    question: :arity) { |chain, from| arity_hit(chain, from) }
+          in Inference::DefinerResolution::Known(answer: _answer, owner: _owner) then nearest_envelope(class_name)
+          in Inference::DefinerResolution::ABSENT then nearest_envelope(class_name) # rubocop:disable Lint/DuplicateBranch
+          in Inference::DefinerResolution::UNKNOWN then decline_unless_recorded_nowhere(class_name)
+          end
+        end
+
+        # A declined read of a name no project level records (`arity_hit` found no level that does, in any world it
+        # was asked) answers no envelope whether or not it stands, so the walk's reads are not the verdict's
+        # dependency: only a `def` appearing can change it, which {#settle_by_definitions} files, as for an
+        # `ABSENT` read. It can leave a stale false negative in a warm run, never a firing. Without this, every
+        # `Widget.new` (the implicit `Class` tail may answer it) would replay the whole walk as a file-level
+        # class edge.
+        def decline_unless_recorded_nowhere(class_name)
+          nowhere = !@recorded && !arity_chain(class_name).truncated?
+          nowhere ? nearest_envelope(class_name) : decline
+        end
+
+        # The chain's nearest level's envelope. `Known#answer` is that envelope, but {#authoritative?} and
+        # {#settle_by_definitions} also read the levels, passed names and owner entries this walk fills, so the
+        # answer is not used on its own. Run only once the candidate-set read has answered, so the chain stands
+        # for the name.
+        def nearest_envelope(class_name) = owner_in(chain_levels(arity_chain(class_name)).first)
+
+        def decline
+          @levels = []
+          @passed = []
+          @owner_entries = []
+          @envelope = nil
+          @unknown = true
+          nil
+        end
+
+        # The first level at or after entry position `from` whose records name the method: its envelope (or
+        # {AMBIGUOUS}), the entry that recorded it and that entry's position and side on the chain. On the
+        # singleton side the class's own record is a `:singleton` entry and an extended module's an `:instance`
+        # one (`owner_entries` names the kind of each).
+        def arity_hit(chain, from)
+          start = 0
+          chain.levels.each_with_index do |raw, index|
+            level = Level.new(*raw)
+            entries = chain.level_entries(index)
+            first = start
+            start += entries.size
+            next if first < from
+
+            found = level_envelopes(level)
+            next if found.empty?
+
+            envelope = found.first
+            answer = found.all?(envelope) && !Source::ParameterEnvelope.opaque?(envelope) ? envelope : AMBIGUOUS
+            owner, owner_kind = owner_entries(level).first
+            position = first + (entries.index { |entry| entry.name == owner && entry.side == owner_kind } || 0)
+            @recorded = true
+            return ArityHit.new(answer, owner, position, owner_kind)
+          end
+          nil
+        end
+
+        def owner_in(levels)
+          levels.each do |level|
             @levels << level
             found = level_envelopes(level)
             if found.empty?
-              @passed.concat([current] + level.modules)
+              @passed.concat([level.class_name] + level.modules)
               next
             end
 
             envelope = found.first
-            @owner_entries = owner_entries(level)
+            @owner_entries |= owner_entries(level)
             unless found.all?(envelope) && !Source::ParameterEnvelope.opaque?(envelope)
               @ambiguous = true
               return nil
@@ -155,56 +256,30 @@ module Rigor
           @scope.discovered_classes.key?(name) || Rigor::Reflection.rbs_class_known?(name, scope: @scope)
         end
 
-        # False when the walk stopped at the ADR-41 budget rather than at the top of the chain: budget
-        # exhaustion is uncertainty, and every caller reads it as a reason to decline.
-        def walked_whole_chain?(class_name)
-          current = class_name.to_s
-          seen = {}
-          while current && !seen[current]
-            return false if seen.size >= Scope::ANCESTOR_WALK_LIMIT
-
-            seen[current] = true
-            yield current
-            current = resolve(current, @scope.superclass_of(current))
-          end
-          true
+        # Yields each level of `class_name`'s chain. False when the walk stopped at the ADR-41 budget rather than
+        # ending: budget exhaustion is uncertainty, and every caller reads it as a reason to decline.
+        def walked_whole_chain?(class_name, &)
+          levels, whole = chain_levels(arity_chain(class_name))
+          levels.each(&)
+          whole
         end
 
-        def level_for(class_name)
-          modules = []
-          externals = []
-          collect_mixins(class_name, own_mixins(class_name), modules, externals, {})
-          Level.new(class_name: class_name, modules: modules, externals: externals)
-        end
+        # `[levels, whole]` for one world of the chain, up to the first superclass the project does not declare.
+        def chain_levels(chain) = [chain.levels.map { |level| Level.new(*level) }, !chain.truncated?]
+
+        def side = @kind == :singleton ? :singleton : :instance
 
         # Instance methods reach a receiver through `include` / `prepend`; class methods through `extend`, and
-        # an extended module's own `include`s reach the same singleton.
-        def own_mixins(class_name)
-          @kind == :singleton ? (@scope.discovered_extends[class_name] || []) : @scope.includes_of(class_name)
-        end
-
-        # Issue #986 — a name the compact-header rename collision left ambiguous resolves to no ONE class,
-        # but BOTH classes it names are ancestors at runtime; only their MRO order is unknowable. Taking
-        # both as levels is what keeps this rule alive for the rest of the receiver: a method only one of
-        # them declares still has one envelope and still fires, a method they disagree about lands two on
-        # `#envelope_for`'s join and declines there, and the class's own `def`s, its superclass's and its
-        # unambiguous mixins are untouched. Letting the decline arrive as an unknown EXTERNAL mixin instead
-        # suppressed the rule for every level of the receiver.
-        def collect_mixins(owner, raw_names, modules, externals, seen)
-          raw_names.each do |raw|
-            resolved = resolve(owner, raw)
-            names = resolved ? [resolved] : @scope.ambiguous_ancestor_resolutions(owner, raw)
-            next externals << @scope.ancestor_name_candidates(owner, raw) if names.empty?
-
-            names.each do |name|
-              next if seen[name]
-
-              seen[name] = true
-              modules << name
-              collect_mixins(name, @scope.includes_of(name), modules, externals, seen)
-            end
-          end
-        end
+        # an extended module's own `include`s reach the same singleton — the chain's singleton side.
+        #
+        # Issue #986 — the `:arity` flavor expands a name the compact-header rename collision left ambiguous
+        # to BOTH classes it names: both are ancestors at runtime and only their MRO order is unknowable. Taking
+        # both into the level is what keeps this rule alive for the rest of the receiver: a method only one of
+        # them declares still has one envelope and still fires, a method they disagree about lands two on the
+        # level's join and declines there, and the class's own `def`s, its superclass's and its unambiguous
+        # mixins are untouched. Letting the decline arrive as an unknown EXTERNAL mixin instead suppressed the
+        # rule for every level of the receiver.
+        def arity_chain(class_name) = Scope::ResolutionChain.for(@scope, class_name.to_s, side, :arity)
 
         def resolve(owner, raw)
           return nil if raw.nil?
@@ -215,8 +290,11 @@ module Rigor
           bucket[raw] = @scope.ancestor_name_candidates(owner, raw).find { |name| project_class?(name) }
         end
 
+        # A bucket of class marks alone (issue #1820: `x.singleton_class.prepend(Comparable)`) does not make a name
+        # the project's.
         def project_class?(name)
-          @scope.known_user_class?(name) || @scope.discovered_parameter_envelopes.key?(name)
+          @scope.known_user_class?(name) ||
+            Scope::DiscoveryIndex.declares_surface?(@scope.discovered_parameter_envelopes[name])
         end
 
         # A module's methods reach the receiver as instance methods whichever side the receiver is on.
@@ -231,8 +309,13 @@ module Rigor
             level.externals.all? { |candidates| external_mixin_lacks_method?(candidates) }
         end
 
+        # Issue #1797 — a class whose body rewrites its method table in a way no literal names. A `refine` of the
+        # class (`ENVELOPE_REFINED_MARK`) is not one here: whether a refinement answers a call is decided per call
+        # site, name and `using` by `CheckRules#refined_redefinition_in_effect?`, which also declines where a
+        # refinement of a subclass of the receiver's class may answer. Counting the mark silenced every name on
+        # every subclass of a refined class, with or without a `using`.
         def dynamic_surface?(class_name)
-          Scope::DiscoveryIndex.rewritten_surface?(@scope.parameter_envelopes_of(class_name))
+          @scope.parameter_envelopes_of(class_name).key?(Scope::DiscoveryIndex::ENVELOPE_DYNAMIC_MARK)
         end
 
         def project_patched?(class_name)
@@ -273,8 +356,8 @@ module Rigor
         # A hook anywhere in the chain, including above the owner, and on either side: a class that answers
         # names it does not define is a class whose `def`s are not the whole story of what a call reaches.
         def chain_free_of_hooks?(class_name)
-          walked_whole_chain?(class_name) do |current|
-            ([current] + level_for(current).modules).each do |name|
+          walked_whole_chain?(class_name) do |level|
+            ([level.class_name] + level.modules).each do |name|
               envelopes = @scope.parameter_envelopes_of(name)
               return false if dynamic_surface?(name)
               return false if MISSING_HOOKS.any? { |hook| hook_recorded?(envelopes, hook) }
@@ -290,15 +373,48 @@ module Rigor
         # receiver may be any of them, and each one's own definition of the name is what runs for it.
         def subclasses_agree?(class_name, envelope)
           each_subclass(class_name) do |subclass|
-            level = level_for(subclass)
-            return false unless clean_level?(level)
-            return false unless level_envelopes(level).all?(envelope)
+            subclass_levels(subclass).each do |level|
+              # A subclass whose own level the budget cut cannot be read, which is a reason to decline.
+              return false if level.nil?
+              return false unless clean_level?(level)
+              return false unless level_envelopes(level).all?(envelope)
+            end
           end
           true
         end
 
+        # A subclass's own level (nil where the budget cut it or the chain does not stand for the name). It asks
+        # {Inference::DefinerResolution} on the receiver's side (ADR-119 C1b, C2-c): the subclass's own level
+        # answers, and a fork, an unproven mixin order, a `possible`-only definer or a hook there is `UNKNOWN`,
+        # which `subclasses_agree?` reads as a reason to decline.
+        def subclass_levels(subclass)
+          case Inference::DefinerResolution.resolve(@scope, subclass, @method_name, side, question: :arity,
+                                                    &own_level_answer(subclass))
+          in Inference::DefinerResolution::Known(answer: _answer, owner: _owner) then [first_level(subclass)]
+          in Inference::DefinerResolution::ABSENT then [nil]
+          in Inference::DefinerResolution::UNKNOWN then NO_LEVELS
+          end
+        end
+
+        # The subclass's own level, always a candidate (an empty answer where it records nothing), so that the
+        # read asks whether the chain stands for the subclass and never whether an ancestor defines the name.
+        def own_level_answer(subclass)
+          lambda do |chain, from|
+            next nil unless from.zero? && !chain.levels.empty?
+
+            level = Level.new(*chain.levels.first)
+            ArityHit.new(level_envelopes(level).uniq, subclass, 0, side)
+          end
+        end
+
+        def first_level(class_name) = chain_levels(arity_chain(class_name)).first.first
+
+        # ADR-46 — every class whose subclasses are enumerated records `subclass_of:<last segment>`, which a class
+        # declaration with that superclass appearing or vanishing fires (issue #1820): a new subclass with a
+        # different envelope re-checks the call.
         def each_subclass(class_name)
           children = children_by_parent
+          record_subclasses_read(class_name)
           queue = children.fetch(class_name.to_s, []).dup
           seen = {}
           until queue.empty?
@@ -306,11 +422,18 @@ module Rigor
             next if seen[subclass]
 
             seen[subclass] = true
+            record_subclasses_read(subclass)
             yield subclass
             queue.concat(children.fetch(subclass, []))
           end
         end
 
+        def record_subclasses_read(class_name)
+          return unless Analysis::DependencyRecorder.active?
+
+          Analysis::DependencyRecorder.read_last_segment(:subclass_of, class_name.to_s)
+        end
+
         def children_by_parent
           @scope.discovered_superclasses.each_with_object({}) do |(child, raw_parent), children|
             parent = resolve(child, raw_parent)