rigortype 0.1.15 → 0.1.16

data/lib/rigor/sig_gen/generator.rb

@@ -7,6 +7,7 @@ require_relative "../environment"
 require_relative "../scope"
 require_relative "../reflection"
 require_relative "../type"
+require_relative "../source/literals"
 require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/rbs_type_translator"
@@ -893,9 +894,7 @@ module Rigor
       end
 
       def extract_symbol_arguments(call_node)
-        (call_node.arguments&.arguments || []).filter_map do |arg|
-          arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
-        end
+        Source::Literals.symbol_arguments(call_node)
       end
 
       # Returns a closure that looks up `:@<attr_name>` in the

data/lib/rigor/sig_gen/observation_collector.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "../environment"
 require_relative "../scope"
 require_relative "../type"
+require_relative "../source/literals"
 require_relative "../inference/scope_indexer"
 
 module Rigor
@@ -307,9 +308,8 @@ module Rigor
       def binding_name_for(call_node)
         first_arg = call_node.arguments&.arguments&.first
         return call_node.name == :subject ? :subject : nil if first_arg.nil?
-        return first_arg.unescaped.to_sym if first_arg.is_a?(Prism::SymbolNode) || first_arg.is_a?(Prism::StringNode)
 
-        nil
+        Source::Literals.symbol_or_string(first_arg)
       end
 
       def type_block_body(block_node, scope_index)

data/lib/rigor/source/literals.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Source
+    # Extracts literal Symbol/String values from Prism call arguments.
+    #
+    # The "is this argument a literal `:sym` or `"str"`, and if so what
+    # Symbol does it name?" question recurs across the analyzer (sig-gen
+    # observation, attr-accessor generation, synthetic-method scanning)
+    # and across nearly every DSL plugin (`state :draft`,
+    # `has_one_attached :avatar`, `validate_presence_of(:name)`, …). This
+    # module is the one place that answers it, so the
+    # `node.unescaped.to_sym if SymbolNode || StringNode` shape is written
+    # once rather than copied per call site.
+    #
+    # `#unescaped` (not `#value`) is used deliberately so an interpolation-
+    # free `"foo"` / `:foo` round-trips to `:foo` consistently for both
+    # node kinds.
+    #
+    # The surface is a small grid over two axes — which node kinds are
+    # accepted (`SymbolNode` only, or `SymbolNode`/`StringNode`) and what
+    # the caller wants back (the interned `Symbol`, or the raw `String`
+    # name). The SymbolNode-only forms ({.symbol} / {.symbol_name}) exist
+    # so a DSL that distinguishes `state :draft` from `state "draft"`
+    # keeps that distinction instead of silently widening to accept the
+    # string literal.
+    #
+    # | accepts            | → Symbol            | → String                 |
+    # | ------------------ | ------------------- | ------------------------ |
+    # | `:sym` only        | {.symbol}           | {.symbol_name}           |
+    # | `:sym` or `"str"`  | {.symbol_or_string} | {.symbol_or_string_name} |
+    module Literals
+      module_function
+
+      # The Symbol a literal `Prism::SymbolNode` / `Prism::StringNode`
+      # names, or `nil` for any other node (including `nil`).
+      #
+      # @param node [Prism::Node, nil]
+      # @return [Symbol, nil]
+      def symbol_or_string(node)
+        return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+
+        node.unescaped.to_sym
+      end
+
+      # The String a literal `Prism::SymbolNode` / `Prism::StringNode`
+      # names, or `nil` for any other node (including `nil`). The
+      # String-returning sibling of {.symbol_or_string} — for callers
+      # that key on the raw name rather than the interned Symbol (route
+      # helpers, factory names, filter targets). `#unescaped` round-trips
+      # an interpolation-free `:foo` / `"foo"` to `"foo"` for both kinds.
+      #
+      # @param node [Prism::Node, nil]
+      # @return [String, nil]
+      def symbol_or_string_name(node)
+        return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+
+        node.unescaped
+      end
+
+      # The Symbol a literal `Prism::SymbolNode` names, or `nil` for any
+      # other node (including a `Prism::StringNode` and `nil`). Stricter
+      # than {.symbol_or_string}: a DSL that accepts only `:draft` and
+      # not `"draft"` keeps that distinction by reaching for this rather
+      # than the Symbol-or-String form.
+      #
+      # @param node [Prism::Node, nil]
+      # @return [Symbol, nil]
+      def symbol(node)
+        return nil unless node.is_a?(Prism::SymbolNode)
+
+        node.unescaped.to_sym
+      end
+
+      # The String a literal `Prism::SymbolNode` names, or `nil` for any
+      # other node (including a `Prism::StringNode` and `nil`). The
+      # String-returning sibling of {.symbol} — SymbolNode-only, but the
+      # caller wants the raw name rather than the interned Symbol.
+      #
+      # @param node [Prism::Node, nil]
+      # @return [String, nil]
+      def symbol_name(node)
+        return nil unless node.is_a?(Prism::SymbolNode)
+
+        node.unescaped
+      end
+
+      # Every literal Symbol/String positional argument of a call, in
+      # source order. Non-literal arguments are dropped. Returns `[]` when
+      # the call has no argument list.
+      #
+      # @param call_node [Prism::CallNode, nil]
+      # @return [Array<Symbol>]
+      def symbol_arguments(call_node)
+        args = call_node&.arguments&.arguments
+        return [] if args.nil?
+
+        args.filter_map { |arg| symbol_or_string(arg) }
+      end
+
+      # The literal Symbol/String at positional `index`, or `nil` when the
+      # call has no argument list, the index is out of range, or the
+      # argument there is not a literal Symbol/String.
+      #
+      # @param call_node [Prism::CallNode, nil]
+      # @param index [Integer]
+      # @return [Symbol, nil]
+      def symbol_arg(call_node, index)
+        args = call_node&.arguments&.arguments
+        return nil if args.nil?
+
+        symbol_or_string(args[index])
+      end
+    end
+  end
+end

data/lib/rigor/source/node_walker.rb

@@ -32,6 +32,32 @@ module Rigor
         yield node
         node.compact_child_nodes.each { |child| walk(child, &) }
       end
+
+      # Like {.each}, but also yields the node's lexical ancestor chain
+      # (outermost first, EXCLUDING the node itself). The yielded
+      # `ancestors` array is the live descent stack — callers that retain
+      # it past the block invocation MUST copy it (`Plugin::NodeContext`
+      # does). Used by the plugin engine to give `node_rule` blocks their
+      # enclosing class / method / block context (ADR-37 slice 1d).
+      #
+      # @yieldparam node [Prism::Node]
+      # @yieldparam ancestors [Array<Prism::Node>]
+      # @return [Enumerator] when no block is given.
+      def each_with_ancestors(root, &)
+        return to_enum(__method__, root) unless block_given?
+
+        walk_with_ancestors(root, [], &)
+        nil
+      end
+
+      def walk_with_ancestors(node, ancestors, &block)
+        return unless node.is_a?(Prism::Node)
+
+        block.call(node, ancestors)
+        ancestors.push(node)
+        node.compact_child_nodes.each { |child| walk_with_ancestors(child, ancestors, &block) }
+        ancestors.pop
+      end
     end
   end
 end

data/lib/rigor/source.rb

@@ -13,3 +13,4 @@ end
 
 require_relative "source/node_locator"
 require_relative "source/node_walker"
+require_relative "source/literals"

data/lib/rigor/type/combinator.rb

@@ -14,6 +14,7 @@ require_relative "difference"
 require_relative "refined"
 require_relative "intersection"
 require_relative "bound_method"
+require_relative "../inference/budget_trace"
 
 module Rigor
   module Type
@@ -360,7 +361,11 @@ module Rigor
       # Normalized union. Flattens nested Unions, deduplicates structurally
       # equal members, drops Bot, and collapses 0/1-member results.
       def union(*types)
-        collapse_union(normalized_union_members(types))
+        result = collapse_union(normalized_union_members(types))
+        if Inference::BudgetTrace.enabled? && result.is_a?(Union)
+          Inference::BudgetTrace.observe(Inference::BudgetTrace::UNION_ARITY, result.members.size)
+        end
+        result
       end
 
       # `key_of[T]` type function — projects the type-level

data/lib/rigor/type/union.rb

@@ -24,8 +24,31 @@ module Rigor
         freeze
       end
 
+      # Display-only adoption of two concise RBS spellings for the
+      # union (see docs/type-specification/normalization.md § "Interaction
+      # with display" and rbs-compatible-types.md § "Optionals"). Both are
+      # purely cosmetic: `@members` keeps every carrier verbatim, so the
+      # underlying type identity, RBS erasure, and round-trip are unchanged
+      # — only the human-facing rendering reads like the RBS the user wrote.
+      #
+      #   * `true | false`           → `bool`   (the RBS boolean alias). The
+      #     `bool` token leads the rendering, so `false | Foo | true` reads
+      #     as `bool | Foo` rather than burying the pair mid-list.
+      #   * `T | nil`                → `T?`     (the RBS optional sugar). Only
+      #     applied when exactly one *logical* member remains beside `nil`,
+      #     matching the rbs gem's own `to_s`: a multi-member union such as
+      #     `Integer | String | nil` stays explicit rather than gaining a
+      #     parenthesised `(Integer | String)?`. The two collapses compose,
+      #     so `false | true | nil` reads as `bool?`.
       def describe(verbosity = :short)
-        members.map { |m| m.describe(verbosity) }.join(" | ")
+        return "#{optional_inner(verbosity)}?" if optional?
+
+        if boolean_pair?
+          rest = members.reject { |m| boolean_literal?(m) }
+          ["bool", *rest.map { |m| m.describe(verbosity) }].join(" | ")
+        else
+          members.map { |m| m.describe(verbosity) }.join(" | ")
+        end
       end
 
       # ADR-1 § "RBS round-trip is lossless" + the value-lattice
@@ -79,6 +102,47 @@ module Rigor
       def inspect
         "#<Rigor::Type::Union #{describe(:short)}>"
       end
+
+      private
+
+      # Both `true` and `false` literals are present, so the pair can
+      # render as `bool`. A union carrying only one of them stays a
+      # plain literal (`true` / `false`) — that asymmetry is meaningful.
+      def boolean_pair?
+        members.any? { |m| boolean_literal?(m, true) } &&
+          members.any? { |m| boolean_literal?(m, false) }
+      end
+
+      def boolean_literal?(member, which = :either)
+        return false unless member.is_a?(Constant)
+
+        case which
+        when :either then member.value.equal?(true) || member.value.equal?(false)
+        else member.value.equal?(which)
+        end
+      end
+
+      def nil_literal?(member)
+        member.is_a?(Constant) && member.value.nil?
+      end
+
+      # `nil` is present and, once the `bool` pair is treated as a
+      # single logical member, exactly one non-`nil` member remains —
+      # so the whole union renders as `T?`. Counting the bool pair as
+      # one is what lets `false | true | nil` reach `bool?`.
+      def optional?
+        return false unless members.any? { |m| nil_literal?(m) }
+
+        significant = members.reject { |m| nil_literal?(m) }
+        logical = significant.size - (boolean_pair? ? 1 : 0)
+        logical == 1
+      end
+
+      def optional_inner(verbosity)
+        return "bool" if boolean_pair?
+
+        members.find { |m| !nil_literal?(m) }.describe(verbosity)
+      end
     end
   end
 end

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.1.15"
+  VERSION = "0.1.16"
 end

data/lib/rigor.rb

@@ -9,6 +9,7 @@ require_relative "rigor/ast"
 require_relative "rigor/environment"
 require_relative "rigor/rbs_extended"
 require_relative "rigor/testing"
+require_relative "rigor/inference/budget_trace"
 require_relative "rigor/inference/fallback"
 require_relative "rigor/inference/fallback_tracer"
 require_relative "rigor/inference/acceptance"

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

@@ -33,35 +33,31 @@ module Rigor
           ::ActionCable.server
         ].freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One broadcast observation. 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 broadcast violations for a single call node, or `[]` when
+        # the node is not a `broadcast_to` / `ActionCable.server.broadcast`
+        # call this plugin recognises. ADR-37: the engine owns the walk.
+        #
+        # @param call_node [Prism::Node]
         # @param channel_index [ChannelIndex]
-        # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, channel_index:)
-          diagnostics = []
-          walk(root) do |call_node|
-            case call_node.name
-            when :broadcast_to
-              diagnostics.concat(analyse_broadcast_to(path, call_node, channel_index))
-            when :broadcast
-              diagnostics.concat(analyse_server_broadcast(path, call_node, channel_index))
-            end
+        # @return [Array<Violation>]
+        def violations_for(call_node:, channel_index:)
+          return [] unless call_node.is_a?(Prism::CallNode)
+
+          case call_node.name
+          when :broadcast_to then analyse_broadcast_to(call_node, channel_index)
+          when :broadcast then analyse_server_broadcast(call_node, channel_index)
+          else []
           end
-          diagnostics
         end
 
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
-
-          yield node if node.is_a?(Prism::CallNode)
-          node.compact_child_nodes.each { |child| walk(child, &) }
-        end
-
-        def analyse_broadcast_to(path, call_node, channel_index)
+        def analyse_broadcast_to(call_node, channel_index)
           class_name = constant_receiver_name(call_node.receiver)
           return [] if class_name.nil?
 
@@ -72,12 +68,12 @@ module Rigor
           return [] unless class_name.end_with?("Channel")
 
           entry = channel_index.find(class_name) || channel_index.find("::#{class_name}")
-          return [unknown_channel_diagnostic(path, call_node, class_name, channel_index)] if entry.nil?
+          return [unknown_channel_violation(class_name, channel_index)] if entry.nil?
 
-          [broadcast_target_info(path, call_node, entry)]
+          [broadcast_target_info(entry)]
         end
 
-        def analyse_server_broadcast(path, call_node, channel_index)
+        def analyse_server_broadcast(call_node, channel_index)
           receiver_path = call_chain_string(call_node.receiver)
           return [] unless SERVER_BROADCAST_RECEIVER_NAMES.include?(receiver_path)
 
@@ -88,60 +84,42 @@ module Rigor
           return [] if channel_index.any_dynamic_streams?
 
           stream_name = stream_arg.unescaped
-          if channel_index.all_stream_names.include?(stream_name)
-            return [server_broadcast_info(path, call_node, stream_name)]
-          end
+          return [server_broadcast_info(stream_name)] if channel_index.all_stream_names.include?(stream_name)
 
-          [unknown_stream_diagnostic(path, call_node, stream_name, channel_index)]
+          [unknown_stream_violation(stream_name, channel_index)]
         end
 
-        def broadcast_target_info(path, call_node, entry)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def broadcast_target_info(entry)
+          Violation.new(
             severity: :info,
             rule: "broadcast-target",
             message: "`#{entry.class_name}.broadcast_to(...)` matches discovered channel"
           )
         end
 
-        def server_broadcast_info(path, call_node, stream_name)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def server_broadcast_info(stream_name)
+          Violation.new(
             severity: :info,
             rule: "broadcast-stream",
             message: "`broadcast(\"#{stream_name}\", ...)` matches a registered `stream_from`"
           )
         end
 
-        def unknown_channel_diagnostic(path, call_node, class_name, channel_index)
-          location = call_node.location
+        def unknown_channel_violation(class_name, channel_index)
           suggestions = DidYouMean::SpellChecker.new(dictionary: channel_index.names).correct(class_name)
           suggestion_part = suggestions.empty? ? "" : " (did you mean `#{suggestions.first}`?)"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "unknown-channel",
             message: "no ActionCable channel `#{class_name}`#{suggestion_part}"
           )
         end
 
-        def unknown_stream_diagnostic(path, call_node, stream_name, channel_index)
-          location = call_node.location
+        def unknown_stream_violation(stream_name, channel_index)
           dictionary = channel_index.all_stream_names.to_a
           suggestions = DidYouMean::SpellChecker.new(dictionary: dictionary).correct(stream_name)
           suggestion_part = suggestions.empty? ? "" : " (did you mean `\"#{suggestions.first}\"`?)"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :warning,
             rule: "unknown-stream",
             message: "no `stream_from \"#{stream_name}\"` registration in any discovered " \

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

@@ -62,17 +62,14 @@ module Rigor
         version: "0.1.0",
         description: "Validates ActionCable broadcast call shape against discovered channels.",
         config_schema: {
-          "channel_search_paths" => :array,
-          "channel_base_classes" => :array
+          "channel_search_paths" => { kind: :array, default: ["app/channels"] },
+          "channel_base_classes" => {
+            kind: :array,
+            default: ["ApplicationCable::Channel", "ActionCable::Channel::Base"]
+          }
         }
       )
 
-      DEFAULT_CHANNEL_SEARCH_PATHS = ["app/channels"].freeze
-      DEFAULT_CHANNEL_BASE_CLASSES = [
-        "ApplicationCable::Channel",
-        "ActionCable::Channel::Base"
-      ].freeze
-
       producer :channel_index do |_params|
         ChannelDiscoverer.new(
           io_boundary: io_boundary,
@@ -82,22 +79,30 @@ module Rigor
       end
 
       def init(_services)
-        @channel_search_paths = Array(
-          config.fetch("channel_search_paths", DEFAULT_CHANNEL_SEARCH_PATHS)
-        ).map(&:to_s)
-        @channel_base_classes = Array(
-          config.fetch("channel_base_classes", DEFAULT_CHANNEL_BASE_CLASSES)
-        ).map(&:to_s)
+        @channel_search_paths = Array(config.fetch("channel_search_paths")).map(&:to_s)
+        @channel_base_classes = Array(config.fetch("channel_base_classes")).map(&:to_s)
         @channel_index = nil
         @load_error = nil
       end
 
+      # File-level only: the load-error emission. Per-call broadcast
+      # validation runs over the engine-owned walk via the node_rule
+      # below (ADR-37). The channel index is lazily loaded + memoised by
+      # channel_index_or_nil, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = channel_index_or_nil
         return [load_error_diagnostic(path)] if index.nil? && @load_error
-        return [] if index.nil? || index.empty?
 
-        Analyzer.diagnose(path: path, root: root, channel_index: index).map { |diag| build_diagnostic(diag) }
+        []
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path|
+        index = channel_index_or_nil
+        next [] if index.nil? || index.empty?
+
+        Analyzer.violations_for(call_node: node, channel_index: index).map do |violation|
+          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
+        end
       end
 
       private
@@ -128,13 +133,6 @@ module Rigor
           rule: "load-error"
         )
       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(Actioncable)

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

@@ -45,53 +45,44 @@ module Rigor
           method instance_method methods
         ].freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One mailer-call observation. 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 mailer-call violations for a single call node (0..2), or
+        # `[]` when it is not a `<Mailer>.action(...)` call on a known
+        # mailer. ADR-37: the engine owns the walk.
+        #
+        # @param call_node [Prism::Node]
         # @param mailer_index [MailerIndex]
-        # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, mailer_index:)
-          diagnostics = []
-          walk(root) do |call_node|
-            class_name = mailer_class_for_call(call_node)
-            next if class_name.nil?
-            next if RESERVED_CLASS_METHODS.include?(call_node.name)
-
-            class_entry = mailer_index.find(class_name) || mailer_index.find("::#{class_name}")
-            next if class_entry.nil?
-
-            action_entry = class_entry.find_action(call_node.name)
-            if action_entry.nil?
-              # Skip `unknown-action` when the mailer's include
-              # set has any unresolved module — the unresolved
-              # module may legitimately define the action
-              # (gem-shipped concern, dynamically loaded
-              # mailer extension). Mirrors the same predicate
-              # `rigor-actionpack` uses for unknown-filter-method.
-              next if class_entry.unresolved_includes?
-
-              diagnostics << unknown_action_diagnostic(path, call_node, class_entry)
-              next
-            end
-
-            diagnostics << action_call_info(path, call_node, class_entry, action_entry)
-            arity_diag = arity_check(path, call_node, class_entry, action_entry)
-            diagnostics << arity_diag if arity_diag
-          end
-          diagnostics
-        end
+        # @return [Array<Violation>]
+        def violations_for(call_node:, mailer_index:)
+          return [] unless call_node.is_a?(Prism::CallNode) && action_call_candidate?(call_node)
+
+          class_name = mailer_class_for_call(call_node)
+          return [] if class_name.nil?
+          return [] if RESERVED_CLASS_METHODS.include?(call_node.name)
 
-        # Walks the tree yielding every CallNode whose receiver
-        # resolves (directly or through `.with(...)`) to a
-        # constant.
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
+          class_entry = mailer_index.find(class_name) || mailer_index.find("::#{class_name}")
+          return [] if class_entry.nil?
+
+          action_entry = class_entry.find_action(call_node.name)
+          if action_entry.nil?
+            # Skip `unknown-action` when the mailer's include set has any
+            # unresolved module — it may legitimately define the action
+            # (gem-shipped concern, dynamically loaded extension).
+            return [] if class_entry.unresolved_includes?
+
+            return [unknown_action_violation(call_node, class_entry)]
+          end
 
-          yield node if node.is_a?(Prism::CallNode) && action_call_candidate?(node)
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          violations = [action_call_info(call_node, class_entry, action_entry)]
+          arity = arity_violation(call_node, class_entry, action_entry)
+          violations << arity if arity
+          violations
         end
 
         def action_call_candidate?(node)
@@ -120,12 +111,8 @@ module Rigor
           end
         end
 
-        def action_call_info(path, call_node, class_entry, action_entry)
-          location = call_node.location
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+        def action_call_info(_call_node, class_entry, action_entry)
+          Violation.new(
             severity: :info,
             rule: "mailer-call",
             message: "`#{class_entry.class_name}.#{action_entry.method_name}` " \
@@ -133,7 +120,7 @@ module Rigor
           )
         end
 
-        def arity_check(path, call_node, class_entry, action_entry)
+        def arity_violation(call_node, class_entry, action_entry)
           args = call_node.arguments&.arguments || []
           actual = args.size
           return nil if action_entry.accepts?(actual)
@@ -147,11 +134,7 @@ module Rigor
           # carrying calls don't surface as wrong-arity.
           return nil if args.last.is_a?(Prism::KeywordHashNode) && action_entry.accepts?(actual - 1)
 
-          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: "`#{class_entry.class_name}.#{action_entry.method_name}` " \
@@ -159,14 +142,10 @@ module Rigor
           )
         end
 
-        def unknown_action_diagnostic(path, call_node, class_entry)
-          location = call_node.location
+        def unknown_action_violation(call_node, class_entry)
           known = class_entry.actions.keys.sort.join(", ")
           known_part = known.empty? ? "no actions defined" : "known actions: #{known}"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "unknown-action",
             message: "`#{class_entry.class_name}.#{call_node.name}` is not a defined " \