rigortype 0.1.18 → 0.1.19

data/lib/rigor/analysis/runner.rb

@@ -155,6 +155,7 @@ module Rigor
         @cached_plugin_prepare_diagnostics = [].freeze
         @project_discovered_classes = {}.freeze
         @project_discovered_def_nodes = {}.freeze
+        @project_discovered_singleton_def_nodes = {}.freeze
         @project_discovered_def_sources = {}.freeze
         @project_discovered_superclasses = {}.freeze
         @project_discovered_includes = {}.freeze
@@ -457,7 +458,7 @@ module Rigor
       # discovery tables at their frozen-empty constructor defaults
       # (the bundle carries `nil` for them, matching the original
       # adopt path that never touched them).
-      def apply_pre_passes_result(result)
+      def apply_pre_passes_result(result) # rubocop:disable Metrics/AbcSize
         @plugin_registry = result.plugin_registry
         @dependency_source_index = result.dependency_source_index
         @cached_plugin_prepare_diagnostics = result.cached_plugin_prepare_diagnostics
@@ -466,6 +467,9 @@ module Rigor
         @pre_eval_diagnostics_from_scanner = result.pre_eval_diagnostics_from_scanner
         @project_discovered_classes = result.discovered_classes if result.discovered_classes
         @project_discovered_def_nodes = result.discovered_def_nodes if result.discovered_def_nodes
+        if result.discovered_singleton_def_nodes
+          @project_discovered_singleton_def_nodes = result.discovered_singleton_def_nodes
+        end
         @project_discovered_def_sources = result.discovered_def_sources if result.discovered_def_sources
         @project_discovered_superclasses = result.discovered_superclasses if result.discovered_superclasses
         @project_discovered_includes = result.discovered_includes if result.discovered_includes
@@ -636,30 +640,44 @@ module Rigor
       # `#diagnostics_for_file` or declared a `node_rule` are visited
       # (`contribution_index.for_file_diagnostics`); a skipped plugin's
       # two hooks could only have returned `[]`.
-      def plugin_emitted_diagnostics(path, root, scope)
+      def plugin_emitted_diagnostics(path, root, scope, node_results)
         return [] if @plugin_registry.empty?
 
-        # ADR-52 WD4 — one engine-owned AST walk per file dispatches each
-        # node to every matching (plugin, rule); the per-plugin results
-        # are bucketed in registry order so emission stays plugin-major
-        # (byte-identical with the old per-plugin walk).
-        node_results = node_rule_results_by_plugin(path, root, scope)
-
         @plugin_registry.contribution_index.for_file_diagnostics.flat_map do |plugin|
           collect_plugin_diagnostics(plugin, path, root, scope, node_results[plugin])
         end
       end
 
-      def node_rule_results_by_plugin(path, root, scope)
+      # ADR-52 WD4 + ADR-53 B4 — one engine-owned AST walk per file
+      # dispatches each node to every matching (plugin, rule) AND drives
+      # the built-in node collectors (`node_collectors`), so the file is
+      # walked once for both. The per-plugin results are bucketed in
+      # registry order so plugin emission stays plugin-major
+      # (byte-identical with the old per-plugin walk); the collectors are
+      # populated in place for `diagnose` to consume.
+      #
+      # When no plugin declares a node rule, the walk still runs to drive
+      # the collectors (the converged path replaces the standalone
+      # `RuleWalk.run`); `node_collectors` nil means a caller that does
+      # not need built-in collection from this walk.
+      def node_rule_results_by_plugin(path, root, scope, node_collectors, scope_index)
         walk = @plugin_registry.node_rule_walk
-        return {}.compare_by_identity if walk.empty?
+        driver = node_collectors && CheckRules.node_collector_driver(node_collectors)
+        return {}.compare_by_identity if walk.empty? && driver.nil?
 
-        results = walk.diagnostics_for_file(path: path, scope: scope, root: root)
+        results = walk.diagnostics_for_file(
+          path: path, scope: scope, root: root, collector_driver: driver
+        )
+        CheckRules.shadow_verify_converged_collectors(path, root, scope_index, node_collectors) if shadow_rule_walk?
         results.each_with_object({}.compare_by_identity) do |result, by_plugin|
           by_plugin[result.plugin] = result
         end
       end
 
+      def shadow_rule_walk?
+        ENV.fetch("RIGOR_SHADOW_RULE_WALK", nil)
+      end
+
       def collect_plugin_diagnostics(plugin, path, root, scope, node_result)
         raw = Array(plugin.diagnostics_for_file(path: path, scope: scope, root: root))
         # A node-rule context/rule raise isolates the whole plugin's
@@ -807,6 +825,9 @@ module Rigor
         tables = {}
         tables[:discovered_classes] = @project_discovered_classes unless @project_discovered_classes.empty?
         tables[:discovered_def_nodes] = @project_discovered_def_nodes unless @project_discovered_def_nodes.empty?
+        unless @project_discovered_singleton_def_nodes.empty?
+          tables[:discovered_singleton_def_nodes] = @project_discovered_singleton_def_nodes
+        end
         tables[:discovered_def_sources] = @project_discovered_def_sources unless @project_discovered_def_sources.empty?
         unless @project_discovered_superclasses.empty?
           tables[:discovered_superclasses] = @project_discovered_superclasses
@@ -861,15 +882,8 @@ module Rigor
         self_call_record = with_self_call_recording(path) do
           index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
         end
-        diagnostics = CheckRules.diagnose(
-          path: path,
-          root: parse_result.value,
-          scope_index: index,
-          self_call_misses: self_call_record ? self_call_record.calls : [],
-          comments: parse_result.comments,
-          disabled_rules: @configuration.disabled_rules
-        )
-        diagnostics += plugin_emitted_diagnostics(path, parse_result.value, scope)
+        self_call_misses = self_call_record ? self_call_record.calls : []
+        diagnostics = rule_and_plugin_diagnostics(path, parse_result, scope, index, self_call_misses)
         diagnostics + explain_diagnostics(path, parse_result.value, scope)
       rescue Errno::ENOENT => e
         [
@@ -893,6 +907,28 @@ module Rigor
         ]
       end
 
+      # ADR-53 B4 — the built-in node collectors and the plugin node rules
+      # share ONE traversal of the file. The collectors are built here (they
+      # need the completed `index`) and populated by the converged plugin
+      # walk; `node_results` carries the per-plugin node-rule output. Both
+      # the built-in `diagnose` output and the plugin diagnostics are then
+      # built from that single walk's results.
+      def rule_and_plugin_diagnostics(path, parse_result, scope, index, self_call_misses)
+        root = parse_result.value
+        node_collectors = CheckRules.build_node_collectors(path, index)
+        node_results = node_rule_results_by_plugin(path, root, scope, node_collectors, index)
+        diagnostics = CheckRules.diagnose(
+          path: path,
+          root: root,
+          scope_index: index,
+          self_call_misses: self_call_misses,
+          comments: parse_result.comments,
+          disabled_rules: @configuration.disabled_rules,
+          node_collectors: node_collectors
+        )
+        diagnostics + plugin_emitted_diagnostics(path, root, scope, node_results)
+      end
+
       # ADR-24 slice 4a — runs `block` (the typing pass) with the self-call
       # recorder active when either the test-only `record_self_calls:` flag is
       # set or the `call.self-undefined-method` rule resolves to a firing
@@ -928,7 +964,8 @@ module Rigor
           else
             Configuration::SeverityProfile.resolve(
               rule: rule, authored_severity: :warning,
-              profile: @configuration.severity_profile, overrides: @configuration.severity_overrides
+              profile: @configuration.severity_profile, overrides: @configuration.severity_overrides,
+              bleeding_edge_overrides: @configuration.bleeding_edge_severity_overrides
             ) != :off
           end
       end

data/lib/rigor/analysis/worker_session.rb

@@ -175,14 +175,18 @@ module Rigor
 
         scope = seed_project_scope(Scope.empty(environment: @environment, source_path: path))
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
+        # ADR-53 B4 — built-in collectors + plugin node rules share one walk.
+        node_collectors = CheckRules.build_node_collectors(path, index)
+        node_results = node_rule_results_by_plugin(path, parse_result.value, scope, node_collectors, index)
         diagnostics = CheckRules.diagnose(
           path: path,
           root: parse_result.value,
           scope_index: index,
           comments: parse_result.comments,
-          disabled_rules: @configuration.disabled_rules
+          disabled_rules: @configuration.disabled_rules,
+          node_collectors: node_collectors
         )
-        diagnostics += plugin_emitted_diagnostics(path, parse_result.value, scope)
+        diagnostics += plugin_emitted_diagnostics(path, parse_result.value, scope, node_results)
         diagnostics + explain_diagnostics(path, parse_result.value, scope)
       rescue Errno::ENOENT => e
         [analyzer_error(path, e.message)]
@@ -294,24 +298,30 @@ module Rigor
         )
       end
 
-      def plugin_emitted_diagnostics(path, root, scope)
+      def plugin_emitted_diagnostics(path, root, scope, node_results)
         return [] if @plugin_registry.empty?
 
-        # ADR-52 WD4 — single engine-owned node-rule walk per file; the
-        # results are bucketed per plugin (registry order) so emission
-        # stays plugin-major and byte-identical with the per-plugin walk.
-        node_results = node_rule_results_by_plugin(path, root, scope)
-
         @plugin_registry.plugins.flat_map do |plugin|
           collect_plugin_diagnostics(plugin, path, root, scope, node_results[plugin])
         end
       end
 
-      def node_rule_results_by_plugin(path, root, scope)
+      # ADR-52 WD4 + ADR-53 B4 — single engine-owned walk per file drives
+      # both the plugin node rules (bucketed per plugin in registry order,
+      # plugin-major emission) and the built-in node collectors
+      # (`node_collectors`, populated in place). Runs even with no node-rule
+      # plugins so the collectors still get driven (converged path).
+      def node_rule_results_by_plugin(path, root, scope, node_collectors, scope_index)
         walk = @plugin_registry.node_rule_walk
-        return {}.compare_by_identity if walk.empty?
+        driver = node_collectors && CheckRules.node_collector_driver(node_collectors)
+        return {}.compare_by_identity if walk.empty? && driver.nil?
 
-        results = walk.diagnostics_for_file(path: path, scope: scope, root: root)
+        results = walk.diagnostics_for_file(
+          path: path, scope: scope, root: root, collector_driver: driver
+        )
+        if ENV["RIGOR_SHADOW_RULE_WALK"]
+          CheckRules.shadow_verify_converged_collectors(path, root, scope_index, node_collectors)
+        end
         results.each_with_object({}.compare_by_identity) do |result, by_plugin|
           by_plugin[result.plugin] = result
         end

data/lib/rigor/bleeding_edge.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Rigor
+  # ADR-50 § WD2 — the bleeding-edge overlay.
+  #
+  # A Rigor-maintained set of the *next major's* queued changes —
+  # severity-map promotions and new-discipline rule enablements — that a
+  # user can adopt early, before they become default-on at a major
+  # (ADR-50 § WD7). It is orthogonal to `severity_profile:` (how loud
+  # *today's* rules are) and is versioned with the gem, NOT a
+  # user-supplied file: the inspectable counterpart to PHPStan's
+  # `bleedingEdge` include.
+  #
+  # The overlay is **empty today** — no discipline has yet been queued
+  # for the next major. This module is the WD2 *foundation* (the v0.1.19
+  # slice): the surface (`bleeding_edge:` config, the
+  # `rigor show-bleedingedge` command, the severity-composition hook in
+  # {Configuration::SeverityProfile.resolve}) exists and is wired
+  # end-to-end, so the first real feature lands as a single {FEATURES}
+  # entry with no engine plumbing.
+  #
+  # Each feature carries a **stable feature id** — part of the ADR-50
+  # WD1 contract vocabulary: the config, the `show` command, and the
+  # eventual CHANGELOG migration note all name the same id, and a
+  # feature graduates to default-on at a major by being removed from
+  # {FEATURES}.
+  module BleedingEdge
+    # One queued change.
+    #
+    # @!attribute id
+    #   @return [String] the stable feature id (contract vocabulary).
+    # @!attribute summary
+    #   @return [String] a one-line description of what it changes.
+    # @!attribute severity_overrides
+    #   @return [Hash{String => Symbol}] canonical rule id → the
+    #     severity this feature imposes. Composed *below* the user's own
+    #     `severity_overrides:` and *above* the active `severity_profile`
+    #     (see {Configuration::SeverityProfile.resolve}).
+    Feature = Data.define(:id, :summary, :severity_overrides) do
+      def to_h
+        {
+          "id" => id,
+          "summary" => summary,
+          "severity_overrides" => severity_overrides.transform_values(&:to_s)
+        }
+      end
+    end
+
+    # The overlay. Empty until the first next-major discipline is
+    # queued; add a {Feature} here (with a stable id) when one is.
+    FEATURES = [].freeze
+
+    module_function
+
+    # @return [Array<Feature>] the whole overlay.
+    def features
+      FEATURES
+    end
+
+    # @return [Array<String>] every feature id in the overlay.
+    def feature_ids
+      FEATURES.map(&:id)
+    end
+
+    # @param id [String]
+    # @return [Feature, nil]
+    def feature(id)
+      FEATURES.find { |f| f.id == id }
+    end
+
+    # Resolves a normalized `bleeding_edge:` selector (see
+    # {Configuration#bleeding_edge}) to the active {Feature} list.
+    # Unknown ids in a `list` / `except` selector are simply absent from
+    # the overlay and contribute nothing — symmetric with how
+    # `severity_overrides:` keeps an unknown rule id inert until it
+    # lands (robust across gem versions).
+    #
+    # @param selector [Hash] `{ "mode" => "none" }`,
+    #   `{ "mode" => "all" }`, `{ "mode" => "all", "except" => [ids] }`,
+    #   or `{ "mode" => "list", "ids" => [ids] }`.
+    # @return [Array<Feature>]
+    def active_features(selector)
+      case selector["mode"]
+      when "all"
+        except = selector["except"] || []
+        FEATURES.reject { |f| except.include?(f.id) }
+      when "list"
+        ids = selector["ids"] || []
+        FEATURES.select { |f| ids.include?(f.id) }
+      else
+        []
+      end
+    end
+
+    # The merged severity-override map the active features impose for a
+    # selector. Frozen so the result is `Ractor.shareable?`.
+    #
+    # @param selector [Hash] see {#active_features}.
+    # @return [Hash{String => Symbol}]
+    def severity_overrides_for(selector)
+      active_features(selector).each_with_object({}) do |feature, acc|
+        acc.merge!(feature.severity_overrides)
+      end.freeze
+    end
+
+    # Feature ids named by a selector that are NOT in the overlay
+    # (typo / graduated / from a newer gem). Surfaced by
+    # `rigor show-bleedingedge` as a hint; never an error.
+    #
+    # @param selector [Hash] see {#active_features}.
+    # @return [Array<String>]
+    def unknown_selected_ids(selector)
+      named =
+        case selector["mode"]
+        when "list" then selector["ids"] || []
+        when "all"  then selector["except"] || []
+        else []
+        end
+      known = feature_ids
+      named.reject { |id| known.include?(id) }
+    end
+  end
+end

data/lib/rigor/cache/descriptor.rb

@@ -13,8 +13,8 @@ module Rigor
     # ([`Rigor::Cache::Store`](store.rb), v0.0.8 slice 2) consumes
     # descriptors but does not extend them.
     #
-    # The descriptor has four slots (`files`, `gems`, `plugins`,
-    # `configs`); every slot is an array of typed entries; an empty
+    # The descriptor has six slots (`files`, `gems`, `plugins`,
+    # `configs`, `dependencies`, `globs`); every slot is an array of typed entries; an empty
     # array means "no dependency in this slot". Composition unions
     # by key per slot; conflicts on the comparison fields raise
     # {Conflict}.
@@ -32,7 +32,12 @@ module Rigor
       # references but never declares, so the marshalled RBS env
       # cached by an older Rigor (which would leave those signatures
       # inert) MUST be rebuilt for the synthesis to take effect.
-      SCHEMA_VERSION = 3
+      # v4: ADR-60 WD3 added the `globs` slot ({GlobEntry}) for the
+      # record-and-validate plugin-producer cache; the new slot
+      # changes `#to_canonical_hash` (and is Marshal-dumped inside
+      # `fetch_or_validate` entry pairs), so entries written by an
+      # older Rigor must read as misses.
+      SCHEMA_VERSION = 4
 
       # Per-slot entry value objects. Constructors validate enums /
       # required fields and freeze the resulting struct so no caller
@@ -160,6 +165,62 @@ module Rigor
         end
       end
 
+      # ADR-60 WD3 — one glob's-worth of watched files, digested as a
+      # single value so the entry covers content change, addition,
+      # AND removal in one row: the digest is the SHA-256 over the
+      # sorted `"<path>\0<sha256-of-content>\n"` rows of every file
+      # matching `File.join(root, pattern)`. A new file adds a row, a
+      # deleted file drops one, an edit changes one — all three move
+      # the digest. {Descriptor#fresh?} re-runs the same computation
+      # and compares.
+      class GlobEntry
+        include Rigor::ValueSemantics
+
+        attr_reader :root, :pattern, :value
+
+        value_fields :root, :pattern, :value
+
+        def initialize(root:, pattern:, value:)
+          @root = root.to_s.dup.freeze
+          @pattern = pattern.to_s.dup.freeze
+          @value = value.to_s.dup.freeze
+          freeze
+        end
+
+        # Builds the entry for the glob's CURRENT filesystem state.
+        def self.compute(root:, pattern:)
+          new(root: root, pattern: pattern, value: digest_for(root: root, pattern: pattern))
+        end
+
+        # The digest the entry's `value` carries. Per-file read
+        # failures (a file vanishing between the glob and the
+        # digest) are treated as the file being absent — same
+        # race posture as {Descriptor#file_entry_fresh?}.
+        def self.digest_for(root:, pattern:)
+          # Dir.glob returns sorted entries by default (sort: true),
+          # so the row order — and therefore the digest — is stable.
+          rows = Dir.glob(File.join(root, pattern)).filter_map do |path|
+            next nil unless File.file?(path)
+
+            "#{path}\0#{Digest::SHA256.file(path).hexdigest}\n"
+          rescue StandardError
+            nil
+          end
+          Digest::SHA256.hexdigest(rows.join)
+        end
+
+        # Composition key — {.compose} unions per (root, pattern)
+        # slot; two contributions for the same slot must agree on
+        # the digest or {Conflict} is raised.
+        def slot_key
+          "#{root}\0#{pattern}"
+        end
+
+        def to_h
+          { "root" => root, "pattern" => pattern, "value" => value }
+        end
+      end
+
       # Raised when {.compose} encounters incompatible entries
       # under the same key (file digest mismatch, gem-locked
       # disagreement, …). Callers handle the exception by
@@ -167,14 +228,15 @@ module Rigor
       # contribution silently.
       class Conflict < StandardError; end
 
-      attr_reader :files, :gems, :plugins, :configs, :dependencies
+      attr_reader :files, :gems, :plugins, :configs, :dependencies, :globs
 
-      def initialize(files: [], gems: [], plugins: [], configs: [], dependencies: [])
+      def initialize(files: [], gems: [], plugins: [], configs: [], dependencies: [], globs: [])
         @files = files.dup.freeze
         @gems = gems.dup.freeze
         @plugins = plugins.dup.freeze
         @configs = configs.dup.freeze
         @dependencies = dependencies.dup.freeze
+        @globs = globs.dup.freeze
         freeze
       end
 
@@ -185,11 +247,15 @@ module Rigor
       # `files` are checked — non-file inputs (config / gems / version)
       # belong in the cache *key*, not the validated dependency set — so
       # a descriptor carrying any non-file slot is never considered fresh
-      # (it was built wrong for this use).
+      # (it was built wrong for this use). ADR-60 WD3 adds `globs`
+      # alongside `files` as a re-validatable slot: a {GlobEntry} is
+      # fresh when re-globbing + re-digesting reproduces its recorded
+      # value.
       def fresh?
         return false unless gems.empty? && plugins.empty? && configs.empty? && dependencies.empty?
 
-        files.all? { |entry| file_entry_fresh?(entry) }
+        files.all? { |entry| file_entry_fresh?(entry) } &&
+          globs.all? { |entry| glob_entry_fresh?(entry) }
       end
 
       # File-comparator strictness ordering. `:digest` is strictest
@@ -212,7 +278,9 @@ module Rigor
         plugins = compose_by_key(descriptors.flat_map(&:plugins), :id)
         configs = compose_by_key(descriptors.flat_map(&:configs), :key)
         dependencies = compose_by_key(descriptors.flat_map(&:dependencies), :gem_name)
-        new(files: files, gems: gems, plugins: plugins, configs: configs, dependencies: dependencies)
+        globs = compose_by_key(descriptors.flat_map(&:globs), :slot_key)
+        new(files: files, gems: gems, plugins: plugins, configs: configs,
+            dependencies: dependencies, globs: globs)
       end
 
       # @param producer_id [String]
@@ -241,6 +309,7 @@ module Rigor
           "dependencies" => sort_entries(dependencies, "gem_name").map(&:to_h),
           "files" => sort_entries(files, "path").map(&:to_h),
           "gems" => sort_entries(gems, "name").map(&:to_h),
+          "globs" => globs.sort_by { |e| [e.root, e.pattern] }.map(&:to_h),
           "plugins" => sort_entries(plugins, "id").map(&:to_h)
         }
       end
@@ -291,6 +360,15 @@ module Rigor
         false
       end
 
+      # ADR-60 WD3 — re-runs the entry's glob + digest and compares
+      # against the recorded value. Any failure reads as stale
+      # (recompute), never a crash.
+      def glob_entry_fresh?(entry)
+        GlobEntry.digest_for(root: entry.root, pattern: entry.pattern) == entry.value
+      rescue StandardError
+        false
+      end
+
       def sort_entries(entries, key)
         entries.sort_by { |e| e.to_h.fetch(key).to_s }
       end

data/lib/rigor/cache/rbs_descriptor.rb

@@ -29,7 +29,8 @@ module Rigor
 
       def self.file_entries(loader)
         roots = loader.signature_paths +
-                Rigor::Environment::RbsLoader.vendored_gem_sig_paths
+                Rigor::Environment::RbsLoader.vendored_gem_sig_paths +
+                Rigor::Environment::RbsLoader.core_overlay_sig_paths
         roots.flat_map do |root|
           next [] unless root.directory?