rigortype 0.4.3 → 0.4.5

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "../../reflection"
+require_relative "../dependency_recorder"
+require_relative "../../inference/singleton_hook_decline"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Issue #1722 — what the project may give an instance of an RBS-declared class beyond the class's RBS, asked
+      # by `call.undefined-method` once the RBS lookup and the project's own tables for the class itself have come
+      # back "absent". Three places the earlier probes do not look:
+      #
+      # - **A `method_missing` on an RBS ancestor.** `class Integer; def method_missing(*)` (or one on `Numeric`,
+      #   `Comparable`, `Object`, `Kernel`, `BasicObject`, or a project module mixed into any of them) answers
+      #   every name Ruby dispatches to an Integer. `respond_to_missing?` is not read: Ruby dispatches to
+      #   `method_missing` whether or not it is defined.
+      # - **A project mixin of the class or an RBS ancestor.** `Integer.include(Ext)` in another file, or
+      #   `Comparable.include(Ext)` / `module Comparable; def zzz`, gives every Integer `zzz`. The earlier probes
+      #   read the class's own chain through `discovered_methods`, which holds no plain `def` written in another
+      #   file than the one being checked; this reads the def table too for a project module, and walks the
+      #   ancestors RBS lists after the class. A cross-file `def` on an RBS-declared class or module itself stays
+      #   ADR-17's monkey-patch report ({.mixin_defines?}). A mixin with an open surface — a project module with a
+      #   recorded `included` / `extended` / … hook, a `"*"` mixin or `ActiveSupport::Concern`, or one neither RBS nor
+      #   the project declares — answers any name, except on `Object`, `Kernel` and `BasicObject`: there only a
+      #   module that defines the name answers, #1697's reading (`Inference::ObjectMixins`) of a module mixed into
+      #   every object.
+      # - **A project subclass** ({.subclass_may_define?}). A value typed by its class's name through a signature
+      #   (`#: () -> String`) may be an instance of any subclass, so a method a project subclass defines may be
+      #   the one that runs.
+      #
+      # Each ancestor's name is filed as an ADR-46 class dependency, so a file that later reopens one re-checks
+      # the call, and the subclass walk files a `subclass_of` edge per class it reads.
+      module RbsReceiverSurface
+        MISSING_HOOK = :method_missing
+        # The roots whose project mixins `Inference::ObjectMixins` answers for.
+        OBJECT_ROOTS = %w[Object Kernel BasicObject].to_set.freeze
+        private_constant :MISSING_HOOK, :OBJECT_ROOTS
+
+        module_function
+
+        # Whether the project may answer `method_name` on an instance of `class_name` through one of its RBS
+        # ancestors.
+        def ancestor_may_answer?(scope, class_name, method_name)
+          ancestor_names(scope, class_name).any? do |name|
+            DependencyRecorder.read_last_segment(:class, name) if DependencyRecorder.active?
+            next false unless scope.known_user_class?(name)
+
+            chain_answers?(scope, name, method_name, open_mixins: !OBJECT_ROOTS.include?(name))
+          end
+        end
+
+        # Whether the singleton side of `class_name` may reach a project `method_missing`: a `def self.method_missing`
+        # on the class or an RBS superclass, or an instance `method_missing` on `Class`, `Module`, `Object`,
+        # `Kernel` or `BasicObject` (a class object is an instance of each).
+        def singleton_hook?(scope, class_name)
+          loader = scope.environment&.rbs_loader
+          pairs = loader ? loader.singleton_ancestors_for(class_name.to_s) : []
+          pairs = [[:singleton, class_name.to_s]] if pairs.empty?
+          pairs.any? do |kind, name|
+            DependencyRecorder.read_last_segment(:class, name) if DependencyRecorder.active?
+            if kind == :singleton
+              !scope.singleton_def_for(name, MISSING_HOOK).nil? ||
+                scope.discovered_method?(name, MISSING_HOOK, :singleton)
+            else
+              scope.known_user_class?(name) && hook_on_chain?(scope, name)
+            end
+          end
+        end
+
+        # Whether a project subclass of `class_name`, at any depth, defines `method_name` (through its own
+        # ancestry, which reaches its project mixins) or a `method_missing`. Its parent is read as written and
+        # resolved the way the class header resolves it: the first project class the spelling can denote, else the
+        # top-level name, which is the RBS class.
+        def subclass_may_define?(scope, class_name, method_name)
+          each_subclass(scope, class_name.to_s) do |subclass|
+            return true if project_defines?(scope, subclass, method_name) ||
+                           project_defines?(scope, subclass, MISSING_HOOK) ||
+                           !scope.user_def_through_ancestors(subclass, method_name).first.nil? ||
+                           scope.discovered_method_through_ancestors?(subclass, method_name, :instance)
+          end
+          false
+        end
+
+        def ancestor_names(scope, class_name)
+          loader = scope.environment&.rbs_loader
+          names = loader ? loader.ancestor_names_for(class_name.to_s) : []
+          names.empty? ? [class_name.to_s] : names
+        end
+
+        # A search of `name`'s project chain for an entry that may answer: a project entry that defines
+        # `method_name` or a `method_missing`, or an external mixin RBS declares `method_name` on. When
+        # `open_mixins` (every ancestor but `Object`, `Kernel` and `BasicObject`, #1697), also a mixin whose surface
+        # is open: a project module SingletonHookDecline reads as hook-capable, or an external neither RBS nor the
+        # project declares. A chain cut at its budget may hold an answer past the cut.
+        def chain_answers?(scope, name, method_name, open_mixins:)
+          chain = Scope::ResolutionChain.for(scope, name, :instance, :methods)
+          found = chain.search(scope, side: :instance) do |entry|
+            if entry.external?
+              external_may_answer?(scope, entry, method_name, open_mixins)
+            else
+              project_defines?(scope, entry.name, MISSING_HOOK) ||
+                mixin_defines?(scope, entry, method_name, open_mixins)
+            end
+          end
+          found || chain.truncated?
+        end
+
+        # The singleton side's question of an instance chain: does a project entry on it define `method_missing`?
+        def hook_on_chain?(scope, name)
+          chain = Scope::ResolutionChain.for(scope, name, :instance, :methods)
+          found = chain.search(scope, side: :instance) do |entry|
+            !entry.external? && project_defines?(scope, entry.name, MISSING_HOOK)
+          end
+          found || chain.truncated?
+        end
+
+        def project_defines?(scope, owner, method_name)
+          !scope.user_def_for(owner, method_name).nil? || scope.discovered_method?(owner, method_name, :instance)
+        end
+
+        # ADR-17 — a `def` the project writes on a class or module RBS declares (`class String; def x`, `module
+        # Comparable; def x`) in another file than the call is a monkey-patch Rigor does not apply cross-file, and the
+        # rule reports it with the `pre_eval:` advice, so on such an entry only what `discovered_methods` carries
+        # answers. A project module's own `def` answers from any file.
+        #
+        # When `open_mixins`, a project module {Inference::SingletonHookDecline} reads as hook-capable — one that
+        # records an `included` / `extended` / … hook (`def self.included(base) = base.class_eval { def x }`), lists
+        # a `"*"` mixin, or extends `ActiveSupport::Concern` — may answer any name.
+        def mixin_defines?(scope, entry, method_name, open_mixins)
+          owner = entry.name
+          if Rigor::Reflection.rbs_class_known?(owner, scope: scope)
+            scope.discovered_method?(owner, method_name, :instance)
+          else
+            project_defines?(scope, owner, method_name) ||
+              (open_mixins && Inference::SingletonHookDecline.entry_hook_capable?(scope, entry))
+          end
+        end
+
+        # An external the project declares (a module with no `def`, which the chain does not hold as a project entry)
+        # is known, and answers only through RBS.
+        def external_may_answer?(scope, entry, method_name, open_mixins)
+          candidates = entry.candidates
+          return open_mixins if candidates.empty?
+          return true if candidates.any? do |candidate|
+            Rigor::Reflection.instance_method_definition(candidate, method_name, scope: scope)
+          end
+
+          open_mixins && candidates.none? { |candidate| declared?(scope, candidate) }
+        end
+
+        def declared?(scope, name)
+          scope.discovered_classes.key?(name) || Rigor::Reflection.rbs_class_known?(name, scope: scope)
+        end
+
+        def each_subclass(scope, class_name)
+          children = children_by_parent(scope)
+          queue = children.fetch(class_name, []).dup
+          seen = {}
+          record_subclasses_read(class_name)
+          until queue.empty?
+            subclass = queue.shift
+            next if seen[subclass]
+
+            seen[subclass] = true
+            record_subclasses_read(subclass)
+            yield subclass
+            queue.concat(children.fetch(subclass, []))
+          end
+        end
+
+        def children_by_parent(scope)
+          scope.discovered_superclasses.each_with_object({}) do |(child, raw_parent), children|
+            next if raw_parent.nil?
+
+            candidates = scope.ancestor_name_candidates(child, raw_parent.to_s)
+            parent = candidates.find { |name| scope.known_user_class?(name) } || candidates.last
+            (children[parent] ||= []) << child if parent
+          end
+        end
+
+        def record_subclasses_read(class_name)
+          return unless DependencyRecorder.active?
+
+          DependencyRecorder.read_last_segment(:subclass_of, class_name)
+        end
+      end
+    end
+  end
+end

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

@@ -168,11 +168,70 @@ module Rigor
       # Bare (dot-less) diagnostic ids the engine emits outside the catalogue (see the `rule:` literals in
       # `Analysis::Runner` / `Runner::DiagnosticAggregator`). A token equal to one of these is treated as
       # known by `suppression.unknown-rule` even though it carries no family prefix; extend the list when
-      # the runner grows a new bare id.
+      # the runner grows a new bare id. Ids a marker or `disable:` cannot suppress (the `--explain`
+      # `fallback` row, the `contribution_merge` conflict reasons) stay out: they are
+      # `ConfigAudit::SEVERITY_ONLY_IDS`, known to the `severity_overrides:` audit alone.
       NON_CHECK_DIAGNOSTIC_IDS = %w[
         configuration-error load-error pool-degraded runtime-error source-rbs-synthesis-failed
         source-rbs-annotation-not-honoured
       ].freeze
+
+      # Resolves a user-supplied rule token (`undefined-method`, `call.undefined-method`, or the family wildcard
+      # `call`) to the set of canonical rule identifiers it disables. Returns `nil` for `"all"` (the existing
+      # wildcard meaning "every rule"), or for unknown tokens.
+      def self.resolve_rule_token(token)
+        return nil if token == "all"
+        return [LEGACY_RULE_ALIASES.fetch(token)] if LEGACY_RULE_ALIASES.key?(token)
+        return PRE_EVAL_RULES if token == "pre-eval"
+        return ALL_RULES.select { |r| r.start_with?("#{token}.") } if RULE_FAMILIES.include?(token)
+
+        ALL_RULES.include?(token) ? [token] : []
+      end
+
+      # Expands a list of user-supplied rule tokens into the canonical-id set per ADR-8 § "Backward
+      # compatibility". `disabled_rules` accepts unprefixed legacy names (`undefined-method`), canonical names
+      # (`call.undefined-method`), family wildcards (`call`) and the `all` sentinel.
+      def self.expand_rule_tokens(tokens)
+        Array(tokens).each_with_object(Set.new) do |token, set|
+          set.merge(expand_token(token.to_s))
+        end
+      end
+
+      def self.expand_token(token)
+        return ["all"] if token == "all"
+
+        resolved = resolve_rule_token(token)
+        resolved.nil? || resolved.empty? ? [token] : resolved
+      end
+
+      # Whether the `.rigor.yml` `disable:` list, expanded by {.expand_rule_tokens}, drops a diagnostic whose rule
+      # id is `rule`: the `all` sentinel drops every rule-bearing row, any other entry its exact id. A nil rule (a
+      # parse, path or internal error) is never dropped.
+      def self.config_disabled?(rule, disabled)
+        return false if rule.nil?
+
+        disabled.include?("all") || disabled.include?(rule)
+      end
+
+      # The source-family prefix the runner stamps on every plugin-emitted row (`plugin.<id>`).
+      PLUGIN_FAMILY_PREFIX = "plugin."
+
+      # Issue #1953 — whether a suppression token set drops a plugin's own row. Such a row answers only to its
+      # qualified id: the exact `plugin.<id>.<rule>` (its `qualified_rule`) or the whole plugin's `plugin.<id>`
+      # (its `source_family`). Both compare whole strings against the row's own fields, so `plugin.<id>` never
+      # reaches a plugin whose id merely starts with `<id>.`. Ids and rules may both hold dots, so plugin `a` with
+      # rule `b.c` and plugin `a.b` with rule `c` share `plugin.a.b.c`, and that exact token drops both. A bare rule
+      # and `all` do not reach these rows: many plugins share a bare rule (`load-error`, `unknown-column`), and a
+      # bare match would hide another plugin's findings. Every other row (built-in, `plugin_loader`, `plugin_trust`)
+      # answers false.
+      def self.plugin_row_disabled?(diagnostic, tokens)
+        return false if diagnostic.rule.nil?
+
+        family = diagnostic.source_family.to_s
+        return false unless family.start_with?(PLUGIN_FAMILY_PREFIX)
+
+        tokens.include?(family) || tokens.include?(diagnostic.qualified_rule)
+      end
     end
   end
 end

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

@@ -101,6 +101,19 @@ module Rigor
           # {#decline_unless_recorded_nowhere}): it settles by definitions, as an `ABSENT` read does.
           return settle_by_walk if @unknown
 
+          # Issue #1833 — a level the `:arity` resolver took to be the project's on a mark alone (a namespace
+          # candidate a marks-only file rewrites) stands only while that mark does, and no definition appearing or
+          # vanishing can overturn it. Only such levels file the edge: the walk's other mark reads would re-check
+          # the call whenever an unrelated namespace reuses an ancestor's last segment.
+          @levels.each do |level|
+            ([level.class_name] + level.modules).each do |name|
+              next if @scope.known_user_class?(name)
+              next unless Scope::DiscoveryIndex.declares_surface?(@scope.discovered_parameter_envelopes[name])
+
+              Analysis::DependencyRecorder.read_last_segment(:mark, name)
+            end
+          end
+
           @owner_entries.each do |name, kind|
             if kind == :singleton
               @scope.user_singleton_def_site_for(name, @method_name)
@@ -121,7 +134,8 @@ module Rigor
         # Stage 2, for the class {#owner_envelope} last answered.
         def authoritative?(class_name)
           !load_order_dependent?(class_name) && !object_extension_may_shadow? &&
-            @levels.all? { |level| clean_level?(level) && public_at?(level.class_name) } &&
+            @levels.all? { |level| clean_level?(level) && (@kind == :singleton || public_at?(level.class_name)) } &&
+            !(@kind == :singleton && singleton_private?(class_name)) &&
             chain_free_of_hooks?(class_name) &&
             subclasses_agree?(class_name, @envelope)
         end
@@ -245,8 +259,10 @@ module Rigor
         end
 
         # A module some method body hands to `obj.extend` sits ahead of the object's class, so if it defines
-        # the name at all, that object answers with the module's definition.
+        # the name at all, that object answers with the module's definition. Every bucket is read, so the answer
+        # records `mark:*`, which an object-extended mark appearing or vanishing anywhere fires (issue #1833).
         def object_extension_may_shadow?
+          Analysis::DependencyRecorder.read_name(:mark, "*") if Analysis::DependencyRecorder.active?
           @scope.discovered_parameter_envelopes.any? do |_name, bucket|
             bucket.key?(Scope::DiscoveryIndex::ENVELOPE_OBJECT_EXTENDED_MARK) && bucket.key?([:instance, @method_name])
           end
@@ -291,7 +307,9 @@ module Rigor
         end
 
         # A bucket of class marks alone (issue #1820: `x.singleton_class.prepend(Comparable)`) does not make a name
-        # the project's.
+        # the project's. The bucket is read directly rather than through `parameter_envelopes_of`: a `mark:<last>`
+        # edge recorded here fires on marks a correctly-fitting call does not depend on, so the dependency on
+        # a mark that could flip this resolution is kept at `settle_by_definitions` instead (issue #1833).
         def project_class?(name)
           @scope.known_user_class?(name) ||
             Scope::DiscoveryIndex.declares_surface?(@scope.discovered_parameter_envelopes[name])
@@ -348,6 +366,17 @@ module Rigor
           false
         end
 
+        # Issue #2059 — a call Ruby rejects as private on the singleton side (`private_class_method :two`, a private
+        # method of a module that extends itself) is `def.method-visibility-mismatch`'s, which reads the same definer;
+        # the arity is not checked. A read that declines leaves the arity to the other conditions.
+        def singleton_private?(class_name)
+          case Inference::DefinerResolution.resolve(@scope, class_name, @method_name, :singleton, question: :visibility)
+          in Inference::DefinerResolution::Known(answer:, owner: _owner) then answer == :private
+          in Inference::DefinerResolution::UNKNOWN then false
+          in Inference::DefinerResolution::ABSENT then false # rubocop:disable Lint/DuplicateBranch
+          end
+        end
+
         def public_at?(class_name)
           visibility = @scope.discovered_method_visibility(class_name, @method_name)
           visibility.nil? || visibility == :public

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

@@ -5,6 +5,7 @@ require "prism"
 require_relative "../../source/node_children"
 require_relative "../../inference/narrowing"
 require_relative "inferred_param_guard"
+require_relative "clause_coverage"
 
 module Rigor
   module Analysis
@@ -36,6 +37,10 @@ module Rigor
       # is code evidence that the subject can hold such an object (`io = STDOUT; case io when StringIO`), and Rigor's
       # reading of the subject's type is what the evidence contradicts. The body scope stays `Bot`, so no call on the
       # subject in it is checked. A subject that is a literal carrier (`x = 1; case x when String`) is still reported.
+      #
+      # Issue #1485 — the same holds for a `:prior_exhaustion` clause: on a subject that is not a literal carrier it is
+      # reported only when every class it names is at or below a class an earlier clause names ({ClauseCoverage}), so
+      # `io = STDOUT; case io when IO … when StringIO` is quiet and `when IO … when File` still reports.
       class UnreachableClauseCollector
         LOOP_OR_BLOCK_NODE_CLASSES = [
           Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::BlockNode
@@ -124,11 +129,13 @@ module Rigor
           return if entry_type.nil? || entry_type.is_a?(Type::Bot) || entry_type.is_a?(Type::Dynamic)
 
           keyword = node.is_a?(Prism::CaseMatchNode) ? "in" : "when"
+          coverage = ClauseCoverage.new(scope, entry_type)
           node.conditions.each do |clause|
             case clause
-            when Prism::WhenNode then collect_when(clause, subject.name)
-            when Prism::InNode then collect_in(clause, subject.name)
+            when Prism::WhenNode then collect_when(clause, subject.name, coverage)
+            when Prism::InNode then collect_in(clause, subject.name, coverage)
             end
+            coverage.record(clause)
           end
           collect_else(node.else_clause, subject.name, keyword)
         end
@@ -138,7 +145,7 @@ module Rigor
           scope&.local(subject_name)
         end
 
-        def collect_when(clause, subject_name)
+        def collect_when(clause, subject_name, coverage)
           return if clause.statements.nil? # empty body → no useful location
           return unless all_constant_conditions?(clause)
 
@@ -149,6 +156,7 @@ module Rigor
           kind = when_clause_kind(clause, subject_name)
           return if kind == :disjoint &&
                     disjoint_nominal_subject?(@scope_index[clause.conditions.first], subject_name, clause.conditions)
+          return if kind == :prior_exhaustion && !coverage.proven?(clause)
 
           @results << Result.new(
             clause: clause, body: clause.statements, subject_name: subject_name,
@@ -187,7 +195,7 @@ module Rigor
         # (prior-exhaustion — true for ANY pattern downstream of a covering set). Non-bare patterns are not
         # narrowed, so their body is `bot` ONLY under prior-exhaustion; they never produce a spurious
         # `:disjoint`.
-        def collect_in(clause, subject_name)
+        def collect_in(clause, subject_name, coverage)
           return if clause.statements.nil?
 
           scope = @scope_index[clause]
@@ -196,6 +204,7 @@ module Rigor
 
           kind = in_clause_kind(clause, subject_name)
           return if kind == :disjoint && disjoint_nominal_pattern?(clause, subject_name)
+          return if kind == :prior_exhaustion && !coverage.proven?(clause)
 
           @results << Result.new(
             clause: clause, body: clause.statements, subject_name: subject_name,