rigortype 0.1.14 → 0.1.16

data/lib/rigor/scope.rb

@@ -20,7 +20,7 @@ module Rigor
                 :ivars, :cvars, :globals,
                 :class_ivars, :class_cvars, :program_globals,
                 :discovered_classes, :in_source_constants, :discovered_methods,
-                :discovered_def_nodes, :discovered_method_visibilities,
+                :discovered_def_nodes, :discovered_def_sources, :discovered_method_visibilities,
                 :discovered_superclasses, :discovered_includes,
                 :indexed_narrowings, :method_chain_narrowings,
                 :source_path
@@ -89,6 +89,7 @@ module Rigor
       in_source_constants: EMPTY_VAR_BINDINGS,
       discovered_methods: EMPTY_CLASS_BINDINGS,
       discovered_def_nodes: EMPTY_CLASS_BINDINGS,
+      discovered_def_sources: EMPTY_CLASS_BINDINGS,
       discovered_method_visibilities: EMPTY_CLASS_BINDINGS,
       discovered_superclasses: EMPTY_CLASS_BINDINGS,
       discovered_includes: EMPTY_CLASS_BINDINGS,
@@ -111,6 +112,7 @@ module Rigor
       @in_source_constants = in_source_constants
       @discovered_methods = discovered_methods
       @discovered_def_nodes = discovered_def_nodes
+      @discovered_def_sources = discovered_def_sources
       @discovered_method_visibilities = discovered_method_visibilities
       @discovered_superclasses = discovered_superclasses
       @discovered_includes = discovered_includes
@@ -361,6 +363,27 @@ module Rigor
       rebuild(discovered_def_nodes: table)
     end
 
+    # Companion to {#user_def_for}: returns the `"path:line"` where
+    # the project defines `class_name#method_name` (instance-side),
+    # or nil. Populated only by the cross-file project pre-pass
+    # ({Inference::ScopeIndexer.discovered_def_index_for_paths}) — a
+    # `Prism::Location` hides its source file, so the site is recorded
+    # at scan time. `CheckRules#undefined_method_diagnostic` consults
+    # this to name the defining file when a project monkey-patch on a
+    # core/stdlib/gem class is called cross-file, so the diagnostic
+    # can point at `pre_eval:` (ADR-17) instead of reading as a bare
+    # unresolved call.
+    def user_def_site_for(class_name, method_name)
+      table = @discovered_def_sources[class_name.to_s]
+      return nil unless table
+
+      table[method_name.to_sym]
+    end
+
+    def with_discovered_def_sources(table)
+      rebuild(discovered_def_sources: table)
+    end
+
     # ADR-24 slice 2 — per-class table mapping a fully
     # qualified user-class name to its superclass name AS
     # WRITTEN at the `class Foo < Bar` declaration (`"Bar"`,
@@ -558,6 +581,7 @@ module Rigor
       class_ivars: @class_ivars, class_cvars: @class_cvars, program_globals: @program_globals,
       discovered_classes: @discovered_classes, in_source_constants: @in_source_constants,
       discovered_methods: @discovered_methods, discovered_def_nodes: @discovered_def_nodes,
+      discovered_def_sources: @discovered_def_sources,
       discovered_method_visibilities: @discovered_method_visibilities,
       discovered_superclasses: @discovered_superclasses,
       discovered_includes: @discovered_includes,
@@ -576,6 +600,7 @@ module Rigor
         in_source_constants: in_source_constants,
         discovered_methods: discovered_methods,
         discovered_def_nodes: discovered_def_nodes,
+        discovered_def_sources: discovered_def_sources,
         discovered_method_visibilities: discovered_method_visibilities,
         discovered_superclasses: discovered_superclasses,
         discovered_includes: discovered_includes,
@@ -607,6 +632,7 @@ module Rigor
         in_source_constants: in_source_constants,
         discovered_methods: discovered_methods,
         discovered_def_nodes: discovered_def_nodes,
+        discovered_def_sources: discovered_def_sources,
         discovered_method_visibilities: discovered_method_visibilities,
         discovered_superclasses: discovered_superclasses,
         discovered_includes: discovered_includes,

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/triage/catalogue.rb

@@ -22,6 +22,7 @@ module Rigor
       module_function
 
       UNDEFINED_METHOD_RULE = "call.undefined-method"
+      UNRESOLVED_TOPLEVEL_RULE = "call.unresolved-toplevel"
 
       # `undefined method `foo' for <receiver>`
       UNDEF_METHOD = /\Aundefined method [`'"]([^`'"]+)['"`] for (.+)\z/
@@ -104,9 +105,19 @@ module Rigor
       # monkey-patch): a known AR method on `Array[...]` deserves
       # the precise relation-misinference hint, not the generic
       # "project core-ext" guess H2 would otherwise claim it for.
+      #
+      # H2K (known project patch) runs before the generic H2: the
+      # engine has already proved the defining site via the
+      # `project_definition_site` field (ADR-17), so those
+      # diagnostics get the high-confidence file-naming hint rather
+      # than the spread-based guess. H7 (unresolved toplevel) runs
+      # before the systemic / genuine-bug catch-alls so toplevel
+      # resolution misses route to `pre_eval:` (ADR-34) instead of
+      # reading as scattered bugs.
       def recognisers
         %i[h1_activesupport h4_ar_relation h3_gem_without_rbs
-           h2_monkey_patch h5_systemic_cluster h6_genuine_bugs]
+           h2k_known_project_patch h2_monkey_patch h7_unresolved_toplevel
+           h5_systemic_cluster h6_genuine_bugs]
       end
 
       # --- H1 — likely ActiveSupport core_ext --------------------
@@ -127,6 +138,31 @@ module Rigor
         ), matched]
       end
 
+      # --- H2K — known project monkey-patch (engine-proven) ------
+      # ADR-17 / WD3 slice 4: the `call.undefined-method` rule sets
+      # `project_definition_site` when the project itself defines the
+      # called method on the receiver class somewhere in the file set
+      # (a reopened core/stdlib/gem class the dispatcher does not
+      # apply cross-file). That is direct evidence — not a spread
+      # heuristic — so this recogniser is `:likely` and names the
+      # defining files outright. It runs before the generic H2.
+      def h2k_known_project_patch(pool)
+        matched = pool.select(&:project_definition_site)
+        return nil if matched.empty?
+
+        files = matched.map { |d| d.project_definition_site.sub(/:\d+\z/, "") }
+                       .uniq.sort
+        [Hint.new(
+          id: "project-monkey-patch-known", confidence: :likely,
+          diagnostic_count: matched.size,
+          summary: "#{matched.size} undefined-method site(s) resolve to project " \
+                   "definitions in #{files.first(3).join(', ')} — reopened core/" \
+                   "stdlib/gem classes Rigor does not apply cross-file",
+          action: "List #{files.size == 1 ? 'this file' : 'these files'} in " \
+                  "`.rigor.yml`'s `pre_eval:` (ADR-17): #{files.join(', ')}"
+        ), matched]
+      end
+
       # --- H2 — likely a project monkey-patch / refinement -------
       def h2_monkey_patch(pool)
         groups = undefined_method_groups(pool).select do |(_method, _recv), diags|
@@ -179,6 +215,30 @@ module Rigor
         ), matched]
       end
 
+      # --- H7 — unresolved toplevel implicit-self calls ----------
+      # ADR-34: `call.unresolved-toplevel` fires on a toplevel
+      # implicit-self call (no receiver, outside any def / class /
+      # module) that resolves against no visible contributor. The
+      # canonical opt-out is `pre_eval:` — the file is usually a
+      # script relying on methods defined by a monkey-patch or a
+      # required helper Rigor did not walk. Grouped, not per-site,
+      # so the report names the cluster once.
+      def h7_unresolved_toplevel(pool)
+        matched = pool.select { |d| rule_of(d) == UNRESOLVED_TOPLEVEL_RULE }
+        return nil if matched.empty?
+
+        files = matched.map(&:path).uniq.sort
+        [Hint.new(
+          id: "unresolved-toplevel", confidence: :possible,
+          diagnostic_count: matched.size,
+          summary: "#{matched.size} toplevel call(s) resolve to nothing visible " \
+                   "across #{files.size} file(s) (#{top_methods(matched, parser: :toplevel)})",
+          action: "If a monkey-patch or required helper defines these, list its " \
+                  "file in `.rigor.yml`'s `pre_eval:` (ADR-17); otherwise they may " \
+                  "be genuine typos or missing requires."
+        ), matched]
+      end
+
       # --- H5 — systemic single-file cluster ---------------------
       def h5_systemic_cluster(pool)
         bucket = pool.group_by { |d| [d.path, rule_of(d)] }
@@ -282,10 +342,16 @@ module Rigor
         groups.keys.first(3).map { |method, recv| "`#{method}` on #{recv}" }.join(", ")
       end
 
-      def top_methods(diagnostics, limit: 5)
-        diagnostics.filter_map { |d| parse_undefined_method(d)&.fetch(:method) }
-                   .tally.sort_by { |method, count| [-count, method] }
-                         .first(limit).map { |method, count| "#{method}×#{count}" }.join(" ")
+      # `parser: :undefined_method` (default) reads the method from
+      # the parsed `undefined-method` shape; `parser: :toplevel`
+      # reads the structured `method_name` field directly (the
+      # `unresolved-toplevel` rule carries no receiver to parse).
+      def top_methods(diagnostics, limit: 5, parser: :undefined_method)
+        names = diagnostics.filter_map do |d|
+          parser == :toplevel ? d.method_name : parse_undefined_method(d)&.fetch(:method)
+        end
+        names.tally.sort_by { |method, count| [-count, method] }
+                   .first(limit).map { |method, count| "#{method}×#{count}" }.join(" ")
       end
 
       def rule_of(diag)

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.14"
+  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 " \