rigortype 0.0.1

data/lib/rigor/inference/acceptance.rb

@@ -0,0 +1,444 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Shared dispatch table for `Rigor::Type#accepts(other, mode:)`.
+    #
+    # The acceptance query answers "is `other` passable to `self` at a
+    # method-parameter or assignment boundary?". It uses gradual-typing
+    # rules from docs/type-specification/value-lattice.md and the
+    # acceptance contract in docs/internal-spec/internal-type-api.md.
+    #
+    # Each concrete type's `accepts` method delegates here so the
+    # case-analysis stays in one place. Type instances remain thin value
+    # objects; routing logic lives in the inference layer.
+    #
+    # Slice 4 phase 2c implements the `:gradual` mode in full and
+    # reserves `:strict` for later slices (the entry point raises
+    # ArgumentError on strict for now). The table covers the leaf and
+    # combinator types added through phase 2b: Top, Bot, Dynamic,
+    # Nominal, Singleton, Constant, and Union.
+    #
+    # Slice 5 registers the shape carriers `Tuple` and `HashShape`.
+    # Tuple/HashShape acceptance compares per-position element types
+    # (covariant) and per-key entry types (depth covariant), including
+    # HashShape required/optional/closed-extra-key policy. When the
+    # receiver side is a
+    # generic `Nominal[Array, [E]]` or `Nominal[Hash, [K, V]]` the
+    # shape is projected to its underlying nominal so the existing
+    # generic-acceptance pipeline continues to apply; the converse
+    # direction (a Tuple receiver accepting a generic Array) stays
+    # conservative because the analyzer cannot verify arity from a
+    # raw nominal alone.
+    # rubocop:disable Metrics/ModuleLength
+    module Acceptance
+      module_function
+
+      # @param self_type [Rigor::Type]
+      # @param other_type [Rigor::Type]
+      # @param mode [Symbol] `:gradual` (default) or `:strict`.
+      # @return [Rigor::Type::AcceptsResult]
+      def accepts(self_type, other_type, mode: :gradual)
+        raise ArgumentError, "Acceptance mode #{mode.inspect} is not implemented yet" unless mode == :gradual
+
+        return Type::AcceptsResult.yes(mode: mode, reasons: "Bot is the empty type") if other_type.is_a?(Type::Bot)
+        if other_type.is_a?(Type::Dynamic)
+          return Type::AcceptsResult.yes(mode: mode, reasons: "gradual: Dynamic[T] passes any boundary")
+        end
+        return accepts_union_other(self_type, other_type, mode) if other_type.is_a?(Type::Union)
+
+        accepts_one(self_type, other_type, mode)
+      end
+
+      # Hash dispatch keeps `accepts_one` linear and lets future shape
+      # carriers register their handlers without re-tripping the
+      # cyclomatic budget on a growing `case` arm. Anonymous Type
+      # subclasses are not expected.
+      TYPE_HANDLERS = {
+        Type::Top => :accepts_top,
+        Type::Bot => :accepts_bot,
+        Type::Dynamic => :accepts_dynamic,
+        Type::Union => :accepts_union_self,
+        Type::Singleton => :accepts_singleton,
+        Type::Nominal => :accepts_nominal,
+        Type::Constant => :accepts_constant,
+        Type::Tuple => :accepts_tuple,
+        Type::HashShape => :accepts_hash_shape
+      }.freeze
+      private_constant :TYPE_HANDLERS
+
+      # rubocop:disable Metrics/ClassLength
+      class << self
+        private
+
+        def accepts_one(self_type, other_type, mode)
+          handler = TYPE_HANDLERS[self_type.class]
+          return send(handler, self_type, other_type, mode) if handler
+
+          Type::AcceptsResult.maybe(mode: mode, reasons: "no rule for self=#{self_type.class}")
+        end
+
+        def accepts_top(_self_type, _other_type, mode)
+          Type::AcceptsResult.yes(mode: mode, reasons: "Top is the universal type")
+        end
+
+        def accepts_bot(_self_type, other_type, mode)
+          # Other is not Bot here (handled in {.accepts}), so Bot rejects it.
+          Type::AcceptsResult.no(
+            mode: mode,
+            reasons: "Bot accepts only Bot, got #{other_type.class}"
+          )
+        end
+
+        # Dynamic[T] in gradual mode is liberally inhabited; any concrete
+        # other type is accepted because gradual consistency permits the
+        # crossing. (Other being Dynamic was handled in {.accepts}.)
+        def accepts_dynamic(_self_type, _other_type, mode)
+          Type::AcceptsResult.yes(
+            mode: mode,
+            reasons: "gradual: Dynamic[T] accepts any concrete type"
+          )
+        end
+
+        # Union[A,B].accepts(X) iff some member accepts X. Yes wins as
+        # soon as we find one; otherwise we surface "maybe" only when at
+        # least one member returned maybe (cannot rule out coverage),
+        # else "no".
+        def accepts_union_self(union, other_type, mode)
+          results = union.members.map { |m| accepts(m, other_type, mode: mode) }
+
+          if results.any?(&:yes?)
+            return Type::AcceptsResult.yes(
+              mode: mode,
+              reasons: "union has a member that accepts"
+            )
+          end
+
+          if results.any?(&:maybe?)
+            Type::AcceptsResult.maybe(mode: mode, reasons: "no union member proved acceptance")
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "no union member accepts #{other_type.class}"
+            )
+          end
+        end
+
+        # self.accepts(Union[Y, Z]) iff self accepts every Y_i. Strict
+        # AND across members: any "no" turns the whole result no, any
+        # "maybe" without a "no" gives maybe, all "yes" gives yes.
+        def accepts_union_other(self_type, union, mode)
+          results = union.members.map { |m| accepts(self_type, m, mode: mode) }
+
+          if results.any?(&:no?)
+            return Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "a union member is rejected"
+            )
+          end
+
+          if results.any?(&:maybe?)
+            Type::AcceptsResult.maybe(
+              mode: mode,
+              reasons: "a union member could not be proven accepted"
+            )
+          else
+            Type::AcceptsResult.yes(mode: mode, reasons: "every union member accepted")
+          end
+        end
+
+        # Singleton[C] only accepts another Singleton[D] where D is a
+        # subclass of (or equal to) C. Any other carrier (instance,
+        # constant, ...) is no, because the singleton type's inhabitants
+        # are the class objects themselves.
+        def accepts_singleton(self_type, other_type, mode)
+          unless other_type.is_a?(Type::Singleton)
+            return Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Singleton[#{self_type.class_name}] does not accept #{other_type.class}"
+            )
+          end
+
+          class_subtype_result(
+            target_name: self_type.class_name,
+            actual_name: other_type.class_name,
+            mode: mode,
+            kind: :singleton
+          )
+        end
+
+        # Nominal[C] accepts:
+        # - Nominal[D] when D <= C (Ruby class subtype) and the
+        #   `type_args` are compatible (see {#accepts_nominal_args});
+        # - Constant[v] when v.is_a?(klass(C)). The type_args of self
+        #   are ignored here because a Constant carries a concrete
+        #   value, not a generic instantiation, and the analyzer has no
+        #   way to refute the args from a literal alone.
+        # - Tuple[*] when self is the Array (or a supertype) family.
+        #   The Tuple is projected to `Nominal[Array, [union(elements)]]`
+        #   so the existing generic-arg machinery handles it.
+        # - HashShape{*} when self is the Hash (or a supertype) family,
+        #   projected to `Nominal[Hash, [union(keys), union(values)]]`.
+        # - Singleton: never (wrong value kind).
+        def accepts_nominal(self_type, other_type, mode)
+          case other_type
+          when Type::Nominal
+            accepts_nominal_from_nominal(self_type, other_type, mode)
+          when Type::Constant
+            accepts_nominal_from_constant(self_type, other_type, mode)
+          when Type::Tuple
+            accepts(self_type, project_tuple_to_nominal(other_type), mode: mode)
+              .with_reason("projected Tuple to Nominal[Array]")
+          when Type::HashShape
+            accepts(self_type, project_hash_shape_to_nominal(other_type), mode: mode)
+              .with_reason("projected HashShape to Nominal[Hash]")
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Nominal[#{self_type.class_name}] rejects #{other_type.class}"
+            )
+          end
+        end
+
+        def accepts_nominal_from_nominal(self_type, other_type, mode)
+          class_result = class_subtype_result(
+            target_name: self_type.class_name,
+            actual_name: other_type.class_name,
+            mode: mode,
+            kind: :instance
+          )
+          return class_result if class_result.no?
+
+          args_result = accepts_nominal_args(self_type, other_type, mode)
+          combine_results(class_result, args_result, mode)
+        end
+
+        def project_tuple_to_nominal(tuple)
+          if tuple.elements.empty?
+            Type::Combinator.nominal_of(Array)
+          else
+            Type::Combinator.nominal_of(
+              Array,
+              type_args: [Type::Combinator.union(*tuple.elements)]
+            )
+          end
+        end
+
+        def project_hash_shape_to_nominal(shape)
+          return Type::Combinator.nominal_of(Hash) if shape.pairs.empty?
+
+          key_types = shape.pairs.keys.map { |k| Type::Combinator.constant_of(k) }
+          value_types = shape.pairs.values
+          Type::Combinator.nominal_of(
+            Hash,
+            type_args: [
+              Type::Combinator.union(*key_types),
+              Type::Combinator.union(*value_types)
+            ]
+          )
+        end
+
+        # Slice 4 phase 2d generic acceptance. Type arguments are
+        # treated covariantly element-wise (gradual default; declared
+        # variance lands in Slice 5+). When either side has no
+        # type_args we are lenient: the absent side is the "raw" form
+        # that historically meant "any instantiation", so we keep
+        # backward compatibility for call sites that have not yet
+        # learned to carry generics.
+        def accepts_nominal_args(self_type, other_type, mode)
+          shortcut = nominal_args_shortcut(self_type, other_type, mode)
+          return shortcut if shortcut
+
+          per_arg = self_type.type_args.zip(other_type.type_args).map do |formal, actual|
+            accepts(formal, actual, mode: mode)
+          end
+          combine_arg_results(per_arg, mode)
+        end
+
+        # Returns an `AcceptsResult` for the universal short-circuits
+        # (raw self, raw other, arity mismatch) or `nil` when the full
+        # element-wise check still has to run.
+        def nominal_args_shortcut(self_type, other_type, mode)
+          return Type::AcceptsResult.yes(mode: mode, reasons: "self has no type_args") if self_type.type_args.empty?
+          if other_type.type_args.empty?
+            return Type::AcceptsResult.maybe(
+              mode: mode,
+              reasons: "other has no type_args; assuming compatible (raw)"
+            )
+          end
+
+          return nil if self_type.type_args.size == other_type.type_args.size
+
+          Type::AcceptsResult.no(
+            mode: mode,
+            reasons: "type_args arity mismatch: #{self_type.type_args.size} vs #{other_type.type_args.size}"
+          )
+        end
+
+        def combine_arg_results(per_arg, mode)
+          if per_arg.any?(&:no?)
+            return Type::AcceptsResult.no(mode: mode, reasons: "a type_arg is rejected (covariant)")
+          end
+
+          if per_arg.any?(&:maybe?)
+            Type::AcceptsResult.maybe(mode: mode, reasons: "a type_arg could not be proven accepted")
+          else
+            Type::AcceptsResult.yes(mode: mode, reasons: "every type_arg accepted (covariant)")
+          end
+        end
+
+        def combine_results(class_result, args_result, mode)
+          combined_trinary = class_result.trinary.and(args_result.trinary)
+          Type::AcceptsResult.new(combined_trinary, mode: mode, reasons: class_result.reasons + args_result.reasons)
+        end
+
+        def accepts_nominal_from_constant(self_type, constant, mode)
+          ruby_class = resolve_class(self_type.class_name)
+          if ruby_class.nil?
+            return Type::AcceptsResult.maybe(
+              mode: mode,
+              reasons: "class #{self_type.class_name} not loadable; cannot prove from Constant"
+            )
+          end
+
+          if constant.value.is_a?(ruby_class)
+            Type::AcceptsResult.yes(mode: mode, reasons: "Constant value is_a?(#{self_type.class_name})")
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Constant value is not a #{self_type.class_name}"
+            )
+          end
+        end
+
+        # Constant[v] accepts only Constant[v'] with structurally equal
+        # value. Any other type is rejected (modulo the universal
+        # Bot/Dynamic short-circuits already applied upstream).
+        def accepts_constant(self_type, other_type, mode)
+          if other_type.is_a?(Type::Constant) && self_type == other_type
+            Type::AcceptsResult.yes(mode: mode, reasons: "structural literal match")
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Constant[#{self_type.value.inspect}] rejects #{other_type.class}"
+            )
+          end
+        end
+
+        # Tuple[A1..An] accepts:
+        # - Tuple[B1..Bn] when arities match and each Ai accepts Bi
+        #   (covariant per-position).
+        # - Anything else: no (we cannot prove the arity from a generic
+        #   nominal alone).
+        def accepts_tuple(self_type, other_type, mode)
+          unless other_type.is_a?(Type::Tuple)
+            return Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "Tuple does not accept #{other_type.class}"
+            )
+          end
+
+          if self_type.elements.size != other_type.elements.size
+            return Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "tuple arity mismatch: #{self_type.elements.size} vs #{other_type.elements.size}"
+            )
+          end
+
+          per_element = self_type.elements.zip(other_type.elements).map do |formal, actual|
+            accepts(formal, actual, mode: mode)
+          end
+          combine_arg_results(per_element, mode)
+        end
+
+        # HashShape{k1: T1, ...} accepts another HashShape when every
+        # required key of self is required on the other side and Ti
+        # accepts Ui (depth covariant). Optional keys may be absent on
+        # the other side; when present, their values are checked. A
+        # closed self rejects known or possible extra keys. Other
+        # types are rejected; the converse direction (a Nominal
+        # accepting a HashShape) is handled by `accepts_nominal` via
+        # projection.
+        def accepts_hash_shape(self_type, other_type, mode)
+          unless other_type.is_a?(Type::HashShape)
+            return Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "HashShape does not accept #{other_type.class}"
+            )
+          end
+
+          missing = self_type.required_keys.reject { |key| other_type.required_key?(key) }
+          return hash_shape_no(mode, "HashShape missing required keys: #{missing.inspect}") unless missing.empty?
+
+          if self_type.closed?
+            return hash_shape_no(mode, "HashShape closed target rejects open source") if other_type.open?
+
+            extra = other_type.pairs.keys - self_type.pairs.keys
+            unless extra.empty?
+              return hash_shape_no(mode, "HashShape closed target rejects extra keys: #{extra.inspect}")
+            end
+          end
+
+          per_entry = hash_shape_entry_results(self_type, other_type, mode)
+          combine_arg_results(per_entry, mode)
+        end
+
+        def hash_shape_entry_results(self_type, other_type, mode)
+          self_type.pairs.filter_map do |key, formal|
+            next unless other_type.pairs.key?(key)
+
+            accepts(formal, other_type.pairs.fetch(key), mode: mode)
+          end
+        end
+
+        def hash_shape_no(mode, reason)
+          Type::AcceptsResult.no(mode: mode, reasons: reason)
+        end
+
+        # Slice 4 phase 2c uses Ruby's actual class hierarchy to answer
+        # "is D a subclass of C?". This works for any class loadable
+        # through Object.const_get -- core, stdlib, and live application
+        # classes. When either name fails to resolve we surface "maybe":
+        # the caller (overload selector) treats yes/maybe identically,
+        # so the conservative answer keeps overload coverage intact.
+        # Slice 5 will replace this with an RBS-driven hierarchy lookup
+        # so ahead-of-time type checking no longer relies on Ruby
+        # loading the application classes.
+        def class_subtype_result(target_name:, actual_name:, mode:, kind:)
+          return Type::AcceptsResult.yes(mode: mode, reasons: "exact name match") if target_name == actual_name
+
+          target_class = resolve_class(target_name)
+          actual_class = resolve_class(actual_name)
+          if target_class.nil? || actual_class.nil?
+            return Type::AcceptsResult.maybe(
+              mode: mode,
+              reasons: "subtype check unresolved (#{kind}: #{actual_name} <= #{target_name})"
+            )
+          end
+
+          if actual_class <= target_class
+            Type::AcceptsResult.yes(
+              mode: mode,
+              reasons: "#{actual_name} <= #{target_name} via Ruby hierarchy"
+            )
+          else
+            Type::AcceptsResult.no(
+              mode: mode,
+              reasons: "#{actual_name} is not a subclass of #{target_name}"
+            )
+          end
+        end
+
+        def resolve_class(name)
+          Object.const_get(name)
+        rescue NameError
+          nil
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/rigor/inference/block_parameter_binder.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../type"
+require_relative "multi_target_binder"
+
+module Rigor
+  module Inference
+    # Builds the entry scope of a block body by translating the block's
+    # parameter list into a `name -> Rigor::Type` map.
+    #
+    # The binder is the symmetric counterpart of {MethodParameterBinder}
+    # for `Prism::BlockNode`. The expected parameter types come from
+    # the receiving method's RBS signature
+    # ({Rigor::Inference::MethodDispatcher.expected_block_param_types});
+    # parameters that the signature does not cover (or that the binder
+    # cannot match by position) default to `Dynamic[Top]`. The default
+    # is the Slice 1 fail-soft answer for unknown values, so a block
+    # whose receiving method has no signature still binds every name
+    # into the scope (a block body whose `Local x` reads return
+    # `Dynamic[Top]` instead of falling through to the unbound-local
+    # `Dynamic[Top]` event is the same observable type, but the
+    # binding presence is what later slices need to attach narrowing
+    # facts to).
+    #
+    # MultiTargetNode parameters (`|(a, b), c|`) are bound by
+    # delegating each destructuring slot to
+    # {Rigor::Inference::MultiTargetBinder}, so a Tuple-shaped
+    # expected element type projects element-wise into the inner
+    # locals (Slice 6 phase C sub-phase 2). Numbered parameters
+    # (`_1`, `_2`, ...) are bound from `Prism::NumberedParametersNode`
+    # using the same per-position `expected_param_types:` array, so
+    # `[1, 2, 3].each { _1 + _2 }` sees `_1`/`_2` typed identically
+    # to their explicit `|x, y|` counterparts.
+    #
+    # Block-local declarations after `;` (e.g., `|x; y, z|`) are
+    # still skipped — they are explicitly block-local, so the outer
+    # 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
+      #   this array (because the array is shorter than the parameter
+      #   list, or because the slot is a kind we do not pull from the
+      #   array) default to `Dynamic[Top]`.
+      def initialize(expected_param_types: [])
+        @expected_param_types = expected_param_types
+      end
+
+      # @param block_node [Prism::BlockNode]
+      # @return [Hash{Symbol => Rigor::Type}] ordered map from parameter
+      #   name to bound type. Anonymous parameters are skipped;
+      #   MultiTargetNode destructuring slots delegate to
+      #   {MultiTargetBinder} and contribute every named local in
+      #   declaration order. Numbered-parameter forms (`_1`, `_2`,
+      #   ...) bind `:_1`, `:_2`, ... up to the maximum the block
+      #   body refers to.
+      def bind(block_node)
+        params_root = block_node.parameters
+        return {} if params_root.nil?
+
+        case params_root
+        when Prism::NumberedParametersNode
+          bind_numbered_parameters(params_root)
+        when Prism::BlockParametersNode
+          bind_block_parameters(params_root)
+        else
+          {}
+        end
+      end
+
+      private
+
+      # `|_1, _2|` numbered-parameter form. Prism exposes the
+      # implicit count through `NumberedParametersNode#maximum`
+      # (the highest `_N` referenced in the body); we materialise
+      # bindings for `:_1` through `:_maximum` so the block body's
+      # `LocalVariableReadNode` lookups see the same types as the
+      # equivalent explicit `|x, y|` form would.
+      def bind_numbered_parameters(numbered_node)
+        bindings = {}
+        numbered_node.maximum.times do |i|
+          bindings[:"_#{i + 1}"] = positional_type_at(i)
+        end
+        bindings
+      end
+
+      def bind_block_parameters(params_root)
+        params_node = params_root.parameters
+        return {} if params_node.nil?
+
+        bindings = {}
+        bind_positionals(params_node, bindings, 0)
+        bind_rest(params_node, bindings)
+        bind_keywords(params_node, bindings)
+        bind_keyword_rest(params_node, bindings)
+        bind_block_param(params_node, bindings)
+        bindings
+      end
+
+      def bind_positionals(params_node, bindings, cursor)
+        cursor = bind_required_positionals(params_node, bindings, cursor)
+        cursor = bind_optional_positionals(params_node, bindings, cursor)
+        bind_trailing_positionals(params_node, bindings, cursor)
+      end
+
+      def bind_required_positionals(params_node, bindings, cursor)
+        params_node.requireds.each do |param|
+          bind_required_param(param, cursor, bindings)
+          cursor += 1
+        end
+        cursor
+      end
+
+      def bind_optional_positionals(params_node, bindings, cursor)
+        params_node.optionals.each do |param|
+          bindings[param.name] = positional_type_at(cursor) if param.respond_to?(:name) && param.name
+          cursor += 1
+        end
+        cursor
+      end
+
+      def bind_trailing_positionals(params_node, bindings, cursor)
+        params_node.posts.each do |param|
+          name = required_name(param)
+          bindings[name] = positional_type_at(cursor) if name
+          cursor += 1
+        end
+        cursor
+      end
+
+      # `|*rest|` binds an Array of the leftover positional arguments.
+      # The expected-types array is per-position, not per-rest; we
+      # cannot reliably pick a single element type for rest, so we
+      # default to `Array[Dynamic[Top]]`. Slice C sub-phase 2 may
+      # tighten this when the receiving method's RBS rest type is
+      # available.
+      def bind_rest(params_node, bindings)
+        rest = params_node.rest
+        return unless rest.respond_to?(:name) && rest&.name
+
+        bindings[rest.name] = Type::Combinator.nominal_of("Array", type_args: [Type::Combinator.untyped])
+      end
+
+      def bind_keywords(params_node, bindings)
+        params_node.keywords.each do |kw|
+          case kw
+          when Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode
+            bindings[kw.name] = Type::Combinator.untyped
+          end
+        end
+      end
+
+      def bind_keyword_rest(params_node, bindings)
+        kw_rest = params_node.keyword_rest
+        return unless kw_rest.respond_to?(:name) && kw_rest&.name
+
+        symbol_nominal = Type::Combinator.nominal_of("Symbol")
+        bindings[kw_rest.name] = Type::Combinator.nominal_of(
+          "Hash",
+          type_args: [symbol_nominal, Type::Combinator.untyped]
+        )
+      end
+
+      def bind_block_param(params_node, bindings)
+        block = params_node.block
+        return unless block.respond_to?(:name) && block&.name
+
+        bindings[block.name] = Type::Combinator.nominal_of(Proc)
+      end
+
+      # Required parameters in a block list can be either a plain
+      # `RequiredParameterNode` (named) or a `MultiTargetNode` (the
+      # `|(a, b), c|` destructuring form). Slice 6 phase C sub-phase 2
+      # delegates the latter to {MultiTargetBinder}, which decomposes
+      # the slot's expected Tuple element-wise and binds every named
+      # inner local. Other shapes (anonymous required parameters,
+      # forward arguments) are silently skipped.
+      def bind_required_param(param, cursor, bindings)
+        case param
+        when Prism::RequiredParameterNode
+          bindings[param.name] = positional_type_at(cursor)
+        when Prism::MultiTargetNode
+          nested = MultiTargetBinder.bind(param, positional_type_at(cursor))
+          bindings.merge!(nested)
+        end
+      end
+
+      def positional_type_at(index)
+        @expected_param_types[index] || Type::Combinator.untyped
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end