rigortype 0.0.3 → 0.0.5

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

@@ -27,18 +27,25 @@ 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
+      module IteratorDispatch # rubocop:disable Metrics/ModuleLength
         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)
           when :upto  then upto_block_params(receiver, args.first)
           when :downto then downto_block_params(receiver, args.first)
+          when :each_with_index then each_with_index_block_params(receiver)
+          when :each_with_object then each_with_object_block_params(receiver, args.first)
+          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)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def times_block_params(receiver)
           return nil unless integer_rooted?(receiver)
@@ -62,6 +69,200 @@ module Rigor
           [build_index_range(lower_bound_of(end_arg), upper_bound_of(receiver))]
         end
 
+        # Generalised iterator: every Enumerable-shaped collection
+        # in v0.0.4 yields `(element, index)` where the index is
+        # always `non-negative-int`. The element comes from the
+        # receiver's shape:
+        #
+        # - `Array[T]` / `Set[T]` / `Range[T]`              → T
+        # - `Tuple[A, B, C]`                                → A | B | C
+        #   (empty tuple cannot iterate, but we conservatively
+        #   fall through to RBS so a missing rule never throws)
+        # - `Hash[K, V]` / `HashShape{...}`                 → Tuple[K, V]
+        #   (Ruby yields `[key, value]` pairs as the element)
+        # - `Constant<Array>` / `Constant<Range>` / `Constant<Set>`
+        #                                                   → corresponding Constant element
+        #
+        # Receivers we cannot project (Top, Dynamic, unknown
+        # nominals, IO, …) decline so the RBS tier still answers
+        # — its element type is correct, only the index would
+        # widen to plain Integer.
+        def each_with_index_block_params(receiver)
+          element = element_type_of(receiver)
+          return nil if element.nil?
+
+          [element, Type::Combinator.non_negative_int]
+        end
+
+        # `each_with_object(memo) { |elem, memo_inner| … }` yields
+        # `(element, memo)` where `memo` is the second argument's
+        # type (passed by reference and threaded across iterations
+        # at runtime — Rigor reflects that by binding the block's
+        # second parameter to whatever the call site supplied).
+        # When the call has no memo argument the dispatcher
+        # declines so the user's RBS / overload selector decides.
+        def each_with_object_block_params(receiver, memo_arg)
+          return nil if memo_arg.nil?
+
+          element = element_type_of(receiver)
+          return nil if element.nil?
+
+          [element, memo_arg]
+        end
+
+        # `inject(seed) { |memo, elem| … }` and `reduce` accept
+        # three call shapes:
+        #
+        # - `(seed) { |memo, elem| … }` — block params `[seed, element]`.
+        #   The memo's static type is the seed's; we cannot prove the
+        #   block return type here without round-tripping through the
+        #   block analyser, so the binding is the seed's type and
+        #   downstream inference widens as needed.
+        # - `() { |memo, elem| … }` — the first iteration uses the
+        #   first element as the memo, so `[element, element]` is the
+        #   sound binding.
+        # - `(seed, :sym)` / `(:sym)` — Symbol method-name forms have
+        #   no block. `inject` with a Symbol final arg is recognised
+        #   and declined (returns nil) so the dispatcher does not
+        #   pretend a block existed.
+        def inject_block_params(receiver, args)
+          element = element_type_of(receiver)
+          return nil if element.nil?
+
+          case args.size
+          when 0
+            [element, element]
+          when 1
+            seed = args.first
+            return nil if symbol_constant?(seed)
+
+            [seed, element]
+          when 2
+            # `inject(seed, :sym)` — Symbol-call form, no block.
+            return nil if symbol_constant?(args[1])
+
+            [args[0], element]
+          end
+        end
+
+        def symbol_constant?(type)
+          type.is_a?(Type::Constant) && type.value.is_a?(Symbol)
+        end
+
+        # Element-yielding Enumerable methods covered as a v0.0.5
+        # placeholder. RBS already binds the block parameter
+        # correctly for plain `Array[T]` / `Set[T]` / `Range[T]`
+        # receivers via generic substitution; this tier exists so
+        # Tuple- and HashShape-shaped receivers reach the block
+        # body with the precise per-position element union /
+        # `Tuple[K, V]` pair rather than the projected
+        # `Array[union]` / `Hash[K, V]` widening.
+        #
+        # NOTE (v0.0.5): the per-method coverage here (group_by,
+        # partition, each_slice, each_cons) is intentionally
+        # narrow. The longer-term direction is to move
+        # Enumerable-aware projections into a plugin tier modelled
+        # after PHPStan's extension API (ADR-2). The placeholders
+        # below stay until the plugin surface is in place; once it
+        # ships, this dispatcher loses these arms and the
+        # equivalent rules move into a built-in plugin loaded at
+        # boot.
+        def single_element_block_params(receiver)
+          element = element_type_of(receiver)
+          return nil if element.nil?
+
+          [element]
+        end
+
+        # `each_slice(n) { |slice| … }` and `each_cons(n) { |window| … }`
+        # both yield an `Array[element]` once per iteration. The
+        # tier ignores the slice-size argument (a Constant<Integer>
+        # `n` could in principle bound the slice's length, but a
+        # tighter Tuple-of-`n` carrier is reserved for the plugin
+        # tier per the NOTE above).
+        def slice_block_params(receiver)
+          element = element_type_of(receiver)
+          return nil if element.nil?
+
+          [Type::Combinator.nominal_of("Array", type_args: [element])]
+        end
+
+        ELEMENT_BY_NOMINAL = {
+          "Array" => :nominal_unary_element,
+          "Set" => :nominal_unary_element,
+          "Range" => :nominal_unary_element,
+          "Hash" => :nominal_hash_pair_element
+        }.freeze
+        private_constant :ELEMENT_BY_NOMINAL
+
+        def element_type_of(receiver)
+          case receiver
+          when Type::Tuple then tuple_element(receiver)
+          when Type::HashShape then hash_shape_pair_element(receiver)
+          when Type::Nominal then nominal_element(receiver)
+          when Type::Constant then constant_element(receiver)
+          end
+        end
+
+        def tuple_element(tuple)
+          return nil if tuple.elements.empty?
+          return tuple.elements.first if tuple.elements.size == 1
+
+          Type::Combinator.union(*tuple.elements)
+        end
+
+        def hash_shape_pair_element(shape)
+          return nil if shape.pairs.empty?
+
+          key = Type::Combinator.union(*shape.pairs.keys.map { |k| Type::Combinator.constant_of(k) })
+          value = Type::Combinator.union(*shape.pairs.values)
+          Type::Combinator.tuple_of(key, value)
+        end
+
+        def nominal_element(nominal)
+          handler = ELEMENT_BY_NOMINAL[nominal.class_name]
+          return nil unless handler
+
+          send(handler, nominal)
+        end
+
+        def nominal_unary_element(nominal)
+          nominal.type_args.first
+        end
+
+        def nominal_hash_pair_element(nominal)
+          key, value = nominal.type_args
+          return nil if key.nil? || value.nil?
+
+          Type::Combinator.tuple_of(key, value)
+        end
+
+        def constant_element(constant)
+          case constant.value
+          when Array
+            return nil if constant.value.empty?
+
+            Type::Combinator.union(*constant.value.map { |v| Type::Combinator.constant_of(v) })
+          when Range
+            range_constant_element(constant.value)
+          end
+        end
+
+        def range_constant_element(range)
+          beg = range.begin
+          en  = range.end
+          return Type::Combinator.constant_of(beg) if beg.is_a?(Integer) && beg == en
+
+          if beg.is_a?(Integer) && en.is_a?(Integer)
+            upper = range.exclude_end? ? en - 1 : en
+            return build_index_range(beg, upper)
+          end
+
+          # Mixed / non-integer ranges decline: the dispatcher
+          # falls through to RBS's element-type answer.
+          nil
+        end
+
         # `Constant<Integer>`, `IntegerRange`, and `Nominal[Integer]`
         # all participate. Non-integer types (Float, String, …) and
         # `Top`/`Dynamic` decline so the RBS tier answers.

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Kernel intrinsic shape-folding — precision tier for the
+      # `Kernel` module-functions whose return type is a function
+      # of the argument's *shape*, not just its class.
+      #
+      # Today the only catalogued intrinsic is `Kernel#Array`. The
+      # default RBS sig is `Array(untyped) -> Array[untyped]`, which
+      # collapses to `Array[Dynamic[top]]` for every caller. This
+      # tier short-circuits with a precise answer when the argument's
+      # type lattice tells us what the result element type MUST be:
+      #
+      #   Array(Constant[nil])         -> Array[bot]      # `[]`
+      #   Array(Nominal["Array",[E]])  -> Array[E]        # already an Array
+      #   Array(Tuple[T1,T2,…])        -> Array[T1|T2|…]
+      #   Array(Union[A,B,…])          -> distribute, then unify
+      #   Array(other Nominal[T])      -> Array[Nominal[T]]
+      #
+      # For receiver shapes we cannot prove (`Top`, `Dynamic`, …)
+      # the tier returns nil and the RBS tier answers with the
+      # generic `Array[untyped]` envelope.
+      #
+      # See `docs/type-specification/value-lattice.md` for the
+      # union-distribution contract this tier mirrors.
+      module KernelDispatch
+        module_function
+
+        def try_dispatch(receiver:, method_name:, args:)
+          return nil unless method_name == :Array
+          return nil if args.length != 1
+          return nil if receiver.nil?
+
+          arg = args.first
+          element = element_type_of(arg)
+          return nil if element.nil?
+
+          Type::Combinator.nominal_of("Array", type_args: [element])
+        end
+
+        # Computes the element type the argument contributes to the
+        # `Array(arg)` result, mirroring Ruby's coercion contract:
+        #
+        # - `nil` becomes `[]` (element type Bot — the empty array
+        #   contributes no inhabitants).
+        # - An existing `Array[E]` is returned as-is, so its element
+        #   type is `E`.
+        # - A `Tuple[T1, T2, …]` is materialised as `Array[T1|T2|…]`
+        #   (every tuple inhabitant is a tuple, hence Array-like).
+        # - Any other value `v` becomes `[v]`, so the element type
+        #   is the value's own type.
+        #
+        # Returns nil for receiver shapes the tier cannot prove
+        # (Top, Dynamic, Bot in pre-coercion position) so the
+        # caller falls back to the RBS-tier envelope.
+        def element_type_of(type)
+          case type
+          when Type::Union
+            distribute_over_union(type)
+          when Type::Constant
+            type.value.nil? ? Type::Combinator.bot : type
+          when Type::Nominal
+            array_element_or_self(type)
+          when Type::Tuple
+            tuple_element_union(type)
+          end
+        end
+
+        def distribute_over_union(union)
+          contributions = union.members.map { |member| element_type_of(member) }
+          return nil if contributions.any?(&:nil?)
+
+          Type::Combinator.union(*contributions)
+        end
+
+        def array_element_or_self(nominal)
+          return nominal unless nominal.class_name == "Array"
+          return Type::Combinator.untyped if nominal.type_args.empty?
+
+          Type::Combinator.union(*nominal.type_args)
+        end
+
+        def tuple_element_union(tuple)
+          return Type::Combinator.bot if tuple.elements.empty?
+
+          Type::Combinator.union(*tuple.elements)
+        end
+      end
+    end
+  end
+end

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

@@ -53,13 +53,22 @@ module Rigor
           overloads = method_definition.method_types
           return nil if overloads.empty?
 
+          # `rigor:v1:param: <name> <refinement>` annotations on
+          # this method override the RBS-declared parameter type
+          # at the matching name. The map is consumed inside
+          # `accepts_param?` so overload selection sees the
+          # tighter type when filtering candidates by argument
+          # compatibility.
+          param_overrides = RbsExtended.param_type_override_map(method_definition)
+
           match = find_matching_overload(
             overloads,
             arg_types: arg_types,
             self_type: self_type,
             instance_type: instance_type,
             type_vars: type_vars,
-            block_required: block_required
+            block_required: block_required,
+            param_overrides: param_overrides
           )
           return match if match
           return overloads.find { |mt| overload_has_block?(mt) } if block_required
@@ -76,7 +85,8 @@ module Rigor
           private
 
           # rubocop:disable Metrics/ParameterLists
-          def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:)
+          def find_matching_overload(overloads, arg_types:, self_type:, instance_type:, type_vars:, block_required:,
+                                     param_overrides:)
             overloads.find do |method_type|
               next false if block_required && !OverloadSelector.overload_has_block?(method_type)
 
@@ -85,13 +95,15 @@ module Rigor
                 arg_types,
                 self_type: self_type,
                 instance_type: instance_type,
-                type_vars: type_vars
+                type_vars: type_vars,
+                param_overrides: param_overrides
               )
             end
           end
           # rubocop:enable Metrics/ParameterLists
 
-          def matches?(method_type, arg_types, self_type:, instance_type:, type_vars:)
+          # 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)
 
             fun = method_type.type
@@ -104,10 +116,12 @@ module Rigor
                 arg,
                 self_type: self_type,
                 instance_type: instance_type,
-                type_vars: type_vars
+                type_vars: type_vars,
+                param_overrides: param_overrides
               )
             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
@@ -152,8 +166,9 @@ module Rigor
             head
           end
 
-          def accepts_param?(param, arg, self_type:, instance_type:, type_vars:)
-            param_type = RbsTypeTranslator.translate(
+          # 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,
               self_type: self_type,
               instance_type: instance_type,
@@ -162,6 +177,7 @@ module Rigor
             result = param_type.accepts(arg, mode: :gradual)
             result.yes? || result.maybe?
           end
+          # rubocop:enable Metrics/ParameterLists
         end
       end
     end

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

@@ -88,14 +88,25 @@ module Rigor
 
         # @return [Rigor::Type, nil] the precise element/value type, or
         #   `nil` to defer to the next dispatcher tier.
+        # Per-carrier dispatch table. Adding a new carrier here
+        # is a one-row change; the helper methods stay private.
+        # Anonymous Type subclasses are not expected.
+        RECEIVER_HANDLERS = {
+          Type::Tuple => :dispatch_tuple,
+          Type::HashShape => :dispatch_hash_shape,
+          Type::Nominal => :dispatch_nominal_size,
+          Type::Difference => :dispatch_difference,
+          Type::Refined => :dispatch_refined,
+          Type::Intersection => :dispatch_intersection
+        }.freeze
+        private_constant :RECEIVER_HANDLERS
+
         def try_dispatch(receiver:, method_name:, args:)
           args ||= []
-          case receiver
-          when Type::Tuple then dispatch_tuple(receiver, method_name, args)
-          when Type::HashShape then dispatch_hash_shape(receiver, method_name, args)
-          when Type::Nominal then dispatch_nominal_size(receiver, method_name, args)
-          when Type::Difference then dispatch_difference(receiver, method_name, args)
-          end
+          handler = RECEIVER_HANDLERS[receiver.class]
+          return nil unless handler
+
+          send(handler, receiver, method_name, args)
         end
 
         # Tightens `Array#size` / `Array#length` / `String#length` /
@@ -220,6 +231,124 @@ module Rigor
             Type::Combinator.positive_int
           end
 
+          # Predicate-subset projections over a `Refined[base,
+          # predicate]` receiver. Today the catalogue is the
+          # String case-normalisation pair: `s.downcase` over a
+          # `lowercase-string` receiver folds to the same
+          # carrier (already lowercase), and `s.upcase` lifts a
+          # `lowercase-string` to `uppercase-string`. Symmetric
+          # rules apply with the predicates swapped. Numeric-
+          # string idempotence over `#downcase` / `#upcase` is
+          # also recognised because a numeric string equals its
+          # own case-normalisation.
+          #
+          # For methods this tier does not have a refinement-
+          # specific rule for, projection delegates to
+          # `dispatch_nominal_size` so size-returning calls on
+          # a `Refined[String, *]` still tighten to
+          # `non_negative_int`.
+          REFINED_STRING_PROJECTIONS = {
+            %i[lowercase downcase] => :refined_self,
+            %i[lowercase upcase] => :uppercase_string,
+            %i[uppercase upcase] => :refined_self,
+            %i[uppercase downcase] => :lowercase_string,
+            %i[numeric downcase] => :refined_self,
+            %i[numeric upcase] => :refined_self,
+            # Digit-only strings are case-invariant; the prefix
+            # letters in `0o…` / `0x…` are accepted by the
+            # predicate in either case so the predicate-subset
+            # is preserved across `#downcase` / `#upcase` even
+            # though the value-set element changes.
+            %i[decimal_int downcase] => :refined_self,
+            %i[decimal_int upcase] => :refined_self,
+            %i[octal_int downcase] => :refined_self,
+            %i[octal_int upcase] => :refined_self,
+            %i[hex_int downcase] => :refined_self,
+            %i[hex_int upcase] => :refined_self
+          }.freeze
+          private_constant :REFINED_STRING_PROJECTIONS
+
+          def dispatch_refined(refined, method_name, args)
+            base = refined.base
+            return nil unless base.is_a?(Type::Nominal)
+
+            if base.class_name == "String" && args.empty?
+              precise = refined_string_projection(refined, method_name)
+              return precise if precise
+            end
+
+            dispatch_nominal_size(base, method_name, args)
+          end
+
+          def refined_string_projection(refined, method_name)
+            handler = REFINED_STRING_PROJECTIONS[[refined.predicate_id, method_name]]
+            return nil unless handler
+
+            case handler
+            when :refined_self then refined
+            when :uppercase_string then Type::Combinator.uppercase_string
+            when :lowercase_string then Type::Combinator.lowercase_string
+            end
+          end
+
+          # Projects a method call over an `Intersection[M1, …]`
+          # receiver by collecting each member's projection and
+          # combining the results. The set-theoretic identity is
+          # `M(A ∩ B) ⊆ M(A) ∩ M(B)`, so the meet of the per-member
+          # projections is sound. Combining is best-effort:
+          #
+          # - If every result is a `Type::IntegerRange`, return
+          #   their bounded-integer meet (max of lower bounds, min
+          #   of upper bounds). This catches the common
+          #   `(non_empty_string ∩ lowercase_string).size`
+          #   pattern where one member projects to `positive-int`
+          #   and the other to `non-negative-int`; the meet is
+          #   `positive-int`.
+          # - Otherwise return the first non-nil result. A richer
+          #   meet (e.g. of Difference + Refined results when both
+          #   project) is left for a future slice; the carrier
+          #   stays sound because every member's projection is
+          #   already a superset of the true intersection.
+          #
+          # Returns nil when no member projects, so the caller
+          # falls through to the next dispatcher tier.
+          def dispatch_intersection(intersection, method_name, args)
+            results = intersection.members.filter_map do |member|
+              ShapeDispatch.try_dispatch(receiver: member, method_name: method_name, args: args)
+            end
+
+            case results.size
+            when 0 then nil
+            when 1 then results.first
+            else combine_intersection_results(results)
+            end
+          end
+
+          def combine_intersection_results(results)
+            return narrow_integer_ranges(results) if results.all?(Type::IntegerRange)
+
+            results.first
+          end
+
+          # Compute the bounded-integer meet of two or more
+          # `IntegerRange` carriers. We compare via the numeric
+          # `lower` / `upper` accessors (`-Float::INFINITY` /
+          # `Float::INFINITY` for the symbolic ends), then map
+          # back to the symbolic-bound representation
+          # `IntegerRange.new` expects. The disjoint-meet case
+          # cannot arise from sound member-wise projections in
+          # v0.0.4 but is guarded defensively to keep the
+          # carrier total.
+          def narrow_integer_ranges(ranges)
+            numeric_low = ranges.map(&:lower).max
+            numeric_high = ranges.map(&:upper).min
+            return Type::Combinator.bot if numeric_low > numeric_high
+
+            min = numeric_low == -Float::INFINITY ? Type::IntegerRange::NEG_INFINITY : numeric_low.to_i
+            max = numeric_high == Float::INFINITY ? Type::IntegerRange::POS_INFINITY : numeric_high.to_i
+            Type::Combinator.integer_range(min, max)
+          end
+
           def tuple_first(tuple, _method_name, args)
             return nil unless args.empty?
             return Type::Combinator.constant_of(nil) if tuple.elements.empty?

data/lib/rigor/inference/method_dispatcher.rb

@@ -6,6 +6,7 @@ require_relative "method_dispatcher/shape_dispatch"
 require_relative "method_dispatcher/rbs_dispatch"
 require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/file_folding"
+require_relative "method_dispatcher/kernel_dispatch"
 
 module Rigor
   module Inference
@@ -93,7 +94,8 @@ module Rigor
 
         ConstantFolding.try_fold(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types)
+          FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types)
       end
 
       def try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)

data/lib/rigor/inference/method_parameter_binder.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../type"
+require_relative "../rbs_extended"
 require_relative "rbs_type_translator"
 
 module Rigor
@@ -59,10 +60,13 @@ module Rigor
         rbs_method = lookup_rbs_method(def_node)
         return types unless rbs_method
 
-        method_types = rbs_method.method_types
-        return types if method_types.empty?
-
-        apply_rbs_overloads(types, slots, method_types)
+        apply_rbs_overloads(types, slots, rbs_method.method_types) unless rbs_method.method_types.empty?
+        # `rigor:v1:param: <name> <refinement>` annotations
+        # tighten the bound type for matching slots. Applied
+        # after the RBS-overload pass so the override is the
+        # authoritative answer regardless of what the RBS
+        # signature declared.
+        apply_param_overrides(types, slots, rbs_method)
         types
       end
 
@@ -165,6 +169,27 @@ module Rigor
         end
       end
 
+      # Reads the override map off the method's annotations and
+      # replaces the binding for any slot whose name appears in
+      # the map. Anonymous slots are skipped (no name to match).
+      # The override is used verbatim — no `:rest_*` re-wrapping —
+      # so authors who tighten a `*rest` parameter to e.g.
+      # `non-empty-array[Integer]` describe the parameter binding
+      # they actually want, not its element type.
+      def apply_param_overrides(types, slots, rbs_method)
+        override_map = RbsExtended.param_type_override_map(rbs_method)
+        return if override_map.empty?
+
+        slots.each do |slot|
+          next if slot.name.nil?
+
+          override = override_map[slot.name]
+          next if override.nil?
+
+          types[slot.name] = override
+        end
+      end
+
       def collect_translated_types(method_types, slot)
         rbs_types = method_types.flat_map do |mt|
           t = rbs_type_for_slot(mt.type, slot)