rigortype 0.2.6 → 0.2.7

data/plugins/rigor-hanami/lib/rigor/plugin/hanami/action_checker.rb

@@ -22,17 +22,20 @@ module Rigor
           @contracts = contracts
         end
 
-        def check(path:, root:)
-          @contracts.flat_map do |contract|
-            next [] unless path_matches?(contract.path_glob, path)
-
-            class_nodes(root).filter_map do |class_node|
-              handle_def = find_handle(class_node, contract)
-              if handle_def.nil?
-                missing_handle_diagnostic(contract, path, class_node)
-              else
-                handle_arity_mismatch_diagnostic(contract, path, class_node, handle_def)
-              end
+        # Per-`ClassNode` check over the engine-owned walk (ADR-37):
+        # called once per class node the `node_rule` in `hanami.rb`
+        # dispatches, against every contract whose `path_glob` matches
+        # the file. No cross-class-node state is needed, so the checker
+        # ships no `class_nodes` traversal of its own.
+        def check_class(class_node, path:)
+          @contracts.filter_map do |contract|
+            next unless path_matches?(contract.path_glob, path)
+
+            handle_def = find_handle(class_node, contract)
+            if handle_def.nil?
+              missing_handle_diagnostic(contract, path, class_node)
+            else
+              handle_arity_mismatch_diagnostic(contract, path, class_node, handle_def)
             end
           end
         end
@@ -49,12 +52,6 @@ module Rigor
             File.fnmatch?(File.join("**", glob), path, FNMATCH_FLAGS)
         end
 
-        def class_nodes(root)
-          found = []
-          walk(root) { |node| found << node if node.is_a?(Prism::ClassNode) }
-          found
-        end
-
         def find_handle(class_node, contract)
           direct_defs(class_node).find do |def_node|
             def_node.name == contract.method_name &&
@@ -107,13 +104,6 @@ module Rigor
           path = class_node.constant_path
           path.respond_to?(:slice) ? path.slice : class_node.name.to_s
         end
-
-        def walk(node, &)
-          return if node.nil?
-
-          yield node
-          node.compact_child_nodes.each { |child| walk(child, &) }
-        end
       end
     end
   end

data/plugins/rigor-hanami/lib/rigor/plugin/hanami.rb

@@ -98,11 +98,18 @@ module Rigor
         @protocol_contracts || manifest.protocol_contracts
       end
 
-      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+      # ADR-37 — per-class-node validation over the engine-owned walk.
+      # Each `Prism::ClassNode` is checked against every contract
+      # independently, so the plugin no longer ships its own `class_nodes`
+      # traversal; `ActionChecker#check_class` keeps the per-class
+      # contract logic. (A per-class contract check is exactly what
+      # `node_rule` is for — the return type is void, so no `scope`
+      # query is needed.)
+      node_rule Prism::ClassNode do |node, _scope, path|
         contracts = protocol_contracts
-        return [] if contracts.empty?
+        next [] if contracts.empty?
 
-        ActionChecker.new(contracts: contracts).check(path: path, root: root)
+        ActionChecker.new(contracts: contracts).check_class(node, path: path)
       end
     end
 

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet.rb

@@ -147,11 +147,7 @@ module Rigor
         # symlink-bearing form here. Look up under both so the
         # match is symlink-agnostic.
         errors = @parse_errors_by_path[path] || @parse_errors_by_path[canonicalize(path)] || []
-        diagnostics = errors.map { |error| parse_error_diagnostic(path, error) }
-        diagnostics.concat(absurd_reachable_diagnostics(path, root))
-        diagnostics.concat(reveal_type_diagnostics(path, root))
-        diagnostics.concat(assert_type_mismatch_diagnostics(path, root))
-        diagnostics
+        errors.map { |error| parse_error_diagnostic(path, error) }
       end
 
       # ADR-52 slice 4 — per-call return-type path via the
@@ -179,6 +175,35 @@ module Rigor
         bind_post_return_facts(call_node, scope)
       end
 
+      # ADR-37 — the three per-call diagnostics ride the engine-owned
+      # walk instead of three hand-rolled `walk_for_*` recursions. Each
+      # candidate `T.` call is *recorded by object identity* during the
+      # inference pass (the `dynamic_return` / `narrowing_facts` rules
+      # above call `record_*`), so by the time these node rules fire in
+      # the diagnostics phase the sets are populated; the membership
+      # `delete` both gates the emission and pops the entry so a re-run
+      # cannot double-fire. The recorded set is the gate — no per-node
+      # `AbsurdRecognizer` / name check is needed here.
+      node_rule Prism::CallNode do |node, _scope, path|
+        next [] unless @reachable_absurd_nodes.delete(node)
+
+        [absurd_diagnostic(path, node)]
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        display = @reveal_type_calls.delete(node)
+        next [] if display.nil?
+
+        [reveal_type_diagnostic(path, node, display)]
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        recorded = @assert_type_mismatches.delete(node)
+        next [] if recorded.nil?
+
+        [assert_type_mismatch_diagnostic(path, node, *recorded)]
+      end
+
       private
 
       # Run-time method-name gate for the `dynamic_return` rule
@@ -536,31 +561,9 @@ module Rigor
         nil
       end
 
-      # Walks the per-file AST looking for `T.absurd(x)` call
-      # nodes and emits a `plugin.sorbet.absurd-reachable`
-      # warning for any whose object identity matches
-      # `@reachable_absurd_nodes` (populated during the engine's
-      # earlier pass through the `dynamic_return` rule). Pops
-      # matched entries so a duplicate run doesn't double-emit.
-      def absurd_reachable_diagnostics(path, root)
-        return [] if @reachable_absurd_nodes.empty?
-
-        diagnostics = []
-        walk_for_absurd(root) do |call_node|
-          next unless @reachable_absurd_nodes.delete(call_node)
-
-          diagnostics << absurd_diagnostic(path, call_node)
-        end
-        diagnostics
-      end
-
-      def walk_for_absurd(node, &)
-        return unless node.is_a?(Prism::Node)
-
-        yield node if node.is_a?(Prism::CallNode) && AbsurdRecognizer.absurd_call?(node)
-        node.compact_child_nodes.each { |child| walk_for_absurd(child, &) }
-      end
-
+      # Emits a `plugin.sorbet.absurd-reachable` warning for the
+      # `T.absurd(x)` call recorded in `@reachable_absurd_nodes` during
+      # inference; the node rule above does the identity match and pop.
       def absurd_diagnostic(path, call_node)
         Rigor::Analysis::Diagnostic.from_node(
           call_node,
@@ -591,29 +594,6 @@ module Rigor
         type.respond_to?(:describe) ? type.describe : type.inspect
       end
 
-      def reveal_type_diagnostics(path, root)
-        return [] if @reveal_type_calls.empty?
-
-        diagnostics = []
-        walk_for_reveal_type(root) do |call_node|
-          display = @reveal_type_calls.delete(call_node)
-          next if display.nil?
-
-          diagnostics << reveal_type_diagnostic(path, call_node, display)
-        end
-        diagnostics
-      end
-
-      def walk_for_reveal_type(node, &)
-        return unless node.is_a?(Prism::Node)
-
-        if node.is_a?(Prism::CallNode) && node.name == :reveal_type &&
-           TypeTranslator.sorbet_t_namespaced?(node.receiver)
-          yield node
-        end
-        node.compact_child_nodes.each { |child| walk_for_reveal_type(child, &) }
-      end
-
       def reveal_type_diagnostic(path, call_node, display)
         Rigor::Analysis::Diagnostic.from_node(
           call_node,
@@ -647,29 +627,6 @@ module Rigor
         @assert_type_mismatches[call_node] = [display_for_type(inferred), display_for_type(asserted)]
       end
 
-      def assert_type_mismatch_diagnostics(path, root)
-        return [] if @assert_type_mismatches.empty?
-
-        diagnostics = []
-        walk_for_assert_type(root) do |call_node|
-          recorded = @assert_type_mismatches.delete(call_node)
-          next if recorded.nil?
-
-          diagnostics << assert_type_mismatch_diagnostic(path, call_node, *recorded)
-        end
-        diagnostics
-      end
-
-      def walk_for_assert_type(node, &)
-        return unless node.is_a?(Prism::Node)
-
-        if node.is_a?(Prism::CallNode) && node.name == :assert_type! &&
-           TypeTranslator.sorbet_t_namespaced?(node.receiver)
-          yield node
-        end
-        node.compact_child_nodes.each { |child| walk_for_assert_type(child, &) }
-      end
-
       def assert_type_mismatch_diagnostic(path, call_node, inferred_display, asserted_display)
         Rigor::Analysis::Diagnostic.from_node(
           call_node,

data/skills/rigor-ask/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: rigor-ask
 description: |
-  Rigor is a niche, fast-moving Ruby type checker; its rules, flags, and type behaviour are version-specific, so what you "remember" about it is likely wrong or stale — do NOT answer from memory or guess. For ANY question about Rigor, use this skill and investigate procedurally: run `rigor docs` (handbook + manual, bundled OFFLINE and version-matched), `rigor explain` for a diagnostic id, and for the user's own code `rigor check` / `annotate` / `type-of`, then answer only from what you read. Covers: why a line is flagged or if it's a false positive; the type model (narrowing, refinements, `Dynamic`, RBS); config keys, flags, baselines; comparisons to Sorbet, Steep, mypy, PHPStan; whether it handles Rails, RSpec, or a gem; writing an RBS signature; "what is Rigor / why use it / is it right for us?". Trigger on any Rigor mention seeking understanding — even casual, comparative, or grumbling. Skip only when Rigor isn't mentioned, or it's purely "set it up / fix / reduce it for me" (→ rigor-next-steps).
+  Answer any question about Rigor by investigating, not from memory — Rigor is niche and version-specific, so run its tools and read its bundled docs, then answer from what you saw. Use `rigor docs` (handbook + manual, offline and version-matched) and `rigor explain <rule>`; for the user's own code, `rigor check` / `annotate` / `type-of`. Covers: why a line is flagged or whether it's a false positive; the type model (narrowing, refinements, `Dynamic`, RBS); config keys, flags, baselines; comparisons to Sorbet, Steep, mypy, PHPStan; whether Rigor handles Rails, RSpec, or a given gem; how to type a method; "what is Rigor / why use it / is it right for us?". Trigger on any Rigor question seeking understanding — even casual, comparative, or grumbling. Skip only when it's purely "set it up / fix / reduce it for me" (use rigor-next-steps).
 license: MPL-2.0
 metadata:
   version: 0.2.0
@@ -36,6 +36,26 @@ This is the user's shortcut: they only ever need to remember two skills —
 into the right lookup or analysis so they never have to remember the
 command.
 
+## Prefer the live map over this skill's tables
+
+The doc-page names and command flags below are a snapshot; Rigor's pages
+and CLI move release to release, and a vendored copy of this skill (e.g.
+added via `npx skills`) lags further still. Treat the tables as
+orientation, then confirm against the **installed** Rigor, which is always
+current:
+
+```sh
+rigor docs --list              # the live doc map — what pages exist in THIS version
+rigor --help                   # the live command + flag list
+rigor skill --full rigor-ask   # the current version of this skill itself
+```
+
+Never cite a page, flag, or rule id you have not just seen in one of these
+— that is this skill's whole discipline. If `rigor` is not installed, you
+can still answer high-level "what is Rigor?" questions from the web
+<https://rigor.typedduck.fail/llms.txt>, but for anything version-specific
+install it first (see `rigor-next-steps`).
+
 ## The toolbox
 
 Everything here is read-only and needs no network.

data/skills/rigor-baseline-reduce/SKILL.md

@@ -19,6 +19,22 @@ This skill is for **users improving their own project**. It uses the
 published `rigor` executable on `PATH` and references only public CLI
 flags and config keys.
 
+## First: load the version-current copy
+
+The step-by-step commands live in this skill's `references/` files, and
+their exact flags drift between Rigor releases — so follow the copy that
+ships with the **installed** Rigor rather than any vendored or frozen copy
+of this file. Get the complete current procedure in one call:
+
+```sh
+rigor skill --full rigor-baseline-reduce   # this body + all its references/, inline
+```
+
+If you already loaded this skill *via* `rigor skill` you have the current
+copy — just proceed (read any `references/NN-*.md` from the directory the
+header names). If `rigor` is not on `PATH`, this task needs it: run
+**`rigor-next-steps`** to install Rigor first, then come back.
+
 ## Phase 0 — When to use this skill
 
 Trigger when the user says "reduce the rigor baseline", "fix some