rigortype 0.3.9 → 0.4.0

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "../../rbs_extended"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #1350 — how `OverloadSelector` reads a `Dynamic[T]` argument. The internal spec keeps a `Dynamic` whose
+      # static facet is not `top` out of the imprecise arguments because its facet discriminates, but acceptance
+      # short-circuits on the wrapper and takes it against any parameter, so the receiver-affinity pre-sort's first arm
+      # won: `Money#add(Integer(v))` typed `Money` and `.even?` reported `call.undefined-method`.
+      #
+      # Selection therefore reads a narrow facet's members ({.select}), leaving out `nil`: a facet's `nil` is usually
+      # the join of an overload that returns it for some untyped input (`Integer(v)`'s `exception:` form), and chosen
+      # by it `Integer | nil` fell through to the only arm that takes `nil` and `Complex(Integer(v), 1)` turned
+      # `Complex?`. One member left stands in for the argument, pass 0 included, and the return stays unwrapped; two
+      # are selected one by one, and the distinct picks come back together for the dispatch layer's join, wrapped in
+      # `Dynamic` when their returns differ (#521).
+      #
+      # Only sealed members are read ({.sealed?}): a literal, or a plain `Integer`, `Float`, `Rational`, `Complex` or
+      # `Symbol`, core classes whose `new` and `allocate` are undefined. Such a member's runtime value is of exactly its
+      # class, where any other member's may be of a subclass and take an arm the member itself skips: `Numeric` in
+      # `2 ** v`'s `Complex | Numeric` skipped a project `(real) -> Float`, whose `real` alias names `Integer`, for a
+      # catch-all `(untyped) -> nil`, and `.floor` on the call reported `call.undefined-method`. Scanning the parameters
+      # for a subclass of the member caught a plain class name and missed aliases, `instance`, type variables,
+      # intersections, singletons and modules.
+      #
+      # Even a sealed member is read only where acceptance can rule it out ({.provable?}). Acceptance reads class
+      # relations from the analyzer's own process, so it answers `no` for `Integer` against a `(Printable)` that project
+      # RBS or source includes into `Integer` (#1352). A plain argument shares that, but the wrapper hid it from a
+      # `Dynamic` one: with `(Printable) -> String | (Integer) -> Integer`, reading the member typed
+      # `fmt(Integer(v)).upcase` as `Integer` and fired `call.undefined-method` where master read `String`. So every
+      # overload's positional parameters must be spelled as a class RBS declares, `untyped`, `top` or `nil`, through `?`
+      # and `|`, which leaves acceptance only a sealed class's fixed ancestry to read. A literal or `bool` parameter
+      # asks for a value, which a class member cannot prove it holds: `Symbol` skipped `(:json) -> String` for
+      # `(untyped) -> nil`, and a `TrueClass` member was refused by `bool` itself. Anything else, a module, a stubbed
+      # name, an alias, an interface, a type variable, `instance`, `self`, an intersection, a singleton or an untyped
+      # `(?)`, keeps the wrapper too. The list names what is provable rather than what is not, so a form it has not met
+      # falls back to master's reading.
+      #
+      # A wider facet keeps the wrapper and the receiver's arm, as before. It is usually itself a #521 join
+      # (`Dynamic[BigDecimal | Complex | Float | Integer | Rational]` from `n * untyped`), and read member by member it
+      # joined every arm again: 256 call sites across the survey corpus lost a precise type to `Dynamic`, and a
+      # recursion's fuel-exhausted `n * of(n - 1)` stopped reading `Integer`.
+      module FacetDistribution
+        # The most facet members, `nil` aside, that selection reads one by one.
+        MEMBER_LIMIT = 2
+        # Member-wise argument lists beyond this keep their wrappers.
+        CAP = 8
+        # Core classes whose `new` and `allocate` are undefined, so plain Ruby cannot make an instance of a subclass
+        # (`Integer`, `Float` and `Symbol` have no allocator at all; a `Rational` or `Complex` subclass instance takes
+        # `Marshal.load` or a rebound `Class#allocate`). `NilClass` leaves with the facet's `nil`, and `true` and
+        # `false` are read only as literals.
+        SEALED_CLASSES = %w[Integer Float Rational Complex Symbol].freeze
+
+        module_function
+
+        # Whether any argument is a `Dynamic` whose facet selection reads; the cheap guard of the hot path.
+        def faceted?(arg_types) = arg_types.any? { |arg| arg.is_a?(Type::Dynamic) && facet_members(arg) }
+
+        # Selects through the block, called as `yield(arg_types, member)`. It yields once per member-wise list, one
+        # member standing in for each faceted argument, with `member` true so the block answers only a genuine match.
+        # It yields once with the arguments as given instead when the overloads are not {.provable?}, when an argument
+        # has two members and the caller is the singular `select` (`member_wise` false, whose one answer a member order
+        # would decide), when there are more than {CAP} lists, or when any list matches nothing.
+        def select(arg_types, definition, member_wise:, environment:, &)
+          choices = arg_types.map { |arg| facet_members(arg) || [arg] }
+          return yield(arg_types, false) unless member_wise || choices.all? { |members| members.size == 1 }
+          return yield(arg_types, false) unless provable?(definition, environment)
+
+          picks = picks_by_member(choices, &)
+          picks.empty? ? yield(arg_types, false) : picks
+        end
+
+        # The distinct overloads the member-wise lists pick; none past {CAP} or when any list picks nothing.
+        def picks_by_member(choices)
+          return [] if choices.reduce(1) { |count, members| count * members.size } > CAP
+
+          lists = choices.first.product(*choices.drop(1)).map { |combination| yield(combination, true) }
+          lists.any?(&:empty?) ? [] : lists.flatten(1).uniq(&:object_id)
+        end
+
+        # Whether every overload's positional parameters, rest and trailing included, are in a provable form
+        # ({.provable_param?}), where acceptance's answer for a sealed member rests only on the member class's fixed
+        # ancestry; a `rigor:v1:param:` override proves nothing either.
+        def provable?(definition, environment)
+          loader = environment&.rbs_loader
+          return false if loader.nil?
+          return false unless RbsExtended.param_type_override_map(definition, environment: environment).empty?
+
+          definition.method_types.all? do |method_type|
+            fun = method_type.type
+            next false unless fun.respond_to?(:required_positionals)
+
+            params = fun.required_positionals + fun.optional_positionals + fun.trailing_positionals
+            params += [fun.rest_positionals] if fun.rest_positionals
+            params.all? { |param| provable_param?(param.type, loader) }
+          end
+        end
+
+        def provable_param?(rbs_type, loader)
+          case rbs_type
+          when RBS::Types::ClassInstance then declared_class?(rbs_type.name.to_s.delete_prefix("::"), loader)
+          when RBS::Types::Optional then provable_param?(rbs_type.type, loader)
+          when RBS::Types::Union then rbs_type.types.all? { |member| provable_param?(member, loader) }
+          when RBS::Types::Bases::Any, RBS::Types::Bases::Top, RBS::Types::Bases::Nil then true
+          else false
+          end
+        end
+
+        # A class RBS declares, not a module and not a name Rigor stubbed because no RBS declares it: a class cannot be
+        # included, and a sealed member's class has a fixed ancestry, so acceptance's answer against it holds.
+        def declared_class?(name, loader)
+          loader.class_known?(name) && !loader.rbs_module?(name) && !loader.synthesized_type_names.include?(name)
+        end
+
+        # A `Dynamic` argument's facet members other than `nil`, or nil when selection keeps the wrapper: not a
+        # `Dynamic`, the untyped carrier, a facet that is only `nil`, one wider than {MEMBER_LIMIT}, or one with a
+        # member that is not sealed, an untyped member included.
+        def facet_members(arg)
+          return nil unless arg.is_a?(Type::Dynamic) && !arg.static_facet.is_a?(Type::Top)
+
+          facet = arg.static_facet
+          members = (facet.is_a?(Type::Union) ? facet.members : [facet]).reject { |member| nil_value?(member) }
+          members if members.size.between?(1, MEMBER_LIMIT) && members.all? { |member| sealed?(member) }
+        end
+
+        # A member whose runtime value is of exactly its class: a `Constant`, which is a value of that exact class, or a
+        # plain instance of {SEALED_CLASSES}.
+        def sealed?(member)
+          case member
+          when Type::Constant then true
+          when Type::Nominal then member.type_args.empty? && SEALED_CLASSES.include?(member.class_name)
+          else false
+          end
+        end
+
+        def nil_value?(type)
+          return type.value.nil? if type.is_a?(Type::Constant)
+
+          type.is_a?(Type::Nominal) && type.class_name == "NilClass"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # `Hash#transform_keys(mapping)` return type, with or without a block.
+      #
+      # CRuby's `transform_keys_hash_i` looks each old key up in the mapping with `rb_hash_lookup2`, which
+      # ignores a default. A hit takes the mapping's value as the new key and never reaches the block. A miss
+      # yields the old key to the block, or keeps it when no block is given. The new key type is therefore the
+      # mapping's value type joined with the block's return type, or with the receiver's key type when there is
+      # no block. The values are the receiver's, untouched.
+      #
+      # Neither RBS line says that. rbs 4.2 declares `[K2] (hash[_Key, K2] replacements) { (K old_key) -> K2 }
+      # -> Hash[K2, V]`, and {RbsDispatch} leaves `K2` untyped because the mapping and the block both decide it.
+      # The blockless `[K2] (hash[_Key, K2]) -> Hash[K | K2, V]` leaves `K2` unbound too. rbs 3.x declares no
+      # mapping overload at all; `data/core_overlay/hash_rbs3.rbs` supplies rbs 4.2's on that line, with the same gaps.
+      # This tier answers ahead of both, so the forms it accepts get one answer on either RBS line.
+      #
+      # A mapping the analysis cannot read contributes a `Dynamic[top]` key arm instead of nothing. That covers an
+      # untyped argument, a `to_hash`-convertible object, a Hash subclass, the unlisted entries of an open shape,
+      # and an empty closed shape, which is what a mapping filled through an alias the engine does not track still
+      # reads as. A block the call carries but the block pass could not type contributes `Dynamic[top]` too. A
+      # literal with a `**splat` entry needs no arm of its own: its type joins the splatted hash's pairs and a
+      # `Dynamic[top]` arm, which also keeps a copy the code writes into (`m = { **o }; m[:b] = :w`) growing. A
+      # non-empty shape filled through an alias still reads narrower than it is: that is a gap in the binding's
+      # own type.
+      #
+      # Declines, leaving the RBS answer, when:
+      #
+      # - the method is not `transform_keys`. `transform_keys!` returns `self` and stays with RBS.
+      # - the argument count is not one, or is unknown with no block. A `*splat`, a forwarded `...`, or a lone
+      #   `**splat` may pass no argument, and with no block that call answers an `Enumerator`. With a block, the
+      #   call is the block form or the mapping form, and a `Dynamic[top]` mapping arm covers both.
+      # - a receiver member is not a `Hash` carrier: a `HashShape` other than the empty closed one, a `Hash`
+      #   nominal, or a difference over one (`non-empty-hash[K, V]`). A subclass may override the method
+      #   (`ActiveSupport::HashWithIndifferentAccess` does), and an empty closed shape answers `{}` whatever the
+      #   mapping says.
+      module HashTransformKeysFolding
+        module_function
+
+        def try_dispatch(context)
+          return nil unless context.method_name == :transform_keys
+
+          block = block_arm(context)
+          renamed = mapping_arm(context, block)
+          return nil if renamed.nil?
+
+          receiver = context.receiver
+          members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+          answers = members.map { |member| answer_for(member, renamed, block) }
+          return nil if answers.any?(&:nil?)
+
+          Type::Combinator.union(*answers)
+        end
+
+        # The mapping form's block parameter: the receiver's key type, as rbs 4.2's `{ (K old_key) -> K2 }`
+        # declares it, and as `data/core_overlay/hash_rbs3.rbs` restates it on the rbs 3.x line. The RBS probe
+        # does not bind it for a union of receiver shapes. Reached through {IteratorDispatch.block_param_types};
+        # nil falls through to the RBS probe.
+        def block_param_types(context)
+          return nil unless context.args.size == 1
+
+          receiver = context.receiver
+          members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+          keys = members.map { |member| receiver_key_value(member)&.first }
+          return nil if keys.any?(&:nil?)
+
+          [Type::Combinator.union(*keys)]
+        end
+
+        # `Hash[unmapped | renamed, V]` for one receiver member, or nil when the member is not a `Hash` carrier.
+        def answer_for(receiver, renamed, block)
+          key_value = receiver_key_value(receiver)
+          return nil if key_value.nil?
+
+          key, value = key_value
+          new_key = Type::Combinator.union(block || key, renamed)
+          Type::Combinator.nominal_of("Hash", type_args: [new_key, value])
+        end
+
+        # The receiver's `[K, V]`, projected the way {RbsDispatch} projects a shape, or nil when the receiver
+        # is not a `Hash` carrier. An open shape may hold entries it does not list, so its key and value take
+        # a `Dynamic[top]` arm.
+        def receiver_key_value(receiver)
+          case receiver
+          when Type::HashShape then shape_key_value(receiver)
+          when Type::Nominal then nominal_key_value(receiver)
+          when Type::Difference then receiver_key_value(receiver.base)
+          end
+        end
+
+        def shape_key_value(shape)
+          return nil if shape.pairs.empty? && shape.closed?
+
+          key = Type::Combinator.union(*shape.pairs.keys.map { |k| Type::Combinator.constant_of(k) })
+          value = Type::Combinator.union(*shape.pairs.values)
+          return [key, value] if shape.closed?
+
+          [Type::Combinator.union(key, unknown), Type::Combinator.union(value, unknown)]
+        end
+
+        def nominal_key_value(nominal)
+          return nil unless nominal.class_name == "Hash"
+          return [unknown, unknown] unless nominal.type_args.size == 2
+
+          nominal.type_args
+        end
+
+        # The new keys the mapping supplies, or nil when the call is not one this tier answers (see the module
+        # comment for the argument-count rule).
+        def mapping_arm(context, block)
+          arguments = argument_nodes(context.call_node)
+          return block.nil? ? nil : unknown if unresolved_argument_count?(arguments)
+          return nil unless context.args.size == 1
+
+          mapping_value_type(context.args.first)
+        end
+
+        # The mapping's value type. Anything whose value type cannot be read contributes `Dynamic[top]`,
+        # including a member that is not a Hash at all (`to_hash` may still convert it, and a `TypeError` for one
+        # that cannot is not this tier's to report).
+        def mapping_value_type(mapping)
+          case mapping
+          when Type::HashShape then shape_value_type(mapping)
+          when Type::Nominal then nominal_value_type(mapping)
+          when Type::Difference then mapping_value_type(mapping.base)
+          when Type::Union then Type::Combinator.union(*mapping.members.map { |member| mapping_value_type(member) })
+          else unknown
+          end
+        end
+
+        # An empty closed shape contributes `Dynamic[top]`, not `bot`: the engine records no aliasing, so
+        # `m = {}; m.tap { |x| x[:a] = :z }` still reads `{}` after the store, and a `bot` arm would drop `:z`.
+        # A non-empty shape filled through an alias has the same gap, which this rule does not close.
+        def shape_value_type(shape)
+          return unknown if shape.pairs.empty? && shape.closed?
+
+          value = Type::Combinator.union(*shape.pairs.values)
+          shape.closed? ? value : Type::Combinator.union(value, unknown)
+        end
+
+        def nominal_value_type(nominal)
+          return unknown unless nominal.class_name == "Hash" && nominal.type_args.size == 2
+
+          nominal.type_args[1]
+        end
+
+        # The block's return type; `Dynamic[top]` when the call carries a block the block pass left untyped (it
+        # rescues to nil); nil when there is no block, so the unmapped keys keep the receiver's key type. `&nil`
+        # passes no block, whatever type the block pass gave it.
+        def block_arm(context)
+          block_node = context.call_node.is_a?(Prism::CallNode) ? context.call_node.block : nil
+          return nil if block_node.is_a?(Prism::BlockArgumentNode) && block_node.expression.is_a?(Prism::NilNode)
+          return context.block_type if context.block_type
+
+          block_node ? unknown : nil
+        end
+
+        # The call's argument nodes, or an empty list for a nil or non-call node (an internal caller, whose
+        # argument types are authoritative).
+        def argument_nodes(call_node)
+          return EMPTY_ARGUMENTS unless call_node.is_a?(Prism::CallNode)
+
+          call_node.arguments&.arguments || EMPTY_ARGUMENTS
+        end
+
+        EMPTY_ARGUMENTS = [].freeze
+        private_constant :EMPTY_ARGUMENTS
+
+        # A `*splat`, a forwarded `...`, or keyword arguments made only of `**splat` entries: each may pass no
+        # argument at all (`transform_keys(**{})` passes none), so whether there is a mapping is not static.
+        def unresolved_argument_count?(arguments)
+          arguments.any? do |argument|
+            case argument
+            when Prism::SplatNode, Prism::ForwardingArgumentsNode then true
+            when Prism::KeywordHashNode then argument.elements.all?(Prism::AssocSplatNode)
+            else false
+            end
+          end
+        end
+
+        def unknown
+          Type::Combinator.untyped
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative "../../type"
 require_relative "singleton_folding"
+require_relative "hash_transform_keys_folding"
 
 module Rigor
   module Inference
@@ -22,6 +23,8 @@ module Rigor
       #   bound from the argument.
       # - `a.downto(b) { |i| … }` yields the same domain `[b, a]`, just iterated in reverse. Lower bound
       #   from the argument, upper bound from the receiver.
+      # - `h.transform_keys(mapping) { |k| … }` yields the receiver's keys, a rule the RBS probe does not state for
+      #   a union of receiver shapes ({HashTransformKeysFolding.block_param_types}).
       module IteratorDispatch
         module_function
 
@@ -41,6 +44,7 @@ module Rigor
           when :group_by, :partition then single_element_block_params(receiver)
           when :each_slice, :each_cons then slice_block_params(receiver)
           when :new then class_new_block_params(receiver, args)
+          when :transform_keys then HashTransformKeysFolding.block_param_types(context)
           end
         end
 

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "regexp_folding"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #1381 — slice reads of the proven `$~`. On a proven-match edge the flow engine narrows `$~` to
+      # `MatchData` and each unconditional group's `$N` to `String` (see `Narrowing#regex_match_predicate_scopes`).
+      # The Integer overload of RBS `MatchData#[]` already reads `String`, but the Range and `(start, length)`
+      # overloads and `values_at` read `Array[String?]`, and destructuring that binds every slot `String?`.
+      # This tier answers those reads with a Tuple, one slot per group, using the rule
+      # {RegexpFolding.fold_last_match_group} applies to `Regexp.last_match(N)`: `String` when `$N` is bound,
+      # `String?` when it is not (an optional or alternation-reachable group is nil on a successful match).
+      # Index 0 is the whole match, always a `String`.
+      #
+      # Supported, all with compile-time constant Integer arguments:
+      #
+      # * `$~[a..b]` / `$~[a...b]`
+      # * `$~[start, length]`
+      # * `$~.values_at(i, j, ...)`
+      #
+      # The receiver must be the `$~` read itself or a no-argument `Regexp.last_match`: a local MatchData carries
+      # no group facts, and the scope's `$N` describe only the frame's current match.
+      #
+      # The scope does not record the regex's group count, and a slice past the last group is shorter than the
+      # range asked for (`$~[1..3]` on a one-group match is `["x"]`) while `values_at` pads with nil. The highest
+      # bound `$K` is a lower bound on the count — `Scope#join_bindings` keeps a key only when both sides bind
+      # it — so every index must be at most K. Declines (RBS answers) when:
+      #
+      # - `$~` is not proven non-nil, or no scope is threaded through,
+      # - no `$1`..`$9` narrows to `String` (every group optional, no group at all, `when /a/, /b/`),
+      # - any index is above K, negative, or not a constant Integer, or a Range bound is nil (endless /
+      #   beginless),
+      # - the slice is empty.
+      #
+      # K is read from `$1`..`$9` only: `Scope#forget_match_globals` does not clear `$10` and above (#1384), so a
+      # binding there may belong to an earlier match.
+      module MatchDataFolding
+        MAX_GROUP_GLOBAL = 9
+        private_constant :MAX_GROUP_GLOBAL
+
+        module_function
+
+        # @return folded Tuple, or nil to defer.
+        def try_dispatch(context)
+          receiver = context.receiver
+          return nil unless receiver.is_a?(Type::Nominal) && receiver.class_name == "MatchData"
+
+          scope = context.scope
+          return nil if scope.nil?
+          return nil unless last_match_read?(context.call_node, scope)
+          return nil unless RegexpFolding.proven_match?(scope.global(:$~))
+
+          highest = highest_bound_group(scope)
+          return nil if highest.nil?
+
+          indices = slot_indices(context.method_name, context.args, highest)
+          return nil if indices.nil?
+
+          Type::Combinator.tuple_of(*indices.map { |index| slot_type(index, scope) })
+        end
+
+        # The receiver expression reads the frame's current match: `$~`, or `last_match` with no arguments and no block
+        # on an expression that types as the core `Regexp` class. A project class that happens to be named `Regexp`
+        # (`Foo::Regexp` read as `Regexp` inside `module Foo`) types as its own singleton and does not count.
+        def last_match_read?(call_node, scope)
+          return false unless call_node.is_a?(Prism::CallNode)
+
+          receiver = call_node.receiver
+          case receiver
+          when Prism::GlobalVariableReadNode
+            receiver.name == :$~
+          when Prism::CallNode
+            receiver.name == :last_match && receiver.arguments.nil? && receiver.block.nil? &&
+              regexp_class?(receiver.receiver, scope)
+          else
+            false
+          end
+        end
+
+        def regexp_class?(node, scope)
+          return false if node.nil?
+
+          type = scope.type_of(node)
+          type.is_a?(Type::Singleton) && type.class_name == "Regexp"
+        end
+
+        # The highest N in 1..9 whose `$N` is narrowed to `String`, or nil when none is.
+        def highest_bound_group(scope)
+          MAX_GROUP_GLOBAL.downto(1).find { |index| string_global?(scope.global(:"$#{index}")) }
+        end
+
+        def string_global?(type)
+          type.is_a?(Type::Nominal) && type.class_name == "String"
+        end
+
+        # The group indices the call reads, in result order, or nil when the call shape is not folded or any index
+        # falls outside `0..highest`.
+        def slot_indices(method_name, args, highest)
+          indices =
+            case method_name
+            when :[] then index_slice(args)
+            when :values_at then values_at_indices(args)
+            end
+          return nil if indices.nil? || indices.none?
+          return nil unless indices.all? { |index| index.between?(0, highest) }
+
+          indices.to_a
+        end
+
+        # `[range]` or `[start, length]`. A single Integer index is left to RBS, which already reads `String`.
+        def index_slice(args)
+          case args.size
+          when 1 then range_indices(args.first)
+          when 2 then start_length_indices(*args)
+          end
+        end
+
+        def range_indices(arg)
+          range = constant_value(arg)
+          return nil unless range.is_a?(Range)
+
+          first = range.begin
+          last = range.end
+          return nil unless first.is_a?(Integer) && last.is_a?(Integer)
+          return nil if first.negative? || last.negative?
+
+          range
+        end
+
+        def start_length_indices(start_arg, length_arg)
+          start = constant_value(start_arg)
+          length = constant_value(length_arg)
+          return nil unless start.is_a?(Integer) && length.is_a?(Integer)
+          return nil if start.negative? || length.negative?
+
+          start...(start + length)
+        end
+
+        def values_at_indices(args)
+          indices = args.map { |arg| constant_value(arg) }
+          indices.all?(Integer) ? indices : nil
+        end
+
+        def constant_value(type)
+          type.is_a?(Type::Constant) ? type.value : nil
+        end
+
+        def slot_type(index, scope)
+          return Type::Combinator.nominal_of("String") if index.zero?
+
+          RegexpFolding.fold_last_match_group(Type::Combinator.constant_of(index), scope)
+        end
+      end
+    end
+  end
+end