rigortype 0.1.19 → 0.2.1

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -23,8 +23,8 @@ module Rigor
       # - `factory :users, aliases: [:author] do ... end` — alias form
       #
       # Inside a factory block, attribute declarations come in
-      # several shapes. Phase 1 (a) recognises the literal-name
-      # forms only (Symbol arg / String arg):
+      # several shapes. Only literal-name forms are recognised
+      # (Symbol arg / String arg):
       #
       # - `name { "Alice" }` — implicit attribute via
       #   `method_missing` with a block (FactoryBot's modern
@@ -116,8 +116,8 @@ module Rigor
           Rigor::Source::Literals.symbol_or_string_name(call_node.arguments&.arguments&.first)
         end
 
-        # Pillar 2 Slice 3 — resolve the model class name for
-        # the factory. Three sources, in priority order:
+        # Resolves the model class name for the factory.
+        # Three sources, in priority order:
         #
         # 1. Explicit `class: <Const>` keyword arg —
         #    ConstantReadNode / ConstantPathNode value.
@@ -188,11 +188,10 @@ module Rigor
           attributes
         end
 
-        # Walks the block body collecting attribute names. The
-        # recogniser looks at top-level statements only —
-        # attributes inside `trait :admin do ... end` or other
-        # nested blocks are NOT collected in Phase 1 (a)
-        # (traits ship in a follow-up).
+        # Walks the block body collecting attribute names. Only
+        # top-level statements are examined — attributes inside
+        # `trait :admin do ... end` or other nested blocks are
+        # not collected (traits deferred to a follow-up).
         def collect_attributes_from(node, accumulator)
           return unless node.is_a?(Prism::Node)
 
@@ -206,8 +205,7 @@ module Rigor
         def record_attribute(node, accumulator)
           return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
           # Skip association / sequence / trait / framework
-          # methods — Phase 1 (a) only records plain attribute
-          # declarations.
+          # methods — only plain attribute declarations are recorded.
           return if SKIPPED_METHODS.include?(node.name)
 
           name = if node.name == :add_attribute

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_index.rb

@@ -4,15 +4,14 @@ module Rigor
   module Plugin
     class Factorybot < Rigor::Plugin::Base
       # Per-run frozen index of discovered FactoryBot factories
-      # and the attribute keys each declares. Phase 1 (a) keys
-      # only the **literal symbol/string** factory name + the
-      # **literal symbol** attribute names; sequences,
-      # parent/child relationships, traits, and dynamically-
-      # named factories ship behind later slices.
+      # and the attribute keys each declares. Indexes only
+      # **literal symbol/string** factory names + **literal
+      # symbol** attribute names; sequences, parent/child
+      # relationships, traits, and dynamically-named factories
+      # are deferred to follow-up slices.
       #
-      # v0.2.0 (Pillar 2 Slice 3) adds `model_class` to each
-      # entry — the inferred or explicit class the factory
-      # builds. Resolved from:
+      # Each entry carries a `model_class` — the inferred or
+      # explicit class the factory builds. Resolved from:
       #
       #   1. An explicit `factory :user, class: User do`
       #      keyword option (ConstantReadNode / ConstantPathNode

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

@@ -13,12 +13,10 @@ module Rigor
     # attributes_for / *_list family against a per-run index
     # built from `factory_search_paths`.
     #
-    # **Phase 1 (a)** of the FactoryBot plugin family — the
-    # self-contained slice. Recognises factory NAMES + literal
-    # ATTRIBUTE KEYS in the call's keyword hash. Phase 1 (c)
-    # ships the AR column cross-check via the
-    # `rigor-activerecord` `:model_index` ADR-9 fact, after
-    # `rigor-activerecord` adds the matching publish hook.
+    # Recognises factory NAMES + literal ATTRIBUTE KEYS in
+    # the call's keyword hash. The AR column cross-check uses
+    # the `rigor-activerecord` `:model_index` ADR-9 fact when
+    # that plugin is loaded (optional `consumes:`).
     # Traits, sequences, parent / child factories, and dynamic
     # factory names are deferred to follow-up slices.
     #
@@ -54,9 +52,9 @@ module Rigor
     # `.build_stubbed_list`. The legacy `FactoryGirl` constant
     # is recognised identically. Implicit-receiver calls
     # (`create(:name)` inside an `include FactoryBot::Syntax::Methods`
-    # context) are NOT recognised in Phase 1 (a) — too many
-    # false positives on plain `create` calls outside test
-    # files; this needs receiver-type inference (Phase 1 (b)).
+    # context) are NOT recognised — too many false positives on
+    # plain `create` calls outside test files; deferred until
+    # receiver-type inference can disambiguate.
     #
     # ## What's recognised inside `factory :name do ... end`
     #

data/plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb

@@ -50,12 +50,13 @@ module Rigor
 
         # @param paths [Array<String>] absolute paths to `.rb` files
         #   the project's `paths:` resolves to.
-        # @return [Hash{Symbol => Hash}] frozen 3-key result with
+        # @return [Hash{Symbol => Hash}] frozen 4-key result:
         #   `:types` (per-`Schema::Object` field table),
-        #   `:enums` (per-`Schema::Enum` value list), and
-        #   `:input_objects` (per-`Schema::InputObject` argument
-        #   table). Any subset may be empty when no recognisable
-        #   declaration of that kind is found.
+        #   `:enums` (per-`Schema::Enum` value list),
+        #   `:input_objects` (per-`Schema::InputObject` argument table),
+        #   `:mutations` (per-`Schema::Mutation` arguments+fields table).
+        #   Any subset may be empty when no recognisable declaration
+        #   of that kind is found.
         def scan(paths:)
           acc = empty_accumulator
           paths.each do |path|
@@ -97,10 +98,9 @@ module Rigor
         private_class_method :scan_file
 
         # Walks the AST collecting `class X < GraphQL::Schema::Object`,
-        # `class X < GraphQL::Schema::Enum`, and
-        # `class X < GraphQL::Schema::InputObject` decls at any
-        # nesting level. Returns a 3-key hash so the caller can
-        # publish multiple cross-plugin facts from one walk.
+        # `Schema::Enum`, `Schema::InputObject`, and `Schema::Mutation`
+        # decls at any nesting level. Returns a 4-key hash so the
+        # caller can publish multiple cross-plugin facts from one walk.
         def collect_definitions(node, qualified_prefix)
           return empty_accumulator if node.nil?
 
@@ -203,10 +203,9 @@ module Rigor
         # The first positional must be a String literal — the
         # graphql-ruby `value` API also accepts a Symbol form
         # (`value :ACTIVE`) but the documented idiom is String.
-        # Slice 2b only stores the GraphQL-side value name; the
-        # optional `value:` kwarg (Ruby-side override) and
-        # `description:` stay out of the published table for
-        # the floor.
+        # Only the GraphQL-side value name is stored; the optional
+        # `value:` kwarg (Ruby-side override) and `description:`
+        # are omitted from the published table.
         def collect_values(body)
           return [] if body.nil?
 

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

@@ -25,10 +25,10 @@ module Rigor
     # resolver methods themselves; rigor's value here is producing a
     # static type table downstream consumers can cross-reference.
     #
-    # ## What downstream consumers DO with `:graphql_type_table`
+    # ## What downstream consumers DO with the published facts
     #
-    # The fact is the substrate for two future capabilities (both
-    # demand-driven, NOT in slice 1):
+    # The tables are the substrate for two future capabilities
+    # (demand-driven, not yet implemented):
     #
     # - Resolver-method check: for each `field :name, Type` whose
     #   `name` is also defined as a Ruby method on the class, verify
@@ -37,33 +37,25 @@ module Rigor
     #   plugin could type `Schema.execute(query).to_h` against the
     #   queried fields.
     #
-    # ## Floor / ceiling (slice 1)
+    # ## What's recognised
     #
-    # Slice 1 ships the **floor**:
+    # - `class T < GraphQL::Schema::Object` subclasses (including
+    #   nested namespaces); `field :name, Type, null: ...`
+    #   declarations with constant-reference or list-array types
+    #   and GraphQL→Ruby scalar mapping.
+    # - `class T < GraphQL::Schema::Enum`; `value "ACTIVE"` calls.
+    # - `class T < GraphQL::Schema::InputObject` /
+    #   `GraphQL::Schema::Mutation`; `argument :name, Type,
+    #   required: ...` declarations.
+    # - No user-facing diagnostics yet.
     #
-    # - Recognises `class T < GraphQL::Schema::Object` subclasses
-    #   (including nested namespaces: `class Types::User < ...`,
-    #   `module Types; class User < ...; end; end`).
-    # - Recognises the `field :name, Type, **opts` declaration with:
-    #   - `Type` as a `ConstantReadNode` / `ConstantPathNode` (`String`
-    #     / `Integer` / `Boolean` / `Float` / `ID`, or a user-defined
-    #     `Types::OtherObject`).
-    #   - `null: true` / `null: false` keyword extracts nullability.
-    # - Maps the canonical GraphQL scalar names to underlying Ruby
-    #   classes (`String` → `String`, `Integer` → `Integer`,
-    #   `Boolean` → `TrueClass`, `Float` → `Float`, `ID` → `String`).
-    # - Publishes the table; no user-facing diagnostics yet.
+    # ## Deferred (demand-driven)
     #
-    # The **ceiling** (future slices, demand-driven):
-    #
-    # - **`GraphQL::Schema::Enum`** with `value "ACTIVE"` calls.
-    # - **`GraphQL::Schema::Mutation`** + **`GraphQL::Schema::InputObject`**.
-    # - **List / Non-Null wrappers** (`[String]`, `String.array`).
     # - **`resolver:` / `mutation:` reroute** recognition.
     # - **String type expressions** (`field :foo, "User"`) — defeats
     #   static resolution by design (graphql-ruby's `BuildType.parse_type`
     #   constantizes at runtime); a future slice could surface these
-    #   as `graphql.string-type` `:info` diagnostics that point the
+    #   as `graphql.string-type` `:info` diagnostics pointing the
     #   user at the constant-reference form for static typing.
     class Graphql < Rigor::Plugin::Base
       manifest(

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

@@ -71,9 +71,9 @@ module Rigor
     # - `is_a?(Result::Ok)` / `Some` / `None` exhaustive
     #   narrowing — core control-flow analysis over a sealed
     #   hierarchy, not a plugin surface.
-    # - The `variants do variant Const, Type end` Enum DSL — needs
-    #   an ADR-16 nested-class emission tier (ADR-36). Today's
-    #   contract has no `const_set`-emitting macro substrate.
+    # - The `variants do variant Const, Type end` Enum DSL is handled
+    #   via ADR-36 `nested_class_templates:` in this plugin's manifest
+    #   (Slice A — see `nested_class_templates:` block below).
     class Mangrove < Rigor::Plugin::Base
       manifest(
         id: "mangrove",

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

@@ -30,10 +30,10 @@ module Rigor
     #
     # ## Configuration
     #
-    # No knobs in v0.1.0. Activate via `plugins: ["rigor-minitest"]`
-    # in `.rigor.yml`.
+    # No configuration knobs. Activate via
+    # `plugins: ["rigor-minitest"]` in `.rigor.yml`.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **No `assert_raises(T) { ... }`** — that's a block-shape
     #   matcher and Rigor's narrowing model is for

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/analyzer.rb

@@ -169,7 +169,7 @@ module Rigor
 
         # Extracts the literal-string first argument when
         # present. Returns nil for variable / expression keys —
-        # those are out of scope for v0.1.0.
+        # only literal keys are statically validated.
         def literal_key_for(call_node)
           args = call_node.arguments&.arguments || []
           return nil if args.empty?
@@ -224,9 +224,7 @@ module Rigor
 
         def collect_assoc_keys(hash_node)
           # Both `Prism::HashNode` and `Prism::KeywordHashNode`
-          # expose `#elements`; the conditional was an
-          # accidental no-op carried over from an earlier
-          # draft.
+          # expose `#elements`, so a single path handles both.
           hash_node.elements.filter_map do |element|
             next nil unless element.is_a?(Prism::AssocNode)
 

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_loader.rb

@@ -57,7 +57,7 @@ module Rigor
             parsed.each do |locale, tree|
               locale = locale.to_s
               locales << locale
-              flatten_tree(tree, []).each do |dotted_key, value|
+              each_flattened(tree, []) do |dotted_key, value|
                 placeholders = (per_key[dotted_key] ||= {})
                 placeholders[locale] = extract_placeholders(value)
                 kinds = (per_key_kinds[dotted_key] ||= {})
@@ -101,24 +101,40 @@ module Rigor
         end
 
         # Recursively walks the per-locale subtree, yielding
-        # `[dotted_key, leaf_value]` pairs. Hash leaves are
+        # `[dotted_key, leaf_value]` for each leaf. Hash leaves are
         # *not* recorded as entries themselves — only their
-        # descendants — but every leaf scalar / array IS
-        # recorded.
-        def flatten_tree(node, breadcrumbs)
-          case node
-          when Hash
-            node.flat_map do |k, v|
-              flatten_tree(v, breadcrumbs + [k.to_s])
+        # descendants — but every leaf scalar / array IS recorded.
+        #
+        # `breadcrumbs` is a single mutable stack reused across the
+        # whole walk (push before recursing, pop after): for the
+        # 530-file / 14 MB Mastodon locale corpus the old
+        # `flat_map { flatten_tree(v, breadcrumbs + [k]) }` shape
+        # allocated a fresh breadcrumb Array at every node plus an
+        # intermediate result Array at every level — millions of
+        # short-lived objects and the run's top allocation site. The
+        # dotted key is still materialised once per leaf (it has to
+        # be); everything else is now allocation-free traversal.
+        def each_flattened(node, breadcrumbs, &)
+          if node.is_a?(Hash)
+            node.each do |k, v|
+              breadcrumbs.push(k.to_s)
+              each_flattened(v, breadcrumbs, &)
+              breadcrumbs.pop
             end
           else
-            [[breadcrumbs.join("."), node]]
+            yield breadcrumbs.join("."), node
           end
         end
 
         def extract_placeholders(value)
           case value
-          when String then value.scan(PLACEHOLDER_RE).flatten.to_set
+          when String
+            # Most locale leaves carry no `%{var}`; skip the scan +
+            # flatten + to_set allocation trio for them. A string with
+            # no `%{` yields an empty placeholder set either way.
+            return Set.new unless value.include?("%{")
+
+            value.scan(PLACEHOLDER_RE).flatten.to_set
           when Array then value.map { |v| extract_placeholders(v) }.reduce(Set.new) { |a, s| a | s }
           else Set.new
           end

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -40,7 +40,7 @@ module Rigor
     #    arguments. Missing placeholders are errors; extra
     #    arguments are warnings.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - Only literal-string keys are validated. `t(key)` with
     #   a variable receiver is silently passed through.

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

@@ -38,11 +38,9 @@ module Rigor
       #   (`user_facebook_omniauth_authorize_path`) and Devise
       #   declares them from the configured providers, which
       #   live in an initializer this static parser does not
-      #   read. We register the SHAPE-FAMILY suffix matchers
-      #   `_omniauth_authorize_path` / `_omniauth_callback_path`
-      #   via a separate hook (see `OMNIAUTH_HELPER_PATTERNS`);
-      #   these are NOT in the table but consulted by the
-      #   `Analyzer.allowed_dynamic_pattern?` check.
+      #   read. The suffix patterns are registered in
+      #   `OMNIAUTH_SUFFIXES` and consulted by
+      #   `HelperTable#omniauth_match?`.
       module DeviseRoutes
         # The standard Devise controllers and the helper
         # actions each generates. Keys are the controller
@@ -190,7 +188,7 @@ module Rigor
 
         # Returns the set of OmniAuth pattern suffixes the
         # analyzer accepts for a given resource. The analyzer
-        # consults this set (via `HelperTable#allows_omniauth?`)
+        # consults this set (via `HelperTable#omniauth_match?`)
         # when a `*_path` / `*_url` call's name does not match
         # any registered entry and its prefix matches a Devise
         # resource.

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

@@ -1171,9 +1171,10 @@ module Rigor
         end
 
         def in_singular_resource?(*)
-          # Slice 1 doesn't model the singular-resource frame
-          # separately; placeholder so member / collection
-          # blocks at least descend.
+          # Stub: always returns true so member / collection
+          # blocks descend. The singular-resource frame
+          # (`push_singular_resource`) is modelled in Context;
+          # a future caller could use it to tighten this check.
           true
         end
 
@@ -1181,21 +1182,14 @@ module Rigor
         # `plural: true` for `resources :users`, `false` for
         # `resource :profile`.
         def register_resourceful_helpers(name, actions, base_arity, context, plural:)
-          # Singular resources (`resource :foo`) use the
-          # given name AS-IS for both path and helper —
-          # singularising would mangle a deliberately-plural
-          # singular-DSL name like Mastodon's
-          # `resource :relationships, only: [:show, :update]`
-          # (Rails generates `relationships_path`, not
-          # `relationship_path`). Plural resources still
-          # singularise for the show / new / edit helpers.
-          # Plural resources singularise for show / new / edit
-          # helpers (`resources :users` → `user_path(id)`);
-          # singular resources use the name AS-IS even when it
-          # looks plural (Mastodon's `resource :relationships,
-          # only: [:show, :update]` → `relationships_path`).
-          # The path segment uses `name` in both shapes — Rails
-          # never singularises the URL.
+          # Plural resources (`resources :users`) singularise
+          # for show / new / edit helpers → `user_path(id)`.
+          # Singular resources (`resource :foo`) use the name
+          # AS-IS — singularising would mangle deliberately-
+          # plural names like Mastodon's `resource
+          # :relationships` → `relationships_path`, not
+          # `relationship_path`. The URL path uses `name`
+          # in both shapes (Rails never singularises the URL).
           singular = plural ? singularize_word(name.to_s) : name.to_s
           path_base = "#{context.path_prefix}/#{name}"
 

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

@@ -26,9 +26,9 @@ module Rigor
     # - One level of nested `resources`
     #
     # The plugin publishes its parsed `:helper_table` through
-    # the ADR-9 cross-plugin fact store so future
-    # `rigor-actionpack` Phase 4 can consume it for
-    # route-helper validation in controller code.
+    # the ADR-9 cross-plugin fact store; `rigor-actionpack`
+    # Phase 4 consumes it for route-helper validation in
+    # controller code.
     #
     # ## Configuration
     #
@@ -147,8 +147,8 @@ module Rigor
       end
 
       # Publishes the parsed table to the cross-plugin fact
-      # store so future Tier 2 plugins (rigor-actionpack
-      # Phase 4) can read it via `services.fact_store.read`.
+      # store; `rigor-actionpack` Phase 4 reads it via
+      # `services.fact_store.read`.
       def prepare(services)
         table = helper_table_or_nil
         return if table.nil?

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

@@ -21,10 +21,9 @@ module Rigor
       #   { ... }` and `subject(:name) { ... }` declarations.
       #   `:subject` is the key for the implicit `subject { ... }`.
       #
-      # Pillar 2 Slice 2 — used by the plugin's let-binding
-      # `dynamic_return` rule to bind `let`-named
-      # method-shape calls inside `it` bodies to the let
-      # block's inferred type.
+      # Used by the plugin's let-binding `dynamic_return`
+      # rule to bind `let`-named method-shape calls inside
+      # `it` bodies to the let block's inferred type.
       class LetScopeIndex
         Record = Struct.new(:outer_range, :describe_const, :lets, keyword_init: true) do
           def contains?(line) = outer_range.cover?(line)

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

@@ -6,7 +6,7 @@ require "rigor/type"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Pillar 2 Slice 2 — resolves the runtime type of a
+      # Resolves the runtime type of a
       # `let(:name) { body }` or `subject(:name) { body }`
       # block by pattern-matching its body's tail expression.
       #

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

@@ -8,7 +8,7 @@ require "rigor/flow_contribution/fact"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Pillar 2 Slice 1 — recognises `expect(x).to MATCHER`
+      # Recognises `expect(x).to MATCHER`
       # patterns at per-call recognition time and emits
       # `post_return_facts` that narrow the named local on the
       # post-call edge.

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

@@ -11,15 +11,13 @@ require_relative "rspec/let_type_resolver"
 module Rigor
   module Plugin
     # rigor-rspec — validates RSpec `let` / `subject`
-    # declarations within each describe / context scope.
+    # declarations within each describe / context scope,
+    # narrows `expect(x).to MATCHER` assertions downstream,
+    # and binds `let`/`subject` locals to their inferred
+    # return types inside `it` bodies.
     #
     # Tier 3A of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Deliberately scoped — the roadmap describes a much
-    # larger plugin (let-typo detection in `it` bodies,
-    # `expect(x).to receive(:method)` mock-target
-    # validation). Both are out of scope for v0.1.0; this
-    # plugin ships the two checks that have the lowest
-    # false-positive risk:
+    # Ships four checks:
     #
     # 1. **Duplicate `let` / `subject` declarations** in
     #    the same scope (`warning`). RSpec's runtime lets
@@ -31,14 +29,21 @@ module Rigor
     #    (`error`). At runtime this infinite-loops; users
     #    typically meant to call a different method or
     #    forgot to introduce a `super`.
+    # 3. **`expect(x).to MATCHER` narrowing** — narrows
+    #    the named local `x` on the post-call edge for
+    #    eight matchers (see `MatcherAnalyzer`).
+    # 4. **`let`/`subject` local binding** — binds `let`
+    #    / `subject` names in `it` bodies to the block's
+    #    inferred return type (see `LetTypeResolver`).
     #
     # ## Configuration
     #
-    # No knobs in v0.1.0. The plugin walks every analysed
-    # file looking for `RSpec.describe ... do` blocks; spec
-    # files outside the project's `paths:` are not scanned.
+    # No configuration knobs. The plugin walks every
+    # analysed file for `RSpec.describe ... do` blocks;
+    # spec files outside the project's `paths:` are not
+    # scanned.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **No let-typo detection.** Detecting an `it`
     #   block's reference to a misspelled `let` name
@@ -102,14 +107,14 @@ module Rigor
         Analyzer.diagnose(path: path, root: root).map { |diag| build_diagnostic(diag) }
       end
 
-      # ADR-37 slice 2 — Pillar 2 Slice 1 matcher narrowing
+      # ADR-37 slice 2 — matcher narrowing
       # (`expect(x).to be_a(T)` → `post_return_facts` on `x`),
       # method-gated by the engine on the expectation verbs.
       type_specifier methods: %i[to not_to to_not] do |call_node, scope|
         MatcherAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
 
-      # Pillar 2 Slice 2 / ADR-52 slice 5a — binds local reads in `it` /
+      # ADR-52 slice 5a — binds local reads in `it` /
       # spec bodies to their `let(:name) { ... }` block's inferred return
       # type. The name set varies per file (each spec file's
       # `describe`/`let` structure), so the rule gates on the per-file
@@ -130,7 +135,7 @@ module Rigor
         let_scope_index_for(path)&.let_names || []
       end
 
-      # Pillar 2 Slice 2 — when the call node is a no-receiver
+      # When the call node is a no-receiver
       # method call (`user`, `subject`, etc.) inside an RSpec
       # `describe` block whose lets include a matching name,
       # return the let block's inferred type.

data/plugins/rigor-shoulda-matchers/lib/rigor/plugin/shoulda_matchers/analyzer.rb

@@ -31,7 +31,6 @@ module Rigor
       #   validate_absence_of(:col)
       #   validate_format_of(:col)
       #   validate_confirmation_of(:col)
-      #   allow_value(...).for(:col)
       #   have_db_column(:col)
       #   have_db_index(:col)
       #

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

@@ -9,10 +9,11 @@ module Rigor
       # analyzer can validate `Worker.perform_async(...)`
       # call sites.
       #
-      # Same envelope shape as `rigor-activejob`'s
-      # `JobIndex::Entry`: `min_arity` / `max_arity` form a
-      # closed range (`Float::INFINITY` for the upper bound
-      # when `*args` is present).
+      # Uses the same `min_arity` / `max_arity` closed-range
+      # envelope as `rigor-activejob`'s `JobIndex::Entry`
+      # (`Float::INFINITY` upper bound when `*args` is present);
+      # Sidekiq workers serialize args to JSON so keyword arity
+      # is not tracked here.
       class WorkerIndex
         Entry = Data.define(:class_name, :min_arity, :max_arity) do
           def arity_label

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

@@ -168,9 +168,8 @@ module Rigor
         # contribution mirrors `T.must` minus the nil-stripping:
         # the call's return type is the inner expression's
         # inferred type. The companion diagnostic is emitted by
-        # the plugin's `diagnostics_for_file` hook through
-        # {RevealTypeRecognizer}; the recogniser here is
-        # contribution-only.
+        # the plugin's `diagnostics_for_file` hook; this
+        # method handles the contribution only.
         def resolve_reveal_type(call_node, scope)
           inner = nth_argument(call_node, 0)
           return Rigor::Type::Combinator.untyped if inner.nil? || scope.nil?

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

@@ -4,22 +4,18 @@ module Rigor
   module Plugin
     class Sorbet < Rigor::Plugin::Base
       # Frozen description of one Sorbet `sig` block as parsed by
-      # {SigParser}. Holds enough to reconstruct the method's
-      # call-site return type (slice 1's deliverable) plus the
-      # parameter shape and modifier list (kept for slice 2+ when
-      # we begin checking call-site argument types and override
-      # compatibility).
+      # {SigParser}. Holds the return type, parameter shape, and
+      # modifier list. Call-site argument-type checking and
+      # override-compatibility validation are deferred; only the
+      # return-type contribution is active.
       #
       # `kind` distinguishes `def foo` (`:instance`) from
       # `def self.foo` / `class << self; def foo; end`
       # (`:singleton`).
       #
-      # `modifiers` is the set of `sig`-level modifiers we
-      # observed: `:abstract`, `:override`, `:overridable`,
-      # `:final`. Slice 1 records them but does not act on them;
-      # later slices wire `:abstract` into the existing
-      # `def.return-type-mismatch` check and `:override` into
-      # override-compatibility validation.
+      # `modifiers` records the `sig`-level flags observed:
+      # `:abstract`, `:override`, `:overridable`, `:final`.
+      # Currently stored but not acted on.
       MethodSignature = Data.define(
         :class_name, :method_name, :kind, :params, :return_type, :modifiers
       )

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

@@ -26,9 +26,8 @@ module Rigor
       # whatever it recognises (`params` / `returns` / `void` /
       # `abstract` / `override` / `overridable` / `final` /
       # `type_parameters` / `checked` / `on_failure`) into a
-      # frozen result hash. Slice 1 wires the parsed structure
-      # into {MethodSignature}; later slices will start *acting*
-      # on the modifiers and `type_parameters`.
+      # frozen result hash stored in {MethodSignature}. Modifiers
+      # and `type_parameters` are recorded but not yet acted on.
       #
       # The parser is intentionally tolerant — unknown chain
       # nodes degrade to "the rest of the chain is opaque" rather
@@ -93,8 +92,8 @@ module Rigor
             when :params
               accumulator[:params].merge!(parse_params(current))
             when :type_parameters
-              # Slice 1: recognise to suppress the degraded
-              # path; widen translation in slice 3.
+              # Recognised to suppress the degraded path;
+              # payload intentionally discarded (deferred).
             when *RECOGNISED_MODIFIERS
               accumulator[:modifiers] << current.name
             when *RUNTIME_ONLY_STEPS