rigortype 0.1.10 → 0.1.12

data/lib/rigor/cli/plugins_renderer.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renderer for `rigor plugins`. Produces a human-readable
+    # text table and a JSON representation from the same row
+    # shape (the Hash documented on
+    # {Rigor::CLI::PluginsCommand#loaded_row}).
+    #
+    # The two formats carry the same content; JSON is meant for
+    # tooling (SKILLs, CI, editor integrations) while text is
+    # for interactive inspection. Rows are printed in the order
+    # the loader resolved them.
+    class PluginsRenderer
+      def initialize(rows:, configuration_path:)
+        @rows = rows
+        @configuration_path = configuration_path
+      end
+
+      def text
+        lines = []
+        lines << header
+        lines << ""
+        @rows.each_with_index do |row, index|
+          lines.concat(row_lines(row))
+          lines << "" unless index == @rows.size - 1
+        end
+        lines << ""
+        lines << footer
+        lines.join("\n")
+      end
+
+      def json
+        JSON.pretty_generate(
+          {
+            "configuration" => @configuration_path,
+            "plugins" => @rows.map { |row| row_json(row) },
+            "summary" => summary
+          }
+        )
+      end
+
+      private
+
+      def header
+        loaded = @rows.count { |r| r[:status] == :loaded }
+        errored = @rows.count { |r| r[:status] == :load_error }
+        config = @configuration_path || "(no .rigor.yml found; using defaults)"
+        "Plugin activation report\n  " \
+          "configuration: #{config}\n  " \
+          "loaded: #{loaded}    load-error: #{errored}"
+      end
+
+      def footer
+        errored = @rows.select { |r| r[:status] == :load_error }
+        if errored.empty?
+          "All configured plugins loaded successfully."
+        else
+          "#{errored.size} plugin(s) failed to load — see above. " \
+            "Run with --strict to make this a CI gate."
+        end
+      end
+
+      def row_lines(row)
+        marker = row[:status] == :loaded ? "OK " : "ERR"
+        head = if row[:status] == :loaded
+                 "  [#{marker}] #{row[:id]}  v#{row[:version]}  (#{row[:gem]})"
+               else
+                 "  [#{marker}] #{row[:gem]}"
+               end
+        lines = [head]
+        lines << "        #{row[:description]}" if row[:description]
+
+        if row[:status] == :load_error
+          lines << "        load error: #{row[:load_error]}"
+          lines << "        config: #{row[:config].inspect}" if row[:config] && !row[:config].empty?
+          return lines
+        end
+
+        lines.concat(loaded_detail_lines(row))
+        lines
+      end
+
+      def loaded_detail_lines(row)
+        lines = []
+        lines.concat(signature_paths_lines(row[:signature_paths])) if row[:signature_paths].any?
+        lines.concat(receiver_and_fact_lines(row))
+        lines.concat(macro_substrate_lines(row))
+        lines.concat(extra_surface_lines(row))
+        lines << "        config: #{row[:config].inspect}" if row[:config] && !row[:config].empty?
+        lines
+      end
+
+      def receiver_and_fact_lines(row)
+        lines = []
+        lines << "        open_receivers: #{row[:open_receivers].join(', ')}" if row[:open_receivers].any?
+        lines << "        owns_receivers: #{row[:owns_receivers].join(', ')}" if row[:owns_receivers].any?
+        lines << "        produces: #{row[:produces].join(', ')}" if row[:produces].any?
+        lines << "        consumes: #{row[:consumes].join(', ')}" if row[:consumes].any?
+        lines
+      end
+
+      def extra_surface_lines(row)
+        lines = []
+        lines << "        protocol_contracts: #{row[:protocol_contracts]}" if row[:protocol_contracts].positive?
+        lines << "        source_rbs_synthesizer: yes" if row[:source_rbs_synthesizer]
+        lines << "        type_node_resolvers: #{row[:type_node_resolvers]}" if row[:type_node_resolvers].positive?
+        if row[:hkt_registrations].positive? || row[:hkt_definitions].positive?
+          lines << "        hkt: #{row[:hkt_registrations]} registration(s), #{row[:hkt_definitions]} definition(s)"
+        end
+        lines
+      end
+
+      def signature_paths_lines(paths)
+        lines = ["        signature_paths:"]
+        paths.each do |entry|
+          marker = entry[:exists] ? "" : " (MISSING)"
+          lines << "          #{entry[:path]}  (#{entry[:rbs_files]} .rbs file(s))#{marker}"
+        end
+        lines
+      end
+
+      def macro_substrate_lines(row)
+        parts = []
+        parts << "block_as_methods=#{row[:block_as_methods]}" if row[:block_as_methods].positive?
+        parts << "heredoc_templates=#{row[:heredoc_templates]}" if row[:heredoc_templates].positive?
+        parts << "trait_registries=#{row[:trait_registries]}" if row[:trait_registries].positive?
+        parts << "external_files=#{row[:external_files]}" if row[:external_files].positive?
+        return [] if parts.empty?
+
+        ["        macro substrate: #{parts.join(', ')}"]
+      end
+
+      def row_json(row)
+        {
+          "gem" => row[:gem],
+          "status" => row[:status].to_s,
+          "id" => row[:id],
+          "version" => row[:version],
+          "description" => row[:description],
+          "config" => row[:config],
+          "signature_paths" => row[:signature_paths].map do |sp|
+            { "path" => sp[:path], "exists" => sp[:exists], "rbs_files" => sp[:rbs_files] }
+          end,
+          "open_receivers" => row[:open_receivers],
+          "owns_receivers" => row[:owns_receivers],
+          "produces" => row[:produces],
+          "consumes" => row[:consumes],
+          "block_as_methods" => row[:block_as_methods],
+          "heredoc_templates" => row[:heredoc_templates],
+          "trait_registries" => row[:trait_registries],
+          "external_files" => row[:external_files],
+          "type_node_resolvers" => row[:type_node_resolvers],
+          "hkt_registrations" => row[:hkt_registrations],
+          "hkt_definitions" => row[:hkt_definitions],
+          "protocol_contracts" => row[:protocol_contracts],
+          "source_rbs_synthesizer" => row[:source_rbs_synthesizer],
+          "load_error" => row[:load_error]
+        }
+      end
+
+      def summary
+        {
+          "total" => @rows.size,
+          "loaded" => @rows.count { |r| r[:status] == :loaded },
+          "load_error" => @rows.count { |r| r[:status] == :load_error }
+        }
+      end
+    end
+  end
+end

data/lib/rigor/cli.rb

@@ -31,7 +31,9 @@ module Rigor
       "mcp" => :run_mcp,
       "baseline" => :run_baseline,
       "triage" => :run_triage,
-      "coverage" => :run_coverage
+      "coverage" => :run_coverage,
+      "plugins" => :run_plugins,
+      "playground" => :run_playground
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -120,7 +122,7 @@ module Rigor
         return false
       end
 
-      baseline = Analysis::Baseline.load(path)
+      baseline = Analysis::Baseline.load(path, project_root: Dir.pwd)
       return false if baseline.nil? || baseline.empty?
 
       drifted = baseline.audit(raw_diagnostics).reject { |row| row.status == :within }
@@ -163,7 +165,7 @@ module Rigor
       path = resolve_baseline_path(configuration, options)
       return result if path.nil?
 
-      baseline = Analysis::Baseline.load(path)
+      baseline = Analysis::Baseline.load(path, project_root: Dir.pwd)
       return result if baseline.nil?
 
       surfaced, silenced_count = baseline.filter(result.diagnostics)
@@ -474,9 +476,29 @@ module Rigor
 
       File.write(path, init_template)
       @out.puts("Created #{path}")
+      print_init_next_steps(path)
       0
     end
 
+    # `rigor init`'s template ships empty `plugins:` so a fresh
+    # init has nothing to validate — but the moment the user adds
+    # any plugin entry, the activation-failure surfaces enumerated
+    # in `rigor plugins`'s docstring become real. Point them at
+    # the verification command + the canonical readiness flow so
+    # silent failures (the cwd / Gemfile / signature_paths
+    # mismatches that surfaced during the Mastodon trial) get
+    # caught the first time the user wires a plugin, not the first
+    # time `rigor check` reports false positives that should have
+    # been covered.
+    def print_init_next_steps(path)
+      @out.puts ""
+      @out.puts "Next steps:"
+      @out.puts "  1. Edit #{path} — add the `plugins:` your project needs."
+      @out.puts "  2. Run `rigor plugins` to verify every configured plugin loads."
+      @out.puts "     (`--strict` exits 1 on failure; ideal CI gate.)"
+      @out.puts "  3. Run `rigor check` to analyse your code."
+    end
+
     # Renders the starter `.rigor.yml` body. The template
     # serialises `Configuration::DEFAULTS` (so the on-disk file
     # round-trips through `Configuration.load`) and prepends a
@@ -596,6 +618,23 @@ module Rigor
       CLI::CoverageCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_plugins
+      require_relative "cli/plugins_command"
+
+      CLI::PluginsCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
+    def run_playground
+      begin
+        require "rigor/playground"
+      rescue LoadError
+        @err.puts "rigor playground requires the rigor-playground gem."
+        @err.puts "Install it with: gem install rigor-playground"
+        return EXIT_USAGE
+      end
+      Rigor::CLI::PlaygroundCommand.new(@argv[1..], @out, @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -641,6 +680,8 @@ module Rigor
           mcp        Run the Rigor MCP server over stdio (ADR-33)
           triage     Summarise diagnostics: distribution, hotspots, hints (ADR-23)
           coverage   Report type-precision coverage (precise vs Dynamic ratio)
+          plugins    Report activation status of every configured plugin
+          playground Start the browser playground (requires rigor-playground gem)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/inference/block_parameter_binder.rb

@@ -106,6 +106,8 @@ module Rigor
         params_node = params_root.parameters
         return {} if params_node.nil?
 
+        apply_auto_splat(params_node)
+
         bindings = {}
         bind_positionals(params_node, bindings, 0)
         bind_rest(params_node, bindings)
@@ -115,6 +117,39 @@ module Rigor
         bindings
       end
 
+      # Ruby blocks (NOT lambdas) auto-splat a single yielded
+      # Tuple-shaped value when the block declares more than one
+      # required positional parameter:
+      #
+      #   { a: 1 }.each { |k, v| ... }
+      #
+      # yields `[key, value]` as a single arg, but the two-param
+      # block sees `k = key, v = value`. RBS / IteratorDispatch
+      # encode this as the block taking ONE `[K, V]` Tuple
+      # parameter; without this fix-up the binder would assign
+      # `k = Tuple[K, V]` and `v = Dynamic[Top]`, and any call
+      # on `k.<method-not-on-Tuple>` would false-fire.
+      #
+      # The rule fires only when (a) the receiver yields exactly
+      # one value (`expected_param_types.size == 1`), (b) the
+      # block declares more than one positional slot, and (c)
+      # that single expected element is a Tuple. Multi-arg yields
+      # (e.g. `each_with_index`'s `(element, index)` pair) are
+      # NOT auto-splatted — matching Ruby semantics where a
+      # multi-arg yield to a `|a, b, c|` block fills the extra
+      # slot with nil rather than splatting any element.
+      def apply_auto_splat(params_node)
+        return unless @expected_param_types.size == 1
+
+        pos_count = params_node.requireds.size + params_node.optionals.size + params_node.posts.size
+        return unless pos_count > 1
+
+        first = @expected_param_types[0]
+        return unless first.is_a?(Type::Tuple)
+
+        @expected_param_types = first.elements
+      end
+
       def bind_positionals(params_node, bindings, cursor)
         cursor = bind_required_positionals(params_node, bindings, cursor)
         cursor = bind_optional_positionals(params_node, bindings, cursor)

data/lib/rigor/inference/expression_typer.rb

@@ -6,6 +6,7 @@ require_relative "../type"
 require_relative "../ast"
 require_relative "block_parameter_binder"
 require_relative "fallback"
+require_relative "indexed_narrowing"
 require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
 require_relative "narrowing"
@@ -1133,6 +1134,69 @@ module Rigor
         type_of(body.last)
       end
 
+      # Indexed-collection narrowing — `receiver[key]` after a
+      # prior `receiver[key] ||= default` reads the post-`||=`
+      # type when the receiver and key are stable enough to
+      # address. Sits ahead of `MethodDispatcher.dispatch` so
+      # the standard `Hash#[]` / `Array#[]` answer (which would
+      # fold to `Constant[nil]` for an empty `HashShape{}` or
+      # `Tuple[]`) does not override the narrowing. See
+      # {Inference::IndexedNarrowing}.
+      def indexed_narrowing_for(node)
+        IndexedNarrowing.lookup_for_call(node, scope) || method_chain_narrowing_for(node)
+      end
+
+      # Stable single-hop chain narrowing — `receiver.method`
+      # after an `is_a?` / `kind_of?` / `instance_of?` predicate
+      # established the narrowing on the dominated edge. The
+      # call MUST be no-arg + no-block + rooted at a local-var /
+      # ivar read; everything else falls through to the
+      # standard dispatcher. ROADMAP § Future cycles —
+      # "Method-call receiver narrowing across stable
+      # receivers" — Law-of-Demeter-justified single-hop scope.
+      def method_chain_narrowing_for(node)
+        return nil unless node.is_a?(Prism::CallNode)
+        return nil unless node.block.nil?
+        return nil unless node.arguments.nil? || node.arguments.arguments.empty?
+
+        case node.receiver
+        when Prism::LocalVariableReadNode
+          scope.method_chain_narrowing(:local, node.receiver.name, node.name)
+        when Prism::InstanceVariableReadNode
+          scope.method_chain_narrowing(:ivar, node.receiver.name, node.name)
+        end
+      end
+
+      # v0.0.3 A — implicit-self calls prefer a same-named
+      # top-level `def` over RBS dispatch. Without this,
+      # a helper like `def select(...)` defined inside an
+      # `RSpec.describe ... do ... end` block mis-routes
+      # through `Enumerable#select` / `Object#select` and
+      # the caller observes `Array[Elem]` instead of the
+      # helper's actual return type. The check fires only
+      # for `node.receiver.nil?` (true implicit self), so
+      # explicit-receiver dispatch is unaffected.
+      def try_local_def_dispatch(node, receiver, arg_types)
+        local_def = node.receiver.nil? ? scope.top_level_def_for(node.name) : nil
+        return nil unless local_def
+
+        local_inference = infer_top_level_user_method(local_def, receiver, arg_types)
+        return local_inference if local_inference && adoptable_self_call_result?(local_inference)
+
+        # The local def matches by name but the inference was
+        # disqualified — either the parameter shape is too complex
+        # for the first-iteration binder (kwargs / optionals /
+        # rest), or ADR-24 slice 1's conservative gate declined
+        # the resolved return type inside a class body (see
+        # `adoptable_self_call_result?`). `Dynamic[Top]` is the
+        # safest answer: RBS dispatch would be wrong (the method
+        # is user-defined and shadows whatever ancestor method the
+        # dispatch would find), and `Dynamic[Top]` propagates
+        # correctly through downstream call chains without
+        # surfacing misleading false-positive diagnostics.
+        dynamic_top
+      end
+
       # Slice 2 routes call expressions through `MethodDispatcher`. The
       # receiver and every argument are typed first, then the dispatcher is
       # asked for a result type. A nil result triggers the fail-soft fallback
@@ -1140,40 +1204,15 @@ module Rigor
       # their own fallbacks for unrecognised receivers/args, so the tracer
       # captures both the immediate dispatch miss and the deeper cause).
       def call_type_for(node)
+        narrowed = indexed_narrowing_for(node)
+        return narrowed if narrowed
+
         receiver = call_receiver_type_for(node)
         arg_types = call_arg_types(node)
         block_type = block_return_type_for(node, receiver, arg_types)
 
-        # v0.0.3 A — implicit-self calls prefer a same-named
-        # top-level `def` over RBS dispatch. Without this,
-        # a helper like `def select(...)` defined inside an
-        # `RSpec.describe ... do ... end` block mis-routes
-        # through `Enumerable#select` / `Object#select` and
-        # the caller observes `Array[Elem]` instead of the
-        # helper's actual return type. The check fires only
-        # for `node.receiver.nil?` (true implicit self), so
-        # explicit-receiver dispatch is unaffected.
-        local_def = node.receiver.nil? ? scope.top_level_def_for(node.name) : nil
-        if local_def
-          local_inference = infer_top_level_user_method(local_def, receiver, arg_types)
-          return local_inference if local_inference && adoptable_self_call_result?(local_inference)
-
-          # The local def matches by name but the inference
-          # was disqualified — either the parameter shape is
-          # too complex for the first-iteration binder
-          # (kwargs / optionals / rest), or ADR-24 slice 1's
-          # conservative gate declined the resolved return
-          # type inside a class body (see
-          # `adoptable_self_call_result?`).
-          # Returning `Dynamic[Top]` is the safest answer:
-          # we know RBS dispatch would be wrong (the
-          # method is user-defined and shadows whatever
-          # ancestor method the dispatch would find), and
-          # `Dynamic[Top]` propagates correctly through
-          # downstream call chains without surfacing
-          # misleading false-positive diagnostics.
-          return dynamic_top
-        end
+        local_def_result = try_local_def_dispatch(node, receiver, arg_types)
+        return local_def_result if local_def_result
 
         # v0.0.6 phase 2 — per-element block fold for Tuple
         # receivers. When `[a, b, c].map { |x| f(x) }` and the

data/lib/rigor/inference/indexed_narrowing.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../type"
+require_relative "mutation_widening"
+
+module Rigor
+  module Inference
+    # Closes the "`params[:f] ||= []; params[:f] << x`" precision
+    # gap surfaced by the Redmine 6.1.2 `Query#as_params` survey
+    # (ROADMAP § Future cycles / Type-language / engine —
+    # "Indexed-collection narrowing through `Hash[k] ||= default`").
+    #
+    # After `receiver[key] ||= default` the next read at
+    # `receiver[key]` is known non-nil, but Rigor types each
+    # `Hash#[]` independently and the subsequent `<<` / `[]=` /
+    # other mutator dispatches against the un-narrowed result —
+    # which on a `HashShape{}` carrier folds to `Constant[nil]`.
+    #
+    # This module is the address-recogniser + invalidator shared
+    # by {Inference::StatementEvaluator}'s `eval_index_or_write`
+    # handler (which RECORDS the narrowing) and `eval_call`
+    # (which INVALIDATES on intervening writes / mutators) and
+    # by {Inference::ExpressionTyper}'s `call_type_for` (which
+    # CONSUMES the narrowing when typing a follow-up `[]` read).
+    #
+    # **Stable receivers.** A receiver is "stable" iff it is a
+    # `LocalVariableReadNode` or `InstanceVariableReadNode`.
+    # Method-call chains (`foo.bar[:k]`) and other shapes are
+    # rejected because a follow-up read against an identical-
+    # looking AST chain has no guarantee of resolving to the
+    # same runtime value — narrowing it would invent a fact.
+    #
+    # **Stable keys.** A key is "stable" iff it is a literal
+    # `SymbolNode` / `StringNode` / `IntegerNode`. Local-variable
+    # keys (`params[field]`) are excluded for the same
+    # invent-a-fact reason: the local could be rebound between
+    # the `||=` and the read.
+    #
+    # **Invalidation.** Three conditions drop a recorded
+    # narrowing:
+    # - The receiver variable is rebound (handled inside
+    #   `Scope#with_local` / `Scope#with_ivar`).
+    # - An intervening `receiver[key] = value` writes the same
+    #   slot — `:[]=` could rebind the slot to nil; conservative
+    #   drop.
+    # - An intervening mutator from {MutationWidening::HASH_MUTATORS}
+    #   or {MutationWidening::ARRAY_MUTATORS} runs against the
+    #   receiver (e.g. `params.delete(:f)`, `params.clear`).
+    #
+    # All three are implemented in `StatementEvaluator#eval_call`'s
+    # post-dispatch path through {.invalidate_after_call}.
+    module IndexedNarrowing
+      # Literal Prism nodes whose Ruby value the analyzer trusts
+      # as a stable address. Symbol / String are the dominant
+      # Hash key shapes; Integer covers numerically-keyed Hashes
+      # and Array indices.
+      STABLE_KEY_NODES = [Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode].freeze
+
+      module_function
+
+      # Returns `[receiver_kind, receiver_name]` when `node` is a
+      # `LocalVariableReadNode` or `InstanceVariableReadNode`,
+      # otherwise nil.
+      def stable_receiver(node)
+        case node
+        when Prism::LocalVariableReadNode then [:local, node.name]
+        when Prism::InstanceVariableReadNode then [:ivar, node.name]
+        end
+      end
+
+      # Returns the literal Ruby value when `node` is a stable
+      # key shape, otherwise nil. Symbols → `Symbol`,
+      # Strings → `String` (unescaped), Integers → `Integer`.
+      def stable_key(node)
+        case node
+        when Prism::SymbolNode then node.unescaped.to_sym
+        when Prism::StringNode then node.unescaped
+        when Prism::IntegerNode then node.value
+        end
+      end
+
+      # Returns `[receiver_kind, receiver_name, key]` when the
+      # CallNode is a `receiver[key]` read or write whose
+      # receiver and key are both stable, otherwise nil. Used
+      # by both the recorder (for `IndexOrWriteNode`'s
+      # receiver/arguments triplet) and the invalidator (for
+      # `CallNode :[]=` / mutator calls). Treats only the FIRST
+      # argument as the key; `:[]=`'s second argument is the
+      # rvalue and is not part of the address.
+      def stable_address(receiver_node, key_node)
+        receiver = stable_receiver(receiver_node)
+        return nil if receiver.nil?
+
+        key = stable_key(key_node)
+        return nil if key.nil?
+
+        [receiver.first, receiver.last, key]
+      end
+
+      # Looks up a recorded narrowing for `receiver[key]` against
+      # `scope`, returning the narrowed type or nil when no
+      # entry applies. Used by ExpressionTyper's `[]` dispatch
+      # to refine the result of a stable indexed read.
+      def lookup_for_call(node, scope)
+        return nil unless node.is_a?(Prism::CallNode)
+        return nil unless node.name == :[]
+        return nil if node.arguments.nil?
+        return nil unless node.arguments.arguments.size == 1
+
+        address = stable_address(node.receiver, node.arguments.arguments.first)
+        return nil if address.nil?
+
+        scope.indexed_narrowing(*address)
+      end
+
+      # Removes recorded narrowings invalidated by `call_node`.
+      # Two patterns:
+      #
+      # - `receiver[key] = value` (a `:[]=` against a stable
+      #   address): drop the specific `(receiver, key)` entry.
+      # - Any mutator from `HASH_MUTATORS` / `ARRAY_MUTATORS`
+      #   against a stable receiver: drop EVERY entry rooted
+      #   at that receiver, because the mutator could rebind
+      #   any slot.
+      #
+      # Returns the updated scope. Always-safe (only forgets;
+      # never invents).
+      def invalidate_after_call(call_node:, current_scope:)
+        return current_scope unless call_node.is_a?(Prism::CallNode)
+
+        if call_node.name == :[]=
+          invalidate_indexed_write(call_node, current_scope)
+        elsif mutator?(call_node.name)
+          invalidate_mutator(call_node, current_scope)
+        else
+          current_scope
+        end
+      end
+
+      def mutator?(method_name)
+        MutationWidening::HASH_MUTATORS.include?(method_name) ||
+          MutationWidening::ARRAY_MUTATORS.include?(method_name)
+      end
+
+      def invalidate_indexed_write(call_node, current_scope)
+        args = call_node.arguments&.arguments
+        return current_scope if args.nil? || args.empty?
+
+        address = stable_address(call_node.receiver, args.first)
+        return current_scope if address.nil?
+
+        current_scope.without_indexed_narrowing(*address)
+      end
+
+      def invalidate_mutator(call_node, current_scope)
+        receiver = stable_receiver(call_node.receiver)
+        return current_scope if receiver.nil?
+
+        current_scope.without_indexed_narrowings_for(*receiver)
+      end
+
+      # Companion invalidator for single-hop method-chain
+      # narrowings (ROADMAP § Future cycles — "Method-call
+      # receiver narrowing across stable receivers", B2 from
+      # the slice's design notes). Drops every
+      # `(receiver, *)` chain narrowing rooted at the call's
+      # OUTER stable receiver — matching the ROADMAP's "any
+      # intervening method call against the same receiver"
+      # criterion. A call against `x.last` (the OUTER receiver
+      # is a `CallNode`, not a stable root) does NOT drop
+      # narrowings keyed on `x`, so the worked-site
+      # `x.last << y` pattern correctly preserves the chain
+      # narrowing for any further `x.last` read in the same
+      # body. Always-safe (only forgets; never invents).
+      def invalidate_chain_after_call(call_node:, current_scope:)
+        return current_scope unless call_node.is_a?(Prism::CallNode)
+
+        receiver = stable_receiver(call_node.receiver)
+        return current_scope if receiver.nil?
+
+        current_scope.without_method_chain_narrowings_for(*receiver)
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher/iterator_dispatch.rb

@@ -42,9 +42,33 @@ module Rigor
           when :inject, :reduce then inject_block_params(receiver, args)
           when :group_by, :partition then single_element_block_params(receiver)
           when :each_slice, :each_cons then slice_block_params(receiver)
+          when :new then class_new_block_params(receiver, args)
           end
         end
 
+        # `Class.new { |c| … }` and `Class.new(Parent) { |c| … }`
+        # — the block parameter is the freshly-created anonymous
+        # class, statically representable as the parent's singleton
+        # type (the new class inherits every singleton method the
+        # parent exposes, which is what callers use this form to
+        # configure: `c.table_name = …`, `c.attribute :foo`, etc.).
+        # No parent → `singleton(Object)`. RBS would otherwise widen
+        # the block param to bare `Nominal[Class]`, dropping access
+        # to the parent's class-side surface.
+        def class_new_block_params(receiver, args)
+          return nil unless class_metaclass_receiver?(receiver)
+
+          parent = args.first
+          return [Type::Combinator.singleton_of("Object")] if parent.nil?
+          return [parent] if parent.is_a?(Type::Singleton)
+
+          nil
+        end
+
+        def class_metaclass_receiver?(type)
+          type.is_a?(Type::Singleton) && type.class_name == "Class"
+        end
+
         def times_block_params(receiver)
           return nil unless integer_rooted?(receiver)