rigortype 0.1.2 → 0.1.4

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

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "conflict"
+require_relative "fact"
+require_relative "merge_result"
+
 module Rigor
   class FlowContribution
     # Composes any number of {FlowContribution} bundles into a
@@ -51,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,
@@ -108,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?
 
@@ -198,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)
 

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

@@ -37,7 +37,7 @@ module Rigor
       # tuple — element-wise block re-evaluation against
       # `Constant<Array>` receivers (the `map` / `filter_map` /
       # `flat_map` precision tier) is reserved for a later slice.
-      module BlockFolding # rubocop:disable Metrics/ModuleLength
+      module BlockFolding
         module_function
 
         FILTER_KEEP_ON_TRUTHY = Set[:select, :filter, :take_while].freeze
@@ -69,7 +69,6 @@ module Rigor
         #   the call's block. `nil` means "no block at the call site"
         #   and disqualifies every rule here.
         # @return [Rigor::Type, nil]
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def try_fold(receiver:, method_name:, args:, block_type:)
           return nil if receiver.nil? || block_type.nil?
 
@@ -86,7 +85,6 @@ module Rigor
             fold_count(receiver, truthiness, args)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def filter_method?(method_name)
           FILTER_KEEP_ON_TRUTHY.include?(method_name) ||
@@ -154,7 +152,7 @@ module Rigor
         end
 
         # @return [:always_true, :always_false, :bool, nil]
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity
         def predicate_decision(method_name, truthiness, emptiness)
           case method_name
           when :all?
@@ -177,7 +175,7 @@ module Rigor
             :bool
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def bool_union
           Type::Combinator.union(

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

@@ -149,7 +149,6 @@ module Rigor
         #   and runs the format. Symbol keys are kept as
         #   Symbols (matching Ruby's `%{key}` resolution).
         # Anything else declines so the RBS tier widens.
-        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_string_format(receiver, method_name, args)
           return nil unless method_name == :%
           return nil unless args.size == 1
@@ -166,7 +165,6 @@ module Rigor
         rescue StandardError
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def format_argument_value(arg)
           case arg
@@ -275,7 +273,6 @@ module Rigor
           [result]
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_unary_set(receiver_values, method_name)
           range_lift = try_fold_range_constant_unary(receiver_values, method_name)
           return range_lift if range_lift
@@ -299,8 +296,6 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
         # v0.0.7 — `Constant<Range>#to_a` and the no-arg
         # `first` / `last` / `min` / `max` short-circuit through a
         # Range-specific arm that catalog dispatch cannot reach:
@@ -353,7 +348,6 @@ module Rigor
           Type::Combinator.constant_of(edge == :first ? values.first : values.last)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def try_fold_binary_set(receiver_values, method_name, arg_values)
           string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return string_lift if string_lift
@@ -369,8 +363,6 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values + arg_values)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
         # v0.0.7 — `Constant<String>#chars` / `bytes` / `lines` /
         # `split` (no-arg) return a Ruby Array of foldable
         # scalars; `foldable_constant_value?` rejects Array
@@ -425,7 +417,6 @@ module Rigor
           nil
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def try_fold_pathname_binary(receiver_values, method_name, arg_values)
           return nil unless PATHNAME_PURE_BINARY.include?(method_name)
           return nil unless receiver_values.size == 1 && arg_values.size == 1
@@ -442,7 +433,6 @@ module Rigor
         rescue StandardError
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def try_fold_string_array_unary(receiver_values, method_name)
           return nil unless STRING_ARRAY_UNARY_METHODS.include?(method_name)
@@ -459,7 +449,6 @@ module Rigor
         # `Constant<String>#split(arg)` / `#scan(arg)` — lift the
         # Array result to a Tuple when both sides are statically
         # known and the cardinality fits.
-        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_string_array_binary(receiver_values, method_name, arg_values)
           return nil unless STRING_ARRAY_BINARY_METHODS.include?(method_name)
           return nil unless receiver_values.size == 1 && arg_values.size == 1
@@ -473,7 +462,6 @@ module Rigor
         rescue StandardError
           nil
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def lift_array_result(result)
           return nil unless result.is_a?(Array)

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

@@ -27,12 +27,11 @@ module Rigor
       # - `a.downto(b) { |i| … }` yields the same domain `[b, a]`,
       #   just iterated in reverse. Lower bound from the
       #   argument, upper bound from the receiver.
-      module IteratorDispatch # rubocop:disable Metrics/ModuleLength
+      module IteratorDispatch
         module_function
 
         # @return [Array<Rigor::Type>, nil] block-param types, or
         #   nil to fall through to the next tier.
-        # rubocop:disable Metrics/CyclomaticComplexity
         def block_param_types(receiver:, method_name:, args:)
           case method_name
           when :times then times_block_params(receiver)
@@ -45,7 +44,6 @@ module Rigor
           when :each_slice, :each_cons then slice_block_params(receiver)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def times_block_params(receiver)
           return nil unless integer_rooted?(receiver)

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

@@ -74,7 +74,7 @@ module Rigor
         private_constant :CONCAT_METHODS, :FORMAT_METHODS,
                          :LITERAL_PRESERVING_METHODS, :WIDTH_PADDING_METHODS
 
-        def try_dispatch(receiver:, method_name:, args:, **) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def try_dispatch(receiver:, method_name:, args:, **)
           return fold_array_join(receiver, args) if method_name == :join
           return fold_format(args) if FORMAT_METHODS.include?(method_name)
 

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Method` (and friends) precision tier.
+      #
+      # Two folds make a `Method` carrier round-trip with its
+      # binding visible:
+      #
+      # 1. **Forward** — `<receiver>.method(:sym)` (or
+      #    `.method("sym")`) lifts to {Type::BoundMethod}
+      #    carrying the receiver type AND the resolved Symbol.
+      #    Calling with a non-literal symbol-shaped argument
+      #    declines so the RBS tier still answers
+      #    `Nominal[Method]`.
+      # 2. **Backward** — `Type::BoundMethod#call(...)` /
+      #    `#()` (Prism lowers `.()` into a CallNode whose
+      #    `name` is `:call`) / `#[](...)` substitutes the
+      #    bound `(receiver_type, method_name)` and recurses
+      #    back into `MethodDispatcher.dispatch`. The
+      #    re-entrant call lets the substituted dispatch
+      #    consume every tier the original call site would
+      #    have — constant folding, shape dispatch, RBS,
+      #    plugin contributions, etc. The original block_type
+      #    / environment / call_node / scope are threaded
+      #    through unchanged so capture-sensitive tiers (the
+      #    block fold) keep working.
+      #
+      # Lives ABOVE the standard precision-tier chain so the
+      # RBS tier never sees a `BoundMethod` receiver — `Method`
+      # erasure means RBS would otherwise return
+      # `Method#call: (*untyped) -> untyped`, which is exactly
+      # the precision loss the carrier exists to avoid.
+      module MethodFolding
+        module_function
+
+        # Forward fold. Returns a {Type::BoundMethod} when the
+        # call shape is `<receiver>.method(:name)` /
+        # `.method("name")` with a precisely-known Symbol /
+        # String argument. Declines on every other shape so
+        # the RBS tier still answers `Method` for non-folding
+        # cases.
+        #
+        # @param receiver [Rigor::Type] caller's receiver
+        # @param method_name [Symbol] the method being
+        #   dispatched on `receiver` — only `:method` triggers
+        #   the fold.
+        # @param args [Array<Rigor::Type>] caller's argument
+        #   types in order. Only the single-argument case
+        #   matches; other arities decline.
+        def try_forward(receiver:, method_name:, args:)
+          return nil unless method_name == :method
+          return nil if args.size != 1
+
+          bound_name = symbol_name_of(args.first)
+          return nil if bound_name.nil?
+
+          Type::Combinator.bound_method_of(receiver, bound_name)
+        end
+
+        # Backward fold. Recurses into `MethodDispatcher.dispatch`
+        # with the bound `(receiver_type, method_name)`. The
+        # `block_type` / `environment` / `call_node` / `scope`
+        # are forwarded so every downstream tier (constant
+        # folding, shape dispatch, plugin contributions, …)
+        # keeps the original call site's context. Returns
+        # `Dynamic[top]` rather than `nil` when the recursive
+        # dispatch declines so the call site still ends in a
+        # well-defined type (the gradual-safety net mirrors
+        # the engine's "BoundMethod erases to `Method`,
+        # `Method#call: (*untyped) -> untyped`" RBS fallback).
+        def try_backward(receiver:, method_name:, args:, block_type:, environment:, call_node:, scope:)
+          return nil unless receiver.is_a?(Type::BoundMethod)
+          return nil unless backward_method?(method_name)
+
+          MethodDispatcher.dispatch(
+            receiver_type: receiver.receiver_type,
+            method_name: receiver.method_name,
+            arg_types: args,
+            block_type: block_type,
+            environment: environment,
+            call_node: call_node,
+            scope: scope
+          ) || Type::Combinator.untyped
+        end
+        # `Method#call` / `Method#()` and `Method#[]` are the
+        # invocation entry points on the `Method` API; the
+        # alias `===` is also `call` semantically but is more
+        # commonly used as a case-equality predicate, so we
+        # do NOT fold through it (the case/when narrowing path
+        # already special-cases `===` for branch typing).
+        BACKWARD_METHOD_NAMES = %i[call []].freeze
+        private_constant :BACKWARD_METHOD_NAMES
+
+        def backward_method?(method_name)
+          BACKWARD_METHOD_NAMES.include?(method_name)
+        end
+
+        # `Object#method` accepts both Symbol and String at
+        # runtime (the latter coerced via `to_sym`). The
+        # `Constant<String>` form is rare in production code
+        # but cheap to support and matches Ruby's documented
+        # contract.
+        def symbol_name_of(arg)
+          return nil unless arg.is_a?(Type::Constant)
+
+          case arg.value
+          when Symbol then arg.value
+          when String then arg.value.to_sym
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ module Rigor
       # (instance vs singleton). Both kinds share the same arity and
       # acceptance shape; the difference is only in which `Definition`
       # the caller fetched.
-      module OverloadSelector # rubocop:disable Metrics/ModuleLength
+      module OverloadSelector
         module_function
 
         # @param method_definition [RBS::Definition::Method]
@@ -64,8 +64,8 @@ module Rigor
         #   back to the first declaration.
         # @return [RBS::MethodType, nil] the chosen overload, or nil
         #   when the definition has no method types at all.
-        # rubocop:disable Metrics/ParameterLists
-        def select(method_definition, arg_types:, self_type:, instance_type:, type_vars: {}, block_required: false)
+        def select(method_definition, arg_types:, self_type:, instance_type:, type_vars: {}, block_required: false,
+                   environment: nil)
           overloads = method_definition.method_types
           return nil if overloads.empty?
 
@@ -75,7 +75,7 @@ module Rigor
           # `accepts_param?` so overload selection sees the
           # tighter type when filtering candidates by argument
           # compatibility.
-          param_overrides = RbsExtended.param_type_override_map(method_definition)
+          param_overrides = RbsExtended.param_type_override_map(method_definition, environment: environment)
 
           # Pass 1: prefer overloads whose param types stay strict —
           # no translator-induced `Dynamic[Top]` from Alias /
@@ -113,7 +113,6 @@ module Rigor
 
           overloads.first
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def overload_has_block?(method_type)
           method_type.respond_to?(:block) && method_type.block
@@ -122,7 +121,7 @@ module Rigor
         class << self
           private
 
-          # rubocop:disable Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/ParameterLists
           def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
                                      param_overrides:, strict:)
             return nil if strict && arg_types.any? { |t| untyped_arg?(t) }
@@ -141,7 +140,7 @@ module Rigor
               )
             end
           end
-          # rubocop:enable Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/ParameterLists
 
           # Treats the literal `untyped` carrier (`Dynamic[Top]`)
           # as too imprecise to drive a strict-pass match. Other
@@ -194,7 +193,6 @@ module Rigor
             end
           end
 
-          # rubocop:disable Metrics/ParameterLists
           def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:, param_overrides:)
             return false if method_type.respond_to?(:type_params) && rejects_keyword_required?(method_type)
 
@@ -213,7 +211,6 @@ module Rigor
               )
             end
           end
-          # rubocop:enable Metrics/ParameterLists
 
           # Slice 4 phase 2c does not pass keyword arguments through the
           # call site (caller passes only positional `arg_types`). An
@@ -258,7 +255,6 @@ module Rigor
             head
           end
 
-          # rubocop:disable Metrics/ParameterLists
           def accepts_param?(param, arg, self_type:, instance_type:, type_vars:, param_overrides:)
             param_type = param_overrides[param.name] || RbsTypeTranslator.translate(
               param.type,
@@ -269,7 +265,6 @@ module Rigor
             result = param_type.accepts(arg, mode: :gradual)
             result.yes? || result.maybe?
           end
-          # rubocop:enable Metrics/ParameterLists
         end
       end
     end