rigortype 0.4.1 → 0.4.3

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

@@ -243,7 +243,8 @@ module Rigor
             method_name: context.method_name,
             args: context.args,
             environment: environment,
-            scope: context.scope
+            scope: context.scope,
+            call_node: context.call_node
           )
         end
 
@@ -277,6 +278,11 @@ module Rigor
 
           def dispatch_one(receiver, method_name, args, environment, block_type, self_type_override = nil, # rubocop:disable Metrics/ParameterLists
                            public_only: false, scope: nil, call_node: nil)
+            # Issue #1794 — a sequence's inherited Enumerable surface reads its Rigor-private element argument, with
+            # `self` still the sequence.
+            element = ArithmeticSequenceElements.element_receiver(receiver, method_name, environment)
+            self_type_override ||= receiver if element
+            receiver = element || receiver
             descriptor = receiver_descriptor(receiver)
             return nil unless descriptor
 
@@ -1006,41 +1012,135 @@ module Rigor
             return override if override
 
             instance_type = Type::Combinator.nominal_of(class_name)
-            resolved_self_type =
-              case kind
-              when :singleton then Type::Combinator.singleton_of(class_name)
-              else                 instance_type
-              end
             # `self_type_override` lets the user-class fallback path preserve the ORIGINAL receiver as the
             # substitute for `Bases::Self` — so `Kernel#dup: () -> self` resolved through the Object
             # fallback returns the caller's type, not Object. `dispatch_one` also routes the receiver's
             # type-argument-bearing projection through it ({SelfSubstitute}, #1092).
-            self_type = self_type_override || resolved_self_type
+            self_type = self_type_override ||
+                        (kind == :singleton ? Type::Combinator.singleton_of(class_name) : instance_type)
+
+            keywords_last = ArgumentNodes.keyword_hash_last?(call_node, args)
+            call_site = [class_name, method_name, kind]
+            if keywords_last && args.last.is_a?(Type::HashShape)
+              distributed = distributed_keyword_return(method_definition, self_type, instance_type, type_vars, args,
+                                                       block_type, scope, call_node, call_site, environment)
+              return distributed unless distributed.equal?(NOT_DISTRIBUTED)
+            end
 
             candidates = OverloadSelector.select_candidates(
               method_definition,
               arg_types: args,
+              keywords_last: keywords_last, splats: splat_indices(call_node, args),
               # A `Dynamic` self (#1092) is a return-side answer; overload selection and ReceiverAffinity
               # read the static facet, as they did before the substitute carried the wrapping.
               self_type: self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type,
-              instance_type: instance_type,
-              type_vars: type_vars,
+              instance_type: instance_type, type_vars: type_vars,
               block_required: !block_type.nil?,
               environment: environment
             )
             return nil if candidates.empty?
 
-            call_site = [class_name, method_name, kind]
             record_dispatch_provenance(method_definition, candidates.first, scope, call_node, call_site)
             join_candidate_returns(
               candidates,
               method_definition: method_definition,
               self_type: self_type, instance_type: instance_type, type_vars: type_vars,
               args: args, block_type: block_type, scope: scope, call_node: call_node, call_site: call_site,
-              alias_expander: environment.rbs_loader
+              alias_expander: environment.rbs_loader, keywords_last: keywords_last
             )
           end
 
+          # Issue #1746 — a keyword hash holding a union value (`headers: flag` with `flag : bool`) selects per member
+          # at runtime, so the return reads one overload per {KeywordArguments.distributions} list and joins their
+          # returns, as the block probe does for its parameters (#1737). Selecting once for the whole value took one
+          # member's overload (`Symbol` for `(headers: true) -> Symbol | (?headers: false) -> Integer`). Each list
+          # counts only a genuine match: a member no overload takes, or more lists than the limit, answers
+          # `Dynamic[top]` rather than lend the first-overload fallback to the join. A precise union value joins the
+          # returns as a union; a `Dynamic` value keeps the answer `Dynamic`, as the #521 join does, since the split
+          # dropped the value's `nil` and the untyped input behind it. A keyword hash with no union value answers
+          # {NOT_DISTRIBUTED}, and the call selects as before; so does one whose values do not split (#1779) and that no
+          # overload genuinely takes.
+          NOT_DISTRIBUTED = Object.new.freeze
+          private_constant :NOT_DISTRIBUTED
+
+          # rubocop:disable Metrics/ParameterLists
+          def distributed_keyword_return(method_definition, self_type, instance_type, type_vars, args, block_type,
+                                         scope, call_node, call_site, environment)
+            # rubocop:enable Metrics/ParameterLists
+            # One overload is the only one any member can select, and a wide union value (`receiver_type: Type::t`)
+            # spelled out member by member would only pass the distribution limit.
+            method_types = method_definition.method_types
+            return NOT_DISTRIBUTED if method_types.size < 2
+            # A keyword hash no overload takes as keywords is a positional `Hash` throughout (#1737).
+            return NOT_DISTRIBUTED unless KeywordArguments.any_declares?(method_types)
+
+            keywords = args.last
+            return NOT_DISTRIBUTED if keywords.pairs.none? { |_name, value| KeywordArguments.union_members(value) }
+
+            selector_self = self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type
+            per_list = distributed_keyword_matches(method_definition, args, selector_self, instance_type, type_vars,
+                                                   !block_type.nil?, environment, splat_indices(call_node, args))
+            return NOT_DISTRIBUTED if per_list.equal?(NOT_DISTRIBUTED)
+            return Type::Combinator.untyped if per_list.nil?
+
+            overloads = per_list.flat_map(&:last).uniq
+            if overloads.size == 1
+              record_dispatch_provenance(method_definition, overloads.first, scope, call_node, call_site)
+            end
+            returns = per_list.map do |arg_types, matches|
+              join_candidate_returns(
+                matches,
+                method_definition: method_definition,
+                self_type: self_type, instance_type: instance_type, type_vars: type_vars,
+                args: arg_types, block_type: block_type, scope: scope, call_node: call_node, call_site: call_site,
+                alias_expander: environment.rbs_loader, keywords_last: true
+              )
+            end
+            join_distributed_returns(returns, keywords)
+          end
+
+          # Each distribution list with its genuine matches, or nil past the distribution limit or when a list has
+          # none. When no value split (no union value's key discriminates between the overloads, #1779), the one list
+          # is the call as given, and one with no genuine match answers {NOT_DISTRIBUTED}: the call then selects as it
+          # did before #1746, first-overload fallback included (`1.step(10, by: (c ? 1 : 2.0))` is
+          # `Enumerator::ArithmeticSequence` through the incomplete stdlib RBS).
+          # rubocop:disable Metrics/ParameterLists
+          def distributed_keyword_matches(method_definition, args, selector_self, instance_type, type_vars,
+                                          block_required, environment, splats)
+            # rubocop:enable Metrics/ParameterLists
+            distributions = keyword_distributions(method_definition, args, selector_self, instance_type, type_vars,
+                                                  environment, splats)
+            return nil if distributions.nil?
+
+            distributions.map do |arg_types|
+              matches = keyword_matches(method_definition, arg_types, selector_self, instance_type, type_vars,
+                                        block_required, environment, splats)
+              return arg_types.equal?(args) ? NOT_DISTRIBUTED : nil if matches.empty?
+
+              [arg_types, matches]
+            end
+          end
+
+          def join_distributed_returns(returns, keywords)
+            return nil if returns.any?(&:nil?)
+
+            joined = Type::Combinator.union(*returns.uniq)
+            dynamic_value = keywords.pairs.any? { |_name, value| value.is_a?(Type::Dynamic) }
+            dynamic_value && !joined.is_a?(Type::Dynamic) ? Type::Combinator.dynamic(joined) : joined
+          end
+
+          # Issue #1801 — the indices of `args` the call passes as splat arguments (`f(*xs, k: 1)`), whose positional
+          # count is not known statically, or nil without one. As for {ArgumentNodes.keyword_hash_last?}, only a call
+          # whose node's arguments are exactly `args` answers.
+          def splat_indices(call_node, args)
+            return nil if args.empty? || !call_node.respond_to?(:arguments)
+
+            arguments = call_node.arguments&.arguments
+            return nil if arguments.nil? || arguments.size != args.size || arguments.none?(Prism::SplatNode)
+
+            arguments.each_index.select { |index| arguments[index].is_a?(Prism::SplatNode) }
+          end
+
           # The two provenance side-tables the return-typing tier is the last place able to populate, recorded
           # together because they share one gate (`scope` && `call_node`) and one call site.
           #
@@ -1074,10 +1174,16 @@ module Rigor
           # A candidate whose return does not translate leaves the join incomplete — decline (fail-soft
           # to Dynamic downstream) rather than answer a join missing an arm the runtime can take.
           # rubocop:disable-next Metrics/ParameterLists
+          # rubocop:disable Metrics/ParameterLists
           def join_candidate_returns(candidates, method_definition:, self_type:, instance_type:, type_vars:, args:,
-                                     block_type:, scope:, call_node:, call_site:, alias_expander: nil)
+                                     block_type:, scope:, call_node:, call_site:, alias_expander: nil,
+                                     keywords_last: false)
+            # rubocop:enable Metrics/ParameterLists
             returns = candidates.map do |method_type|
-              full_type_vars = compose_type_vars(method_type, type_vars, args, block_type, scope, call_node, call_site)
+              # An overload that takes the keyword hash as its keywords binds no positional parameter to it.
+              positional = KeywordArguments.positional(method_type, args, keywords_last)
+              full_type_vars = compose_type_vars(method_type, type_vars, args, positional, block_type, scope,
+                                                 call_node, call_site)
               returned = RbsTypeTranslator.translate(
                 method_type.type.return_type,
                 self_type: self_type,
@@ -1087,7 +1193,7 @@ module Rigor
               )
               next returned unless combining_overload?(method_definition, method_type, call_site)
 
-              class_level_sum(returned, method_type, args)
+              class_level_sum(returned, method_type, positional)
             end
             return returns.first if returns.size == 1
             return nil if returns.any?(&:nil?)
@@ -1098,11 +1204,17 @@ module Rigor
             Type::Combinator.dynamic(Type::Combinator.union(*distinct))
           end
 
-          def compose_type_vars(method_type, type_vars, args, block_type, scope, call_node, call_site)
+          # `positional` is `args` less a keyword hash the overload takes as its keywords (#1727). The block-return
+          # rule reads every argument, the keyword hash included: a keyword parameter naming the block's variable
+          # (`[T] (?default: T) { () -> T } -> T`) is an argument reaching it. The positional binding reads only the
+          # arguments that land in positional parameters.
+          # rubocop:disable Metrics/ParameterLists
+          def compose_type_vars(method_type, type_vars, args, positional, block_type, scope, call_node, call_site)
+            # rubocop:enable Metrics/ParameterLists
             vars = compose_block_type_vars(method_type, type_vars, block_type, args,
                                            scope: scope, call_node: call_node, call_site: call_site)
-            compose_arg_type_vars(method_type, vars, args, scope: scope, call_node: call_node,
-                                                           call_site: call_site)
+            compose_arg_type_vars(method_type, vars, positional, scope: scope, call_node: call_node,
+                                                                 call_site: call_site)
           end
 
           # Whether the overload is one `Enumerable` declares for `sum`, whose declared return the tier reads
@@ -1268,7 +1380,8 @@ module Rigor
           # Whether an argument the call passes may land in a parameter whose type names `name`, anywhere
           # inside it (`hash[_Key, K2]` names `K2`). The argument count is not matched against the
           # parameter list: a `*splat` argument stands for any number of arguments, and keyword arguments
-          # arrive as one more entry in `args`, so any argument counts as reaching every parameter.
+          # arrive as one more entry in `args` (untrimmed, #1727), so any argument counts as reaching every
+          # parameter.
           def argument_reaches_variable?(method_type, name, args)
             return false if args.empty?
 
@@ -1602,11 +1715,15 @@ module Rigor
 
           # ----- block parameter probe (Phase C sub-phase 1) -----
 
-          def probe_block_param_types(receiver:, method_name:, args:, environment:, scope: nil)
+          def probe_block_param_types(receiver:, method_name:, args:, environment:, scope: nil, call_node: nil)
             args ||= []
+            keywords_last = ArgumentNodes.keyword_hash_last?(call_node, args)
+            splat = splat_indices(call_node, args)
             case receiver
-            when Type::Union then probe_block_param_types_union(receiver, method_name, args, environment, scope)
-            else                  probe_block_param_types_one(receiver, method_name, args, environment, scope)
+            when Type::Union
+              probe_block_param_types_union(receiver, method_name, args, environment, scope, keywords_last, splat)
+            else
+              probe_block_param_types_one(receiver, method_name, args, environment, scope, keywords_last, splat)
             end
           end
 
@@ -1614,9 +1731,9 @@ module Rigor
           # member resolves the same arity and types (otherwise the call sites would have to thread
           # per-member binders, which the slice does not support yet). Mismatches degrade to the empty
           # array so the binder defaults all params to Dynamic[Top].
-          def probe_block_param_types_union(receiver, method_name, args, environment, scope)
+          def probe_block_param_types_union(receiver, method_name, args, environment, scope, keywords_last, splat)
             results = receiver.members.map do |member|
-              probe_block_param_types_one(member, method_name, args, environment, scope)
+              probe_block_param_types_one(member, method_name, args, environment, scope, keywords_last, splat)
             end
             return [] if results.empty?
             return [] unless results.all? { |r| r == results.first }
@@ -1624,7 +1741,9 @@ module Rigor
             results.first
           end
 
-          def probe_block_param_types_one(receiver, method_name, args, environment, scope)
+          def probe_block_param_types_one(receiver, method_name, args, environment, scope, keywords_last, splat)
+            receiver = ArithmeticSequenceElements.element_receiver(receiver, method_name, environment, block: true) ||
+                       receiver
             descriptor = receiver_descriptor(receiver)
             return [] unless descriptor
 
@@ -1642,7 +1761,8 @@ module Rigor
               environment: environment,
               receiver: receiver,
               receiver_args: receiver_args,
-              method_name: method_name
+              method_name: method_name,
+              keywords_last: keywords_last, positional_splat: splat
             )
           rescue StandardError
             []
@@ -1651,7 +1771,7 @@ module Rigor
           # rubocop:disable Metrics/ParameterLists
           def extract_block_param_types(method_definition, class_name:, kind:, args:, type_vars:,
                                         environment: nil, receiver: nil, receiver_args: [],
-                                        method_name: nil)
+                                        method_name: nil, keywords_last: false, positional_splat: nil)
             # rubocop:enable Metrics/ParameterLists
             instance_type = Type::Combinator.nominal_of(class_name)
             self_type =
@@ -1672,12 +1792,25 @@ module Rigor
             substitute = SelfSubstitute.for(receiver, receiver_args, method_name, args, nil)
             self_type = Type::Combinator.nominal_of(class_name, type_args: receiver_args) if substitute
 
+            selector_self = self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type
+            if keywords_last
+              return agreed_keyword_block_params(method_definition, args, self_type, selector_self, instance_type,
+                                                 type_vars, environment, positional_splat)
+            end
+
+            # A splat (#1801) leaves the positional count open, so every overload some count reaches must agree.
+            if positional_splat || FacetDistribution.faceted?(args)
+              matches = facet_matches(method_definition, args, selector_self, instance_type, type_vars, true,
+                                      environment, false, positional_splat)
+              return agreed_block_params(matches, self_type, instance_type, type_vars, environment)
+            end
+
             method_type = OverloadSelector.select(
               method_definition,
               arg_types: args,
               # Overload selection reads a `Dynamic` self's static facet, mirroring the return path;
               # the substitution verdict here is built from the receiver's type arguments alone.
-              self_type: self_type.is_a?(Type::Dynamic) ? self_type.static_facet : self_type,
+              self_type: selector_self,
               instance_type: instance_type,
               type_vars: type_vars,
               block_required: true,
@@ -1685,8 +1818,20 @@ module Rigor
             )
             return [] unless method_type
 
+            block_params_of(method_type, self_type, instance_type, type_vars, environment) || []
+          end
+
+          # The block parameters every overload in `matches` declares alike, or no information (`[]`).
+          def agreed_block_params(matches, self_type, instance_type, type_vars, environment)
+            answers = matches.uniq.map do |method_type|
+              block_params_of(method_type, self_type, instance_type, type_vars, environment)
+            end
+            answers.uniq.size == 1 && answers.first ? answers.first : []
+          end
+
+          def block_params_of(method_type, self_type, instance_type, type_vars, environment)
             block = method_type.respond_to?(:block) ? method_type.block : nil
-            return [] unless block
+            return nil unless block
 
             translate_block_positional_params(
               block,
@@ -1697,6 +1842,80 @@ module Rigor
             )
           end
 
+          # {KeywordArguments.distributions} for the call's keyword hash. An overload that declares no keywords may read
+          # the hash as a positional `Hash`, and then every union value splits: with
+          # `(a: Integer) -> Integer | (Hash[Symbol, String]) -> String`, `a: Integer | String`'s `String` member takes
+          # the second overload and its `Integer` member the first. A parameter that cannot take a `Hash` (`(String)`)
+          # leaves the split to the keyword declarations.
+          # `splats`: a splat argument hides how many positional arguments precede the hash.
+          def keyword_distributions(method_definition, args, selector_self, instance_type, type_vars, environment,
+                                    splats)
+            hash = Type::Combinator.nominal_of("Hash")
+            count = splats ? nil : args.size
+            KeywordArguments.distributions(args, true, method_definition.method_types, count) do |param|
+              param_type = RbsTypeTranslator.translate(
+                param.type, self_type: selector_self, instance_type: instance_type, type_vars: type_vars,
+                            alias_expander: environment.rbs_loader
+              )
+              !param_type.accepts(hash, mode: :gradual).no?
+            end
+          end
+
+          # rubocop:disable Metrics/ParameterLists
+          def agreed_keyword_block_params(method_definition, args, self_type, selector_self, instance_type, type_vars,
+                                          environment, splats)
+            # rubocop:enable Metrics/ParameterLists
+            distributions = keyword_distributions(method_definition, args, selector_self, instance_type, type_vars,
+                                                  environment, splats)
+            return [] if distributions.nil?
+
+            candidates = []
+            distributions.each do |arg_types|
+              # Genuine matches only (`member` true): a member no overload takes must not lend the first-overload
+              # fallback to the agreement, which bound `headers: (true | nil)`'s block to the `true` arm.
+              matches = keyword_matches(method_definition, arg_types, selector_self, instance_type, type_vars, true,
+                                        environment, splats)
+              return [] if matches.empty?
+
+              candidates.concat(matches)
+            end
+            agreed_block_params(candidates, self_type, instance_type, type_vars, environment)
+          end
+
+          # One distribution's genuine matches. A faceted positional argument (a `Dynamic` with sealed facet members) is
+          # read member-wise as `OverloadSelector.select_candidates` reads it, but every list answers only a genuine
+          # match: the first-overload fallback must not count toward the block probe's agreement or the return path's
+          # join.
+          # rubocop:disable Metrics/ParameterLists
+          def keyword_matches(method_definition, arg_types, selector_self, instance_type, type_vars, block_required,
+                              environment, splats)
+            # rubocop:enable Metrics/ParameterLists
+            unless FacetDistribution.faceted?(arg_types)
+              return OverloadSelector.select_declared(method_definition, arg_types, selector_self, instance_type,
+                                                      type_vars, block_required, environment, true, true, splats)
+            end
+
+            facet_matches(method_definition, arg_types, selector_self, instance_type, type_vars, block_required,
+                          environment, true, splats)
+          end
+
+          # Issue #1750 — the overloads a faceted argument list may reach, read member-wise with genuine matches only.
+          # Where `FacetDistribution.select` falls back to the arguments as given (overloads not provable, more lists
+          # than its cap, or a member no overload takes), the bare `Dynamic` gradually matches every arm and the
+          # strict pass's pick is the first by position, so the answer is every gradual match
+          # (`OverloadSelector.select_declared`'s `:gradual`) and the caller binds only what they all agree on.
+          # rubocop:disable Metrics/ParameterLists
+          def facet_matches(method_definition, arg_types, selector_self, instance_type, type_vars, block_required,
+                            environment, keywords_last, splats = nil)
+            # rubocop:enable Metrics/ParameterLists
+            FacetDistribution.select(arg_types, method_definition, member_wise: true, environment:) do |list, member|
+              # The fallback list (`member` false) answers every gradual match rather than the strict pass's pick.
+              OverloadSelector.select_declared(method_definition, list, selector_self, instance_type, type_vars,
+                                               block_required, environment, member || :gradual, keywords_last,
+                                               splats)
+            end
+          end
+
           # `RBS::Types::Block#type` is normally an `RBS::Types::Function` carrying the block's parameter
           # list; some signatures use `RBS::Types::UntypedFunction` (a `(?)` block) which exposes no
           # parameter types -- we treat it as "no information" and return an empty array so the binder

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # How `OverloadSelector` reads a call whose positional arguments include a splat (`f(*xs, a: v)`), #1801.
+      #
+      # A splat stands for any number of arguments, so the call's positional count is not known statically. The
+      # selector sees each splat as one untyped entry of the argument list, and counted that way it ruled out every
+      # overload whose arity the splat may still meet: `ph(*xs, a: "s")` skipped `(Hash[Symbol, String]) -> String`,
+      # which takes `{ a: "s" }` when `xs` is empty (`def ph(h) = h; ph(*[], a: "s")` is `{ a: "s" }`). Instead, an
+      # overload matches when some count of the splats' elements fits its arity and every argument, the splats'
+      # untyped elements included, is accepted at the parameter that count binds it to.
+      module SplatArity
+        # The most argument lists {.expansions} spells out; past it, the selector only asks that every other argument
+        # fit some positional parameter of the overload.
+        LIMIT = 32
+        private_constant :LIMIT
+
+        module_function
+
+        # The argument lists `arg_types` stands for against `fun`, each splat entry (at `splats`, indices into
+        # `arg_types`) repeated as often as `fun`'s positional parameters can take, from none upward; nil past
+        # {LIMIT}. An untyped `(?)` parameter list takes any count, so the list as given stands for all of them.
+        def expansions(fun, arg_types, splats)
+          return [arg_types] unless fun.respond_to?(:required_positionals)
+
+          indices = splats.select { |index| index < arg_types.size }
+          return [arg_types] if indices.empty?
+
+          bound = element_bound(fun, arg_types.size - indices.size)
+          counts = counts(indices.size, bound)
+          return nil if counts.nil?
+
+          counts.map { |count| expand(arg_types, indices, count) }
+        end
+
+        # The most splat elements a call with `fixed` other positional arguments can pass to `fun`: up to its maximum
+        # arity, or, with a `*rest`, one past filling every other parameter, since further elements land in the rest
+        # parameter alike.
+        def element_bound(fun, fixed)
+          declared = fun.required_positionals.size + fun.optional_positionals.size + fun.trailing_positionals.size
+          return declared + 1 if fun.rest_positionals
+
+          [declared - fixed, 0].max
+        end
+
+        # Every way to give `splats` splats at most `bound` elements in all, or nil past {LIMIT}.
+        def counts(splats, bound)
+          combinations = [[]]
+          splats.times do
+            combinations = combinations.flat_map do |partial|
+              (0..(bound - partial.sum)).map { |count| partial + [count] }
+            end
+            return nil if combinations.size > LIMIT
+          end
+          combinations
+        end
+
+        def expand(arg_types, indices, counts)
+          expanded = []
+          arg_types.each_with_index do |arg, index|
+            position = indices.index(index)
+            position ? expanded.concat([arg] * counts[position]) : expanded << arg
+          end
+          expanded
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,7 @@ module Rigor
       #    `StructInstance`, the member map built from the call's arguments (positional or keyword per the
       #    class's `keyword_init`). A form / arity mismatch degrades to `Dynamic[top]` rather than a wrong
       #    member map. `.members` on the class folds.
-      # 3. member reads + `[]` / `to_h` / `deconstruct` / `deconstruct_keys` / `members` / `with` on a
+      # 3. member reads + `[]` / `to_h` / `deconstruct` / `deconstruct_keys` / `members` on a
       #    *fresh* `StructInstance` -> the precise projected type; member *setters* (`s.x = v`) return the
       #    assigned value type. Unhandled / stored-receiver calls return nil so the pipeline projects the
       #    instance to its nominal through RbsDispatch.
@@ -38,8 +38,9 @@ module Rigor
       module StructFolding
         module_function
 
-        # The `[]` / `to_h` / `deconstruct` / `members` / `with` projections
+        # The `[]` / `to_h` / `deconstruct` / `members` projections
         # and the reader-redefinition guard are shared with {DataFolding}.
+        # `Struct` has no `#with` (issue #1335): that projection stays on {DataFolding} only.
         extend MemberShapeProjection
 
         # Issue #595 / #525 — the shared materialisation test; see {StructMaterialization}.
@@ -239,10 +240,6 @@ module Rigor
           when :deconstruct then instance_deconstruct(instance)
           when :deconstruct_keys then instance_deconstruct_keys(instance, args)
           when :members then instance_members(instance)
-          when :with
-            instance_with(instance, args) do |members, class_name|
-              Type::Combinator.struct_instance_of(members: members, class_name: class_name)
-            end
           end
         end
 
@@ -332,7 +329,7 @@ module Rigor
           node = context.call_node
           return false if node.nil?
 
-          materialization_call?(node.receiver, context.receiver, context.scope)
+          materialization_call?(node.receiver, context.scope)
         end
 
         # ADR-48 slice 4 — precise mutated-member re-typing. After a `local.member = v` setter on a

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

@@ -34,18 +34,20 @@ module Rigor
         # Issue #595 / #525 — the ONE materialisation test. Both places that must answer "was this receiver
         # expression's struct newly built?" go through it: this module's direct member-read gate above, and
         # `ExpressionTyper`'s caller-side `:self`-grant arm. They had forked answers once (the grant arm was
-        # tightened for #591 while this one still trusted any chained call), which is exactly how the
-        # composed `x.dup_self.with(indent: 9).shout` shape survived — a correctly whitelisted `.with` fold
-        # firing off a receiver the other gate should never have called fresh.
+        # tightened for #591 while this one still trusted any chained call), so both consumers must share this
+        # one answer. A `.with` call is never a materialisation: the composed `x.dup_self.with(indent: 9)`
+        # shape once slipped through as one, and `Struct#with` no longer exists to fold (#1335).
         #
         # @param node — the receiver EXPRESSION.
-        # @param receiver — the carrier the expression produced.
-        def materialization_call?(node, receiver, scope)
+        # @param scope — the scope the factory and ancestor lookups resolve against.
+        def materialization_call?(node, scope)
           return false unless node.is_a?(Prism::CallNode)
 
           case node.name
           when :new, :[] then struct_class_expression?(node.receiver, scope)
-          when :with then !hand_written_with?(receiver, scope)
+          # `Struct` has no `#with` (#1335), so a `.with` call is never a materialisation here; `Data#with` is
+          # a frozen copy and needs no freshness gate.
+          when :with then false
           else fresh_factory_call?(node, scope)
           end
         end
@@ -127,26 +129,6 @@ module Rigor
           found
         end
 
-        # `.with` copies the receiver into a new instance — unless the struct wrote its own, which is free to
-        # return `self` and would reopen the very hole above.
-        #
-        # An ANONYMOUS carrier cannot have one: a `StructInstance` with no class name came from a blockless
-        # `Struct.new(…)` (the block form defers in {fold_struct_new} before any instance exists), and a
-        # blockless factory defines nothing but the generated accessors. So it is the NAMED carriers that
-        # need the lookup — and a named one with no scope to ask refuses, since unproven is not fresh.
-        def hand_written_with?(receiver, scope)
-          return true unless receiver.is_a?(Type::StructInstance)
-
-          class_name = receiver.class_name
-          return false if class_name.nil?
-          return true if scope.nil?
-
-          # The ANCESTOR walk, not the own-class table: a `with` contributed by an included module is just as
-          # free to return `self`. Both consumers reach the identical answer because there is one lookup here
-          # rather than a parameter each of them supplies (#598 review).
-          !scope.user_def_through_ancestors(class_name, :with).first.nil?
-        end
-
         # An expression naming the struct class itself. All three definition forms ADR-48 supports qualify,
         # because each of them really does construct: a constant whose member layout the project side-table
         # recorded (`Point.new(…)`), a local holding a `StructClass` carrier (`c = Struct.new(:x, :y)` then

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #1357 — `Kernel#Rational(x, 1)` converts its argument. CRuby's `nurat_convert` returns a
+      # `Rational` for a `Float` / `Integer` / `Rational` / `String`-free numerator and for a `BigDecimal` (which
+      # has `to_r`; NaN and Infinity raise). A `Complex` is unwrapped only when its imaginary part is an exact
+      # zero, otherwise `a / 1` comes back, a `Complex`, so a `Complex` numerator answers `Rational | Complex`.
+      # The core RBS spells the `1`-denominator form `[T < Numeric] (T value, 1) -> T`, which binds `T` to the
+      # argument's own class and read `Rational(f, 1)` as a `Float`. Any other numerator (a user `Numeric`
+      # without `to_r`) keeps the RBS answer.
+      module UnitDenominatorRational
+        module_function
+
+        CONVERTING = Set["Float", "Integer", "Rational", "BigDecimal"].freeze
+        private_constant :CONVERTING
+
+        # Answers `Rational` (or `Rational | Complex`), or nil when the call is not the unit-denominator form.
+        def answer(method_name, args)
+          return nil unless method_name == :Rational && args.size.between?(2, 3)
+          return nil if args.size == 3 && !exception_keyword?(args[2])
+
+          denominator = args[1]
+          return nil unless denominator.is_a?(Type::Constant) && denominator.value.eql?(1)
+
+          classes = numerator_classes(args.first)
+          return nil if classes.nil?
+
+          members = [Type::Combinator.nominal_of("Rational")]
+          members << Type::Combinator.nominal_of("Complex") if classes.include?(:complex)
+          Type::Combinator.union(*members)
+        end
+
+        # The trailing `exception:` keyword hash: a `HashShape` whose only key is `:exception`. Its value
+        # does not change the answer (a Float that cannot convert raises either way).
+        def exception_keyword?(type)
+          type.is_a?(Type::HashShape) && type.pairs.keys == [:exception]
+        end
+
+        # `[:converting]`, `[:complex]` or both for a recognised numerator; nil when any member is unknown.
+        def numerator_classes(type)
+          case type
+          when Type::Union then union_classes(type)
+          when Type::IntegerRange then [:converting]
+          when Type::Refined then type.base.is_a?(Type::Nominal) ? numerator_classes(type.base) : nil
+          when Type::Constant then class_kind(type.value.class.name)
+          when Type::Nominal then type.type_args.empty? ? class_kind(type.class_name) : nil
+          end
+        end
+
+        def union_classes(union)
+          kinds = union.members.map { |member| numerator_classes(member) }
+          kinds.any?(&:nil?) ? nil : kinds.flatten.uniq
+        end
+
+        def class_kind(name)
+          return [:complex] if name == "Complex"
+
+          CONVERTING.include?(name) ? [:converting] : nil
+        end
+      end
+    end
+  end
+end