rigortype 0.4.2 → 0.4.4

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

@@ -1019,7 +1019,7 @@ module Rigor
             self_type = self_type_override ||
                         (kind == :singleton ? Type::Combinator.singleton_of(class_name) : instance_type)
 
-            keywords_last = keyword_arguments_last?(call_node, args)
+            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,
@@ -1129,21 +1129,9 @@ module Rigor
             dynamic_value && !joined.is_a?(Type::Dynamic) ? Type::Combinator.dynamic(joined) : joined
           end
 
-          # Issue #1727 — whether `args`' last entry is the call's keyword hash (`f(a, k: 1)`), which the overload
-          # selector then matches against an overload's keywords. Only the AST tells a keyword hash from a
-          # braced positional one (`f(a, { k: 1 })`), so a dispatch without the call node, or one whose
-          # arguments are not the node's own (a forwarded `...`, a `send` re-dispatch), answers false and keeps
-          # reading every argument positionally.
-          def keyword_arguments_last?(call_node, args)
-            return false if args.empty? || !call_node.respond_to?(:arguments)
-
-            arguments = call_node.arguments&.arguments
-            !arguments.nil? && arguments.size == args.size && arguments.last.is_a?(Prism::KeywordHashNode)
-          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 {#keyword_arguments_last?}, only a call whose
-          # node's arguments are exactly `args` answers.
+          # 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)
 
@@ -1729,7 +1717,7 @@ module Rigor
 
           def probe_block_param_types(receiver:, method_name:, args:, environment:, scope: nil, call_node: nil)
             args ||= []
-            keywords_last = keyword_arguments_last?(call_node, args)
+            keywords_last = ArgumentNodes.keyword_hash_last?(call_node, args)
             splat = splat_indices(call_node, args)
             case receiver
             when Type::Union

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

data/lib/rigor/inference/method_dispatcher.rb

@@ -11,6 +11,7 @@ require_relative "dynamic_origin"
 require_relative "flow_tracer"
 require_relative "void_tail_summary"
 require_relative "method_dispatcher/call_context"
+require_relative "method_dispatcher/argument_nodes"
 require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/literal_string_folding"
 require_relative "method_dispatcher/shape_dispatch"
@@ -39,6 +40,7 @@ require_relative "method_dispatcher/kernel_dispatch"
 require_relative "method_dispatcher/universal_object_dispatch"
 require_relative "method_dispatcher/singleton_mixin_dispatch"
 require_relative "method_dispatcher/method_folding"
+require_relative "method_dispatcher/optional_count"
 
 module Rigor
   module Inference
@@ -105,6 +107,16 @@ module Rigor
                   call_node: nil, scope: nil, plugin_typed_sink: nil, skip_project_patched: false)
         return nil if receiver_type.nil?
 
+        # Issue #1393 — a `nil` count on `min` / `max` / `min_by` / `max_by` is the no-count call.
+        nil_count = OptionalCount.split(receiver_type, method_name, arg_types, block: !block_type.nil?)
+        if nil_count
+          return resolve_nil_count(nil_count.first, receiver_type: receiver_type, method_name: method_name,
+                                                    block_type: block_type, environment: environment,
+                                                    call_node: call_node, scope: scope,
+                                                    plugin_typed_sink: plugin_typed_sink,
+                                                    skip_project_patched: skip_project_patched)
+        end
+
         # Build the call context once and thread it — unchanged — through every tier
         # (`_DispatchTier#try_dispatch`). The dispatcher's own private fallback tiers still read
         # the positional locals below; only the tier modules consume the context object.
@@ -288,6 +300,20 @@ module Rigor
         try_composite_receiver(context)
       end
 
+      # The `nil` part of an optional count dispatches as the no-argument call, the rest as written; a count
+      # that is both answers the union of the two, or declines when either declines. See {OptionalCount}.
+      def resolve_nil_count(rest, **common)
+        return resolve(arg_types: [], **common) if rest.nil?
+
+        # The counted leg runs first: a leg's plugin answer records on the scope (or buffers in the sink, #1101),
+        # and a declining counted leg must not leave the no-argument leg's record behind for a call that answers nil.
+        counted = resolve(arg_types: [rest], **common)
+        return nil if counted.nil?
+
+        without = resolve(arg_types: [], **common)
+        without && Type::Combinator.union(without, counted)
+      end
+
       # ADR-100 WD4 — records the transitive `-> void` provenance when the called method is a
       # discovered project `def` whose {VoidTailSummary} chain ends in an author-declared `-> void`
       # leaf on the same owner. Guards cheapest-first: the internal dispatcher callers nil `scope` /
@@ -1170,7 +1196,7 @@ module Rigor
         set_lift = set_new_lift(receiver_type.class_name, arg_types)
         return set_lift if set_lift
 
-        hash_lift = hash_new_lift(receiver_type.class_name, arg_types)
+        hash_lift = hash_new_lift(receiver_type.class_name, arg_types, context&.call_node)
         return hash_lift if hash_lift
 
         regexp_lift = regexp_new_lift(receiver_type.class_name, arg_types)
@@ -1445,9 +1471,15 @@ module Rigor
       # form (`Hash.new { |h, k| … }`) keep the bare `Nominal[Hash]` answer — the block's value
       # type is not available at this `:new` dispatch site, and conservatively leaving the read
       # as today's behaviour is precision-additive.
-      def hash_new_lift(class_name, arg_types)
+      #
+      # Issue #1812 — a brace-less keyword hash is `Hash#initialize`'s `capacity:` keyword, not the
+      # default (`Hash.new(capacity: 10).default` is `nil`), so it is dropped before counting the
+      # positionals. A braced hash (`Hash.new({ capacity: 10 })`) is a positional and stays the default.
+      def hash_new_lift(class_name, arg_types, call_node = nil)
         return nil unless class_name == "Hash"
-        return nil unless arg_types.size == 1
+
+        arg_types = hash_new_positionals(arg_types, call_node)
+        return nil unless arg_types&.size == 1
 
         default = arg_types.first
         return nil if default.nil?
@@ -1456,6 +1488,23 @@ module Rigor
         Type::Combinator.nominal_of("Hash", type_args: [Type::Combinator.untyped, value])
       end
 
+      # `Hash.new`'s positional argument types: `arg_types` without a trailing brace-less keyword hash. A literal
+      # send (`Hash.send(:new, capacity: 1)`) dispatches with the outer call node, whose arguments are the
+      # selector symbol followed by `arg_types`' own, and is read through that offset. When the node's arguments
+      # correspond otherwise, a sole hash argument may be the keyword hash, so the answer is nil (decline) and the
+      # bare `Hash` stands; any other argument cannot be a keyword hash and is kept.
+      def hash_new_positionals(arg_types, call_node)
+        return arg_types[0...-1] if ArgumentNodes.keyword_hash_last?(call_node, arg_types)
+
+        arguments = call_node.respond_to?(:arguments) ? call_node.arguments&.arguments : nil
+        return arg_types if arguments.nil? || arguments.size == arg_types.size
+        if arguments.size == arg_types.size + 1 && arguments.first.is_a?(Prism::SymbolNode)
+          return arguments.last.is_a?(Prism::KeywordHashNode) ? arg_types[0...-1] : arg_types
+        end
+
+        arg_types.last.is_a?(Type::HashShape) ? nil : arg_types
+      end
+
       # `Range.new(b, e)` / `Range.new(b, e, excl)` — folds to `Constant[Range]` when both
       # endpoints are `Constant[Integer]` or both are `Constant[String]`, and the optional third
       # argument is a `Constant[true/false]`. Nil endpoints (beginless / endless ranges) are not

data/lib/rigor/inference/module_function_state.rb

@@ -11,8 +11,8 @@ module Rigor
     # [#1197](https://github.com/rigortype/rigor/issues/1197)). Four readers used to compute it in four
     # places. They disagree with each other and, in places, with Ruby. Each entry point below reproduces
     # one reader's answer exactly: this module gives the readings one place to live, and does not yet make
-    # them agree. A change to one reading lands here, beside the other three. Examples are #1550's
-    # named-form snapshot and the reset a bare `public`, `private` or `protected` makes.
+    # them agree. A change to one reading lands here, beside the other three. An example is the reset a bare
+    # `public`, `private` or `protected` makes.
     #
     # - The singleton def-node table (`ScopeIndexer#walk_singleton_body`) reads
     #   {.each_singleton_sibling} and {.each_singleton_copy}. A bare call covers the later direct
@@ -78,23 +78,49 @@ module Rigor
         end
       end
 
-      # The defs a named call copies onto the module's singleton, for the singleton def-node table. Yields
-      # `name, def_node` for each Symbol or String argument that names a receiverless def among the body's
-      # direct `statements`. The last def of that name wins wherever it sits. A def written after the call
-      # is therefore taken, although Ruby copies the one in effect at the call (#1550), and a name defined
-      # only after the call resolves, although Ruby raises `NameError` there. A `module_function def x`
-      # argument names nothing here.
+      # The defs a named call copies onto the module's singleton, for the singleton def-node table. Ruby
+      # copies the method in effect at the call (#1550), so a later def of the name redefines only the
+      # instance method. This reading approximates that from the body's direct `statements`: it yields
+      # `name, def_node` for each Symbol or String argument, where `def_node` is the last receiverless def
+      # of that name written as a direct statement before the call.
+      #
+      # A name declines (nothing is yielded) when no def precedes the call, where Ruby raises `NameError` or
+      # copies a def another file may load first, and when a statement after that def and before the call
+      # may rebind it in a way this reading cannot name: a def nested in control flow or a block, an `alias`,
+      # an `undef`, or a receiverless or `self.` `alias_method`, `define_method`, `attr_*`, `remove_method`
+      # or `undef_method` call. Such a call or `alias` with a non-literal name anywhere before the call, even
+      # before the def, declines every name. A `module_function def x` argument names nothing here.
+      #
+      # It does not see `send(:define_method, ...)`, a `define_method` on an explicit module receiver, a
+      # `prepend`, another file's singleton defs, or that a `rescue` clause's statements may run after an
+      # `ensure` call's (#1969).
       def each_singleton_copy(call, statements)
-        defs_by_name = statements.each_with_object({}) do |stmt, acc|
-          acc[stmt.name] = stmt if stmt.is_a?(Prism::DefNode) && stmt.receiver.nil?
+        call_start = call.location.start_offset
+        in_effect = {}
+        statements.each do |stmt|
+          next unless stmt.location.end_offset <= call_start
+
+          if stmt.is_a?(Prism::DefNode)
+            in_effect[stmt.name] = stmt if stmt.receiver.nil?
+          else
+            each_rebound_name(stmt) { |name| in_effect[name] = :unknown }
+          end
         end
         call.arguments&.arguments&.each do |arg|
           name = symbol_argument_name(arg)
-          def_node = name && defs_by_name[name]
-          yield name, def_node if def_node
+          def_node = name && !in_effect.key?(ANY_NAME) && in_effect[name]
+          yield name, def_node if def_node.is_a?(Prism::DefNode)
         end
       end
 
+      # The key {.each_singleton_copy} records when a statement may rebind a name it cannot read.
+      ANY_NAME = Object.new.freeze
+
+      # Calls that may define, alias or remove an instance method of the receiverless module.
+      REBINDING_CALLS = %i[
+        alias_method define_method attr attr_reader attr_writer attr_accessor remove_method undef_method
+      ].freeze
+
       # The deferred-ranges reading, over one class-ish body's subtree. Appends to `offsets` the start of
       # every bare call; each def that starts after one is a module function
       # ({.deferred_module_function?}). Appends to `ranges` one row per named call, in the table's
@@ -173,6 +199,46 @@ module Rigor
         active && kind == :instance
       end
 
+      # Yields each instance-method name `node` may rebind on the module whose body holds it, or
+      # {ANY_NAME} when one is not a literal. It does not enter a nested class, module or `class <<` body,
+      # whose methods belong to another module.
+      def each_rebound_name(node, &)
+        case node
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode then nil
+        when Prism::DefNode then yield node.name if node.receiver.nil?
+        else
+          each_own_rebound_name(node, &)
+          node.compact_child_nodes.each { |child| each_rebound_name(child, &) }
+        end
+      end
+
+      # The names `node` itself may rebind, apart from its children: an `alias`, an `undef` or a
+      # {REBINDING_CALLS} call on the module.
+      def each_own_rebound_name(node, &)
+        case node
+        when Prism::AliasMethodNode then yield symbol_argument_name(node.new_name) || ANY_NAME
+        when Prism::UndefNode then node.names.each { |name| yield symbol_argument_name(name) || ANY_NAME }
+        when Prism::CallNode
+          each_rebinding_call_name(node, &) if REBINDING_CALLS.include?(node.name) &&
+                                               (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+        end
+      end
+
+      # The names a {REBINDING_CALLS} call may rebind: the first argument of `alias_method` and
+      # `define_method`, every argument of the others (and its writer, for the `attr_*` family), or
+      # {ANY_NAME} for a non-literal one.
+      def each_rebinding_call_name(call)
+        arguments = call.arguments&.arguments || []
+        arguments = arguments.first(1) if %i[alias_method define_method].include?(call.name)
+        arguments.each do |arg|
+          name = symbol_argument_name(arg)
+          next yield(ANY_NAME) unless name
+
+          yield name
+          yield :"#{name}=" if call.name.start_with?("attr")
+        end
+      end
+
       # The prescan's call arm.
       def prescan_call(node, qualified_prefix, in_singleton_class, offsets, ranges)
         if bare?(node)
@@ -208,7 +274,8 @@ module Rigor
         Source::Literals.symbol_or_string(arg)
       end
 
-      private_class_method :prescan_call, :prescan_eval_call, :symbol_argument_name
+      private_class_method :prescan_call, :prescan_eval_call, :symbol_argument_name, :each_rebound_name,
+                           :each_own_rebound_name, :each_rebinding_call_name
     end
   end
 end