rigortype 0.1.15 → 0.1.16

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

@@ -94,19 +94,20 @@ module Rigor
         Analyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
       end
 
-      # Pillar 2 Slice 1 — spec-derived flow facts from RSpec
-      # matcher assertions (six-matcher floor: `be_a`,
-      # `be_kind_of`, `be_instance_of`, `be_nil`, `eq(literal)`,
-      # `eql(literal)`; `match(/regex/)`; `not_to` / `to_not`).
-      #
-      # Pillar 2 Slice 2 (v0.3.0) — additionally binds local
-      # reads in `it` / spec bodies to their `let(:name) { ... }`
-      # block's inferred return type. Composes with Slice 1:
-      # a matcher narrowing fires after the let binding.
-      def flow_contribution_for(call_node:, scope:)
-        matcher = MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)
-        return matcher if matcher
+      # ADR-37 slice 2 — Pillar 2 Slice 1 matcher narrowing
+      # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
+      # method-gated by the engine on the expectation verbs.
+      type_specifier methods: %i[to not_to to_not] do |call_node, scope|
+        MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
+      end
 
+      # Pillar 2 Slice 2 — binds local reads in `it` / spec bodies to
+      # their `let(:name) { ... }` block's inferred return type. This is
+      # a *method-gated return type* (keyed on the let-bound name read),
+      # which the receiver-gated `dynamic_return` cannot express, so it
+      # stays on `flow_contribution_for` — the deprecated escape valve
+      # (ADR-37 slice 2 § "Outcome").
+      def flow_contribution_for(call_node:, scope:)
         let_binding_contribution(call_node, scope)
       end
 

data/plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails/have_http_status_analyzer.rb

@@ -35,29 +35,27 @@ module Rigor
       # in shared-context bodies; the diagnostic is the same
       # regardless of the surrounding chain.
       module HaveHttpStatusAnalyzer
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One matcher violation: the kebab-case `rule` and the
+        # human-readable `message`. Carries no location/path — the
+        # caller (the `node_rule` block) positions the diagnostic at the
+        # matcher's `message_loc` via `Plugin::Base#diagnostic`.
+        Violation = Struct.new(:rule, :message, keyword_init: true)
 
         MATCHER_NAME = :have_http_status
 
         module_function
 
-        # @param path [String]
-        # @param root [Prism::Node]
-        # @return [Array<Diagnostic>]
-        def diagnose(path:, root:)
-          diagnostics = []
-          walk(root) do |call_node|
-            diagnostic = diagnostic_for(call_node, path)
-            diagnostics << diagnostic if diagnostic
-          end
-          diagnostics
-        end
-
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
-
-          yield node if call_to_matcher?(node)
-          node.compact_child_nodes.each { |child| walk(child, &) }
+        # The matcher violation for a single CallNode, or nil when the
+        # node is not a `have_http_status(<int|symbol>)` matcher or its
+        # argument is statically valid. ADR-37: the engine owns the
+        # walk, so this is per-node logic — no traversal here.
+        #
+        # @param call_node [Prism::Node]
+        # @return [Violation, nil]
+        def violation_for(call_node)
+          return nil unless call_to_matcher?(call_node)
+
+          diagnostic_for(call_node)
         end
 
         # `have_http_status` is a matcher — called either with
@@ -77,32 +75,34 @@ module Rigor
           args.size == 1
         end
 
-        def diagnostic_for(call_node, path)
+        def diagnostic_for(call_node)
           arg = call_node.arguments.arguments.first
           case arg
-          when Prism::IntegerNode then integer_diagnostic(call_node, path, arg)
-          when Prism::SymbolNode then symbol_diagnostic(call_node, path, arg)
+          when Prism::IntegerNode then integer_violation(arg)
+          when Prism::SymbolNode then symbol_violation(arg)
           end
         end
 
-        def integer_diagnostic(call_node, path, integer_node)
+        def integer_violation(integer_node)
           value = integer_node.value
           return nil if HttpStatusCodes::VALID_NUMERIC_RANGE.cover?(value)
 
-          build_diagnostic(
-            call_node, path,
+          Violation.new(
             rule: "have_http_status.out-of-range",
             message: "have_http_status(#{value}) is outside the valid HTTP status " \
                      "range #{HttpStatusCodes::VALID_NUMERIC_RANGE}"
           )
         end
 
-        def symbol_diagnostic(call_node, path, symbol_node)
+        def symbol_violation(symbol_node)
           sym = symbol_node.unescaped.to_sym
-          return nil if HttpStatusCodes::KNOWN_SYMBOLS.include?(sym)
+          known = HttpStatusCodes.known_symbols
+          # ADR-39: Rack unavailable → the accepted symbol set is
+          # unknowable, so decline rather than flag from a guess.
+          return nil if known.nil?
+          return nil if known.include?(sym)
 
-          build_diagnostic(
-            call_node, path,
+          Violation.new(
             rule: "have_http_status.unknown-symbol",
             message: "have_http_status(:#{sym}) is not a recognised HTTP status symbol " \
                      "(see Rack::Utils::SYMBOL_TO_STATUS_CODE) or Rails status-group " \
@@ -110,18 +110,6 @@ module Rigor
                      ":client_error / :server_error / :informational)"
           )
         end
-
-        def build_diagnostic(call_node, path, rule:, message:)
-          location = call_node.message_loc || call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
-            severity: :warning,
-            rule: rule,
-            message: message
-          )
-        end
       end
     end
   end

data/plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails/http_status_codes.rb

@@ -3,57 +3,54 @@
 module Rigor
   module Plugin
     class RspecRails < Rigor::Plugin::Base
-      # Curated set of HTTP-status symbols `have_http_status`
-      # accepts. Derived from `Rack::Utils::SYMBOL_TO_STATUS_CODE`
-      # (Rack 3.x snapshot) plus Rails' status-group aliases
-      # accepted by `ActionDispatch::TestResponse`.
+      # The set of HTTP-status symbols `have_http_status` accepts.
       #
-      # Vendored as a frozen Set so the plugin has no
-      # `rack` / `actionpack` runtime dependency — checking
-      # against a static catalogue is intentional: a future
-      # Rack release that adds a new alias would require
-      # bumping this constant, but the false-positive risk is
-      # bounded (the diagnostic just suggests a typo when in
-      # fact the symbol is newly-added).
+      # ADR-39 — the HTTP status symbols come from the **real**
+      # `Rack::Utils::SYMBOL_TO_STATUS_CODE` (the authority `have_http_status`
+      # itself resolves through `Rack::Utils.status_code`), not a vendored
+      # snapshot: a snapshot that lagged the installed Rack would flag a
+      # newly-added status symbol as a false `unknown-symbol` (a false
+      # positive on working code). When Rack cannot be loaded the symbol
+      # set is unknowable, so {known_symbols} returns `nil` and the caller
+      # **declines** to flag anything — reduced coverage, never a guess.
+      #
+      # The Rails status-group aliases (`:success`, `:missing`, …) are a
+      # small, stable convention set defined by Rails
+      # (`ActionDispatch::TestResponse`) — not a growing catalogue — so
+      # they are kept as a constant rather than pulling in actionpack.
       module HttpStatusCodes
-        SYMBOL_TO_STATUS_CODE = {
-          # 1xx Informational
-          continue: 100, switching_protocols: 101, processing: 102, early_hints: 103,
-          # 2xx Success
-          ok: 200, created: 201, accepted: 202, non_authoritative_information: 203,
-          no_content: 204, reset_content: 205, partial_content: 206, multi_status: 207,
-          already_reported: 208, im_used: 226,
-          # 3xx Redirection
-          multiple_choices: 300, moved_permanently: 301, found: 302, see_other: 303,
-          not_modified: 304, use_proxy: 305, temporary_redirect: 307,
-          permanent_redirect: 308,
-          # 4xx Client Error
-          bad_request: 400, unauthorized: 401, payment_required: 402, forbidden: 403,
-          not_found: 404, method_not_allowed: 405, not_acceptable: 406,
-          proxy_authentication_required: 407, request_timeout: 408, conflict: 409,
-          gone: 410, length_required: 411, precondition_failed: 412,
-          payload_too_large: 413, uri_too_long: 414, unsupported_media_type: 415,
-          range_not_satisfiable: 416, expectation_failed: 417, misdirected_request: 421,
-          unprocessable_entity: 422, unprocessable_content: 422, locked: 423,
-          failed_dependency: 424, too_early: 425, upgrade_required: 426,
-          precondition_required: 428, too_many_requests: 429,
-          request_header_fields_too_large: 431, unavailable_for_legal_reasons: 451,
-          # 5xx Server Error
-          internal_server_error: 500, not_implemented: 501, bad_gateway: 502,
-          service_unavailable: 503, gateway_timeout: 504, http_version_not_supported: 505,
-          variant_also_negotiates: 506, insufficient_storage: 507, loop_detected: 508,
-          not_extended: 510, network_authentication_required: 511,
-          # Rails status-group aliases (see
-          # ActionDispatch::TestResponse RESPONSE_PREDICATES)
-          informational: :informational_group, success: :success_group,
-          successful: :success_group, redirect: :redirect_group,
-          client_error: :client_error_group, missing: :client_error_group,
-          server_error: :server_error_group, error: :server_error_group
-        }.freeze
-
-        KNOWN_SYMBOLS = SYMBOL_TO_STATUS_CODE.keys.to_set.freeze
+        RAILS_STATUS_GROUP_ALIASES = %i[
+          informational success successful redirect
+          client_error missing server_error error
+        ].to_set.freeze
 
         VALID_NUMERIC_RANGE = (100..599)
+
+        module_function
+
+        # The authoritative set of accepted `have_http_status` symbols
+        # (real Rack status symbols ∪ the Rails group aliases), or `nil`
+        # when it cannot be determined because Rack is unavailable. A
+        # `nil` return means "decline" — the caller MUST NOT flag any
+        # symbol as unknown (ADR-39: never guess from a stale copy).
+        def known_symbols
+          rack = rack_status_symbols
+          return nil if rack.nil?
+
+          rack | RAILS_STATUS_GROUP_ALIASES
+        end
+
+        # The real `Rack::Utils::SYMBOL_TO_STATUS_CODE` keys, or `nil` when
+        # Rack is not loadable. Lazy require (core Rigor carries no Rack
+        # dependency; the plugin brings it); memoised for the process.
+        def rack_status_symbols
+          return @rack_status_symbols if defined?(@rack_status_symbols)
+
+          require "rack/utils"
+          @rack_status_symbols = Rack::Utils::SYMBOL_TO_STATUS_CODE.keys.to_set.freeze
+        rescue LoadError, StandardError
+          @rack_status_symbols = nil
+        end
       end
     end
   end

data/plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails.rb

@@ -56,17 +56,18 @@ module Rigor
         description: "Validates rspec-rails behavioral matchers (have_http_status floor)."
       )
 
-      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        HaveHttpStatusAnalyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
-      end
-
-      private
+      # ADR-37 — the engine walks each file and hands us every
+      # CallNode; the analyzer is now pure per-node logic. The
+      # diagnostic points at the matcher name (`message_loc`),
+      # reproducing the previous `message_loc || location` positioning.
+      node_rule Prism::CallNode do |node, _scope, path|
+        violation = HaveHttpStatusAnalyzer.violation_for(node)
+        next [] unless violation
 
-      def build_diagnostic(diag)
-        Rigor::Analysis::Diagnostic.new(
-          path: diag.path, line: diag.line, column: diag.column,
-          message: diag.message, severity: diag.severity, rule: diag.rule
-        )
+        [diagnostic(
+          node, path: path, location: node.message_loc,
+                message: violation.message, severity: :warning, rule: violation.rule
+        )]
       end
     end
 

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers/analyzer.rb

@@ -37,7 +37,7 @@ module Rigor
       #
       # All look up `:col` against the model's columns
       # (`Entry#column?`). Unknown columns fire
-      # `shoulda-matchers.unknown-column`.
+      # `unknown-column`.
       #
       # ### Association matchers
       #
@@ -47,12 +47,15 @@ module Rigor
       #   have_and_belong_to_many(:assoc) ← expects :collection
       #
       # Unknown associations fire
-      # `shoulda-matchers.unknown-association`. Known
+      # `unknown-association`. Known
       # associations with mismatched kind (`should belong_to(:posts)`
       # where `:posts` is `has_many`) fire
-      # `shoulda-matchers.association-kind-mismatch`.
+      # `association-kind-mismatch`.
       module Analyzer
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One matcher violation (always `:warning`). Carries no
+        # path/location — the caller (the `node_rule` block) positions it
+        # at the matcher name (`message_loc`) via `Plugin::Base#diagnostic`.
+        Violation = Struct.new(:rule, :message, keyword_init: true)
 
         # `(matcher_name) => (:column | :association_singular | :association_collection)`
         # — the validation lane each matcher routes to.
@@ -85,68 +88,38 @@ module Rigor
         # @param model_index [Object, nil] the `:model_index`
         #   fact value. When nil the analyzer falls silent.
         # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, model_index:)
+        # The matcher violations for a single call node (0..1), or `[]`
+        # when it is not a shoulda matcher, sits outside any
+        # `describe <ModelConst>` block, or the model is unknown.
+        # ADR-37: the engine owns the walk; the model anchor comes from
+        # the node-rule `NodeContext` ancestors (the innermost enclosing
+        # `describe`-with-constant — nested const describes override,
+        # `describe ".method"` string blocks inherit), exactly as the
+        # former recursive anchor propagation did.
+        #
+        # @param matcher_call [Prism::Node]
+        # @param ancestors [Array<Prism::Node>]
+        # @param model_index [Object, nil]
+        # @return [Array<Violation>]
+        def violations_for(matcher_call:, ancestors:, model_index:)
           return [] if model_index.nil?
+          return [] unless matcher_invocation?(matcher_call)
 
-          diagnostics = []
-          walk_describe(root, anchor_model: nil) do |matcher_call, anchor|
-            entry = model_index.find(anchor)
-            next if entry.nil?
+          anchor = anchor_for(ancestors)
+          return [] if anchor.nil?
 
-            diagnostic = diagnostic_for(matcher_call, path, anchor, entry)
-            diagnostics << diagnostic if diagnostic
-          end
-          diagnostics
-        end
-
-        # Walks for `RSpec.describe(Const)` / `describe(Const)`
-        # blocks (the Const is the model anchor) and yields
-        # every matcher call found in their body.
-        #
-        # The anchor stays the OUTERMOST describe-with-const
-        # — nested describes / contexts inherit it without
-        # overriding (a nested `describe ".active"` is not a
-        # model constant). When a nested describe DOES name a
-        # different model, the nested anchor wins inside that
-        # subtree (rare; we still honour it).
-        def walk_describe(node, anchor_model:, &)
-          return unless node.is_a?(Prism::Node)
+          entry = model_index.find(anchor)
+          return [] if entry.nil?
 
-          if describe_with_constant?(node)
-            inner_anchor = describe_const_name(node) || anchor_model
-            collect_matchers(node.block.body, inner_anchor, &) if node.block&.body
-            return
-          end
-
-          node.compact_child_nodes.each do |child|
-            walk_describe(child, anchor_model: anchor_model, &)
-          end
+          violation = diagnostic_for(matcher_call, anchor, entry)
+          violation ? [violation] : []
         end
 
-        # Walks the body of a describe block looking for:
-        #   (a) matcher calls — `should MATCHER` or
-        #       `expect(...).to MATCHER` chains; we yield the
-        #       inner MATCHER call.
-        #   (b) nested describe / context blocks — we recurse
-        #       so deeper matchers are reachable.
-        def collect_matchers(body, anchor, &)
-          return unless body.is_a?(Prism::Node)
-          return if anchor.nil?
-
-          if matcher_invocation?(body)
-            yield body, anchor
-            return
-          end
-
-          if describe_with_constant?(body)
-            inner_anchor = describe_const_name(body) || anchor
-            collect_matchers(body.block.body, inner_anchor, &) if body.block&.body
-            return
-          end
-
-          body.compact_child_nodes.each do |child|
-            collect_matchers(child, anchor, &)
-          end
+        # The model anchor in effect at a node: the constant named by the
+        # innermost enclosing `describe <Const> do … end`, or nil.
+        def anchor_for(ancestors)
+          describe = ancestors.rfind { |n| describe_with_constant?(n) }
+          describe && describe_const_name(describe)
         end
 
         # A direct matcher invocation is a `CallNode` whose
@@ -203,63 +176,48 @@ module Rigor
 
         # --- diagnostics ---
 
-        def diagnostic_for(matcher_call, path, anchor, entry)
+        def diagnostic_for(matcher_call, anchor, entry)
           lane = MATCHER_TABLE.fetch(matcher_call.name)
           target = matcher_call.arguments.arguments.first.unescaped.to_sym
 
           case lane
           when :column
-            column_diagnostic(matcher_call, path, anchor, entry, target)
+            column_violation(matcher_call, anchor, entry, target)
           when :association_singular
-            association_diagnostic(matcher_call, path, anchor, entry, target, expected_kind: :singular)
+            association_violation(matcher_call, anchor, entry, target, expected_kind: :singular)
           when :association_collection
-            association_diagnostic(matcher_call, path, anchor, entry, target, expected_kind: :collection)
+            association_violation(matcher_call, anchor, entry, target, expected_kind: :collection)
           end
         end
 
-        def column_diagnostic(matcher_call, path, anchor, entry, column_name)
+        def column_violation(matcher_call, anchor, entry, column_name)
           return nil if entry.column?(column_name)
 
-          build_diagnostic(
-            matcher_call, path,
-            rule: "shoulda-matchers.unknown-column",
+          Violation.new(
+            rule: "unknown-column",
             message: "#{matcher_call.name}(:#{column_name}) — no column `#{column_name}` on " \
                      "#{anchor} (columns: #{entry.column_names.sort.join(', ')})"
           )
         end
 
-        def association_diagnostic(matcher_call, path, anchor, entry, assoc_name, expected_kind:)
+        def association_violation(matcher_call, anchor, entry, assoc_name, expected_kind:)
           if entry.association?(assoc_name)
             actual = entry.association(assoc_name)[:kind]
             return nil if actual == expected_kind
 
-            build_diagnostic(
-              matcher_call, path,
-              rule: "shoulda-matchers.association-kind-mismatch",
+            Violation.new(
+              rule: "association-kind-mismatch",
               message: "#{matcher_call.name}(:#{assoc_name}) on #{anchor} — `#{assoc_name}` is " \
                        "a #{actual} association; #{matcher_call.name} expects #{expected_kind}"
             )
           else
-            build_diagnostic(
-              matcher_call, path,
-              rule: "shoulda-matchers.unknown-association",
+            Violation.new(
+              rule: "unknown-association",
               message: "#{matcher_call.name}(:#{assoc_name}) — no association `#{assoc_name}` on " \
                        "#{anchor} (associations: #{entry.association_names.sort.join(', ')})"
             )
           end
         end
-
-        def build_diagnostic(call_node, path, rule:, message:)
-          location = call_node.message_loc || call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
-            severity: :warning,
-            rule: rule,
-            message: message
-          )
-        end
       end
     end
   end

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers.rb

@@ -76,13 +76,19 @@ module Rigor
         @model_index_resolved = false
       end
 
-      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+      # ADR-37 — per-matcher validation over the engine-owned walk. The
+      # model anchor (the enclosing `describe <Model>` const) comes from
+      # the node-rule NodeContext ancestors; the diagnostic points at the
+      # matcher name (message_loc). The :model_index fact (from
+      # rigor-activerecord) is read lazily; without it the rule is silent.
+      node_rule Prism::CallNode do |node, _scope, path, _fc, context|
         index = model_index_or_nil
-        return [] if index.nil?
+        next [] if index.nil?
 
-        Analyzer.diagnose(
-          path: path, root: root, model_index: index
-        ).map { |diag| build_diagnostic(diag) }
+        Analyzer.violations_for(matcher_call: node, ancestors: context.ancestors, model_index: index).map do |violation|
+          diagnostic(node, path: path, location: node.message_loc,
+                           message: violation.message, severity: :warning, rule: violation.rule)
+        end
       end
 
       private
@@ -99,13 +105,6 @@ module Rigor
         @model_index_resolved = true
         @model_index
       end
-
-      def build_diagnostic(diag)
-        Rigor::Analysis::Diagnostic.new(
-          path: diag.path, line: diag.line, column: diag.column,
-          message: diag.message, severity: diag.severity, rule: diag.rule
-        )
-      end
     end
 
     Rigor::Plugin.register(ShouldaMatchers)

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/analyzer.rb

@@ -31,35 +31,34 @@ module Rigor
 
         ENTRY_METHODS = (DIRECT_ENTRY_METHODS + SCHEDULED_ENTRY_METHODS).freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One worker-call observation: the kebab-case `rule`, `severity`,
+        # and human-readable `message`. Carries no path/location — the
+        # caller (the `node_rule` block) positions it via
+        # `Plugin::Base#diagnostic`.
+        Violation = Struct.new(:rule, :severity, :message, keyword_init: true)
 
         module_function
 
-        # @param path [String]
-        # @param root [Prism::Node]
+        # The worker-call violations for a single call node (0..2), or
+        # `[]` when the node is not a `<Worker>.perform_*` entry call on a
+        # known worker. ADR-37: the engine owns the walk.
+        #
+        # @param call_node [Prism::Node]
         # @param worker_index [WorkerIndex]
-        # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, worker_index:)
-          diagnostics = []
-          walk(root) do |call_node|
-            class_name = constant_receiver_name(call_node.receiver)
-            next if class_name.nil?
-
-            entry = worker_index.find(class_name) || worker_index.find("::#{class_name}")
-            next if entry.nil?
-
-            diagnostics << info_diagnostic(path, call_node, entry)
-            arity_diag = arity_check(path, call_node, entry)
-            diagnostics << arity_diag if arity_diag
-          end
-          diagnostics
-        end
+        # @return [Array<Violation>]
+        def violations_for(call_node:, worker_index:)
+          return [] unless call_node.is_a?(Prism::CallNode) && entry_call?(call_node)
+
+          class_name = constant_receiver_name(call_node.receiver)
+          return [] if class_name.nil?
 
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
+          entry = worker_index.find(class_name) || worker_index.find("::#{class_name}")
+          return [] if entry.nil?
 
-          yield node if node.is_a?(Prism::CallNode) && entry_call?(node)
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          violations = [info_violation(call_node, entry)]
+          arity = arity_violation(call_node, entry)
+          violations << arity if arity
+          violations
         end
 
         def entry_call?(node)
@@ -67,12 +66,8 @@ module Rigor
             (node.receiver.is_a?(Prism::ConstantReadNode) || node.receiver.is_a?(Prism::ConstantPathNode))
         end
 
-        def info_diagnostic(path, call_node, entry)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def info_violation(call_node, entry)
+          Violation.new(
             severity: :info,
             rule: "worker-call",
             message: "`#{entry.class_name}.#{call_node.name}` matches `#perform` " \
@@ -80,24 +75,20 @@ module Rigor
           )
         end
 
-        def arity_check(path, call_node, entry)
+        def arity_violation(call_node, entry)
           all_args = (call_node.arguments&.arguments || []).size
           # Scheduled entries consume the first arg as the
           # schedule; the rest are forwarded.
           forwarded_count = SCHEDULED_ENTRY_METHODS.include?(call_node.name) ? all_args - 1 : all_args
 
           if SCHEDULED_ENTRY_METHODS.include?(call_node.name) && all_args.zero?
-            return missing_schedule_diagnostic(path, call_node, entry)
+            return missing_schedule_violation(call_node, entry)
           end
 
           return nil if forwarded_count.negative?
           return nil if entry.accepts?(forwarded_count)
 
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "wrong-arity",
             message: "`#{entry.class_name}.#{call_node.name}` expects " \
@@ -106,12 +97,8 @@ module Rigor
           )
         end
 
-        def missing_schedule_diagnostic(path, call_node, entry)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def missing_schedule_violation(call_node, entry)
+          Violation.new(
             severity: :error,
             rule: "missing-schedule",
             message: "`#{entry.class_name}.#{call_node.name}` requires a schedule " \