rigortype 0.1.10 → 0.1.12

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "worker_index"
+
+module Rigor
+  module Plugin
+    class Sidekiq < Rigor::Plugin::Base
+      # Walks the configured worker-search paths via the
+      # plugin's `IoBoundary`, parses each `.rb` file with
+      # Prism, and collects classes that `include
+      # Sidekiq::Job` (or one of the configured marker
+      # modules). For each discovered class, the discoverer
+      # also reads the `#perform` method's parameter list
+      # and computes the arity envelope.
+      #
+      # Limitations (intentional for v0.1.0):
+      #
+      # - Only direct `include` matches against the
+      #   configured marker modules. `class MyWorker;
+      #   include Concerns::Sidekiqable; end` where
+      #   `Concerns::Sidekiqable` re-includes `Sidekiq::Job`
+      #   is NOT discovered. Add the intermediate module to
+      #   `worker_marker_modules` if needed.
+      # - The qualified class name is the lexical path
+      #   (`Admin::WelcomeWorker` for a class declared
+      #   inside `module Admin`).
+      # - `#perform` arity is read from the syntactic
+      #   parameter list. Methods built via
+      #   `define_method` are out of scope.
+      class WorkerDiscoverer
+        def initialize(io_boundary:, search_paths:, marker_modules:)
+          @io_boundary = io_boundary
+          @search_paths = search_paths
+          @marker_modules = marker_modules.to_set
+        end
+
+        # @return [WorkerIndex]
+        def discover
+          entries = []
+          ruby_files_under(@search_paths).each do |path|
+            contents = read_safely(path)
+            next if contents.nil?
+
+            tree = Prism.parse(contents).value
+            walk_for_workers(tree, []) do |class_name, perform_def|
+              entries << build_entry(class_name, perform_def)
+            end
+          end
+          WorkerIndex.new(entries)
+        end
+
+        private
+
+        def read_safely(path)
+          @io_boundary.read_file(path)
+        rescue Plugin::AccessDeniedError, Errno::ENOENT
+          nil
+        end
+
+        def ruby_files_under(roots)
+          roots.flat_map do |root|
+            absolute = File.expand_path(root)
+            next [] unless File.directory?(absolute)
+
+            Dir.glob(File.join(absolute, "**", "*.rb"))
+          end
+        end
+
+        def walk_for_workers(node, lexical_path, &)
+          return if node.nil?
+
+          case node
+          when Prism::ClassNode then visit_class(node, lexical_path, &)
+          when Prism::ModuleNode then visit_module(node, lexical_path, &)
+          else
+            node.compact_child_nodes.each { |child| walk_for_workers(child, lexical_path, &) }
+          end
+        end
+
+        def visit_class(node, lexical_path, &)
+          class_local_name = constant_path_name(node.constant_path)
+          return if class_local_name.nil?
+
+          full_name = (lexical_path + [class_local_name]).join("::")
+          if includes_marker_module?(node.body)
+            perform_def = lookup_perform_def(node.body)
+            yield full_name, perform_def
+          end
+
+          inner_path = lexical_path + [class_local_name]
+          walk_for_workers(node.body, inner_path, &) if node.body
+        end
+
+        def visit_module(node, lexical_path, &)
+          module_local_name = constant_path_name(node.constant_path)
+          return if module_local_name.nil?
+
+          inner_path = lexical_path + [module_local_name]
+          walk_for_workers(node.body, inner_path, &) if node.body
+        end
+
+        # Returns true if the class body contains a top-level
+        # `include <Module>` call where `<Module>` matches
+        # one of the configured marker modules.
+        def includes_marker_module?(body)
+          return false if body.nil?
+
+          body.compact_child_nodes.any? do |node|
+            next false unless node.is_a?(Prism::CallNode)
+            next false unless node.name == :include
+            next false unless node.receiver.nil?
+
+            arg = node.arguments&.arguments&.first
+            module_name = constant_path_name(arg)
+            module_name && @marker_modules.include?(module_name)
+          end
+        end
+
+        def constant_path_name(node)
+          return nil if node.nil?
+
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parts = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              parts.unshift(current.name.to_s)
+              current = current.parent
+            end
+            case current
+            when nil then "::#{parts.join('::')}"
+            when Prism::ConstantReadNode then "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+
+        # Returns the instance-side `def perform(...)` node
+        # from a class body, or `nil` when the class doesn't
+        # override `#perform`.
+        def lookup_perform_def(body)
+          return nil if body.nil?
+
+          body.compact_child_nodes.each do |node|
+            next unless node.is_a?(Prism::DefNode) && node.name == :perform
+            next if node.receiver.is_a?(Prism::SelfNode)
+
+            return node
+          end
+          nil
+        end
+
+        # Builds a `WorkerIndex::Entry` from the discovered
+        # class's `#perform` def. When the class doesn't
+        # override `#perform`, we record an "any-arity"
+        # entry — Sidekiq itself doesn't supply a default
+        # `#perform`, so calling `perform_async` on a
+        # worker without one is the user's bug, not the
+        # plugin's call to flag without runtime context.
+        def build_entry(class_name, perform_def)
+          if perform_def.nil?
+            return WorkerIndex::Entry.new(
+              class_name: class_name, min_arity: 0,
+              max_arity: Float::INFINITY
+            )
+          end
+
+          parameters = perform_def.parameters
+          if parameters.nil?
+            return WorkerIndex::Entry.new(
+              class_name: class_name, min_arity: 0, max_arity: 0
+            )
+          end
+
+          required_count = (parameters.requireds || []).size
+          optional_count = (parameters.optionals || []).size
+          rest_present = !parameters.rest.nil?
+
+          WorkerIndex::Entry.new(
+            class_name: class_name,
+            min_arity: required_count,
+            max_arity: rest_present ? Float::INFINITY : required_count + optional_count
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Sidekiq < Rigor::Plugin::Base
+      # Frozen catalogue of discovered Sidekiq worker
+      # classes keyed by qualified class name. Each entry
+      # holds the `#perform` method's arity envelope so the
+      # analyzer can validate `Worker.perform_async(...)`
+      # call sites.
+      #
+      # Same envelope shape as `rigor-activejob`'s
+      # `JobIndex::Entry`: `min_arity` / `max_arity` form a
+      # closed range (`Float::INFINITY` for the upper bound
+      # when `*args` is present).
+      class WorkerIndex
+        Entry = Data.define(:class_name, :min_arity, :max_arity) do
+          def arity_label
+            return "#{min_arity}+" if max_arity == Float::INFINITY
+            return min_arity.to_s if min_arity == max_arity
+
+            "#{min_arity}..#{max_arity}"
+          end
+
+          def accepts?(actual)
+            actual.between?(min_arity, max_arity)
+          end
+        end
+
+        attr_reader :entries
+
+        def initialize(entries)
+          @entries = entries.freeze
+          @by_name = entries.to_h { |entry| [entry.class_name, entry] }.freeze
+          freeze
+        end
+
+        # @return [Entry, nil]
+        def find(class_name)
+          @by_name[class_name.to_s]
+        end
+
+        def known?(class_name)
+          @by_name.key?(class_name.to_s)
+        end
+
+        def empty?
+          @entries.empty?
+        end
+
+        def size
+          @entries.size
+        end
+
+        def names
+          @by_name.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "sidekiq/worker_index"
+require_relative "sidekiq/worker_discoverer"
+require_relative "sidekiq/analyzer"
+
+module Rigor
+  module Plugin
+    # rigor-sidekiq — validates `Worker.perform_async(...)`
+    # / `.perform_in(...)` / `.perform_at(...)` /
+    # `.perform_inline(...)` argument arity against the
+    # discovered `#perform` definitions.
+    #
+    # Tier 3C of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
+    # Statically discovers Sidekiq workers by walking
+    # `worker_search_paths` and parsing each file with
+    # Prism — no `sidekiq` runtime dependency.
+    #
+    # ## Configuration
+    #
+    #     plugins:
+    #       - gem: rigor-sidekiq
+    #         config:
+    #           worker_search_paths: ["app/workers", "app/sidekiq"]   # default; optional
+    #           worker_marker_modules: ["Sidekiq::Job", "Sidekiq::Worker"]  # default; optional
+    #
+    # ## What it checks
+    #
+    # 1. **Argument arity** — `perform_async(args)` /
+    #    `perform_inline(args)` forward every argument to
+    #    `#perform`; `perform_in(t, args)` /
+    #    `perform_at(t, args)` consume the first argument
+    #    as the schedule and forward the rest. Mismatches
+    #    emit `wrong-arity`.
+    # 2. **Missing schedule** — `perform_in()` /
+    #    `perform_at()` with zero arguments emit
+    #    `missing-schedule`.
+    #
+    # ## Limitations (v0.1.0)
+    #
+    # - Direct `include` matches only against the
+    #   configured marker modules. Indirect includes via a
+    #   custom concern are out of scope.
+    # - `#perform` arity is read from the syntactic
+    #   parameter list. `define_method` actions are out of
+    #   scope.
+    # - Required keyword arguments are not validated at
+    #   the call site (positional-only for v0.1.0). Sidekiq
+    #   serialises arguments to JSON, so keyword args are
+    #   uncommon in practice.
+    # - The schedule argument's type isn't validated (no
+    #   "is this a Time?" check); we just consume it.
+    class Sidekiq < Rigor::Plugin::Base
+      manifest(
+        id: "sidekiq",
+        version: "0.1.0",
+        description: "Validates Sidekiq `Worker.perform_async` argument arity.",
+        config_schema: {
+          "worker_search_paths" => :array,
+          "worker_marker_modules" => :array
+        }
+      )
+
+      DEFAULT_WORKER_SEARCH_PATHS = ["app/workers", "app/sidekiq"].freeze
+      DEFAULT_WORKER_MARKER_MODULES = %w[Sidekiq::Job Sidekiq::Worker].freeze
+
+      producer :worker_index do |_params|
+        WorkerDiscoverer.new(
+          io_boundary: io_boundary,
+          search_paths: @worker_search_paths,
+          marker_modules: @worker_marker_modules
+        ).discover
+      end
+
+      def init(_services)
+        @worker_search_paths = Array(config.fetch("worker_search_paths", DEFAULT_WORKER_SEARCH_PATHS)).map(&:to_s)
+        @worker_marker_modules = Array(
+          config.fetch("worker_marker_modules", DEFAULT_WORKER_MARKER_MODULES)
+        ).map(&:to_s)
+        @worker_index = nil
+        @load_error = nil
+      end
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        index = worker_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, worker_index: index).map { |diag| build_diagnostic(diag) }
+      end
+
+      private
+
+      def worker_index_or_nil
+        return @worker_index if @worker_index
+
+        @worker_index = cache_for(:worker_index, params: {}).call
+      rescue StandardError => e
+        @load_error = "rigor-sidekiq: failed to discover workers: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def load_error_diagnostic(path)
+        Rigor::Analysis::Diagnostic.new(
+          path: path, line: 1, column: 1,
+          message: @load_error,
+          severity: :warning,
+          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(Sidekiq)
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/sidekiq"

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # ADR-16 Tier A worked plugin: recognises Sinatra's class-
+    # level route DSL.
+    #
+    # Sinatra's modular style:
+    #
+    #     class MyApp < Sinatra::Base
+    #       get "/hello" do
+    #         "Hello #{params['name']}"
+    #       end
+    #
+    #       post "/bye" do
+    #         halt 403 if params["forbidden"]
+    #         redirect "/landing"
+    #       end
+    #     end
+    #
+    # At runtime `Sinatra::Base#generate_method`
+    # (`lib/sinatra/base.rb:1788-1793`) does `define_method(name,
+    # &block); remove_method`, turning each block into a real
+    # instance method of the user's app class. The substrate's
+    # Tier A hook (`Rigor::Inference::MacroBlockSelfType`)
+    # replays the same contract statically: the block runs with
+    # `self : Nominal[MyApp]`, so bare identifiers (`params`,
+    # `redirect`, `halt`, `session`, `headers`, `content_type`,
+    # `body`, `status`, `erb`, …) resolve through
+    # `Sinatra::Base`'s RBS via rigor's normal inference path.
+    #
+    # ## Reach
+    #
+    # All nine class-level HTTP verb methods Sinatra exposes:
+    # `get`, `post`, `put`, `delete`, `head`, `options`, `patch`,
+    # `link`, `unlink` (`lib/sinatra/base.rb:1531-1553`). Both
+    # modular-style subclasses of `Sinatra::Base` and `Sinatra::Application`
+    # (classic top-level style, when used via `class App <
+    # Sinatra::Application`) match because the receiver
+    # constraint accepts every subclass.
+    #
+    # ## What the plugin does NOT do (yet)
+    #
+    # - **Routing diagnostics.** Path uniqueness, conflict
+    #   detection, named-route reverse lookup — none of these
+    #   are in slice 1c's scope.
+    # - **Custom helpers.** `helpers do ... end` blocks that
+    #   inject module methods into the app's instance namespace
+    #   are Tier C / Tier B work, not Tier A.
+    # - **Configure / settings.** `configure do ... end` and
+    #   `set :session_secret, "..."` are settings DSL, not
+    #   route DSL — handled by separate substrate entries when
+    #   demand surfaces.
+    # - **Classic-style top-level routes.** A bare
+    #   `get '/path' do ... end` at the top of a script (no
+    #   enclosing `class < Sinatra::Base`) is the classic-mode
+    #   pattern (`lib/sinatra/main.rb`). Tier A as currently
+    #   wired requires the receiver's class to be visible at
+    #   the call site; a top-level call's receiver is the
+    #   classic-mode `Sinatra::Application`, which the
+    #   `Sinatra::Delegator` mixin forwards from `main`. The
+    #   classic style is deferred until the demand justifies
+    #   the extra match shape.
+    #
+    # See `plugins/rigor-sinatra/README.md` for usage and the
+    # demo script under `plugins/rigor-sinatra/demo/`.
+    class Sinatra < Rigor::Plugin::Base
+      manifest(
+        id: "sinatra",
+        version: "0.1.0",
+        description: "Recognises Sinatra's class-level route DSL via ADR-16 Tier A.",
+        block_as_methods: [
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Sinatra::Base",
+            verbs: %i[get post put delete head options patch link unlink]
+          )
+        ]
+      )
+    end
+
+    Rigor::Plugin.register(Sinatra)
+  end
+end

data/plugins/rigor-sinatra/lib/rigor-sinatra.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Gem entry point. Required by Rigor's plugin loader when
+# `.rigor.yml` lists `rigor-sinatra` under `plugins:`. The
+# loader expects this `require` to side-effect a call to
+# `Rigor::Plugin.register`, which the body of
+# `lib/rigor/plugin/sinatra.rb` performs at load time.
+require_relative "rigor/plugin/sinatra"

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "type_translator"
+
+module Rigor
+  module Plugin
+    class Sorbet < Rigor::Plugin::Base
+      # Slice 6 of ADR-11 — recognises `T.absurd(x)` calls and
+      # composes them with the engine's flow-sensitive
+      # narrowing. `T.absurd` asserts that a code branch is
+      # statically unreachable; it's the standard Sorbet idiom
+      # for case/when exhaustiveness:
+      #
+      #   case x
+      #   when A then ...
+      #   when B then ...
+      #   else
+      #     T.absurd(x)
+      #   end
+      #
+      # If every case has been handled, `x` at the `else` branch
+      # has been narrowed to `T.noreturn` (Rigor's `Type::Bot`)
+      # and the assertion holds. If the user forgot a case, `x`
+      # narrows to whatever's left and the assertion is wrong —
+      # we surface that mistake as `plugin.sorbet.absurd-reachable`.
+      #
+      # ## Two-phase mechanism
+      #
+      # The recogniser is invoked from `flow_contribution_for`
+      # where the per-node `scope:` carries the proper narrowing
+      # context. It returns:
+      #
+      # - A `FlowContribution` with `return_type: bot` and
+      #   `exceptional: :raises` regardless of reachability
+      #   (faithful to `T.absurd`'s runtime behaviour: it always
+      #   raises). This lets the engine's existing flow analysis
+      #   treat code after `T.absurd` as unreachable, matching
+      #   what users of Sorbet expect.
+      # - When the branch is REACHABLE (the discriminant's type
+      #   isn't `bot`), the recogniser also records the call
+      #   node in a per-plugin set. The plugin's
+      #   `diagnostics_for_file` later walks the AST for
+      #   `T.absurd` calls and emits a
+      #   `plugin.sorbet.absurd-reachable` warning at every
+      #   call_node whose object identity matches the recorded
+      #   set. We rely on the runner only parsing each file
+      #   once per run, so the same Prism node object is seen
+      #   in both `flow_contribution_for` and
+      #   `diagnostics_for_file`.
+      module AbsurdRecognizer
+        # @param call_node [Prism::CallNode]
+        # @return [Boolean] true when `call_node` is `T.absurd(x)`.
+        def self.absurd_call?(call_node)
+          return false unless call_node.is_a?(Prism::CallNode)
+          return false unless call_node.name == :absurd
+          return false unless TypeTranslator.sorbet_t_namespaced?(call_node.receiver)
+
+          # Slice 6 only handles single-argument `T.absurd(x)`;
+          # no-arg / multi-arg shapes are syntax errors at
+          # Sorbet's level too.
+          arguments = call_node.arguments&.arguments
+          arguments&.size == 1
+        end
+
+        # @param call_node [Prism::CallNode]
+        # @param scope [Rigor::Scope, nil]
+        # @return [Boolean] true when the discriminant has been
+        #   narrowed to `bot` (the branch is unreachable, so
+        #   `T.absurd` is correct). The caller suppresses the
+        #   `absurd-reachable` diagnostic in this case.
+        def self.exhaustive?(call_node, scope)
+          return false if scope.nil?
+
+          arg = call_node.arguments.arguments.first
+          arg_type = scope.type_of(arg)
+          arg_type.equal?(Rigor::Type::Bot.instance) || arg_type.is_a?(Rigor::Type::Bot)
+        rescue StandardError
+          # On synthetic / unrecognised nodes the typer may
+          # raise; treat as "can't prove unreachable" so the
+          # diagnostic fires conservatively.
+          false
+        end
+
+        # The contribution every `T.absurd` call gets,
+        # regardless of static reachability — `T.absurd` raises
+        # at runtime, so its return type is `bot` and the call
+        # is exceptional. This lets the engine's flow analysis
+        # treat code after the call as unreachable (no
+        # `flow.unreachable-branch` from us; that's an engine
+        # rule that consults the same effect lattice).
+        def self.contribution(call_node, plugin_id)
+          Rigor::FlowContribution.new(
+            return_type: Rigor::Type::Combinator.bot,
+            exceptional: :raises,
+            provenance: Rigor::FlowContribution::Provenance.new(
+              source_family: "plugin.#{plugin_id}",
+              plugin_id: plugin_id,
+              node: call_node,
+              descriptor: nil
+            )
+          )
+        end
+      end
+    end
+  end
+end