rigortype 0.4.0 → 0.4.2

data/docs/manual/plugins/rigor-typelizer.md

@@ -0,0 +1,71 @@
+# rigor-typelizer
+
+Teaches `rigor unused` about the serializer classes the [typelizer](https://github.com/skryukov/typelizer) gem
+generates TypeScript types from. typelizer writes an interface for every named class that does
+`include Typelizer::DSL` or `extend Typelizer::DSL`, and for all of its subclasses. Such a class may never be
+referenced from Ruby and still be used by your frontend through the generated type, so without this plugin
+`rigor unused` lists it as a removal candidate. The plugin adds no diagnostic and no return type.
+
+It ships bundled in `rigortype`. Activate it under `plugins:`:
+
+```yaml
+plugins:
+  - rigor-typelizer
+```
+
+## What it roots
+
+```ruby
+# app/serializers/application_serializer.rb
+class ApplicationSerializer
+  include Typelizer::DSL           # rooted
+end
+
+# app/serializers/user_serializer.rb
+class UserSerializer < ApplicationSerializer   # rooted: a subclass of a DSL class
+end
+
+# app/serializers/event_serializer.rb
+class EventSerializer
+  extend Typelizer::DSL            # rooted
+end
+
+class PlainFormatter               # not rooted: no Typelizer::DSL on its chain
+end
+```
+
+A subclass is followed through any chain of project classes, and a compact header such as
+`class Admin::UserSerializer < Base` resolves `Base` the way Ruby does (against the lexical scope, not
+`Admin`).
+
+## What it does not root
+
+- A class outside the configured `dirs`. typelizer generates any DSL class that is loaded, but it loads only `dirs`;
+  a class elsewhere is loaded when something references it, so it is not dead.
+- A `module` that includes `Typelizer::DSL`. typelizer registers the module's own name and then calls
+  `.descendants` on it, which a plain module does not have, so it generates no interface.
+- A DSL call that does not run with the class as `self`: inside a method, a block, a lambda or `class << self`.
+- A class whose DSL comes only from an `ActiveSupport::Concern` `included do include Typelizer::DSL end` block.
+  typelizer does register such a class; the plugin does not follow module hooks, so this is a missed root and the
+  class stays a candidate.
+
+`reject_class`, the lambda typelizer's configuration uses to drop a class from the output, is evaluated at
+runtime and is not modelled. A rejected class is still rooted, which hides a candidate and never invents a
+finding.
+
+## Configuration
+
+```yaml
+plugins:
+  - gem: rigor-typelizer
+    config:
+      dirs: ["app/resources", "app/serializers"]   # default
+```
+
+`dirs` mirrors `Typelizer.dirs`; the default is what `Typelizer::Railtie` sets when you configure none. Set it
+to the same list you give typelizer. Superclasses are resolved over all of your project's `paths:`, so a class
+that shadows a base outside `dirs` is noticed.
+
+## More
+
+Internals and the known limits: [plugins/rigor-typelizer/README.md](../../../plugins/rigor-typelizer/README.md).

data/lib/rigor/analysis/check_rules/ivar_write_collector.rb

@@ -40,8 +40,10 @@ module Rigor
         NODE_CLASSES = [Prism::DefNode].freeze
         RULE_WALK_GATES = %i[inside_def detached_ivar_facet].freeze
 
-        # Returns `Hash[class_name (String) => Hash[ivar_name (Symbol) => Array<{node:, type:}>]]`. Empty
-        # when the tree has no qualifying writes.
+        # Returns `Hash[class_name (String) => Hash[ivar_name (Symbol) => Array<{node:, type:, declared:}>]]`.
+        # Empty when the tree has no qualifying writes. `declared` is the translated type of the class's RBS
+        # declaration of the ivar — an `@x: T` member or the slot an `attr_*` member implies, own or
+        # inherited — and nil when the RBS declares none.
         def initialize(scope_index)
           @scope_index = scope_index
           @accumulator = {}
@@ -112,9 +114,31 @@ module Rigor
           return if scope.nil?
 
           rvalue_type = scope.type_of(node.value)
+          declared = declared_ivar(scope, class_name, node.name)
           @accumulator[class_name] ||= {}
           @accumulator[class_name][node.name] ||= []
-          @accumulator[class_name][node.name] << { node: node, type: rvalue_type }
+          @accumulator[class_name][node.name] << { node: node, type: rvalue_type, declared: declared }
+        end
+
+        def declared_ivar(scope, class_name, ivar_name)
+          loader = scope.environment&.rbs_loader
+          return nil if loader.nil?
+
+          variable = loader.instance_definition(class_name)&.instance_variables&.[](ivar_name)
+          return nil if variable.nil?
+
+          translate_declared(variable.type, loader, class_name)
+        end
+
+        # `self` / `instance` in a class's declaration is that class; a module's stays untyped, since its
+        # instances belong to includers no RBS type names. A translation failure reads as untyped, which only
+        # ever withholds a finding.
+        def translate_declared(rbs_type, loader, class_name)
+          owner = Type::Combinator.nominal_of(class_name) unless loader.rbs_module?(class_name)
+          Inference::RbsTypeTranslator.translate(rbs_type, self_type: owner, instance_type: owner,
+                                                           alias_expander: loader)
+        rescue StandardError
+          Type::Combinator.untyped
         end
       end
     end

data/lib/rigor/analysis/check_rules/lexical_method_sites.rb

@@ -3,7 +3,6 @@
 require "prism"
 
 require_relative "../../inference/scope_indexer"
-require_relative "../../source/constant_path"
 require_relative "../../source/node_children"
 
 module Rigor
@@ -12,13 +11,9 @@ module Rigor
       # Issue #1120 — the two ways one file makes a method callable at some sites and not at others, which
       # `call.undefined-method` has to ask the file's syntax about because no project-wide table can answer:
       #
-      # - **Refinements.** `using M` activates M's refinements from the end of the call to the end of the body
-      #   that holds it — the file's top level or a `class` / `module` body, including everything nested in it —
-      #   and nowhere else, not even in another file. A `refine X do … end` block is active inside itself. What
-      #   each module refines is the project-wide `Scope#discovered_refinements`; this answers whether any of
-      #   those modules is in effect at a call site. A `using` whose argument is not a constant
-      #   (`using Module.new { refine … }`) names no module, so every refinement counts as in effect throughout
-      #   its file. A `using` inside a `def` raises in Ruby and activates nothing.
+      # - **Refinements.** Issue #1673 — answered by the file's in-effect refinements ({#refinements}, the
+      #   {Inference::InEffectRefinements} the typer reads too); the rules ask it for derived answers
+      #   (`refinement_active?`, `any_at?`, `refinement_def?`).
       # - **Singleton defs on locals.** `def o.m` defines `m` on the one object `o` holds. The local's type
       #   is not changed; `o.m` is simply not reported within the scope the `def` is written in (the
       #   enclosing `def`, `class` / `module` body, or file — a block shares its enclosing scope's locals).
@@ -26,42 +21,18 @@ module Rigor
       # Built lazily: the walk runs the first time a would-fire call asks, so a file with no such call pays
       # one small object and nothing else.
       class LexicalMethodSites
-        def initialize(root)
+        # Issue #1703 — the file's root, which `call.possible-nil-receiver` re-walks for a `key?` guard.
+        attr_reader :root
+
+        # `refinements` is the query `Inference::ScopeIndexer` stamped on the file's discovery index, so the rules and
+        # the typer share one walk; a query over another tree, or none, builds this file's own on the first ask.
+        def initialize(root, refinements = nil)
           @root = root
           @built = false
+          @refinements = refinements if refinements&.over?(root)
         end
 
-        # Is a refinement from one of `modules` (refining-module names) in effect at `call_node`?
-        def refinement_active?(call_node, modules)
-          build
-          return true if @unresolved_using
-
-          offset = call_node.location.start_offset
-          return true if @refine_blocks.any? { |start, stop| offset >= start && offset < stop }
-
-          @usings.any? do |start, stop, candidates|
-            offset >= start && offset < stop && candidates.any? { |name| modules.include?(name) }
-          end
-        end
-
-        # Issue #1367 — is any refinement in effect at `node`: a `using` of any module, a `using` of a non-constant, or
-        # the inside of a `refine` block? The `global.*` stream check asks it where it cannot name the refining
-        # module (a `define_method` or `alias_method` inside `refine` records none).
-        def using_in_effect?(node)
-          build
-          return true if @unresolved_using
-
-          offset = node.location.start_offset
-          @refine_blocks.any? { |start, stop| offset >= start && offset < stop } ||
-            @usings.any? { |start, stop, _candidates| offset >= start && offset < stop }
-        end
-
-        # Is `def_node` one of the defs a `refine X do … end` body defines on X? Such a def redefines X's method by
-        # design, so X's declared signature for the name is not its contract (issue #1120, maintainer ruling a′).
-        def refinement_def?(def_node)
-          build
-          @refinement_defs.include?(def_node.location.start_offset)
-        end
+        def refinements = (@refinements ||= Inference::InEffectRefinements.new(@root))
 
         # Does a `def <local>.<name>` for this call's local receiver and method name sit in the scope the call
         # is in?
@@ -92,45 +63,35 @@ module Rigor
           return if @built
 
           @built = true
-          @usings = []
-          @refine_blocks = []
           @singleton_defs = []
           @scopes = []
-          @refinement_defs = Set.new
-          @unresolved_using = false
           return if @root.nil?
 
           location = @root.location
           span = [location.start_offset, location.end_offset]
-          walk(@root, [], span, span, false)
+          walk(@root, span)
         end
 
-        # `body` is the `[start, end]` of the body a `using` here stays in effect to the end of; `locals` is the
-        # span of the scope a local written here belongs to.
-        def walk(node, prefix, body, locals, in_def)
+        # `locals` is the span of the scope a local written here belongs to.
+        def walk(node, locals)
           case node
           when Prism::ClassNode, Prism::ModuleNode
-            span = scope_span(node)
-            inner = Source::ConstantPath.declaration_prefix(prefix, node.constant_path) || prefix
-            return walk_children(node.body, inner, span, span, false)
+            return walk_children(node.body, scope_span(node))
           when Prism::SingletonClassNode
-            walk(node.expression, prefix, body, locals, in_def)
-            span = scope_span(node)
-            return walk_children(node.body, prefix, span, span, false)
+            walk(node.expression, locals)
+            return walk_children(node.body, scope_span(node))
           when Prism::DefNode
             record_singleton_def(node, locals)
-            return walk_children(node.body, prefix, body, scope_span(node), true)
-          when Prism::CallNode
-            record_call(node, prefix, body, in_def)
+            return walk_children(node.body, scope_span(node))
           end
 
-          walk_children(node, prefix, body, locals, in_def)
+          walk_children(node, locals)
         end
 
-        def walk_children(node, prefix, body, locals, in_def)
+        def walk_children(node, locals)
           return if node.nil?
 
-          node.rigor_each_child { |child| walk(child, prefix, body, locals, in_def) }
+          node.rigor_each_child { |child| walk(child, locals) }
         end
 
         def record_singleton_def(node, locals)
@@ -140,38 +101,6 @@ module Rigor
           @singleton_defs << [receiver.name, node.name, *locals]
         end
 
-        def record_call(node, prefix, body, in_def)
-          if Inference::ScopeIndexer.refine_target(node)
-            @refine_blocks << span_of(node.block)
-            record_refinement_defs(node.block.body)
-          elsif using_call?(node) && !in_def
-            record_using(node, prefix, body)
-          end
-        end
-
-        def record_refinement_defs(body)
-          return if body.nil?
-
-          Inference::ScopeIndexer.each_refinement_def(body) do |def_node|
-            @refinement_defs << def_node.location.start_offset
-          end
-        end
-
-        def using_call?(node)
-          node.name == :using && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)) &&
-            node.arguments&.arguments&.size == 1
-        end
-
-        def record_using(node, prefix, body)
-          argument = node.arguments.arguments.first
-          if argument.is_a?(Prism::ConstantReadNode) || argument.is_a?(Prism::ConstantPathNode)
-            candidates = Inference::ScopeIndexer.constant_receiver_candidates(argument, prefix)
-            @usings << [node.location.end_offset, body.last, candidates]
-          else
-            @unresolved_using = true
-          end
-        end
-
         # The span of a node that opens a local scope, recorded for {#nested_scope_holds?}.
         def scope_span(node)
           span = span_of(node)

data/lib/rigor/analysis/check_rules/ruby_deprecations.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "rule_ids"
+require_relative "../diagnostic"
+require_relative "../../inference/version_guard"
+require_relative "../../source/constant_path"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Issue #1692 (the ADR-47 WD5 amendment) — `call.deprecated-ruby2-keywords`: a call to a method of the
+      # `ruby2_keywords` family, which Ruby 4.1 deprecates (Feature #22205). `Module#ruby2_keywords`, top-level
+      # `ruby2_keywords` and `Proc#ruby2_keywords` are removed in Ruby 4.4, `Hash.ruby2_keywords_hash?` and
+      # `Hash.ruby2_keywords_hash` in Ruby 4.5.
+      #
+      # The rule runs only when `.rigor.yml` states the runtime: `target_ruby` set explicitly to 4.1 or later
+      # ({Configuration#stated_runtime_ruby}). On Ruby 4.0 the same calls are correct and silent, so the default
+      # `target_ruby` fires nothing. The file walk is paid only by a project that states such a target.
+      #
+      # A call counts only where it can reach the core method and nothing else:
+      #
+      # - `ruby2_keywords` with no receiver (or `self`), in a class or module body, a `class << self` body or a
+      #   singleton method, where `self` is a Module. At the top level outside any block, it is the `main`
+      #   method (a top-level `def` body included). Inside a top-level block, inside any `instance_eval` /
+      #   `instance_exec` block, and in an instance method of a class or module, it is not judged.
+      # - `ruby2_keywords` on a receiver typed `Proc`.
+      # - `ruby2_keywords_hash?` / `ruby2_keywords_hash` on `Hash` or a class RBS knows as its subclass, or with
+      #   no receiver where `self` is one.
+      # - The same names through `send` / `__send__` with a literal Symbol, which also reach the private
+      #   `Module#ruby2_keywords` on an explicit Module receiver.
+      #
+      # A project or `pre_eval:` file that defines a method by the same name anywhere silences that name, since
+      # the call may then reach the project's method. A call in an arm of a version guard that cannot run on the
+      # stated Ruby, or whose guard cannot be decided, is not reported, nor are the statements after a guard
+      # that jumps away (`return if RUBY_VERSION < "2.7"`).
+      module RubyDeprecations
+        module_function
+
+        # The first Ruby that deprecates the family.
+        DEPRECATED_SINCE = "4.1"
+
+        MODULE_FORM = ["Module#ruby2_keywords", "4.4"].freeze
+        TOPLEVEL_FORM = ["top-level ruby2_keywords", "4.4"].freeze
+        PROC_FORM = ["Proc#ruby2_keywords", "4.4"].freeze
+        HASH_FORMS = {
+          ruby2_keywords_hash?: ["Hash.ruby2_keywords_hash?", "4.5"].freeze,
+          ruby2_keywords_hash: ["Hash.ruby2_keywords_hash", "4.5"].freeze
+        }.freeze
+        NAMES = (%i[ruby2_keywords] + HASH_FORMS.keys).freeze
+        SEND_NAMES = %i[send __send__].freeze
+        INSTANCE_EVAL_NAMES = %i[instance_eval instance_exec].freeze
+        private_constant :MODULE_FORM, :TOPLEVEL_FORM, :PROC_FORM, :HASH_FORMS, :NAMES, :SEND_NAMES,
+                         :INSTANCE_EVAL_NAMES
+
+        # The walk's lexical context: whether a block hides `self`, and whether a version guard makes the node
+        # unreportable.
+        Context = Data.define(:in_block, :in_instance_eval, :guarded)
+        ROOT_CONTEXT = Context.new(in_block: false, in_instance_eval: false, guarded: false)
+        private_constant :Context, :ROOT_CONTEXT
+
+        # @param stated_ruby — {Configuration#stated_runtime_ruby}, or nil
+        # @return whether the rule runs at all for this target
+        def active?(stated_ruby)
+          return false if stated_ruby.nil? || !::Gem::Version.correct?(stated_ruby)
+
+          ::Gem::Version.new(stated_ruby) >= ::Gem::Version.new(DEPRECATED_SINCE)
+        end
+
+        def diagnostics(path, root, scope_index, stated_ruby)
+          return [] unless active?(stated_ruby)
+
+          guard_ruby = guard_version(stated_ruby)
+          results = []
+          shadowed = {}
+          walk(root, ROOT_CONTEXT, guard_ruby) do |call, context|
+            form = deprecated_form(call, context, scope_index, shadowed)
+            results << build(path, call, form, stated_ruby) if form
+          end
+          results
+        end
+
+        # `RUBY_VERSION` reads `"4.1.0"` on Ruby 4.1, so a stated `"4.1"` is padded before a guard compares it
+        # as a String.
+        def guard_version(stated_ruby)
+          segments = stated_ruby.split(".")
+          (segments + (["0"] * (3 - segments.size))).join(".")
+        end
+
+        def walk(node, context, guard_ruby, &)
+          # Nothing under a guarded node is reported, so the walk does not descend into it.
+          return if !node.is_a?(Prism::Node) || context.guarded
+
+          yield node, context if node.is_a?(Prism::CallNode) && candidate?(node)
+
+          jumped = false
+          node.rigor_each_child do |child|
+            child_context = child_context(node, child, context, guard_ruby)
+            child_context = child_context.with(guarded: true) if jumped
+            walk(child, child_context, guard_ruby, &)
+            jumped ||= node.is_a?(Prism::StatementsNode) && jumping_version_guard?(child)
+          end
+        end
+
+        def candidate?(call)
+          return true if NAMES.include?(call.name)
+
+          SEND_NAMES.include?(call.name) && NAMES.include?(send_target(call))
+        end
+
+        # The Symbol a `send` names as its first argument, or nil.
+        def send_target(call)
+          first = call.arguments&.arguments&.first
+          first.is_a?(Prism::SymbolNode) ? first.unescaped.to_sym : nil
+        end
+
+        def child_context(node, child, context, guard_ruby)
+          if node.is_a?(Prism::CallNode) && child.equal?(node.block) && child.is_a?(Prism::BlockNode)
+            instance_eval = context.in_instance_eval || INSTANCE_EVAL_NAMES.include?(node.name)
+            context = context.with(in_block: true, in_instance_eval: instance_eval)
+          end
+          return context if context.guarded
+
+          version_guard_live?(node, child, guard_ruby) ? context : context.with(guarded: true)
+        end
+
+        # Whether `child` stays reportable under `node`'s condition. An `if` / `unless` arm is, when its guard is
+        # decided on the stated Ruby and selects it. Any other branch of a conditional whose condition reads
+        # `RUBY_VERSION` is not, because the stated version is the lowest one the project runs on and an
+        # undecided guard may deselect the call on it.
+        def version_guard_live?(node, child, guard_ruby)
+          case node
+          when Prism::IfNode, Prism::UnlessNode
+            return true if child.equal?(node.predicate) || !reads_ruby_version?(node.predicate)
+
+            arm_live?(node, child, guard_ruby)
+          when Prism::CaseNode, Prism::CaseMatchNode, Prism::WhileNode, Prism::UntilNode
+            condition = node.predicate
+            condition.nil? || child.equal?(condition) || !reads_ruby_version?(condition)
+          when Prism::AndNode, Prism::OrNode
+            child.equal?(node.left) || !reads_ruby_version?(node.left)
+          else
+            true
+          end
+        end
+
+        def arm_live?(node, child, guard_ruby)
+          verdict = Inference::VersionGuard.verdict(node.predicate, stated_ruby: guard_ruby)
+          return false if verdict.nil?
+
+          then_live = verdict == (node.is_a?(Prism::IfNode) ? :truthy : :falsey)
+          child.equal?(node.statements) ? then_live : !then_live
+        end
+
+        # `return if RUBY_VERSION < "2.7"` (or `raise` / `next` / `break` under such a guard): the statements
+        # after it run only on the Rubies the guard lets through.
+        def jumping_version_guard?(node)
+          return false unless node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+          return false unless reads_ruby_version?(node.predicate)
+
+          other_arm = node.is_a?(Prism::IfNode) ? node.subsequent : node.else_clause
+          contains_jump?(node.statements) || contains_jump?(other_arm)
+        end
+
+        JUMP_CALLS = %i[raise fail exit exit! abort].freeze
+        private_constant :JUMP_CALLS
+
+        def contains_jump?(node)
+          return false unless node.is_a?(Prism::Node)
+
+          case node
+          when Prism::ReturnNode, Prism::NextNode, Prism::BreakNode then return true
+          when Prism::CallNode then return true if node.receiver.nil? && JUMP_CALLS.include?(node.name)
+          end
+          found = false
+          node.rigor_each_child { |child| found ||= contains_jump?(child) }
+          found
+        end
+
+        def reads_ruby_version?(node)
+          return false unless node.is_a?(Prism::Node)
+          return true if (node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)) &&
+                         Source::ConstantPath.qualified_name_or_nil(node) == "RUBY_VERSION"
+
+          found = false
+          node.rigor_each_child { |child| found ||= reads_ruby_version?(child) }
+          found
+        end
+
+        # @return `[display, removal]` for a call that reaches a deprecated method, or nil
+        def deprecated_form(call, context, scope_index, shadowed)
+          scope = scope_index[call]
+          return nil if scope.nil?
+
+          via_send = SEND_NAMES.include?(call.name)
+          name = via_send ? send_target(call) : call.name
+          shadowed[name] = project_defines?(scope, name) unless shadowed.key?(name)
+          return nil if shadowed[name]
+
+          receiver = call.receiver
+          if receiver.nil? || receiver.is_a?(Prism::SelfNode)
+            self_form(name, scope, context)
+          else
+            receiver_form(name, scope.type_of(receiver), scope, via_send)
+          end
+        end
+
+        def self_form(name, scope, context)
+          self_type = scope.self_type
+          if self_type.nil?
+            return nil if context.in_block || name != :ruby2_keywords
+
+            return TOPLEVEL_FORM
+          end
+          return nil if context.in_instance_eval || !self_type.is_a?(Type::Singleton)
+
+          name == :ruby2_keywords ? MODULE_FORM : hash_form(name, self_type, scope)
+        end
+
+        def receiver_form(name, type, scope, via_send)
+          if name == :ruby2_keywords
+            return PROC_FORM if type.is_a?(Type::Nominal) && class_at_or_below?(type.class_name, "Proc", scope)
+
+            # `Module#ruby2_keywords` is private: only `send` reaches it on an explicit receiver.
+            return via_send && type.is_a?(Type::Singleton) ? MODULE_FORM : nil
+          end
+          type.is_a?(Type::Singleton) ? hash_form(name, type, scope) : nil
+        end
+
+        def hash_form(name, singleton, scope)
+          return nil unless HASH_FORMS.key?(name)
+
+          class_at_or_below?(singleton.class_name, "Hash", scope) ? HASH_FORMS.fetch(name) : nil
+        end
+
+        def class_at_or_below?(class_name, ancestor, scope)
+          return true if class_name == ancestor
+          return false if scope.environment.nil?
+
+          %i[equal subclass].include?(Rigor::Reflection.class_ordering(class_name, ancestor, scope: scope))
+        end
+
+        # Whether a project or `pre_eval:` file defines a method called `name` anywhere — on any class, on either
+        # side, or at the top level. Asked once per name per file.
+        def project_defines?(scope, name)
+          return true if scope.discovered_methods.any? { |_owner, table| table.key?(name) }
+          return true if scope.discovered_def_nodes.any? { |_owner, table| table.key?(name) }
+
+          registry = scope.environment&.project_patched_methods
+          return false if registry.nil? || registry.empty?
+
+          registry.by_key.each_key.any? { |(_owner, method_name, _kind)| method_name == name }
+        end
+
+        def build(path, call, form, stated_ruby)
+          display, removal = form
+          tail = if ::Gem::Version.new(stated_ruby) >= ::Gem::Version.new(removal)
+                   "was removed in Ruby #{removal}"
+                 else
+                   "is deprecated since Ruby 4.1 and will be removed in Ruby #{removal}"
+                 end
+          Diagnostic.from_message_loc(
+            call,
+            rule: RULE_DEPRECATED_RUBY2_KEYWORDS,
+            path: path,
+            message: "`#{display}' #{tail} (target_ruby: #{stated_ruby.inspect})",
+            severity: :warning,
+            method_name: display
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rigor/analysis/check_rules/rule_ids.rb

@@ -78,6 +78,9 @@ module Rigor
       # (`SpecialGlobalSetters`), not the global's RBS declaration.
       RULE_GLOBAL_WRITE_TYPE_MISMATCH = "global.write-type-mismatch"
       RULE_GLOBAL_READONLY_WRITE = "global.readonly-write"
+      # Issue #1692 (the ADR-47 WD5 amendment) — a call to the `ruby2_keywords` family Ruby 4.1 deprecates. Runs only
+      # under an explicit `target_ruby` of 4.1 or later; see {RubyDeprecations}.
+      RULE_DEPRECATED_RUBY2_KEYWORDS = "call.deprecated-ruby2-keywords"
 
       ALL_RULES = [
         RULE_UNDEFINED_METHOD,
@@ -87,6 +90,7 @@ module Rigor
         RULE_ARGUMENT_TYPE,
         RULE_NIL_RECEIVER,
         RULE_RAISE_NON_EXCEPTION,
+        RULE_DEPRECATED_RUBY2_KEYWORDS,
         RULE_DUMP_TYPE,
         RULE_ASSERT_TYPE,
         RULE_ALWAYS_RAISES,