rigortype 0.1.15 → 0.1.16

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/analyzer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 module Rigor
   module Plugin
@@ -11,8 +12,6 @@ module Rigor
       # recognised helpers and error diagnostics for typos /
       # arity mismatches.
       module Analyzer
-        DID_YOU_MEAN_DISTANCE = 3
-
         # Built-in Rails helpers we don't want to flag as
         # unknown. The plugin's HelperTable describes
         # user-declared routes; Rails (and a small set of
@@ -33,7 +32,10 @@ module Rigor
           audio_path audio_url
         ].freeze
 
-        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+        # One route-helper 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
 
@@ -76,70 +78,45 @@ module Rigor
         # @param root [Prism::Node]
         # @param helper_table [HelperTable]
         # @return [Array<Diagnostic>]
-        def diagnose(path:, root:, helper_table:)
+        # The route-helper violations for a single call node (0..2),
+        # or `[]` when the node is not an implicit `*_path` / `*_url`
+        # helper call, is shadowed by a same-file binding, or is in a
+        # suppressed directory. ADR-37: the engine owns the walk; the
+        # same-file `shadowing` set is built once as the node-rule file
+        # context.
+        #
+        # @param call_node [Prism::Node]
+        # @param helper_table [HelperTable]
+        # @param shadowing [Set<String>]
+        # @param path [String]
+        # @return [Array<Violation>]
+        def violations_for(call_node:, helper_table:, shadowing:, path:)
+          return [] unless call_node.is_a?(Prism::CallNode) && implicit_helper_call?(call_node)
+
+          name = call_node.name.to_s
+          return [] if BUILTIN_PASSTHROUGH.include?(name)
+          return [] if shadowing.include?(name)
+
+          # The SKIP set silences both `unknown-helper` and `wrong-arity`:
+          # a `group_path` inside `app/services/...` is more likely the
+          # file's own method (an `attr_accessor`) than a route helper.
           suppress_unknown = SKIP_UNKNOWN_HELPER_PATHS.any? { |re| path.match?(re) }
-          # Same SKIP set silences `wrong-arity` too. A call
-          # like `group_path` inside `app/services/groups/nested_
-          # create_service.rb` is almost certainly the service's
-          # own instance method (`attr_accessor :group_path`) —
-          # both the unknown-helper check and the arity check
-          # against a registered route helper would FP.
-          diagnostics = []
-          # Pre-walk the file to collect every name that
-          # shadows a route helper at call time: `let(:foo)`,
-          # `subject(:foo)`, `def foo`, and explicit local
-          # assignments (`foo_url = "..."`). At the call site
-          # `foo` then resolves to the shadowing local, not to
-          # the registered route helper — firing `unknown-helper`
-          # / `wrong-arity` against the helper would be a false
-          # positive against canonical RSpec idioms (Mastodon
-          # has 200+ such patterns in `spec/`).
-          shadowing = collect_shadowing_names(root)
-
-          walk(root) do |call_node|
-            name = call_node.name.to_s
-            next unless name.end_with?("_path") || name.end_with?("_url")
-            next if BUILTIN_PASSTHROUGH.include?(name)
-            next if shadowing.include?(name)
 
-            entry = helper_table.find(name)
-            if entry
-              # When the file is in a `SKIP_UNKNOWN_HELPER_PATHS`
-              # directory (models / services / workers / lib /
-              # …), don't emit the info or arity diagnostic
-              # against a registered helper either — the call
-              # is more likely the file's own instance method
-              # (e.g. `group_path` as an `attr_accessor`) that
-              # happens to share a name with a registered
-              # route helper. The unknown-helper suppression
-              # already silences the inverse case.
-              next if suppress_unknown
-
-              diagnostics << info_diagnostic(path, call_node, entry)
-              arity_diagnostic = arity_check(path, call_node, entry, helper_table)
-              diagnostics << arity_diagnostic if arity_diagnostic
-            elsif helper_table.recognised?(name)
-              # Custom helper (discovered via
-              # `app/helpers/**/*.rb`) or a dynamic-provider
-              # Devise OmniAuth helper. We do NOT have an
-              # arity / path to validate — the helper is just
-              # known-to-exist. Skip the arity / info
-              # diagnostic; the absence of an `unknown-helper`
-              # error is the user-visible outcome.
-              next
-            elsif suppress_unknown
-              # File is in a directory where route helpers are
-              # not customarily resolved (models / lib / db /
-              # config). Skip `unknown-helper` to avoid false
-              # positives on AR column accessors / gem-side
-              # instance methods that happen to end in `_url` /
-              # `_path`.
-              next
-            else
-              diagnostics << unknown_helper_diagnostic(path, call_node, name, helper_table)
-            end
+          entry = helper_table.find(name)
+          if entry
+            return [] if suppress_unknown
+
+            violations = [info_violation(entry)]
+            arity = arity_violation(call_node, entry, helper_table, path)
+            violations << arity if arity
+            violations
+          elsif helper_table.recognised?(name) || suppress_unknown
+            # Recognised custom / dynamic helper (no arity to check), or
+            # a directory where helpers aren't customarily resolved.
+            []
+          else
+            [unknown_helper_violation(name, helper_table)]
           end
-          diagnostics
         end
 
         # Walks the AST once and returns the Set of names that
@@ -156,23 +133,17 @@ module Rigor
         #   (`foo_url = "..."`).
         def collect_shadowing_names(root)
           names = Set.new
-          walk_for_shadowing(root, names)
-          names
-        end
-
-        def walk_for_shadowing(node, names)
-          return unless node.is_a?(Prism::Node)
-
-          case node
-          when Prism::DefNode
-            names << node.name.to_s if node.receiver.nil?
-          when Prism::LocalVariableWriteNode
-            names << node.name.to_s
-          when Prism::CallNode
-            record_let_like_name(node, names)
+          Source::NodeWalker.each(root) do |node|
+            case node
+            when Prism::DefNode
+              names << node.name.to_s if node.receiver.nil?
+            when Prism::LocalVariableWriteNode
+              names << node.name.to_s
+            when Prism::CallNode
+              record_let_like_name(node, names)
+            end
           end
-
-          node.compact_child_nodes.each { |child| walk_for_shadowing(child, names) }
+          names
         end
 
         def record_let_like_name(call_node, names)
@@ -180,21 +151,15 @@ module Rigor
           return unless SHADOWING_DSL.include?(call_node.name)
 
           arg = call_node.arguments&.arguments&.first
-          if arg.is_a?(Prism::SymbolNode)
-            names << arg.unescaped
+          name = Rigor::Source::Literals.symbol_name(arg)
+          if name
+            names << name
           elsif call_node.name == :subject && call_node.arguments.nil?
             # Bare `subject { ... }` defines `:subject` itself.
             names << "subject"
           end
         end
 
-        def walk(node, &)
-          return unless node.is_a?(Prism::Node)
-
-          yield node if node.is_a?(Prism::CallNode) && implicit_helper_call?(node)
-          node.compact_child_nodes.each { |child| walk(child, &) }
-        end
-
         # `*_path` / `*_url` calls without an explicit
         # receiver. Calls like `obj.users_path` or
         # `Foo::users_path` are NOT route-helper invocations
@@ -223,20 +188,16 @@ module Rigor
           IMPLICIT_FILL_PATHS.any? { |re| path.match?(re) }
         end
 
-        def info_diagnostic(path, call_node, entry)
-          location = call_node.location
+        def info_violation(entry)
           method_label = entry.http_method ? entry.http_method.to_s.upcase : "*"
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :info,
             rule: "helper",
             message: "`#{entry.name}` → #{method_label} #{entry.path}"
           )
         end
 
-        def arity_check(path, call_node, entry, helper_table)
+        def arity_violation(call_node, entry, helper_table, path)
           args = call_node.arguments&.arguments || []
           actual = args.size
           # Uncountable nouns (`news` / `series` / `media`) cause
@@ -279,71 +240,26 @@ module Rigor
 
           arities = arities_set.sort
           expected = arities.length == 1 ? arities.first.to_s : "#{arities.first}..#{arities.last}"
-          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.name}` expects #{expected} argument(s), got #{actual}"
           )
         end
 
-        def unknown_helper_diagnostic(path, call_node, name, helper_table)
-          location = call_node.location
-          suggestion = did_you_mean(name, helper_table.names)
+        def unknown_helper_violation(name, helper_table)
+          # ADR-39 / boilerplate 0c — the shared DidYouMean-backed suggester
+          # replaces the hand-rolled Levenshtein this module used to carry.
+          suggestion = Rigor::Plugin::Base.suggest(name, helper_table.names)
           message = "no route helper `#{name}`"
           message += " (did you mean `#{suggestion}`?)" if suggestion
 
-          Diagnostic.new(
-            path: path,
-            line: location.start_line,
-            column: location.start_column + 1,
+          Violation.new(
             severity: :error,
             rule: "unknown-helper",
             message: message
           )
         end
-
-        # Levenshtein-style nearest neighbour. Returns the
-        # closest known helper within {DID_YOU_MEAN_DISTANCE}
-        # edits, or nil.
-        def did_you_mean(name, candidates)
-          best = nil
-          best_distance = DID_YOU_MEAN_DISTANCE + 1
-          candidates.each do |candidate|
-            d = levenshtein(name, candidate)
-            if d < best_distance
-              best = candidate
-              best_distance = d
-            end
-          end
-          best
-        end
-
-        # Standard iterative Levenshtein. Lifted from
-        # rigor-routes' equivalent helper for parity.
-        def levenshtein(left, right)
-          return right.length if left.empty?
-          return left.length if right.empty?
-
-          rows = Array.new(left.length + 1) { Array.new(right.length + 1, 0) }
-          (0..left.length).each { |i| rows[i][0] = i }
-          (0..right.length).each { |j| rows[0][j] = j }
-
-          (1..left.length).each do |i|
-            (1..right.length).each do |j|
-              cost = left[i - 1] == right[j - 1] ? 0 : 1
-              rows[i][j] = [
-                rows[i - 1][j] + 1,
-                rows[i][j - 1] + 1,
-                rows[i - 1][j - 1] + cost
-              ].min
-            end
-          end
-          rows[left.length][right.length]
-        end
       end
     end
   end

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/devise_routes.rb

@@ -198,24 +198,11 @@ module Rigor
           OMNIAUTH_SUFFIXES
         end
 
-        # The same tiny singularizer used by `RoutesParser`.
-        # We duplicate the catalogue here so this module does
-        # not need to reach into `Context`'s private state.
-        UNCOUNTABLE = %w[
-          equipment information rice money species series fish
-          sheep jeans police news media settings
-        ].to_set.freeze
-        private_constant :UNCOUNTABLE
-
+        # ADR-39 — delegates to the shared inflector (real
+        # `ActiveSupport::Inflector` when available), replacing the tiny
+        # AS-replica this module used to duplicate from `RoutesParser`.
         def singularize(word)
-          return word if UNCOUNTABLE.include?(word)
-          return "#{word.chomp('ies')}y" if word.end_with?("ies") && word.length > 3
-          return word.chomp("es") if word.end_with?("ses") || word.end_with?("xes")
-          # `ss` preserved — Rails default inflector behaviour.
-          return word if word.end_with?("ss")
-          return word.chomp("s") if word.end_with?("s")
-
-          word
+          Rigor::Plugin::Inflector.singularize(word)
         end
 
         # Approximate path generation. We don't honour the

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/routes_parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 require_relative "helper_table"
 
@@ -407,83 +408,24 @@ module Rigor
             end
           end
 
-          # Tiny English inflector. Sufficient for the standard
-          # `posts` ↔ `post`, `users` ↔ `user` rename Rails
-          # generates by default; users with custom
-          # inflections need to author RBS by hand for the
-          # affected helpers (out of scope for v0.1.0).
-          #
-          # The canonical English uncountable noun set from
-          # ActiveSupport::Inflector::Inflections (Rails 8.x).
-          # `singularize("news")` returns `"news"` rather than
-          # `"new"`. Pre-fix the parser stripped the trailing
-          # 's' from `news`, so `resources :news` registered
-          # `new_path` / `news_path` / `new_news_path` (broken
-          # — Rails actually generates `news_path` for both
-          # index and show, with the show form taking `:id`).
-          # Redmine hit this 81× across `news_path(id)` calls.
-          UNCOUNTABLE = %w[
-            equipment information rice money species series fish
-            sheep jeans police news settings
-          ].to_set.freeze
-          private_constant :UNCOUNTABLE
-
-          # Latin / Greek irregular plurals Rails ships in its
-          # default inflector. `media` → `medium` is the
-          # dominant Rails-app case (Mastodon's `resources
-          # :media, only: [:show]` generates `medium_path(id)`,
-          # not `media_path`). Pre-fix `media` was in
-          # UNCOUNTABLE which produced `media_path` for both
-          # index and show — incorrect.
-          IRREGULAR_SINGULARS = {
-            "media" => "medium",
-            "data" => "datum",
-            "criteria" => "criterion",
-            "phenomena" => "phenomenon"
-          }.freeze
-          private_constant :IRREGULAR_SINGULARS
-
+          # ADR-39: inflection delegates to the shared
+          # `Rigor::Plugin::Inflector`, which calls the real
+          # `ActiveSupport::Inflector` (the authority Rails itself uses to
+          # generate helper names) when available, falling back to a
+          # built-in approximation otherwise. This replaces the hand-tuned
+          # AS-replica these methods used to carry — every special case
+          # they accreted (`news` uncountable, `media`→`medium`,
+          # `databases`→`database`, `custom_css` ss-preservation,
+          # `async_refresh`→`async_refreshes`) was reverse-engineered
+          # `ActiveSupport::Inflector` behaviour, so the real inflector
+          # produces the same result for those and the correct one for the
+          # words the replica never covered.
           def singularize(word)
-            return IRREGULAR_SINGULARS[word] if IRREGULAR_SINGULARS.key?(word)
-            return word if UNCOUNTABLE.include?(word)
-            return "#{word.chomp('ies')}y" if word.end_with?("ies") && word.length > 3
-            # Rails ships specific `*es$` → `*` rules for
-            # `(alias|status)es` and `(bus)es` (these have
-            # singular endings that the generic-chomp rules
-            # would mis-singularise to `aliase` / `statuse` /
-            # `buse`).
-            return word.chomp("es") if /(?:alias|status|bus)es\z/.match?(word)
-            # Rails only chomps `es` after `x|ch|ss|sh|z` for
-            # the generic case (`inflect.singular(/(x|ch|ss|sh)
-            # es$/i, '\1')`). A generic `ses` suffix removed
-            # `es` and broke `databases` → `databas` (correct:
-            # `database`). Restrict to the explicit suffix set.
-            return word.chomp("es") if word.end_with?("ches", "shes", "sses", "xes", "zes")
-            # Words ending in `ss` are their own singular —
-            # Rails' default inflector ships
-            # `inflect.singular(/(ss)$/i, '\1')` that preserves
-            # the double-s. Mastodon's `resources :custom_css`
-            # was singularising to `custom_cs` and producing a
-            # bogus `custom_cs_path(id)`.
-            return word if word.end_with?("ss")
-            return word.chomp("s") if word.end_with?("s")
-
-            word
+            Rigor::Plugin::Inflector.singularize(word)
           end
 
           def pluralize(word)
-            return IRREGULAR_SINGULARS.key(word) if IRREGULAR_SINGULARS.value?(word)
-            return word if UNCOUNTABLE.include?(word)
-            return word if word.end_with?("s") && !word.end_with?("ss")
-            return "#{word.chomp('y')}ies" if word.end_with?("y") && word.length > 1
-            # Words ending in s/sh/ch/x/z take "es" in plural,
-            # matching Rails' default inflector. Without this
-            # `async_refresh` (singular) pluralised to
-            # `async_refreshs`, mismatching the actual
-            # `/async_refreshes` URL.
-            return "#{word}es" if word.end_with?("ss", "sh", "ch", "x", "z")
-
-            "#{word}s"
+            Rigor::Plugin::Inflector.pluralize(word)
           end
         end
 
@@ -586,11 +528,7 @@ module Rigor
         # auto-pairing in `parse` adds `name_url`). Only handled
         # for literal Symbol or String first-arg.
         def handle_direct(node, context)
-          first = node.arguments&.arguments&.first
-          name = case first
-                 when Prism::SymbolNode then first.unescaped
-                 when Prism::StringNode then first.unescaped
-                 end
+          name = Rigor::Source::Literals.symbol_or_string_name(node.arguments&.arguments&.first)
           return if name.nil? || name.empty?
 
           block = node.block
@@ -798,7 +736,8 @@ module Rigor
             next if child.receiver
 
             (child.arguments&.arguments || []).each do |arg|
-              skips << arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode)
+              sym = Rigor::Source::Literals.symbol(arg)
+              skips << sym if sym
             end
           end
           skips
@@ -1495,42 +1434,12 @@ module Rigor
           path.scan(/\([^)]*\)/).sum { |group| group.scan(/[:*][a-z_][a-z0-9_]*/).size }
         end
 
-        # Shared with `Context::Inflector#singularize` — kept in
-        # sync until one of the two call sites can adopt the
-        # other.
-        UNCOUNTABLE = %w[
-          equipment information rice money species series fish
-          sheep jeans police news settings
-        ].to_set.freeze
-
-        # Same `IRREGULAR_SINGULARS` map as `Context#singularize`.
-        IRREGULAR_SINGULARS = {
-          "media" => "medium",
-          "data" => "datum",
-          "criteria" => "criterion",
-          "phenomena" => "phenomenon"
-        }.freeze
-
+        # ADR-39 — delegates to the shared inflector (real
+        # `ActiveSupport::Inflector` when available). Previously a
+        # hand-tuned AS-replica kept in sync with `Context#singularize`;
+        # both now share the one authoritative implementation.
         def singularize_word(word)
-          return IRREGULAR_SINGULARS[word] if IRREGULAR_SINGULARS.key?(word)
-          return word if UNCOUNTABLE.include?(word)
-          return "#{word.chomp('ies')}y" if word.end_with?("ies") && word.length > 3
-          # Rails-shipped `(alias|status|bus)es$` → `$1`
-          # specifics — without these the generic chomp rules
-          # mis-singularise `statuses` → `statuse` and
-          # `aliases` → `aliase`.
-          return word.chomp("es") if /(?:alias|status|bus)es\z/.match?(word)
-          # Match the Rails default-inflector rule:
-          # `(x|ch|ss|sh)es$` → strip "es". A generic `ses`
-          # suffix would over-strip (`databases` → `databas`).
-          return word.chomp("es") if word.end_with?("ches", "shes", "sses", "xes", "zes")
-          # Preserve trailing `ss` — Rails ships
-          # `inflect.singular(/(ss)$/i, '\1')` so `custom_css`
-          # singularises as `custom_css`, not `custom_cs`.
-          return word if word.end_with?("ss")
-          return word.chomp("s") if word.end_with?("s")
-
-          word
+          Rigor::Plugin::Inflector.singularize(word)
         end
       end
     end

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -66,29 +66,26 @@ module Rigor
         version: "0.27.0",
         description: "Validates Rails route-helper calls against `config/routes.rb`.",
         config_schema: {
-          "routes_file" => :string,
-          "helper_paths" => :array
+          "routes_file" => { kind: :string, default: "config/routes.rb" },
+          # `helper_paths` — the directories `HelperDiscoverer` walks
+          # for project-defined `*_path` / `*_url` methods. Default to
+          # the whole `app/` tree — the suffix filter inside the
+          # discoverer keeps the registered set tight, and real-world
+          # Rails apps routinely keep URL builders under
+          # `app/controllers` (private `def page_url`, `def callback_url`
+          # shapes), `app/lib` (Mastodon's
+          # `TranslationService::DeepL#base_url`), `app/services`
+          # (`SoftwareUpdateCheckService#api_url`), `app/serializers`,
+          # `app/presenters`, `app/decorators`, not only `app/helpers/`.
+          # Walking the whole tree is the honest answer to "does this
+          # `_path` / `_url` name exist anywhere in the project?"; the
+          # cost is a one-time Prism parse per file at startup, which is
+          # bounded.
+          "helper_paths" => { kind: :array, default: ["app"] }
         },
         produces: [:helper_table]
       )
 
-      DEFAULT_ROUTES_FILE = "config/routes.rb"
-
-      # The directories `HelperDiscoverer` walks for project-
-      # defined `*_path` / `*_url` methods. Default to the whole
-      # `app/` tree — the suffix filter inside the discoverer
-      # keeps the registered set tight, and real-world Rails
-      # apps routinely keep URL builders under `app/controllers`
-      # (private `def page_url`, `def callback_url` shapes),
-      # `app/lib` (Mastodon's `TranslationService::DeepL#base_url`),
-      # `app/services` (`SoftwareUpdateCheckService#api_url`),
-      # `app/serializers`, `app/presenters`, `app/decorators`,
-      # not only `app/helpers/`. Walking the whole tree is the
-      # honest answer to "does this `_path` / `_url` name exist
-      # anywhere in the project?"; the cost is a one-time Prism
-      # parse per file at startup, which is bounded.
-      DEFAULT_HELPER_PATHS = ["app"].freeze
-
       # Cached producer — reads `config/routes.rb` through
       # the trusted `IoBoundary` and parses through
       # {RoutesParser}. The descriptor's auto-collected
@@ -110,8 +107,8 @@ module Rigor
       end
 
       def init(_services)
-        @routes_file = config.fetch("routes_file", DEFAULT_ROUTES_FILE)
-        @helper_paths = Array(config.fetch("helper_paths", DEFAULT_HELPER_PATHS)).map(&:to_s)
+        @routes_file = config.fetch("routes_file")
+        @helper_paths = Array(config.fetch("helper_paths")).map(&:to_s)
         @helper_table = nil
         @load_error = nil
       end
@@ -165,6 +162,10 @@ module Rigor
         )
       end
 
+      # File-level only: the once-per-run load-error emission. Per-call
+      # helper validation runs over the engine-owned walk via the
+      # node_rule below (ADR-37), with the same-file `shadowing` set
+      # built once as the node-rule file context.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         table = helper_table_or_nil
         if table.nil? && @load_error
@@ -173,10 +174,21 @@ module Rigor
           @load_error_emitted = true
           return [load_error_diagnostic(path)]
         end
-        return [] if table.nil? || table.empty?
 
-        Analyzer.diagnose(path: path, root: root, helper_table: table)
-                .map { |diag| build_diagnostic(diag) }
+        []
+      end
+
+      node_file_context do |root, _scope|
+        Analyzer.collect_shadowing_names(root)
+      end
+
+      node_rule Prism::CallNode do |node, _scope, path, shadowing|
+        table = helper_table_or_nil
+        next [] if table.nil? || table.empty?
+
+        Analyzer.violations_for(call_node: node, helper_table: table, shadowing: shadowing, path: path).map do |violation|
+          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
+        end
       end
 
       private
@@ -221,13 +233,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(RailsRoutes)

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -138,7 +138,6 @@ module Rigor
           id: base.id,
           version: base.version,
           description: base.description,
-          protocols: base.protocols,
           config_schema: base.config_schema,
           produces: base.produces,
           consumes: base.consumes,

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 require_relative "scope_walker"
 
@@ -82,7 +83,10 @@ module Rigor
           if describe_call?(node)
             record = build_record(node, anchor)
             accumulator << record
-            if node.block&.body
+            # `describe_call?` already guarantees a `Prism::CallNode`; the
+            # explicit `is_a?` re-states it so the analyzer narrows `node`
+            # from `Prism::Node` and resolves `#block` (a CallNode method).
+            if node.is_a?(Prism::CallNode) && node.block&.body
               collect(node.block.body, anchor: record.describe_const || anchor, accumulator: accumulator)
             end
             return
@@ -190,9 +194,8 @@ module Rigor
 
             return nil
           end
-          return nil unless first_arg.is_a?(Prism::SymbolNode)
 
-          first_arg.unescaped.to_sym
+          Rigor::Source::Literals.symbol(first_arg)
         end
       end
     end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "rigor/source/literals"
 
 module Rigor
   module Plugin
@@ -157,10 +158,11 @@ module Rigor
               block_node: call_node.block
             )
           end
-          return nil unless first_arg.is_a?(Prism::SymbolNode)
+          name = Rigor::Source::Literals.symbol(first_arg)
+          return nil if name.nil?
 
           Declaration.new(
-            name: first_arg.unescaped.to_sym,
+            name: name,
             kind: call_node.name,
             location: call_node.location,
             block_node: call_node.block