rigortype 0.4.6 → 0.4.8

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/schema_table.rb

@@ -9,9 +9,10 @@ module Rigor
       #
       # The mapping from Rails column types to Ruby class names is deliberately conservative —
       # `:string`/`:text` → `String`, `:integer`/`:bigint` → `Integer`, `:boolean` → `bool`,
-      # `:datetime`/`:timestamp` → `Time`, `:date` → `Date`, `:decimal`/`:float` → `Float`. Exotic types
-      # (json, jsonb, ltree, hstore, custom) fall back to `Object` so the plugin stays silent rather than
-      # guessing.
+      # `:datetime`/`:timestamp` → `Time`, `:date` → `Date`, `:float` → `Float`. A `:decimal` column's class
+      # follows its scale, so it is typed by {.decimal_ruby_type} from the parser that reads the scale, and
+      # reads `Object` here. Exotic types (json, jsonb, ltree, hstore, custom) fall back to `Object` so the
+      # plugin stays silent rather than guessing.
       class SchemaTable
         Column = Struct.new(:name, :type, :ruby_type, :array, keyword_init: true) do
           def to_h = { name: name, type: type, ruby_type: ruby_type, array: array }
@@ -21,14 +22,16 @@ module Rigor
           end
         end
 
-        # Map ActiveRecord column types → Ruby class names.
         RUBY_TYPE_MAPPING = {
           string: "String",
           text: "String",
           integer: "Integer",
           bigint: "Integer",
+          # PostgreSQL's dumper writes `id: :serial` / `t.serial` for a sequence-backed integer column.
+          serial: "Integer",
+          bigserial: "Integer",
           float: "Float",
-          decimal: "Float",
+          decimal: "Object",
           boolean: "bool",
           datetime: "Time",
           timestamp: "Time",
@@ -46,7 +49,7 @@ module Rigor
         }.freeze
 
         # Implicit columns that every Rails table has unless the schema explicitly opts out. The plugin
-        # assumes these exist; users who run `create_table id: false` get no implicit `id` column from
+        # assumes these exist; users who run `create_table id: false` or `id: nil` get no implicit `id` column from
         # the parser, but most apps never disable it.
         IMPLICIT_COLUMNS = [
           Column.new(name: "id", type: :integer, ruby_type: "Integer").freeze
@@ -84,6 +87,17 @@ module Rigor
         def self.ruby_type_for(column_type)
           RUBY_TYPE_MAPPING.fetch(column_type.to_sym, "Object")
         end
+
+        # Maps a `decimal` column's scale to its Ruby class. Rails registers `Type::DecimalWithoutScale`
+        # (an Integer) at scale 0 and `Type::Decimal` (a BigDecimal) at any other scale. An absent or
+        # non-literal scale (`nil`) is left to the adapter, which decides it, so it reads as `Object`.
+        def self.decimal_ruby_type(scale)
+          case scale
+          when 0 then "Integer"
+          when Integer then "BigDecimal"
+          else "Object"
+          end
+        end
       end
     end
   end

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/structure_sql_parser.rb

@@ -138,21 +138,23 @@ module Rigor
         end
 
         def build_column(name, rest)
-          type_str, array = extract_type(rest)
+          type_str, array, scale = extract_type(rest)
           return nil if type_str.empty?
 
           rails_type = PG_TYPE_TO_RAILS.fetch(type_str, type_str.to_sym)
+          ruby_type = rails_type == :decimal ? SchemaTable.decimal_ruby_type(scale) : SchemaTable.ruby_type_for(rails_type)
           SchemaTable::Column.new(
             name: name,
             type: rails_type,
-            ruby_type: SchemaTable.ruby_type_for(rails_type),
+            ruby_type: ruby_type,
             array: array
           )
         end
 
         # The type is every token before the first uppercase-initial token (a column modifier such as
         # `NOT`, `NULL`, `DEFAULT`, `GENERATED`, `COLLATE`). A trailing `[]` marks a Postgres array column;
-        # a `(length[,scale])` specifier is dropped. Returns `[normalized_type, array?]`.
+        # a `(length[,scale])` specifier is dropped. Returns `[normalized_type, array?, scale]`, where `scale` is
+        # the literal second number of a `(precision, scale)` specifier, or nil when there is none.
         def extract_type(rest)
           type_tokens = []
           rest.split(/\s+/).each do |token|
@@ -162,8 +164,9 @@ module Rigor
           end
           type_str = type_tokens.join(" ")
           array = type_str.include?("[]")
+          scale = type_str[/\(\s*\d+\s*,\s*(\d+)\s*\)/, 1]&.to_i
           type_str = type_str.gsub("[]", "").gsub(/\([0-9,\s]*\)/, "").strip.downcase
-          [type_str, array]
+          [type_str, array, scale]
         end
       end
     end

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

@@ -59,12 +59,20 @@ module Rigor
     # capital R) is intentional — keeps the constant lookup distinct from `::ActiveRecord` even though the
     # gem name is hyphenated.
     #
-    # Note: this plugin is the seventh worked example. It does NOT require `active_record` at runtime — it
-    # only reads project source, the same way the other examples do. Rigor stays decoupled from Rails.
+    # Note: this plugin does NOT require `active_record` at runtime — it only reads project source, the
+    # same way the other examples do. Rigor stays decoupled from Rails.
     class Activerecord < Rigor::Plugin::Base
       manifest(
         id: "activerecord",
         target_gems: ["activerecord"],
+        # 0.16.0, 2026-11-13 (#2956) — the `id` column takes the primary key's type (`id: :uuid` reads `String`)
+        # instead of always `Integer`, and `serial` / `bigserial` columns read `Integer`. The schema table
+        # payload changes, so the bump follows the 0.15.0 entry.
+        #
+        # 0.15.0, 2026-11-07 (#2945) — `create_table`'s `primary_key: "name"` registers that column, so a query
+        # on it, or on an `alias_attribute` targeting it, no longer reports `unknown-column`. The schema table
+        # payload changes, and the bump (part of the producer cache KEY) stops a warm run serving the old one.
+        #
         # 0.14.0, 2026-10-10 (#1721) — the plugin publishes `:reachability_roots`: the models ActiveRecord loads
         # by name from an association. The association rows gain `macro`, `class_name_option`, `through` and
         # `source_type_option`, so a cached 0.13.0 payload lacks the fields the roots are derived from and
@@ -124,7 +132,7 @@ module Rigor
         # a scope lambda body / class-method body now contributes `Relation[Model]` via `scope.self_type`
         # instead of falling through to `Kernel#select` (the IO multiplexer, `Array[String]` return). Plus
         # `:select` added to the relation-entry-point list.
-        version: "0.14.0",
+        version: "0.16.0",
         description: "Types ActiveRecord finders against the project's db/schema.rb and AR models.",
         config_schema: {
           "schema_file" => { kind: :string, default: "db/schema.rb" },
@@ -491,8 +499,8 @@ module Rigor
       # The project's OWN definition wins, and is not merely a precision preference: `def name` on the
       # model — or on an ancestor it declares — is an override Ruby dispatches to, and the plugin tier sits
       # ABOVE the engine's body-inference tiers, so answering here would displace the override's real return
-      # type with `Dynamic`. `discovered_method_through_ancestors?` is the same table the veto's own
-      # discovery arm reads, and it fails toward declining (a budget-exhausted walk answers true).
+      # type with `Dynamic`. `Reflection.project_method_defined(source: :discovered)` is the same table the veto's own
+      # discovery arm reads, and it fails toward declining (a budget-exhausted walk answers `maybe`).
       def implicit_self_instance_member_type(call_node, scope, index)
         return nil if scope.nil?
         return nil unless call_node.arguments.nil?
@@ -504,7 +512,9 @@ module Rigor
         entry = index.find(self_type.class_name)
         return nil if entry.nil?
         return nil unless instance_member_name?(entry, call_node.name)
-        return nil if scope.discovered_method_through_ancestors?(self_type.class_name, call_node.name, :instance)
+        return nil unless Rigor::Reflection.project_method_defined(
+          self_type.class_name, call_node.name, kind: :instance, source: :discovered, scope: scope
+        ).no?
         return nil if rbs_answers_before_object?(self_type.class_name, call_node.name, scope)
 
         Rigor::Type::Combinator.untyped
@@ -552,9 +562,22 @@ module Rigor
         !entry.column(column_name).nil?
       end
 
+      # A project `self.find` on the model or an ancestor, or a walk that ran out of budget before ruling one out
+      # (`maybe`): the veto fails toward declining, as the discovery walk always has.
+      def project_find_defined?(entry, scope)
+        project_singleton_defined?(entry, :find, scope)
+      end
+
+      # The same veto for any class-side selector the plugin answers in Rails' name (`find`, `select`).
+      def project_singleton_defined?(entry, name, scope)
+        !Rigor::Reflection.project_method_defined(entry.class_name, name, kind: :singleton, source: :discovered,
+                                                                          scope: scope).no?
+      end
+
       # Class-side finders + the class-side relation entry points. `find` returns the model, or an Array of
-      # them for two or more ids, or with a block the model or `nil`; `find_by!` returns the model; `find_by` adds the `nil` arm; `where` /
-      # `all` / `order` / `limit` / `none` open a relation. The relation then carries its element type
+      # them for two or more ids, or with a block the model or `nil`; `find_by!` returns the model;
+      # `find_by` adds the `nil` arm; `where` / `all` / `order` / `limit` / `none` open a relation. The
+      # relation then carries its element type
       # through any further chained query method via the bundled `ActiveRecord::Relation` RBS.
       def finder_return_type(call_node, entry, scope)
         case call_node.name
@@ -571,7 +594,7 @@ module Rigor
 
           # A model that defines its own `self.find` (`find(owner, id)`) takes two arguments for its own
           # reasons, so the Array reading of Rails' `find` is withheld and the project's method answers.
-          return nil if scope.discovered_method_through_ancestors?(entry.class_name, :find, :singleton)
+          return nil if project_find_defined?(entry, scope)
 
           Rigor::Type::Combinator.nominal_of("Array", type_args: [model])
         when :find_by!
@@ -583,13 +606,10 @@ module Rigor
             Rigor::Type::Combinator.nominal_of(entry.class_name),
             Rigor::Type::Combinator.constant_of(nil)
           )
-        when :where, :all, :order, :limit, :none, :select
-          # `:select` was added to close Mastodon's
-          # `scope :duplicate_uris, -> { select(:uri).group(:uri).having(...) }` shape: the implicit-self
-          # `select(:uri)` inside the scope lambda body had been resolving to `Kernel#select` (IO
-          # multiplexer, return `Array[String]`), masking the AR class-side relation entry point. The rest
-          # of the query DSL chains through the bundled `ActiveRecord::Relation` RBS once a relation is
-          # open.
+        when :select then class_select_return_type(call_node, entry, scope)
+        when :where, :all, :order, :limit, :none
+          # The rest of the query DSL chains through the bundled `ActiveRecord::Relation` RBS once a
+          # relation is open.
           relation_of(entry.class_name)
         when :table_name
           table_name_return_type(entry)
@@ -600,6 +620,23 @@ module Rigor
         end
       end
 
+      # `:select` was added to close Mastodon's `scope :duplicate_uris, -> { select(:uri).group(:uri).having(...) }`
+      # shape: the implicit-self `select(:uri)` inside the scope lambda body had been resolving to `Kernel#select`
+      # (IO multiplexer, return `Array[String]`), masking the AR class-side relation entry point.
+      #
+      # `Model.select` is `all.select`, so a block makes it `Enumerable#select` over the loaded records, as the
+      # bundled `Relation#select` overload says (#1408), and the answer is an Array of the model. Fields next to a
+      # block answer the Array too, for the reason given on that overload. A model that defines its own
+      # `self.select` keeps its own answer for the block forms, as it does for `find`'s block and multi-id
+      # forms (`project_find_defined?`); the builder form stays the relation, as `find`'s one-id form stays the
+      # model.
+      def class_select_return_type(call_node, entry, scope)
+        return relation_of(entry.class_name) if call_node.block.nil?
+        return nil if project_singleton_defined?(entry, :select, scope)
+
+        Rigor::Type::Combinator.nominal_of("Array", type_args: [Rigor::Type::Combinator.nominal_of(entry.class_name)])
+      end
+
       # `Model.find { |m| … }` / `Model.find(&:pred?)` never reaches the id lookup: `Core.find` passes a
       # block to `super` (`all.find`), whose `Relation#find` does `return super if block_given?`, landing on
       # `Enumerable#find` over the loaded records. So the answer is the element or `nil`, exactly what the
@@ -614,7 +651,7 @@ module Rigor
       # `Relation#find` overload does. A project `self.find` keeps its own answer, as it does for the
       # multi-id form.
       def block_find_return_type(call_node, entry, scope)
-        return nil if scope.discovered_method_through_ancestors?(entry.class_name, :find, :singleton)
+        return nil if project_find_defined?(entry, scope)
         return Rigor::Type::Combinator.untyped unless call_argument_count(call_node).zero?
 
         Rigor::Type::Combinator.union(

data/plugins/rigor-activerecord/sig/active_record/relation.rbs

@@ -231,12 +231,26 @@ module ActiveRecord
     def left_outer_joins: (*untyped) -> self
     %a{pure}
     def references: (*untyped) -> self
-    # With a block, `select` is Enumerable's and returns an Array. It
-    # stays `self`: on this open receiver a method the file does not
-    # declare is not reported, while on `Array[Elem]` any ActiveSupport
-    # method the bundled overlay leaves out would be.
+    # With a block, `select` is `Enumerable#select` over the loaded
+    # records and returns an Array (`return super()` when a block is
+    # given, `relation/query_methods.rb:413` in activerecord 8.1.3.1).
+    # Fields and a block together raise `ArgumentError` there; Rails 4
+    # ignored the fields and returned the Array, so that form answers
+    # the Array too, which holds on either version. Without a block it
+    # is the query builder.
+    #
+    # `Array[Elem]` is a closed receiver, unlike this one: an
+    # ActiveSupport Array method on the result (`pluck`, `second`,
+    # `to_sentence`, `blank?`) resolves only with the
+    # `rigor-activesupport-core-ext` plugin enabled, and reports
+    # `call.undefined-method` without it, as it does after `to_a`.
+    #
+    # The `%a{pure}` is the builder form's. The block form's
+    # `io.db.read` comes from the plugin's `RELATION_MATERIALIZERS` row,
+    # which labels both forms today (#1318).
     %a{pure}
-    def select: (*untyped) -> self
+    def select: (*untyped) { (Elem) -> boolish } -> Array[Elem]
+              | (*untyped) -> self
     %a{pure}
     def reselect: (*untyped) -> self
     %a{pure}

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_discoverer.rb

@@ -105,10 +105,9 @@ module Rigor
           walk(node.body, inner_path, &) if node.body
         end
 
-        # The full constant name a `class` / `module` declaration defines, given the rendered local name
-        # and the enclosing lexical path. A ROOTED local name (`class ::User`) names the top-level constant
-        # whatever the nesting, so the lexical path is dropped and the `::` with it; otherwise the name is
-        # appended to the path (`class User` inside `module Admin` → `Admin::User`).
+        # The full constant name a `class` / `module` declaration defines. A ROOTED local name (`class ::User`)
+        # names the top-level constant whatever the nesting, so the lexical path is dropped; otherwise the
+        # name is appended to it (`class User` inside `module Admin` → `Admin::User`).
         def declared_constant_name(local_name, lexical_path)
           return local_name.delete_prefix("::") if local_name.start_with?("::")
 

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_index.rb

@@ -8,7 +8,7 @@ module Rigor
       #
       # Each row is `{ name:, kind: }`:
       #
-      # - `name` — String, the attachment method name as the user invokes it (`"avatar"`).
+      # - `name` — the attachment method name as the user invokes it (`"avatar"`).
       # - `kind` — `:singular` (`has_one_attached`) or `:collection` (`has_many_attached`).
       class AttachmentIndex
         attr_reader :entries

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

@@ -89,13 +89,15 @@ module Rigor
       # decline — they take side-effecting argument types that the RBS surface already covers.
       dynamic_return receivers: -> { attachment_index&.class_names || [] } do |call_node, scope|
         next nil unless call_node.is_a?(Prism::CallNode)
-        next nil if call_node.receiver.nil?
+
+        receiver = call_node.receiver
+        next nil if receiver.nil?
         next nil unless call_node.arguments.nil?
 
         index = attachment_index
         next nil if index.nil? || index.empty?
 
-        receiver_type = scope.type_of(call_node.receiver)
+        receiver_type = scope.type_of(receiver)
         next nil unless receiver_type.is_a?(Rigor::Type::Nominal)
 
         # `AttachmentIndex#attachments_for` de-roots the query itself (#621) — no retry arm here.
@@ -137,19 +139,14 @@ module Rigor
         nil
       end
 
-      # Issue #1056 — "the attachment index did not load" is a fact about the run's INPUTS, not about the
-      # file being analysed, so both outcomes are registered rather than returned: see
-      # {Plugin::Base#disclose_once} for the channel and the position. Returned from the per-file hook they
-      # carried no once-guard at all — the `.uniq` collapsed repeats within one instance's list, but the
-      # whole list was re-emitted on every analysed file.
+      # Issue #1056 — "the attachment index did not load" is a fact about the run's INPUTS, not the file
+      # being analysed, so it is registered via {Plugin::Base#disclose_once} rather than returned from the
+      # per-file hook (which had no once-guard and re-emitted the list on every file).
       #
-      # The `key`s carry an ordinal prefix because the engine emits a plugin's disclosures in KEY order
-      # (#1051), and a refused read must still precede a discovery failure the way `@load_errors` records
-      # them — `@load_errors` is now keyed by that same string, which also caps it: `#attachment_index`
-      # re-attempts the load per call site, and the old Array appended a fresh interpolated string every
-      # time (the unbounded-growth shape #569 measured at 4.2 M retained strings on Redmine). The key, not
-      # the message, is the identity: a second refusal naming a different path collapses into the first row
-      # rather than adding one — the notice is "the index did not load", said once.
+      # The `key`s carry an ordinal prefix because the engine emits disclosures in KEY order (#1051), and
+      # a refused read must precede a discovery failure. `@load_errors` is keyed by the same string, which
+      # caps it: `#attachment_index` re-attempts the load per call site (#569). The key, not the message,
+      # is the identity, so a second refusal collapses into the first row.
       def disclose_load_errors
         @load_errors.each do |key, message|
           disclose_once(key, message: message, severity: :warning, rule: "load-error")

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

@@ -3,4 +3,4 @@
 # Entry point matching the `rigor-<id>` gem-name convention. The Plugin::Loader's `require_gem!` step
 # calls `require "rigor-activestorage"`, and this file loads the plugin's actual implementation under
 # the `rigor/plugin/` namespace so the require / register pair fires.
-require "rigor/plugin/activestorage"
+require_relative "rigor/plugin/activestorage"

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext/effects.rb

@@ -12,7 +12,7 @@ module Rigor
       # the core_ext predicate surface — the single cheapest purity win in a Rails app, per WD10 — is issue
       # #388 and lands in this plugin's shipped RBS, not here (`try` was audited and skipped: it dispatches
       # to whatever method the caller names, so its purity is a fact about the call site, not about `try`).
-      # One row below (`in_time_zone_row`) is #388's own addition: `DateTime#in_time_zone` reads `Time.zone`
+      # The `in_time_zone_rows` group is #388's own addition: `DateTime#in_time_zone` reads `Time.zone`
       # through a default argument, a gap the RBS sweep found but can only fix here.
       #
       # ## The clock

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext/symbolize_keys.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "rigor/type"
+
+module Rigor
+  module Plugin
+    class ActivesupportCoreExt < Rigor::Plugin::Base
+      # #2433 — the result type of `Hash#symbolize_keys` / `#to_options`.
+      #
+      # ActiveSupport implements them as `transform_keys { |key| key.to_sym rescue key }`, so a String or
+      # Symbol key becomes a Symbol and a key without `to_sym` (an Integer, a Float) survives unchanged. One
+      # RBS return type cannot say that: `Hash[Symbol, V]` reads an Integer key as a Symbol, and
+      # `Hash[Symbol | K, V]` makes a String-keyed hash fail a declared `Hash[Symbol, untyped]` parameter.
+      # So the RBS rows answer `Hash[untyped, V]` and this module maps each key member where it can.
+      #
+      # A key that is not a String or Symbol (an Integer, a project class) reads `Dynamic[top]`: no Rigor fact proves
+      # a class has no `to_sym` (a mixin, a `pre_eval` file or a reopening can add one), so a kept key could claim
+      # a type the program does not have. It declines (`nil`, the RBS row answers) when a receiver member is
+      # neither a `Hash[K, V]` nor `nil`. A `nil` member is dropped: `nil.symbolize_keys` raises, and the engine
+      # adds `nil` back for `&.`.
+      module SymbolizeKeys
+        HASH = "Hash"
+        SYMBOLIZED_CLASSES = %w[String Symbol].freeze
+
+        module_function
+
+        # Answers `Hash[K', V]` (the union of such over the receiver's Hash members), or nil to decline.
+        def result(receiver_type, scope)
+          members = receiver_type.is_a?(Rigor::Type::Union) ? receiver_type.members : [receiver_type]
+          answers = members.reject { |member| nil_member?(member) }.map { |member| member_answer(member, scope) }
+          return nil if answers.empty? || answers.any?(:decline)
+
+          hashes = answers.reject { |answer| answer == :empty }
+          hashes.empty? ? nil : Rigor::Type::Combinator.union(*hashes)
+        end
+
+        # An empty closed shape is `{}`: it adds no key, so it drops out of the union rather than declining it.
+        def member_answer(member, scope)
+          return :empty if member.is_a?(Rigor::Type::HashShape) && member.closed? && member.pairs.empty?
+
+          key_type, value_type = hash_arguments(member)
+          return :decline if key_type.nil?
+
+          Rigor::Type::Combinator.nominal_of(HASH, type_args: [map_key(key_type, scope), value_type])
+        end
+
+        def nil_member?(type)
+          (type.is_a?(Rigor::Type::Constant) && type.value.nil?) ||
+            (type.is_a?(Rigor::Type::Nominal) && type.class_name == "NilClass")
+        end
+
+        def hash_arguments(type)
+          case type
+          when Rigor::Type::Nominal
+            type.class_name == HASH && type.type_args.size == 2 ? type.type_args : nil
+          when Rigor::Type::Difference
+            hash_arguments(type.base)
+          when Rigor::Type::HashShape
+            shape_arguments(type)
+          end
+        end
+
+        # A closed, non-empty shape reads as `Hash[<its keys>, <union of its values>]`.
+        def shape_arguments(shape)
+          return nil if shape.open? || shape.pairs.empty?
+
+          keys = shape.pairs.keys.map { |key| Rigor::Type::Combinator.constant_of(key) }
+          [Rigor::Type::Combinator.union(*keys), Rigor::Type::Combinator.union(*shape.pairs.values)]
+        end
+
+        def map_key(type, scope)
+          members = type.is_a?(Rigor::Type::Union) ? type.members : [type]
+          Rigor::Type::Combinator.union(*members.map { |member| map_member(member, scope) })
+        end
+
+        def map_member(member, scope)
+          case member
+          when Rigor::Type::Constant
+            member.value.is_a?(String) || member.value.is_a?(Symbol) ? symbol : Rigor::Type::Combinator.untyped
+          when Rigor::Type::Nominal
+            symbolized_class?(member.class_name, scope) ? symbol : Rigor::Type::Combinator.untyped
+          else Rigor::Type::Combinator.untyped
+          end
+        end
+
+        def symbol
+          Rigor::Type::Combinator.nominal_of("Symbol")
+        end
+
+        # String, Symbol and their subclasses go through `to_sym`.
+        def symbolized_class?(name, scope)
+          SYMBOLIZED_CLASSES.include?(name) ||
+            SYMBOLIZED_CLASSES.any? { |base| %i[equal subclass].include?(ordering(name, base, scope)) }
+        end
+
+        def ordering(name, base, scope)
+          Rigor::Reflection.class_ordering(name, base, scope: scope)
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext.rb

@@ -3,6 +3,7 @@
 require "rigor/plugin"
 
 require_relative "activesupport_core_ext/effects"
+require_relative "activesupport_core_ext/symbolize_keys"
 
 module Rigor
   module Plugin
@@ -43,12 +44,15 @@ module Rigor
       manifest(
         id: "activesupport-core-ext",
         target_gems: ["activesupport"],
+        # Bumped 2026-10-27 (#2433) — `Hash#symbolize_keys` / `#to_options` map each key member through a
+        # `dynamic_return` hook instead of claiming `Hash[Symbol, V]`.
+        #
         # Bumped 2026-09-10 (#534 item 7) — `ActiveSupport::Concern` is declared, so `extend
         # ActiveSupport::Concern` resolves instead of reading as an unresolved constant.
         #
         # Bumped 2026-09-02 (#632) — `ActiveSupport::Duration`'s reader surface (`ago`/`to_i`/`iso8601`/…)
         # is now declared, open_receivers-protected; see the class comment above.
-        version: "0.5.0",
+        version: "0.6.0",
         description: "RBS bundle for the most-frequently-flagged ActiveSupport core_ext extensions, " \
                      "plus the `ActiveSupport::Duration` type of the numeric time multipliers and its " \
                      "reader surface.",
@@ -128,10 +132,12 @@ module Rigor
 
       dynamic_return methods: DURATION_MULTIPLIERS do |call_node, scope|
         next nil unless call_node.is_a?(Prism::CallNode)
-        next nil unless call_node.receiver # `day` with no receiver is somebody's own method
+
+        receiver = call_node.receiver
+        next nil unless receiver # `day` with no receiver is somebody's own method
         next nil unless call_node.arguments.nil?
         next nil unless call_node.block.nil?
-        next nil unless numeric_receiver?(scope&.type_of(call_node.receiver))
+        next nil unless numeric_receiver?(scope&.type_of(receiver))
 
         Rigor::Type::Combinator.nominal_of(DURATION_NOMINAL)
       end
@@ -190,20 +196,35 @@ module Rigor
         argument = duration_arithmetic_argument(call_node)
         next nil if argument.nil?
 
-        # The ARGUMENT is checked before the receiver: it is the cheaper of the two on the overwhelmingly
-        # common shapes (`i + 1`, `n * 2`), and a call with no Duration operand must cost as little as
-        # possible — this rule is consulted on every `+` / `-` / `*` in the project. The early exit is
-        # what makes the ordering worth anything: an argument that is no Duration operand at all
-        # (`"a" + b`, `list + other`) declines here and never types its receiver on this rule's behalf.
+        # The ARGUMENT is checked before the receiver: it is the cheaper test on the common shapes (`i + 1`,
+        # `n * 2`), and this rule is consulted on every `+` / `-` / `*`. An argument that is no Duration
+        # operand (`"a" + b`, `list + other`) declines here and never types its receiver on this rule's behalf.
         argument_kind = duration_operand_kind(scope&.type_of(argument))
         next nil if argument_kind.nil?
 
-        receiver_kind = duration_operand_kind(scope&.type_of(call_node.receiver))
+        receiver = call_node.receiver
+        # Prism gives every parsed `+` / `-` / `*` call a receiver; the guard is for the RBS `Node?` type.
+        next nil if receiver.nil?
+
+        receiver_kind = duration_operand_kind(scope&.type_of(receiver))
         next nil if receiver_kind.nil?
 
         duration_arithmetic_result(call_node.name, receiver_kind, argument_kind)
       end
 
+      # #2433 — `symbolize_keys` / `to_options` keep a key without `to_sym`, so the key type is mapped per
+      # member; see {SymbolizeKeys}. The RBS rows answer `Hash[untyped, V]` wherever this declines.
+      dynamic_return methods: %i[symbolize_keys to_options] do |call_node, scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+
+        receiver = call_node.receiver
+        next nil unless receiver
+        next nil unless call_node.arguments.nil?
+
+        # A block is ignored by `symbolize_keys`, so it does not decline.
+        SymbolizeKeys.result(scope&.type_of(receiver), scope)
+      end
+
       # ADR-88 WD1 — both tables are static and the RBS bundle ships with the gem; nothing here reads a
       # project file, so a project enabling this plugin stays incremental-capable.
       def incremental_state_fingerprint