rigortype 0.1.3 → 0.1.4

data/lib/rigor/cli/sig_gen_command.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "optionparser"
+
+require_relative "../configuration"
+require_relative "../sig_gen"
+
+module Rigor
+  class CLI
+    # Executes the `rigor sig-gen` command — ADR-14 slices 1–3.
+    #
+    # Walks the given paths (or `configuration.paths` when none
+    # are supplied), classifies every reachable instance method
+    # via {Rigor::SigGen::Generator}, and either prints the
+    # resulting RBS skeletons / unified-style diffs (`--print`,
+    # `--diff`; slice 1) or writes them to the project signature
+    # tree via {Rigor::SigGen::Writer} (`--write`; slice 2).
+    #
+    # `--write` follows the established Ruby community
+    # convention: `lib/foo/bar.rb` → `sig/foo/bar.rbs`. New
+    # methods are inserted into the matching class declaration
+    # just before its closing `end`; new classes are appended
+    # to the file; non-existent target files are created. User-
+    # authored declarations are NEVER replaced unless
+    # `--overwrite` is set AND the candidate is a
+    # `tighter-return`.
+    #
+    # Parameter policy defaults to `untyped`. `--params=observed`
+    # (slice 3) opts in to caller-side observation harvesting:
+    # the `ObservationCollector` walks `--observe=PATH...`
+    # (default `spec/` when no flag is given AND a `spec/`
+    # directory exists), unions per-position arg types, and the
+    # generator emits the union per ADR-5 clause 2.
+    # `--params=observed-strict` stays reserved-but-inert until
+    # the capability-role catalog ships (rejected with a usage
+    # error so the surface stays stable).
+    class SigGenCommand
+      USAGE = "Usage: rigor sig-gen [options] [paths]"
+
+      VALID_MODES = %w[print diff write].freeze
+      VALID_PARAM_POLICIES = %w[untyped observed observed-strict].freeze
+      VALID_FORMATS = %w[text json].freeze
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        return CLI::EXIT_USAGE if options.nil?
+
+        configuration = Configuration.load(options.fetch(:config))
+        paths = @argv.empty? ? configuration.paths : @argv
+
+        observations = collect_observations(configuration, options)
+        candidates = SigGen::Generator.new(configuration: configuration, paths: paths,
+                                           observations: observations,
+                                           include_private: options.fetch(:include_private)).run
+        mode = options.fetch(:mode).to_sym
+
+        if mode == :write
+          dispatch_write(candidates, configuration, options)
+        else
+          dispatch_print_or_diff(candidates, mode, options)
+        end
+        0
+      end
+
+      private
+
+      def dispatch_print_or_diff(candidates, mode, options)
+        SigGen::Renderer.new(out: @out).render(
+          candidates: candidates,
+          mode: mode,
+          format: options.fetch(:format),
+          selection: options.fetch(:selection)
+        )
+      end
+
+      def dispatch_write(candidates, configuration, options)
+        layout_index = SigGen::LayoutIndex.new(signature_paths: configuration.signature_paths)
+        path_mapper = SigGen::PathMapper.new(configuration: configuration, layout_index: layout_index)
+        writer = SigGen::Writer.new(path_mapper: path_mapper, overwrite: options.fetch(:overwrite))
+
+        results = writer.write_all(candidates)
+
+        SigGen::Renderer.new(out: @out).render_write(results: results, format: options.fetch(:format))
+      end
+
+      # Slice 3 — collect call-site argument observations when
+      # `--params=observed` is set. When `--observe=PATH` is
+      # not specified, default to `spec/` (skipped silently
+      # when the directory is absent).
+      def collect_observations(configuration, options)
+        return {} if options.fetch(:params) != "observed"
+
+        observe_paths = options.fetch(:observe)
+        observe_paths = ["spec"] if observe_paths.empty? && File.directory?("spec")
+        SigGen::ObservationCollector.new(configuration: configuration, paths: observe_paths).collect
+      end
+
+      def parse_options
+        options = {
+          mode: "print",
+          format: "text",
+          params: "untyped",
+          selection: [],
+          overwrite: false,
+          observe: [],
+          include_private: false,
+          config: nil
+        }
+        build_option_parser(options).parse!(@argv)
+
+        message = validation_error(options)
+        return options if message.nil?
+
+        @err.puts("sig-gen: #{message}")
+        nil
+      end
+
+      def build_option_parser(options) # rubocop:disable Metrics/AbcSize
+        OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
+          opts.banner = USAGE
+          opts.on("--print", "Write RBS skeletons to stdout (default)") { options[:mode] = "print" }
+          opts.on("--diff", "Write a unified diff against existing RBS") { options[:mode] = "diff" }
+          opts.on("--write", "Write generated RBS to sig/<path>.rbs files") { options[:mode] = "write" }
+          opts.on("--overwrite", "Allow tighter-return updates to replace user-authored RBS") do
+            options[:overwrite] = true
+          end
+          opts.on("--include-private", "Emit private / protected instance methods (default: public only)") do
+            options[:include_private] = true
+          end
+          opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
+          opts.on("--params=POLICY", "Parameter policy: untyped (default), observed, observed-strict") do |value|
+            options[:params] = value
+          end
+          opts.on("--observe=PATH", "Directory / file to scan for call-site observations (repeatable)") do |value|
+            options[:observe] << value
+          end
+          opts.on("--new-files", "Emit only new-file classifications") do
+            options[:selection] << SigGen::Classification::NEW_FILE
+          end
+          opts.on("--new-methods", "Emit only new-method classifications") do
+            options[:selection] << SigGen::Classification::NEW_METHOD
+          end
+          opts.on("--tighter-returns", "Emit only tighter-return classifications") do
+            options[:selection] << SigGen::Classification::TIGHTER_RETURN
+          end
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+        end
+      end
+
+      def validation_error(options)
+        mode = options.fetch(:mode)
+        format = options.fetch(:format)
+        params = options.fetch(:params)
+
+        return "--print, --diff, and --write are mutually exclusive flags; pick one" unless VALID_MODES.include?(mode)
+        return "unsupported --format=#{format}" unless VALID_FORMATS.include?(format)
+        return "unsupported --params=#{params}" unless VALID_PARAM_POLICIES.include?(params)
+        if params == "observed-strict"
+          return "--params=observed-strict is reserved until the capability-role catalog ships"
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/cli/type_of_command.rb

@@ -61,7 +61,7 @@ module Rigor
         options
       end
 
-      def execute(target:, options:) # rubocop:disable Metrics/AbcSize
+      def execute(target:, options:)
         file, line, column = target
         return 1 unless file_exists?(file)
 

data/lib/rigor/cli/type_scan_renderer.rb

@@ -10,7 +10,7 @@ module Rigor
     # branches share a single source of truth (the `Report` value object) so
     # the two formats stay in lockstep; that pairing is why this class is a
     # bit longer than the default class-length budget.
-    class TypeScanRenderer # rubocop:disable Metrics/ClassLength
+    class TypeScanRenderer
       def initialize(out:)
         @out = out
       end

data/lib/rigor/cli/type_scan_report.rb

@@ -5,14 +5,14 @@ module Rigor
     # Aggregated report assembled by `TypeScanCommand` and consumed by
     # `TypeScanRenderer`. The struct holds per-file paths, accumulated
     # per-class counts, located fallback events, and any parse errors.
-    Report = Data.define(
+    class Report < Data.define(
       :files,
       :parse_errors,
       :visits,
       :unrecognized,
       :events,
       :options
-    ) do
+    )
       def visited_count
         visits.values.sum
       end

data/lib/rigor/cli.rb

@@ -24,7 +24,8 @@ module Rigor
       "type-of" => :run_type_of,
       "type-scan" => :run_type_scan,
       "explain" => :run_explain,
-      "diff" => :run_diff
+      "diff" => :run_diff,
+      "sig-gen" => :run_sig_gen
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -279,6 +280,12 @@ module Rigor
       DiffCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_sig_gen
+      require_relative "cli/sig_gen_command"
+
+      SigGenCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -318,6 +325,7 @@ module Rigor
           type-scan  Report Scope#type_of coverage across PATHs
           explain    Print the description of one or all CheckRules
           diff       Compare current diagnostics to a saved baseline JSON
+          sig-gen    Emit RBS skeletons inferred from .rb sources (ADR-14)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/configuration/dependencies.rb

@@ -13,7 +13,7 @@ module Rigor
     # is read, but no analyzer machinery consumes it yet. Slice 2
     # wires `Analysis::DependencySourceInference` against this
     # value object.
-    class Dependencies # rubocop:disable Metrics/ClassLength
+    class Dependencies
       # Walking modes per
       # [ADR-10 § "Decision"](../../../docs/adr/10-dependency-source-inference.md#decision).
       VALID_MODES = %i[disabled when_missing full].freeze
@@ -61,7 +61,7 @@ module Rigor
       # walk time); `mode:` is one of {VALID_MODES}; `roots:` is
       # the list of subdirectories within the gem's installation
       # directory to walk (defaults to `["lib"]`).
-      Entry = Data.define(:gem, :mode, :roots) do
+      class Entry < Data.define(:gem, :mode, :roots)
         def disabled? = mode == :disabled
         def when_missing? = mode == :when_missing
         def full? = mode == :full

data/lib/rigor/configuration.rb

@@ -214,7 +214,7 @@ module Rigor
     private_class_method :load_with_includes, :merge_includes, :resolve_paths_in, :deep_merge,
                          :merge_value, :merge_dependencies_hash
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def initialize(data = DEFAULTS)
       cache = DEFAULTS.fetch("cache").merge(data.fetch("cache", {}))
       plugins_io = DEFAULTS.fetch("plugins_io").merge(data.fetch("plugins_io", {}))
@@ -247,7 +247,7 @@ module Rigor
         data.fetch("dependencies", DEFAULTS.fetch("dependencies"))
       )
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
     def to_h
       {

data/lib/rigor/environment.rb

@@ -2,6 +2,8 @@
 
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
+require_relative "type_node/name_scope"
+require_relative "type_node/resolver_chain"
 
 module Rigor
   # The engine's view of the type universe outside the current scope.
@@ -41,7 +43,8 @@ module Rigor
       prism rbs
     ].freeze
 
-    attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index
+    attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index,
+                :rbs_extended_reporter, :boundary_cross_reporter, :name_scope
 
     # @param class_registry [Rigor::Environment::ClassRegistry]
     # @param rbs_loader [Rigor::Environment::RbsLoader, nil] when nil the
@@ -63,11 +66,15 @@ module Rigor
     #   When nil (the default), no dep-source contribution
     #   participates and the dispatcher tier is a no-op.
     def initialize(class_registry: ClassRegistry.default, rbs_loader: nil,
-                   plugin_registry: nil, dependency_source_index: nil)
+                   plugin_registry: nil, dependency_source_index: nil,
+                   rbs_extended_reporter: nil, boundary_cross_reporter: nil)
       @class_registry = class_registry
       @rbs_loader = rbs_loader
       @plugin_registry = plugin_registry
       @dependency_source_index = dependency_source_index
+      @rbs_extended_reporter = rbs_extended_reporter
+      @boundary_cross_reporter = boundary_cross_reporter
+      @name_scope = build_name_scope
       freeze
     end
 
@@ -98,7 +105,8 @@ module Rigor
       #   default) to skip caching for this environment.
       # @return [Rigor::Environment]
       def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil, # rubocop:disable Metrics/ParameterLists
-                      plugin_registry: nil, dependency_source_index: nil)
+                      plugin_registry: nil, dependency_source_index: nil,
+                      rbs_extended_reporter: nil, boundary_cross_reporter: nil)
         resolved_paths = signature_paths || default_signature_paths(root)
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         loader = RbsLoader.new(
@@ -109,7 +117,9 @@ module Rigor
         new(
           rbs_loader: loader,
           plugin_registry: plugin_registry,
-          dependency_source_index: dependency_source_index
+          dependency_source_index: dependency_source_index,
+          rbs_extended_reporter: rbs_extended_reporter,
+          boundary_cross_reporter: boundary_cross_reporter
         )
       end
 
@@ -204,5 +214,26 @@ module Rigor
     def normalize_class_name(name)
       name.to_s.delete_prefix("::")
     end
+
+    # ADR-13 slice 3b — composes the per-run plugin-supplied
+    # {Rigor::TypeNode::ResolverChain} into a single
+    # {Rigor::TypeNode::NameScope} that the RBS::Extended
+    # directive parser threads down to the
+    # {Rigor::Builtins::ImportedRefinements::Resolver}. Returns
+    # `nil` when no plugin contributes a type-node resolver so
+    # the parser short-circuits the chain consultation and
+    # behaves bit-for-bit like the v0.1.0 → v0.1.3 default.
+    def build_name_scope
+      return nil if @plugin_registry.nil? || @plugin_registry.empty?
+
+      resolvers = @plugin_registry.type_node_resolvers
+      return nil if resolvers.empty?
+
+      TypeNode::NameScope.new(
+        resolver: TypeNode::ResolverChain.new(resolvers),
+        class_context: nil,
+        type_alias_table: {}
+      )
+    end
   end
 end

data/lib/rigor/flow_contribution/conflict.rb

@@ -28,8 +28,8 @@ module Rigor
       lower_tier_contradiction
     ].freeze
 
-    Conflict = Data.define(:target, :edge, :kind, :reason, :provenances, :message) do
-      def initialize(target:, edge:, kind:, reason:, provenances:, message:) # rubocop:disable Metrics/ParameterLists
+    class Conflict < Data.define(:target, :edge, :kind, :reason, :provenances, :message)
+      def initialize(target:, edge:, kind:, reason:, provenances:, message:)
         unless CONFLICT_VALID_REASONS.include?(reason)
           raise ArgumentError,
                 "FlowContribution::Conflict reason must be one of " \

data/lib/rigor/flow_contribution/element.rb

@@ -28,7 +28,7 @@ module Rigor
       role
     ].freeze
 
-    Element = Data.define(:target, :edge, :kind, :payload, :provenance) do
+    class Element < Data.define(:target, :edge, :kind, :payload, :provenance)
       def initialize(target:, edge:, kind:, payload:, provenance:)
         unless ELEMENT_VALID_EDGES.include?(edge)
           raise ArgumentError,

data/lib/rigor/flow_contribution/fact.rb

@@ -55,7 +55,7 @@ module Rigor
     # land in the same merge bucket.
     FACT_VALID_TARGET_KINDS = %i[parameter self].freeze
 
-    Fact = Data.define(:target_kind, :target_name, :type, :negative) do
+    class Fact < Data.define(:target_kind, :target_name, :type, :negative)
       def initialize(target_kind:, target_name:, type:, negative: false)
         unless FACT_VALID_TARGET_KINDS.include?(target_kind)
           raise ArgumentError,

data/lib/rigor/flow_contribution/merge_result.rb

@@ -42,7 +42,7 @@ module Rigor
         !@conflicts.empty?
       end
 
-      def empty? # rubocop:disable Metrics/CyclomaticComplexity
+      def empty?
         @return_type.nil? && @truthy_facts.empty? && @falsey_facts.empty? &&
           @post_return_facts.empty? && @mutations.empty? && @invalidations.empty? &&
           @exceptional.nil? && @role_conformance.empty?

data/lib/rigor/flow_contribution/merger.rb

@@ -55,7 +55,7 @@ module Rigor
     # In every conflict case the result keeps the higher-tier value
     # for that slot, records a {Conflict} with both provenances, and
     # continues processing the remaining slots / contributions.
-    module Merger # rubocop:disable Metrics/ModuleLength
+    module Merger
       AUTHORITY_TIERS = {
         builtin: 0,
         rbs_extended: 1,
@@ -112,7 +112,7 @@ module Rigor
           fold_role_conformance(state, contribution)
         end
 
-        def fold_return_type(state, contribution, tier) # rubocop:disable Metrics/AbcSize
+        def fold_return_type(state, contribution, tier)
           incoming = contribution.return_type
           return if incoming.nil?
 
@@ -202,7 +202,7 @@ module Rigor
           end
         end
 
-        def build_conflict(target:, edge:, kind:, reason:, provenances:, message:) # rubocop:disable Metrics/ParameterLists
+        def build_conflict(target:, edge:, kind:, reason:, provenances:, message:)
           Conflict.new(target: target, edge: edge, kind: kind, reason: reason,
                        provenances: provenances, message: message)
         end

data/lib/rigor/flow_contribution.rb

@@ -32,7 +32,7 @@ module Rigor
     # `descriptor` is the {Rigor::Cache::Descriptor} this
     # contribution attaches to (or `nil` when the contribution does
     # not need its own cache slice).
-    Provenance = Data.define(:source_family, :plugin_id, :node, :descriptor) do
+    class Provenance < Data.define(:source_family, :plugin_id, :node, :descriptor)
       def self.builtin
         new(source_family: :builtin, plugin_id: nil, node: nil, descriptor: nil)
       end
@@ -122,7 +122,7 @@ module Rigor
     # | role_conformance    | normal        | role                | (per-role target)       |
     #
     # @return [Array<Element>]
-    def to_element_list # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def to_element_list # rubocop:disable Metrics/AbcSize
       elements = []
       elements << element_for(:return, :normal, :return_type, return_type) unless return_type.nil?
       Array(truthy_facts).each { |fact| elements << element_for(fact_target(fact), :truthy, :truthy_fact, fact) }

data/lib/rigor/inference/block_parameter_binder.rb

@@ -45,7 +45,6 @@ module Rigor
     # scope MUST NOT observe them and the binder leaves them unbound.
     #
     # See docs/internal-spec/inference-engine.md for the binding contract.
-    # rubocop:disable Metrics/ClassLength
     class BlockParameterBinder
       # @param expected_param_types [Array<Rigor::Type>] positional block
       #   parameter types in order. Indices the binder cannot fill from
@@ -208,6 +207,5 @@ module Rigor
         @expected_param_types[index] || Type::Combinator.untyped
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rigor/inference/coverage_scanner.rb

@@ -24,7 +24,7 @@ module Rigor
     # hot inference path: it allocates a tracer per visited node and discards
     # the inferred type values.
     class CoverageScanner
-      Result = Data.define(:visits, :unrecognized, :events) do
+      class Result < Data.define(:visits, :unrecognized, :events)
         # @return [Integer] sum of all visits across node classes.
         def visited_count
           visits.values.sum

data/lib/rigor/inference/expression_typer.rb

@@ -111,7 +111,21 @@ module Rigor
         Prism::IndexOrWriteNode => :type_of_assignment_write,
         Prism::IndexAndWriteNode => :type_of_assignment_write,
         Prism::MultiWriteNode => :type_of_assignment_write,
+        # LHS-only target nodes (destructuring assignment, pattern matching,
+        # `for x in xs`, block parameter `|a, (b, c)|`). They have no value
+        # to extract — the type-of pass acknowledges the node class so the
+        # coverage scanner stops flagging it; binding the inner names back
+        # into the scope is the StatementEvaluator / MultiTargetBinder /
+        # BlockParameterBinder side's concern.
         Prism::LocalVariableTargetNode => :type_of_non_value,
+        Prism::MultiTargetNode => :type_of_non_value,
+        Prism::InstanceVariableTargetNode => :type_of_non_value,
+        Prism::ClassVariableTargetNode => :type_of_non_value,
+        Prism::GlobalVariableTargetNode => :type_of_non_value,
+        Prism::ConstantTargetNode => :type_of_non_value,
+        Prism::ConstantPathTargetNode => :type_of_non_value,
+        Prism::CallTargetNode => :type_of_non_value,
+        Prism::IndexTargetNode => :type_of_non_value,
         # Hashes and interpolation
         Prism::HashNode => :type_of_hash,
         Prism::KeywordHashNode => :type_of_hash,
@@ -931,7 +945,6 @@ module Rigor
       # for the CallNode itself (the inner type_of calls already record
       # their own fallbacks for unrecognised receivers/args, so the tracer
       # captures both the immediate dispatch miss and the deeper cause).
-      # rubocop:disable Metrics/CyclomaticComplexity
       def call_type_for(node)
         receiver = call_receiver_type_for(node)
         arg_types = call_arg_types(node)
@@ -1004,7 +1017,6 @@ module Rigor
 
         fallback_for(node, family: :prism)
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       # v0.0.2 #5 — re-types the body of a user-defined
       # instance method with the call site's argument types
@@ -1160,9 +1172,20 @@ module Rigor
       # when typing the body raises (defensive against malformed
       # subtrees); the dispatcher then runs in its no-block-aware
       # path.
+      #
+      # ADR-14 gap-#3 (d): a `Prism::BlockArgumentNode` carrying
+      # `&:symbol` (the Symbol#to_proc shorthand) is treated as
+      # a block. The block's return type is computed by
+      # dispatching `:symbol` on the expected block param type
+      # (per `Symbol#to_proc`'s `{ |x| x.symbol }` semantics).
+      # A precise inner dispatch produces the right return; any
+      # failure step falls back to `Dynamic[Top]` so the
+      # dispatcher still SEES a block — selecting the block-
+      # bearing overload of e.g. `Hash#transform_values` over
+      # the no-block overload that returns `Enumerator`.
       def block_return_type_for(call_node, receiver_type, arg_types)
-        block_node = call_node.block
-        return nil unless block_node.is_a?(Prism::BlockNode)
+        block_arg = call_node.block
+        return nil if block_arg.nil?
         return nil if receiver_type.nil?
 
         expected = MethodDispatcher.expected_block_param_types(
@@ -1171,13 +1194,50 @@ module Rigor
           arg_types: arg_types,
           environment: scope.environment
         )
-        bindings = BlockParameterBinder.new(expected_param_types: expected).bind(block_node)
-        block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
-        type_block_body(block_node, block_scope)
+        block_return_for(block_arg, expected)
       rescue StandardError
         nil
       end
 
+      def block_return_for(block_arg, expected)
+        case block_arg
+        when Prism::BlockNode
+          bindings = BlockParameterBinder.new(expected_param_types: expected).bind(block_arg)
+          block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
+          type_block_body(block_arg, block_scope)
+        when Prism::BlockArgumentNode
+          symbol_block_return_type(block_arg, expected)
+        end
+      end
+
+      # `&:symbol` desugars to a one-arg Proc that dispatches
+      # `symbol` against its argument. When the param type is
+      # known and the resulting inner dispatch is precise,
+      # this returns the precise carrier; otherwise it
+      # returns `Dynamic[Top]` (still non-nil) so the outer
+      # dispatcher selects the block-bearing overload.
+      # `&proc_local` / `&method(:foo)` and friends — anything
+      # not a bare SymbolNode — still resolve to
+      # `Dynamic[Top]` for the same block-presence signal.
+      def symbol_block_return_type(block_arg, expected_param_types)
+        expression = block_arg.expression
+        return dynamic_top unless expression.is_a?(Prism::SymbolNode)
+
+        param_type = expected_param_types&.first
+        return dynamic_top if param_type.nil?
+
+        result = MethodDispatcher.dispatch(
+          receiver_type: param_type,
+          method_name: expression.unescaped.to_sym,
+          arg_types: [],
+          block_type: nil,
+          environment: scope.environment,
+          call_node: block_arg,
+          scope: scope
+        )
+        result || dynamic_top
+      end
+
       def type_block_body(block_node, block_scope)
         body = block_node.body
         return Type::Combinator.constant_of(nil) if body.nil?
@@ -1213,7 +1273,6 @@ module Rigor
       PER_ELEMENT_RANGE_LIMIT = 8
       private_constant :PER_ELEMENT_RANGE_LIMIT
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def try_per_element_block_fold(call_node, receiver_type)
         return nil unless PER_ELEMENT_TUPLE_METHODS.include?(call_node.name)
         return nil if find_family_with_args?(call_node)
@@ -1231,7 +1290,6 @@ module Rigor
 
         assemble_per_element_result(call_node.name, per_position, element_types)
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       # Returns the per-position element types for a finite,
       # statically-known receiver shape — or nil when the
@@ -1254,7 +1312,6 @@ module Rigor
         end
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
       def constant_range_elements(value)
         return nil unless value.is_a?(Range)
         return nil unless value.begin.is_a?(Integer) && value.end.is_a?(Integer)
@@ -1264,7 +1321,6 @@ module Rigor
 
         value.to_a.map { |v| Type::Combinator.constant_of(v) }
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       # `index(value)` and `find_index(value)` carry a positional
       # argument and search by `==` rather than running the block.

data/lib/rigor/inference/fallback.rb

@@ -20,7 +20,7 @@ module Rigor
     # - inner_type: the Rigor::Type returned to the caller (currently
     #   always Dynamic[Top]; later slices may carry richer fallback
     #   types).
-    Fallback = Data.define(:node_class, :location, :family, :inner_type) do
+    class Fallback < Data.define(:node_class, :location, :family, :inner_type)
       def initialize(node_class:, location:, family:, inner_type:)
         raise ArgumentError, "node_class must be a Class, got #{node_class.class}" unless node_class.is_a?(Class)