rigortype 0.4.2 → 0.4.4

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

@@ -156,6 +156,13 @@ module Rigor
       # first segment appears here as KNOWN and stays silent: these ids are legitimate suppression /
       # `severity_overrides:` vocabulary the light rule-id table cannot enumerate (plugins load dynamically;
       # aggregator ids live in the engine-heavy runner), so under-warning is the FP-safe direction.
+      # The `pre-eval.*` ids (ADR-17 WD6) the bare family wildcard `pre-eval` expands to. Emitted by the
+      # `pre_eval:` pre-pass, outside the CheckRules catalogue, so the family cannot ride `RULE_FAMILIES`
+      # (which also drives the catalogue and the config audit over `ALL_RULES`).
+      PRE_EVAL_RULES = %w[
+        pre-eval.parse-error pre-eval.file-not-found pre-eval.duplicate-declaration
+      ].freeze
+
       NON_CHECK_DIAGNOSTIC_FAMILIES = %w[rbs_extended dynamic rbs pre-eval plugin plugin_trust].freeze
 
       # Bare (dot-less) diagnostic ids the engine emits outside the catalogue (see the `rule:` literals in
@@ -166,6 +173,63 @@ module Rigor
         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.rb

@@ -79,18 +79,8 @@ module Rigor
       # runtime one and `def.override-visibility-reduced` cannot prove a reduction.
       IMPLICITLY_PRIVATE_METHODS = (LIFECYCLE_HOOKS + %i[respond_to_missing?]).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 ALL_RULES.select { |r| r.start_with?("#{token}.") } if RULE_FAMILIES.include?(token)
-
-        ALL_RULES.include?(token) ? [token] : []
-      end
+      # The token expansion (`resolve_rule_token` / `expand_rule_tokens` / `expand_token`) lives in the light
+      # `check_rules/rule_ids.rb`, so {SeverityStamp} can apply the `disable:` list on the engine-free hit path.
 
       module_function
 
@@ -479,7 +469,7 @@ module Rigor
       # - **File-level** (v0.1.2): `# rigor:disable-file <rule1>,
       #   <rule2>` anywhere in the file suppresses the matching
       #   diagnostic for every line. `# rigor:disable-file all`
-      #   suppresses every rule across the file. Convention is
+      #   suppresses every built-in rule across the file. Convention is
       #   to put the comment near the top, but Rigor accepts it
       #   anywhere — the comment scope is "this file" regardless
       #   of position.
@@ -487,7 +477,8 @@ module Rigor
       #   on the same line as the offending expression
       #   suppresses the matching diagnostic for that line
       #   only. `# rigor:disable all` on a line suppresses
-      #   every rule on that line.
+      #   every built-in rule on that line. A plugin's rows are
+      #   not passed here; see {.filter_plugin_suppressed}.
       #
       # Both in-source forms are recognised only when the
       # marker is the FIRST thing in the comment, so a
@@ -506,7 +497,7 @@ module Rigor
         diagnostics.reject do |diagnostic|
           rule = diagnostic.rule
           next false if rule.nil?
-          next true if disabled.include?(rule)
+          next true if config_disabled?(rule, disabled)
           next true if file_suppressions.include?("all") || file_suppressions.include?(rule)
 
           line_rules = line_suppressions[diagnostic.line]
@@ -514,6 +505,26 @@ module Rigor
         end
       end
 
+      # Issue #1953 — the in-source markers over the rows a plugin emitted while `path` was analysed
+      # (`#diagnostics_for_file` and node rules). A row answers to a `plugin.<id>.<rule>` or `plugin.<id>` token
+      # only ({.plugin_row_disabled?}); a bare id and `all` keep reaching built-in rows alone. `comments` are
+      # `path`'s, so a row the plugin positioned in another file is left to the `disable:` list and the baseline.
+      # The `disable:` list itself is applied to these rows by {SeverityStamp}, on every run shape.
+      def filter_plugin_suppressed(diagnostics, path:, comments:)
+        return diagnostics if diagnostics.empty?
+
+        line_suppressions, file_suppressions = parse_suppression_comments(comments)
+        return diagnostics if line_suppressions.empty? && file_suppressions.empty?
+
+        diagnostics.reject do |diagnostic|
+          next false unless diagnostic.path == path
+          next true if plugin_row_disabled?(diagnostic, file_suppressions)
+
+          line_rules = line_suppressions.fetch(diagnostic.line, nil)
+          !line_rules.nil? && plugin_row_disabled?(diagnostic, line_rules)
+        end
+      end
+
       # Every suppression-recognition pattern below is anchored with `\A` against the COMMENT SLICE —
       # Prism hands us a slice that starts at the `#`, so `\A#` means "the marker is the first thing in
       # the comment". A real directive always has that shape, in both the whole-line form and the
@@ -654,7 +665,7 @@ module Rigor
       # `dynamic.*`, `rbs.*`, `pre-eval.*`, and any `plugin.`-prefixed id — plugins load dynamically, so
       # their rule vocabulary cannot be enumerated here and under-warning is the FP-safe direction).
       def known_suppression_token?(token)
-        return true if token == "all"
+        return true if %w[all pre-eval].include?(token)
         return true if ALL_RULES.include?(token) || LEGACY_RULE_ALIASES.key?(token) ||
                        RULE_FAMILIES.include?(token) || NON_CHECK_DIAGNOSTIC_IDS.include?(token)
 
@@ -703,24 +714,6 @@ module Rigor
         )
       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`), and family wildcards (`call`).
-      def expand_rule_tokens(tokens)
-        Array(tokens).each_with_object(Set.new) do |token, set|
-          set.merge(expand_token(token.to_s))
-        end
-      end
-
-      def expand_token(token)
-        return ["all"] if token == "all"
-
-        resolved = resolve_rule_token(token)
-        resolved.nil? || resolved.empty? ? [token] : resolved
-      end
-
       # rubocop:disable-next Metrics/ClassLength
       class << self
         private
@@ -863,29 +856,23 @@ module Rigor
 
         # Is a refinement of `call_node`'s method name into `class_name` (or an ancestor) in effect at the call?
         # Issue #1120 asks it for a method the class lacks. The two argument rules ask
-        # {#refined_redefinition_in_effect?} instead (issue #1740), and this only for a class-object receiver.
-        # Typing the call from the refine body is #1664.
-        # A refinement answers instance-side receivers only: a refined singleton (`refine X.singleton_class`) names
-        # no constant target, so nothing records it. Issue #1673 — the answer is derived from the file's in-effect
-        # refinements ({Inference::InEffectRefinements}), the list the typer reads, with each `using` expanded
-        # through its module's includes (issue #1671).
+        # {#refined_redefinition_in_effect?} instead (issue #1740). Typing the call from the refine body is #1664.
+        # Issue #1752 — a class-object receiver (`kind` `:singleton`) is reached by a refinement of any class or module
+        # on its lookup: `Class`, `Module`, `Object`, `Kernel`, `BasicObject`, or a module it extends. A refined
+        # singleton class (`refine X.singleton_class`) names no constant target, so its rows are class-unknown, which
+        # reach every receiver. Issue #1673 — the answer is derived from the file's in-effect refinements
+        # ({Inference::InEffectRefinements}), the list the typer reads, with each `using` expanded through its
+        # module's includes (issue #1671).
         #
         # ADR-121 WD7 — a module in effect whose refinements Rigor cannot read
         # ({Inference::InEffectRefinements.opaque_module?}: a gem's, one from outside the analysed paths, one with an
         # unreadable `refine`) may refine any class, a class object's included, so the call declines whatever its
-        # receiver. Issue #1796; both argument rules ask this predicate too.
+        # receiver. Issue #1796.
         def refined_method_in_effect?(class_name, call_node, scope, kind, lexical_sites)
           return false if lexical_sites.nil?
           return true if opaque_refinement_in_effect?(call_node, scope, lexical_sites)
 
-          modules =
-            if kind == :instance
-              Inference::InEffectRefinements.refining_modules(scope, class_name, call_node.name)
-            else
-              # ADR-121 WD7 — a row whose class the walk could not name (`refine(k)` with `k` a singleton class)
-              # reaches a class object too.
-              Inference::InEffectRefinements.class_unknown_refining_modules(scope, call_node.name)
-            end
+          modules = Inference::InEffectRefinements.refining_modules(scope, class_name, call_node.name, kind)
           !modules.nil? &&
             lexical_sites.refinements.refinement_active?(call_node.location.start_offset, modules,
                                                          scope.declared_refinements) do |name|
@@ -902,8 +889,8 @@ module Rigor
         #
         # A call with nothing in effect is checked. Otherwise it reports only from positive knowledge: the list
         # carries no unknown marker and no opaque module, and {Inference::RefinedDispatch::OwnMethod} proves the
-        # receiver's own definer answers first. A class-object receiver keeps {#refined_method_in_effect?}'s
-        # answer: its singleton-side levels are not walked yet.
+        # receiver's own definer answers first. Issue #1752 — a class-object receiver (`kind` `:singleton`) walks its
+        # singleton levels: `Integer.sqrt(1, 2)` under `refine Object do def sqrt(a, b)` runs `Integer.sqrt` and raises.
         def refined_redefinition_in_effect?(class_name, call_node, scope, kind, lexical_sites)
           return false if lexical_sites.nil?
 
@@ -911,9 +898,8 @@ module Rigor
           return false if list.empty?
           return true if list.include?(Inference::InEffectRefinements::UNKNOWN)
           return true if opaque_refinement_in_effect?(call_node, scope, lexical_sites)
-          return refined_method_in_effect?(class_name, call_node, scope, kind, lexical_sites) unless kind == :instance
 
-          !Inference::RefinedDispatch::OwnMethod.answers?(scope, class_name, call_node.name, list)
+          !Inference::RefinedDispatch::OwnMethod.answers?(scope, class_name, call_node.name, list, kind: kind)
         end
 
         # The in-effect list at the call as the typer reads it: the lexical activations, each `using` expanded,
@@ -1399,6 +1385,21 @@ module Rigor
         GEM_OVERLAY_OPEN_RECEIVERS = Set["ActiveSupport::Duration", "ActiveSupport::Concern"].freeze
         private_constant :GEM_OVERLAY_OPEN_RECEIVERS
 
+        # Issue #1456 — the `data/core_overlay/` twin of {GEM_OVERLAY_OPEN_RECEIVERS}. `OpenStruct` defines each field
+        # as a per-instance singleton method and answers the rest through a private `method_missing` (ostruct 0.6), so
+        # no signature can enumerate its surface. The only other declaration in the environment is json's add-on
+        # reopening (`json_create` / `as_json` / `to_json`), which made the class read as fully declared and every
+        # field access a `call.undefined-method`. `data/core_overlay/ostruct.rbs` declares that `method_missing`, and
+        # an RBS-declared `method_missing` does not by itself open a receiver here, so the class is named. No load
+        # gate is needed: the core overlay loads into every environment that has RBS at all, so the list is active
+        # whenever the declaration it protects is. Both sides of the class are open, as with
+        # {GEM_OVERLAY_OPEN_RECEIVERS}, and an inherited Object / Kernel signature stops deciding `call.wrong-arity`
+        # and `call.argument-type-mismatch` ({#unauthoritative_inherited_signature?}): lost true positives,
+        # accepted. The general rule — a class declared only by another library's partial reopening — is #1978, not
+        # this list.
+        CORE_OVERLAY_OPEN_RECEIVERS = Set["OpenStruct"].freeze
+        private_constant :CORE_OVERLAY_OPEN_RECEIVERS
+
         # ADR-26 — whether `class_name` is declared "open" by a
         # loaded plugin (manifest `open_receivers:`). An open
         # class responds beyond its RBS surface, so the
@@ -1407,11 +1408,14 @@ module Rigor
         # RBS method table, so proving a call "undefined" against it is
         # unsound: a plugin-declared open receiver, a Rigor-bundled-
         # overlay open receiver ({GEM_OVERLAY_OPEN_RECEIVERS}) whose
-        # bundled directory this run actually loaded, or a
+        # bundled directory this run actually loaded, a core-overlay
+        # open receiver ({CORE_OVERLAY_OPEN_RECEIVERS}), or a
         # Rigor-synthesized stub type (see `RbsLoader#synthesized_type_names`).
         def unbounded_receiver_surface?(class_name, scope)
+          bare_name = class_name.to_s.sub(/\A::/, "")
           open_receiver?(class_name, scope) || synthesized_stub_receiver?(class_name, scope) ||
-            (GEM_OVERLAY_OPEN_RECEIVERS.include?(class_name.to_s.sub(/\A::/, "")) && gem_overlay_loaded?(scope))
+            CORE_OVERLAY_OPEN_RECEIVERS.include?(bare_name) ||
+            (GEM_OVERLAY_OPEN_RECEIVERS.include?(bare_name) && gem_overlay_loaded?(scope))
         end
 
         def open_receiver?(class_name, scope)
@@ -2093,7 +2097,13 @@ module Rigor
         # arm restores the polarity without touching the shared helper:
         # `String | nil` keeps firing, and so does `Dynamic | String | nil` —
         # the nameless arm stays permissive inside the all-arms check, which is
-        # only about the arms' method surface.
+        # only about the arms' method surface. That union no longer arises from
+        # a merge re-joining the narrowed edges of one untyped local, which
+        # binds it back to `Dynamic[top]` (issue #1840,
+        # `Inference::UntypedRejoin`); it still does when the program writes
+        # the `nil` (`x = nil if c`) and no `nil?` edge strips it before the
+        # re-joining merge, or when the arms are not a narrowing of one
+        # untyped value.
         def union_has_nameable_non_nil_arm?(union, scope)
           union.members.any? do |m|
             next false if nil_member?(m)
@@ -2195,7 +2205,8 @@ module Rigor
         # ADR-121 WD7 — a refinement in effect (or one Rigor cannot read) may define the name on one arm's class.
         def refined_on_some_arm?(members, call_node, scope, lexical_sites)
           members.any? do |member|
-            refined_method_in_effect?(concrete_class_name(member), call_node, scope, :instance, lexical_sites)
+            kind = member.is_a?(Type::Singleton) ? :singleton : :instance
+            refined_method_in_effect?(concrete_class_name(member), call_node, scope, kind, lexical_sites)
           end
         end
 

data/lib/rigor/analysis/effects_cache_probe.rb

@@ -80,7 +80,7 @@ module Rigor
       private
 
       def effects_descriptor(paths)
-        files = PathExpansion.ruby_files(paths, @configuration.exclude_patterns)
+        files = PathExpansion.ruby_files(paths, @configuration.exclude_patterns, base: @configuration.exclude_base)
         base = RunCacheKey.descriptor(
           configuration: @configuration, files: files, explain: false,
           rbs_config_entries: RunCacheKey.libraries_config_entries(@configuration)

data/lib/rigor/analysis/incremental.rb

@@ -120,6 +120,18 @@ module Rigor
         appeared.freeze
       end
 
+      # Issue #1459 — the method names some file in `paths` started or stopped defining in this edit, on any class or
+      # side. A consumer whose answer asked whether the program defines a name anywhere
+      # (`Inference::BlockCallTiming.project_defines_anywhere?`) recorded a `defines:<name>` edge whichever way it
+      # answered. `paths` MUST include removed files, whose every name vanished. `before` / `after` map a path to the
+      # Set of names it defines (`Inference::ScopeIndexer.defined_method_names`); a path absent from either side
+      # defines nothing there.
+      def changed_defined_names(paths, before, after)
+        moved = Set.new
+        paths.each { |path| moved.merge((before[path] || Set.new) ^ (after[path] || Set.new)) }
+        moved.freeze
+      end
+
       # Issue #1120 — the method names whose refinements moved in this edit. A consumer whose answer consulted the
       # refinement table recorded a `refinement:<method>` edge whichever way it answered, because the answer is a
       # function of the whole project's refinements of that name. `paths` MUST include removed files, whose whole

data/lib/rigor/analysis/incremental_run_slot.rb

@@ -42,8 +42,8 @@ module Rigor
     # plugin's identity and the engine's (key slots), so a project whose plugins claim template globs is served
     # too. The ADR-87 probe misses on one: the plain slot's key carries the `template-units` slot.
     #
-    # `explain:` is always false: the session's runners never set it (#1533), and the CLI declines the probe under
-    # `--explain`.
+    # `explain:` is always false: the session writes no slot for an `--explain` run (#1533), and the CLI declines
+    # the probe under `--explain`.
     module IncrementalRunSlot
       module_function
 
@@ -115,7 +115,7 @@ module Rigor
       def serve(configuration:, cache_root:, paths:)
         return nil if configuration.effects_enabled?
 
-        files = PathExpansion.ruby_files(paths, configuration.exclude_patterns)
+        files = PathExpansion.ruby_files(paths, configuration.exclude_patterns, base: configuration.exclude_base)
         slot_key = key(configuration: configuration, target: Target.new(files: files, roots: paths))
         return nil if slot_key.nil?