rigortype 0.4.6 → 0.4.8

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers.rb

@@ -161,9 +161,8 @@ module Rigor
       end
 
       def project_defines_object?(serializer_name, scope)
-        return false unless scope.respond_to?(:user_def_through_ancestors)
-
-        !scope.user_def_through_ancestors(serializer_name, :object).first.nil?
+        Rigor::Reflection.project_method_defined(serializer_name, :object, kind: :instance, source: :def,
+                                                                           scope: scope).yes?
       end
 
       # The model a serializer serializes, or nil where nothing corroborates it. Memoised per serializer
@@ -237,13 +236,11 @@ module Rigor
       # the check would decline nearly every real serializer. On the serializer side it is a base
       # serializer's own rendering method, which is not a read of the resource at all.
       def project_defines?(class_name, method_name, scope)
-        return false unless scope.respond_to?(:user_def_through_ancestors)
-
         # A name no Symbol can hold cannot be a method the project defines (#1831): decline, do not raise.
         method = Rigor::Source::SymbolName.of(method_name.to_s)
         return false if method.nil?
 
-        !scope.user_def_through_ancestors(class_name, method).first.nil?
+        Rigor::Reflection.project_method_defined(class_name, method, kind: :instance, source: :def, scope: scope).yes?
       end
 
       # `REST::AccountSerializer` offers two readings — the namespaced `REST::Account` and the

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/analyzer.rb

@@ -55,8 +55,24 @@ module Rigor
           )
         end
 
+        # Ruby binds a trailing `k: v` / `**opts` group to keyword parameters, never to positional ones, so
+        # when `#perform` takes keywords the group is not counted (the message's "got N" is then the
+        # positional count too). A job without keyword parameters keeps counting the group as one positional
+        # argument — `NoArgsJob.perform_later(name: 1)` raises at runtime. A `Hash` literal / local stays
+        # positional either way (Ruby 3 does not convert it).
+        #
+        # The call is declined (no report) when its shape is unknown: a `*splat` or `...` argument may supply
+        # any number of positionals (or a trailing keyword group), and a keyword group made only of `**opts`
+        # arguments sent to a job without keywords may be empty — declined only when the verdict differs
+        # between "empty" and "one positional hash" (`NoArgsJob.perform_later(**opts)`).
         def arity_violation(call_node, entry)
-          actual = (call_node.arguments&.arguments || []).size
+          args = call_node.arguments&.arguments || []
+          return nil if args.any? { |arg| arg.is_a?(Prism::SplatNode) || arg.is_a?(Prism::ForwardingArgumentsNode) }
+
+          keyword_group = args.last.is_a?(Prism::KeywordHashNode) ? args.last : nil
+          return nil if keyword_group && !entry.accepts_keywords && empty_group_decides?(args, keyword_group, entry)
+
+          actual = entry.accepts_keywords && keyword_group ? args.size - 1 : args.size
           return nil if entry.accepts?(actual)
 
           Violation.new(
@@ -66,6 +82,14 @@ module Rigor
           )
         end
 
+        # True when the group is only `**splat` arguments (so it may be empty) AND the entry's verdict changes
+        # between counting it and not counting it.
+        def empty_group_decides?(args, keyword_group, entry)
+          return false unless keyword_group.elements.all?(Prism::AssocSplatNode)
+
+          entry.accepts?(args.size - 1) != entry.accepts?(args.size)
+        end
+
         # Renders a constant-path receiver as a String. Mirrors the helpers in rigor-activerecord /
         # rigor-rails-routes for parity.
         def constant_receiver_name(node)

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/effects.rb

@@ -35,7 +35,7 @@ module Rigor
 
         # Where a Rails app declares its adapter. Per-environment files are read too, because an app that
         # sets the adapter only in `config/environments/production.rb` is common; agreement across every
-        # file that names one is what licenses the narrowing (see {.transport_for}).
+        # file that names one is what licenses the narrowing (see {.detect_adapter}).
         CONFIG_PATHS = ["config/application.rb", "config/environments"].freeze
 
         SETTING = /queue_adapter\s*=\s*[:"']([a-z_]+)["']?/

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_discoverer.rb

@@ -76,7 +76,8 @@ module Rigor
           base.with(
             min_arity: [base.min_arity, addition.min_arity].min,
             max_arity: [base.max_arity, addition.max_arity].max,
-            keyword_required: base.keyword_required & addition.keyword_required
+            keyword_required: base.keyword_required & addition.keyword_required,
+            accepts_keywords: base.accepts_keywords || addition.accepts_keywords
           )
         end
 
@@ -187,7 +188,7 @@ module Rigor
           if perform_def.nil?
             return JobIndex::Entry.new(
               class_name: class_name, min_arity: 0,
-              max_arity: Float::INFINITY, keyword_required: []
+              max_arity: Float::INFINITY, keyword_required: [], accepts_keywords: true
             )
           end
 
@@ -195,22 +196,31 @@ module Rigor
           if parameters.nil?
             return JobIndex::Entry.new(
               class_name: class_name, min_arity: 0,
-              max_arity: 0, keyword_required: []
+              max_arity: 0, keyword_required: [], accepts_keywords: false
             )
           end
 
-          required_count = (parameters.requireds || []).size
+          # Parameters after an optional or rest one (`def perform(a, b = 1, c)`) are required too.
+          required_count = (parameters.requireds || []).size + (parameters.posts || []).size
           optional_count = (parameters.optionals || []).size
           rest_present = !parameters.rest.nil?
           keyword_required = (parameters.keywords || []).filter_map do |kw|
             kw.name if kw.is_a?(Prism::RequiredKeywordParameterNode)
           end
 
+          keyword_rest = parameters.keyword_rest
+          # `...` lives in `keyword_rest` and forwards every argument, so it widens the envelope; `**nil`
+          # also lives there but declares that NO keywords are taken (ActiveJob then hands them over as a
+          # positional hash, exactly like a method with no keyword parameters).
+          forwards_all = keyword_rest.is_a?(Prism::ForwardingParameterNode)
+          takes_keywords = !(parameters.keywords || []).empty? || keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+
           JobIndex::Entry.new(
             class_name: class_name,
             min_arity: required_count,
-            max_arity: rest_present ? Float::INFINITY : required_count + optional_count,
-            keyword_required: keyword_required.map(&:to_sym)
+            max_arity: rest_present || forwards_all ? Float::INFINITY : required_count + optional_count,
+            keyword_required: keyword_required.map(&:to_sym),
+            accepts_keywords: takes_keywords || forwards_all
           )
         end
       end

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_index.rb

@@ -10,9 +10,11 @@ module Rigor
       # `min_arity` / `max_arity` form a closed range (`Float::INFINITY` for the upper bound when
       # `*args` is present). `keyword_required` lists any required keyword arguments — Active Job
       # supports keyword args but they're rare in user code, so the analyzer validates positional arity
-      # only (keyword arity validation is deferred).
+      # only (keyword name validation is deferred). `accepts_keywords` records whether `#perform` binds
+      # keywords at all (`k:`, `k: 1` or `**opts`), so the analyzer can keep a call's keyword arguments out
+      # of the positional count.
       class JobIndex
-        Entry = Data.define(:class_name, :min_arity, :max_arity, :keyword_required) do
+        Entry = Data.define(:class_name, :min_arity, :max_arity, :keyword_required, :accepts_keywords) do
           # Flexible-friendly textual form of the arity for error messages: `1`, `1..2`, `2+`.
           def arity_label
             return "#{min_arity}+" if max_arity == Float::INFINITY

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

@@ -13,7 +13,7 @@ module Rigor
     # rigor-activejob — validates `Job.perform_later(...)` / `.perform_now(...)` / `.perform(...)`
     # argument arity against the discovered `#perform` definitions.
     #
-    # Tier 1D of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
+    # Tier 1D of the [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md).
     # Statically discovers ActiveJob subclasses by walking the configured `job_search_paths` and
     # parsing each file with Prism — no `active_job` runtime dependency.
     #
@@ -98,9 +98,10 @@ module Rigor
       # Cached separately from `:job_index` because the two invalidate on different files: editing a
       # schedule changes which jobs are reached without touching `app/jobs` at all. The `watch:` roots the
       # glob at the working directory so that CREATING a schedule file — not just editing one — is seen. Each
-      # configured path is escaped to a literal name, so `recurring[1].yml` is watched as that file.
+      # configured path is escaped to a literal name, so `recurring[1].yml` is watched as that file, and an
+      # absolute path is watched under its own directory (`RootedGlob.split_file`, #2222).
       producer :recurring_jobs,
-               watch: -> { [[".", *@recurring_paths.map { |path| Rigor::RootedGlob.literal(path) }]] } do |_params|
+               watch: -> { @recurring_paths.map { |path| Rigor::RootedGlob.split_file(path) } } do |_params|
         RecurringScan.new(
           io_boundary: io_boundary,
           recurring_paths: @recurring_paths

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

@@ -110,7 +110,8 @@ module Rigor
         # The predicate `Activerecord#finder_return_type` declines on, so the note and the type agree in a
         # CLI run. In an editor run this scope lacks the file's own methods (#1329).
         def own_find?(entry)
-          @scope.discovered_method_through_ancestors?(entry.class_name, :find, :singleton)
+          !Rigor::Reflection.project_method_defined(entry.class_name, :find, kind: :singleton, source: :discovered,
+                                                                             scope: @scope).no?
         end
 
         def validate_column_hash_call(node, entry)

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

@@ -20,8 +20,9 @@ module Rigor
       #
       # Declined — no root, never a guess: a polymorphic association (no single target), a non-literal
       # `class_name:` / `**opts`, `anonymous_class:`, a `with_options` group with non-literal options, and a
-      # `through:` association without a literal `class_name:` / `source_type:`. Without them a `through:` target is the SOURCE association's class on the through model, and
-      # that association (declared there, hence in this same index) roots it itself.
+      # `through:` association without a literal `class_name:` / `source_type:`. Without them a `through:`
+      # target is the SOURCE association's class on the through model, and that association (declared
+      # there, hence in this same index) roots it itself.
       #
       # A computed name equal to the owner's own demodulized name declines too (Rails 7.2+ tries `::Name`
       # first; the target is then the owner itself or a top-level class).

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

@@ -28,8 +28,8 @@ module Rigor
       #
       # An `ActiveRecord::Base` row reaches `User.find` through the project's own
       # `User < ApplicationRecord < ActiveRecord::Base` lines, so one row covers every model in the app.
-      # That is the whole economy of the framework layer: thirty-odd rows here colour the several thousand
-      # database touches a Rails app performs, and none of them needed a line of application code.
+      # That is the whole economy of the framework layer: a fixed set of rows here colours the several
+      # thousand database touches a Rails app performs, and none of them needed a line of application code.
       module Effects
         BASE = "ActiveRecord::Base"
         RELATION = "ActiveRecord::Relation"

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

@@ -186,27 +186,20 @@ module Rigor
           merge_redeclarations(rows)
         end
 
-        # Collapses the rows that declare the SAME constant into one, so {ModelIndex.build} — which keys
-        # its entries by `class_name` — receives at most one row per model.
+        # Collapses the rows that declare the SAME constant into one, so {ModelIndex.build} (keyed by
+        # `class_name`) receives at most one row per model.
         #
-        # A model is routinely declared more than once: `app/models/user.rb` holds `class User <
-        # ApplicationRecord` and a second file reopens it (`class ::User`, `class User`, or a full
-        # `class User < ApplicationRecord` redeclaration) to add a method. Ruby's own semantics are
-        # ADDITIVE — a reopen contributes what it spells and leaves the rest of the class alone — so the
-        # rows are UNIONed here. Taking the last row instead dropped the real declaration's associations,
-        # scopes, enums, validations, callbacks and `alias_attribute`s whenever the reopen sorted later in
-        # the glob, and `where(<a declared alias>: …)` then surfaced a false `unknown-column` on correct
-        # code; taking the first dropped whatever the reopen added. Neither order loses anything now.
+        # A model is routinely declared more than once (`app/models/user.rb` plus a reopening file). Ruby's
+        # semantics are ADDITIVE, so the rows are UNIONed. Taking the last row dropped the real declaration's
+        # associations, scopes, enums, validations, callbacks and `alias_attribute`s whenever the reopen sorted
+        # later, producing false `unknown-column`s; taking the first dropped what the reopen added.
         #
-        # Merge is by field: the first non-nil `superclass_name` wins (a second declaration is the same
-        # thing, or invalid Ruby); `self.table_name =` is an ASSIGNMENT, so the LATER declaration's
-        # `table_name_override` wins as it does at load time, and when the two declarations disagree the
-        # resolved name is marked computed so no value is pinned — the glob order is not the load order for
-        # two full declarations, and a pinned wrong literal folds `Model.table_name == "…"` on correct code;
-        # `table_name_computed` is otherwise an OR (any computed name in the class makes the resolved one
-        # inexact); name-keyed rows (associations, enums, aliases) let the LAST declaration override an
-        # earlier same-name row exactly as {ModelIndex.merge_named_rows} does across an STI chain, and the
-        # plain lists union.
+        # Merge is by field: the first non-nil `superclass_name` wins. `self.table_name =` is an ASSIGNMENT, so
+        # the later `table_name_override` wins, but when two declarations disagree the name is marked computed
+        # so no value is pinned: glob order is not load order, and a pinned wrong literal would fold
+        # `Model.table_name == "…"` on correct code. `table_name_computed` is otherwise an OR. Name-keyed rows
+        # let the LAST declaration override an earlier same-name row, as {ModelIndex.merge_named_rows} does
+        # across an STI chain; plain lists union.
         def merge_redeclarations(rows)
           return rows if rows.length < 2
 
@@ -459,7 +452,6 @@ module Rigor
             macro_methods: lookup_macro_methods(node.body)
           })
 
-          # Recurse into the body in case nested classes exist.
           walk_for_classes(node.body, [full_name], &) if node.body
         end
 
@@ -869,8 +861,8 @@ module Rigor
 
         # Walks the namespace body's TOP-LEVEL statements only — a decorator declared inside a nested
         # `module`/`class` belongs to THAT namespace, not this one, and must not be attributed here.
-        # Returns `Hash<:prefix|:suffix => { literal: } | { computed: true }>`, only for the names this body
-        # actually mentions. A later statement overrides an earlier one within the SAME body — real Ruby
+        # Returns the decorators keyed by `:prefix` / `:suffix`, only for the names this body actually mentions.
+        # A later statement overrides an earlier one within the SAME body — real Ruby
         # assignment order, not a guess: `mattr_accessor :table_name_prefix` (no `default:`, so `computed:
         # true`) followed two lines down by a real `self.table_name_prefix = "blog_"` folds to the literal.
         #
@@ -1234,8 +1226,8 @@ module Rigor
         end
 
         # Recognised single-instance and collection association DSL methods. The kind drives the eventual
-        # return-type contribution: singular associations narrow to `Nominal[Target] | nil`, plural ones
-        # narrow to `ActiveRecord::Relation[Target]`.
+        # return-type contribution: singular associations narrow to the target or nil, plural ones to a
+        # relation of the target.
         #
         # `composed_of` value-object aggregations and `delegated_type` roles are folded in here too — both
         # accept the association name as a `where` / `find_by` query key, so omitting them turns every
@@ -1336,7 +1328,7 @@ module Rigor
                         association_option(args, "polymorphic") == true
 
           # A polymorphic association has no single static target class — `target` is nil and the flow
-          # contribution declines to narrow rather than inventing a wrong `Nominal[<classified-name>]`.
+          # contribution declines to narrow rather than inventing a wrong class-name target.
           if polymorphic
             target = nil
           else
@@ -1460,8 +1452,7 @@ module Rigor
         end
 
         # `enum status: { active: 0, archived: 1 }` (Rails ≤6) and `enum :status, [:active, :archived]`
-        # (Rails 7+). Returns `Hash<column_name => Array<Symbol>>`. Non-literal forms decline rather than
-        # guess.
+        # (Rails 7+). Non-literal forms decline rather than guess.
         def lookup_enums(body)
           return {} if body.nil?
 
@@ -1516,7 +1507,7 @@ module Rigor
         end
 
         # `scope :active, -> { ... }`. Records the scope name only (the body is intentionally NOT
-        # introspected — the caller contributes `ActiveRecord::Relation[Model]` based on the name alone
+        # introspected — the caller contributes a relation of the model based on the name alone
         # via `class_scope_return_type`).
         def lookup_scopes(body)
           return [] if body.nil?
@@ -1585,8 +1576,7 @@ module Rigor
 
         # `alias_attribute :new_name, :old_name`. Records the mapping so the analyzer accepts the alias
         # as a query key — without it every `where(<alias>: ...)` / `find_by(<alias>: ...)` call surfaces
-        # as a false `unknown-column`. Returns `Hash<alias => target>`; non-Symbol-literal forms decline
-        # rather than guess.
+        # as a false `unknown-column`. Non-Symbol-literal forms decline rather than guess.
         def lookup_aliases(body)
           return {} if body.nil?
 
@@ -1626,7 +1616,7 @@ module Rigor
         # macro and `images`, `images=`, `images_attachments`, `images_blobs` for the collection one — the
         # `has_one_attached` / `has_many_attached` generated-methods surface, none of it column-backed.
         # This is name MEMBERSHIP only, and does not overlap `rigor-activestorage`, which contributes the
-        # accessor's TYPE (`ActiveStorage::Attached::One`) and publishes no fact: a consumer that reads
+        # accessor's type and publishes no fact: a consumer that reads
         # `:model_index` to ask "does this model answer `avatar`?" gets nothing from that plugin, and gets
         # nothing at all when the project does not load it.
         ATTACHMENT_MACROS = {

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

@@ -29,14 +29,12 @@ module Rigor
       # {Entry} resolves its table from the root model and inherits the chain's declared associations /
       # enums / aliases / scopes / validations / callbacks / macro methods.
       class ModelIndex
-        # `associations` is a frozen `Array<Hash>` where each row carries `{ name:, kind:, target:,
-        # nullable: }`:
+        # `associations` is a frozen list of rows `{ name:, kind:, target:, nullable: }`:
         #
-        # - `name`   — String, the association method name as the user invokes it (`"posts"`).
+        # - `name`   — the association method name as the user invokes it (`"posts"`).
         # - `kind`   — `:singular` (`belongs_to` / `has_one`) or `:collection` (`has_many`).
-        # - `target` — String, the target class name resolved either from an explicit `class_name:`
-        #              option or via {Inflector.classify}.
-        # - `nullable` — Boolean; whether a `:singular` accessor can return `nil`. `has_one` → `true`;
+        # - `target` — the target class name, from an explicit `class_name:` option or via {Inflector.classify}.
+        # - `nullable` — whether a `:singular` accessor can return `nil`. `has_one` → `true`;
         #              `belongs_to` → `false` (required by default since Rails 5) unless `optional: true`
         #              / `required: false`. Meaningless for `:collection` rows.
         #
@@ -71,27 +69,23 @@ module Rigor
 
           def association_names = associations.map { |a| a[:name] }
 
-          # `enums` is `Hash<column_name => Array<value_name>>`.
+          # `enums` maps a column name to its value names.
           def enum?(name) = enums.key?(name.to_s)
           def enum_values(name) = enums.fetch(name.to_s, [])
 
-          # `scopes` is `Array<scope_name>`.
           def scope?(name) = scopes.include?(name.to_s)
 
-          # `validations` is `Array<attribute_name>` covering both `validates :name, ...` and the
-          # `validates_*_of :name, ...` shorthand families.
+          # `validations` covers both `validates :name, ...` and the `validates_*_of :name, ...` shorthand families.
           def validation?(name) = validations.include?(name.to_s)
           def validated_attributes = validations
 
-          # `callbacks` is `Array<{ name:, callback: }>`.
           def callback_targets = callbacks.map { |c| c[:name] }
 
-          # `aliases` is `Hash<alias_name => target_attribute>` populated from `alias_attribute`
-          # declarations.
+          # `aliases` maps an alias name to its target attribute, from `alias_attribute` declarations.
           def alias?(name) = aliases.key?(name.to_s)
           def resolve_alias(name) = aliases[name.to_s]
 
-          # `macro_methods` is `Array<method_name>` — the instance methods a declaration macro installs that
+          # `macro_methods` lists the instance methods a declaration macro installs that
           # none of the sets above already carries (#1049): `delegate`'s names, the Paperclip / Active
           # Storage attachment readers, and an `enum`'s per-value predicates. Names only, with no type: a
           # consumer asks "does this model answer `followers_count`?", which is what a fail-closed check
@@ -312,7 +306,7 @@ module Rigor
           seen.values.map(&:freeze).freeze
         end
 
-        # `Hash<column => Array<value>>` merged across the STI chain; a child redeclaration of the same
+        # Enum value lists merged across the STI chain; a child redeclaration of the same
         # enum column overrides the ancestor's value list.
         def self.merge_enums(chain)
           chain.each_with_object({}) do |row, acc|
@@ -320,7 +314,7 @@ module Rigor
           end.freeze
         end
 
-        # `Hash<alias => target>` merged across the STI chain.
+        # Alias map merged across the STI chain.
         def self.merge_aliases(chain)
           chain.each_with_object({}) do |row, acc|
             (row[:aliases] || {}).each { |name, target| acc[name.to_s] = target.to_s }

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

@@ -31,10 +31,17 @@ module Rigor
       # `Object` per `SchemaTable.ruby_type_for` rather than being dropped. Only the structural calls in
       # {NON_COLUMN_METHODS} (indexes, constraints, foreign keys) are skipped.
       #
+      # `create_table "x", primary_key: "name"` adds that column, typed from the `id:` option when the call is
+      # read completely and untyped otherwise. `record.id` reads the primary key column's value, so the `id`
+      # column takes the same type; a composite or unreadable `primary_key:` leaves it untyped. `id: false` or
+      # `id: nil` removes it and adds neither.
+      #
       # Designed for the Prism interpretation pattern from rigor-lisp-eval — recursive descent on the AST,
       # no eval.
       class SchemaParser
         TIMESTAMPS_COLUMNS = %w[created_at updated_at].freeze
+        DEFAULT_PRIMARY_KEY_TYPE = :bigint
+        UNKNOWN_PRIMARY_KEY_TYPE = :unknown
 
         # Structural `t.<method>` calls inside a `create_table` block that declare indexes / constraints
         # rather than columns. Everything NOT in this set that carries a literal column name is treated as
@@ -75,8 +82,10 @@ module Rigor
           return [nil, nil] if table_name.nil?
 
           block_node = call_node.block
-          columns = { "id" => SchemaTable::Column.new(name: "id", type: :integer, ruby_type: "Integer") }
+          columns = { "id" => implicit_id_column(call_node) }
           columns.delete("id") if id_disabled?(call_node)
+          primary_key = named_primary_key_column(call_node)
+          columns[primary_key.name] = primary_key if primary_key
 
           if block_node.is_a?(Prism::BlockNode) && block_node.body
             collect_column_calls(block_node.body) do |column_call|
@@ -92,25 +101,133 @@ module Rigor
           [table_name, columns.freeze]
         end
 
+        # `record.id` reads the primary key column's value, so the `id` reader takes the key's type — the
+        # same shape the `id:` option gives the column `primary_key:` names or the implicit `id` column.
+        # A composite `primary_key:` makes `id` an Array this parser does not type, and a `primary_key:`
+        # it cannot read leaves `id` untyped as well.
+        def implicit_id_column(call_node)
+          unless single_primary_key?(call_node)
+            return SchemaTable::Column.new(name: "id", type: UNKNOWN_PRIMARY_KEY_TYPE, ruby_type: "Object")
+          end
+
+          SchemaTable::Column.new(name: "id", **primary_key_shape(call_node))
+        end
+
+        # `primary_key:` names one key column when it is a String or Symbol literal; `nil` or `false` falls
+        # back to the default `id` column the way `primary_key || ...` does in Rails.
+        def single_primary_key?(call_node)
+          primary_key = keyword_value(call_node, :primary_key)
+          primary_key.nil? || primary_key.is_a?(Prism::NilNode) || primary_key.is_a?(Prism::FalseNode) ||
+            !literal_name(primary_key).nil?
+        end
+
         def id_disabled?(call_node)
-          return false if call_node.arguments.nil?
+          id = keyword_value(call_node, :id)
+          (id.is_a?(Prism::FalseNode) || id.is_a?(Prism::NilNode)) && keywords_read?(call_keywords(call_node))
+        end
+
+        # `create_table "settings", primary_key: "name", id: { type: :string }` creates the column `name`
+        # without the block declaring it, so the option is the only place the schema names it.
+        def named_primary_key_column(call_node)
+          return nil if id_disabled?(call_node)
+
+          name = literal_name(keyword_value(call_node, :primary_key))
+          return nil if name.nil?
+
+          SchemaTable::Column.new(name: name, **primary_key_shape(call_node))
+        end
+
+        # The `id:` option describes the primary key column's type whether the key column is `id` itself or
+        # the column `primary_key:` names. An unreadable call still yields a shape — the column stays
+        # queryable, just untyped.
+        def primary_key_shape(call_node)
+          id = keyword_value(call_node, :id)
+          options = id.is_a?(Prism::HashNode) ? id.elements : []
+          array = keyword_in(options, :array).is_a?(Prism::TrueNode)
+          unless primary_key_type_stated?(call_node, options)
+            return { type: UNKNOWN_PRIMARY_KEY_TYPE, ruby_type: "Object", array: array }
+          end
+
+          type = primary_key_type(id, options)
+          { type: type, ruby_type: primary_key_ruby_type(type), array: array }
+        end
+
+        # `id: :string` or `id: { type: :string, ... }`. `id: true` asks for the default key, as does an
+        # `id:` hash that names no `type:`. A type this parser cannot read as a literal is left unknown
+        # rather than assumed to be bigint.
+        def primary_key_type(id, options)
+          return DEFAULT_PRIMARY_KEY_TYPE if id.is_a?(Prism::TrueNode)
+
+          declared = id.is_a?(Prism::HashNode) ? keyword_in(options, :type) : id
+          return DEFAULT_PRIMARY_KEY_TYPE if declared.nil?
+
+          literal_name(declared)&.to_sym || UNKNOWN_PRIMARY_KEY_TYPE
+        end
+
+        # The key is typed only from a call this parser reads completely. `as:` is excluded because the query
+        # may define the column, and a non-literal `array:` because it decides the reader's shape.
+        def primary_key_type_stated?(call_node, options)
+          array = keyword_in(options, :array)
+          keywords_read?(call_keywords(call_node)) && keywords_read?(options) &&
+            keyword_value(call_node, :as).nil? &&
+            (array.nil? || array.is_a?(Prism::TrueNode) || array.is_a?(Prism::FalseNode))
+        end
+
+        def call_keywords(call_node)
+          call_node.arguments.arguments.grep(Prism::KeywordHashNode).flat_map(&:elements)
+        end
+
+        # Every element has a static Symbol key and no key repeats, so `keyword_in` sees what Ruby would pass.
+        def keywords_read?(elements)
+          keys = elements.map { |element| symbol_key(element.key) if element.is_a?(Prism::AssocNode) }
+          keys.none?(&:nil?) && keys.uniq.size == keys.size
+        end
+
+        # A decimal key stays untyped, because its class depends on the scale: `Type::DecimalWithoutScale`
+        # at scale 0, `Type::Decimal` otherwise.
+        def primary_key_ruby_type(type)
+          type == :decimal ? "Object" : SchemaTable.ruby_type_for(type)
+        end
+
+        # A `decimal` column's class follows its literal `scale:`. Any other type takes its SchemaTable mapping.
+        # A call this parser does not read completely may still hold a different scale, so it reads untyped.
+        def column_ruby_type(type, call_node)
+          return SchemaTable.ruby_type_for(type) unless type == :decimal
+          return "Object" unless keywords_read?(call_keywords(call_node))
+
+          scale = keyword_value(call_node, :scale)
+          SchemaTable.decimal_ruby_type(scale.is_a?(Prism::IntegerNode) ? scale.value : nil)
+        end
+
+        def literal_name(node)
+          case node
+          when Prism::StringNode, Prism::SymbolNode then node.unescaped
+          end
+        end
+
+        def keyword_value(call_node, name)
+          return nil if call_node.arguments.nil?
 
           call_node.arguments.arguments.each do |arg|
             next unless arg.is_a?(Prism::KeywordHashNode)
 
-            arg.elements.each do |pair|
-              next unless pair.is_a?(Prism::AssocNode)
+            value = keyword_in(arg.elements, name)
+            return value if value
+          end
+          nil
+        end
 
-              key = symbol_key(pair.key)
-              return true if key == :id && pair.value.is_a?(Prism::FalseNode)
-            end
+        def keyword_in(elements, name)
+          elements.each do |pair|
+            next unless pair.is_a?(Prism::AssocNode)
+
+            return pair.value if symbol_key(pair.key) == name
           end
-          false
+          nil
         end
 
-        # Walks the block body collecting `t.<method>(...)` calls. Skips nested blocks (e.g. inside
-        # `if`-conditioned columns) only at the top level — for richer schema constructs the parser falls
-        # back silently.
+        # Walks the block body collecting `t.<method>(...)` calls. It descends through nested constructs
+        # (e.g. `if` branches) but does not recurse into a matched call.
         def collect_column_calls(node, &)
           return if node.nil?
 
@@ -148,7 +265,7 @@ module Rigor
           SchemaTable::Column.new(
             name: name,
             type: type,
-            ruby_type: SchemaTable.ruby_type_for(type),
+            ruby_type: column_ruby_type(type, call_node),
             array: keyword_true?(call_node, :array)
           )
         end
@@ -177,19 +294,7 @@ module Rigor
         # modifiers like `t.bigint "status_ids", array: true` (Postgres array column) and `t.references
         # "x", polymorphic: true`.
         def keyword_true?(call_node, name)
-          return false if call_node.arguments.nil?
-
-          call_node.arguments.arguments.each do |arg|
-            next unless arg.is_a?(Prism::KeywordHashNode)
-
-            arg.elements.each do |pair|
-              next unless pair.is_a?(Prism::AssocNode)
-              next unless symbol_key(pair.key) == name
-
-              return pair.value.is_a?(Prism::TrueNode)
-            end
-          end
-          false
+          keyword_value(call_node, name).is_a?(Prism::TrueNode)
         end
 
         # `t.column "name", "type"` / `t.column "name", :type` — the explicit generic column form. The
@@ -203,7 +308,7 @@ module Rigor
           SchemaTable::Column.new(
             name: name,
             type: type_sym,
-            ruby_type: SchemaTable.ruby_type_for(type_sym),
+            ruby_type: column_ruby_type(type_sym, call_node),
             array: keyword_true?(call_node, :array)
           )
         end
@@ -217,13 +322,7 @@ module Rigor
         def string_argument(call_node, index)
           return nil if call_node.arguments.nil?
 
-          arg = call_node.arguments.arguments[index]
-          return nil if arg.nil?
-
-          case arg
-          when Prism::StringNode then arg.unescaped
-          when Prism::SymbolNode then arg.unescaped
-          end
+          literal_name(call_node.arguments.arguments[index])
         end
 
         def symbol_key(node)