rigortype 0.3.9 → 0.4.0

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "../mutation_widening"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Issue #1092 — the substitute {RbsDispatch} hands the translator for `Bases::Self` on an instance
+      # receiver whose projection carries type arguments, so `Array[Integer]#tap {}` answers
+      # `Array[Integer]` rather than the raw `Array` the class name alone builds. `nil` keeps that raw
+      # nominal.
+      #
+      # The substitute is always a nominal built from the receiver's projected arguments, never the
+      # receiver's shape: the pure self-returners keep the shape through ShapeDispatch (ADR-76 WD3), and a
+      # block can mutate the receiver through its yielded alias, which MutationWidening does not follow.
+      # For the same reason every argument is widened DEEPLY — a literal to its class, a nested
+      # `Tuple` / `HashShape` to its projected nominal — so `[[1, 2]].tap { |a| a[0] << 3 }` cannot fold
+      # `.first.size == 3`.
+      #
+      # A `-> self` method that can change the element types keeps the arguments only when the call
+      # provably adds nothing outside them; otherwise the call value would claim `ints.map!(&:to_s)` is
+      # still an `Array[Integer]`.
+      module SelfSubstitute
+        # In-place methods that cannot change the receiver's element, key, or value types.
+        TYPE_PRESERVING = %i[
+          sort! sort_by! reverse! uniq! compact! shuffle! rotate!
+          select! filter! reject! keep_if delete_if delete subtract
+          clear compare_by_identity rehash reset
+        ].to_set.freeze
+
+        # Adders whose positional arguments are each a new element (`Array` / `Set`).
+        ELEMENT_ADDERS = %i[<< push append unshift prepend add add?].to_set.freeze
+
+        # Adders whose positional arguments are each a collection of the receiver's own class.
+        COLLECTION_ADDERS = %i[concat merge merge! update].to_set.freeze
+
+        # Every other name MutationWidening knows as a receiver mutator (`map!`, `replace`, `fill`,
+        # `flatten!`, `transform_values!`, ...) rewrites or may rewrite the element types.
+        KNOWN_MUTATORS = (MutationWidening::ARRAY_MUTATORS | MutationWidening::HASH_MUTATORS).freeze
+
+        module_function
+
+        # @param args — the call's positional argument types.
+        # @param block_type — the call's block return type, nil without a block.
+        def for(receiver, receiver_args, method_name, args, block_type)
+          return nil if receiver_args.empty?
+
+          case receiver
+          when Type::Nominal
+            nominal_self(receiver.class_name, receiver_args, method_name, args, block_type)
+          when Type::Tuple
+            projected_self("Array", receiver_args) unless MutationWidening::ARRAY_MUTATORS.include?(method_name)
+          when Type::HashShape
+            projected_self("Hash", receiver_args) unless MutationWidening::HASH_MUTATORS.include?(method_name)
+          when Type::Refined, Type::Difference
+            self.for(receiver.base, receiver_args, method_name, args, block_type)
+          when Type::Dynamic
+            inner = self.for(receiver.static_facet, receiver_args, method_name, args, block_type)
+            inner && Type::Combinator.dynamic(inner)
+          end
+        end
+
+        def nominal_self(class_name, receiver_args, method_name, args, block_type)
+          return nil unless preserves_type_args?(class_name, receiver_args, method_name, args, block_type)
+
+          projected_self(class_name, receiver_args)
+        end
+
+        # Nil when every argument widens to the bare `Dynamic[top]`: `Hash[untyped, untyped]` says nothing
+        # the raw `Hash` does not.
+        def projected_self(class_name, receiver_args)
+          type_args = receiver_args.map { |arg| deep_widen(arg) }
+          return nil if type_args.all? { |arg| untyped?(arg) }
+
+          Type::Combinator.nominal_of(class_name, type_args: type_args)
+        end
+
+        def preserves_type_args?(class_name, receiver_args, method_name, args, block_type)
+          return true if TYPE_PRESERVING.include?(method_name)
+
+          if ELEMENT_ADDERS.include?(method_name)
+            receiver_args.size == 1 && all_provably_within?(receiver_args.first, args)
+          elsif method_name == :insert
+            receiver_args.size == 1 && all_provably_within?(receiver_args.first, args.drop(1))
+          elsif COLLECTION_ADDERS.include?(method_name)
+            block_type.nil? &&
+              all_provably_within?(Type::Combinator.nominal_of(class_name, type_args: receiver_args), args)
+          else
+            !KNOWN_MUTATORS.include?(method_name) && !method_name.end_with?("!")
+          end
+        end
+
+        def all_provably_within?(bound, args)
+          args.all? { |arg| !imprecise?(arg) && bound.accepts(arg, mode: :gradual).yes? }
+        end
+
+        def imprecise?(type)
+          case type
+          when Type::Dynamic then true
+          when Type::Union then type.members.any? { |member| imprecise?(member) }
+          else false
+          end
+        end
+
+        def untyped?(type)
+          type.is_a?(Type::Dynamic) && type.static_facet.is_a?(Type::Top)
+        end
+
+        # `widen_value_pinned`, extended through nested shape carriers and applied type arguments.
+        def deep_widen(type)
+          case type
+          when Type::Tuple
+            return Type::Combinator.nominal_of("Array") if type.elements.empty?
+
+            Type::Combinator.nominal_of("Array", type_args: [deep_widen(Type::Combinator.union(*type.elements))])
+          when Type::HashShape
+            deep_widen_hash_shape(type)
+          when Type::Nominal
+            return type if type.type_args.empty?
+
+            Type::Combinator.nominal_of(type.class_name, type_args: type.type_args.map { |arg| deep_widen(arg) })
+          when Type::Union
+            Type::Combinator.union(*type.members.map { |member| deep_widen(member) })
+          when Type::Dynamic
+            untyped?(type) ? type : Type::Combinator.dynamic(deep_widen(type.static_facet))
+          else
+            Type::Combinator.widen_value_pinned(type)
+          end
+        end
+
+        def deep_widen_hash_shape(shape)
+          return Type::Combinator.nominal_of("Hash") if shape.pairs.empty?
+
+          keys = Type::Combinator.union(*shape.pairs.keys.map { |key| Type::Combinator.constant_of(key) })
+          values = Type::Combinator.union(*shape.pairs.values)
+          Type::Combinator.nominal_of("Hash", type_args: [deep_widen(keys), deep_widen(values)])
+        end
+      end
+    end
+  end
+end

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

@@ -197,21 +197,11 @@ module Rigor
           Type::Difference => :dispatch_difference,
           Type::Refined => :dispatch_refined,
           Type::Intersection => :dispatch_intersection,
-          Type::IntegerRange => :dispatch_integer_range
+          Type::IntegerRange => :dispatch_integer_range,
+          Type::FloatRange => :dispatch_float_range
         }.freeze
         private_constant :RECEIVER_HANDLERS
 
-        # v0.1.1 Track 1 slice 5b — `Integer#to_s(base)` on a non-negative `IntegerRange` receiver. The
-        # output of `n.to_s(b)` for `n >= 0` is digit-string-only (no leading sign), so when the base is in
-        # this table the result lifts to the matching imported refinement. Bases not listed (2, 36, ...)
-        # keep the v0.1.0 baseline since Rigor has no carrier for the resulting alphabet.
-        TO_S_BASE_REFINEMENTS = {
-          10 => :decimal_int_string,
-          8 => :octal_int_string,
-          16 => :hex_int_string
-        }.freeze
-        private_constant :TO_S_BASE_REFINEMENTS
-
         def try_dispatch(context)
           receiver = context.receiver
           method_name = context.method_name
@@ -304,7 +294,9 @@ module Rigor
             when "String"
               dispatch_string_binary_from_arg(method_name, args.first) if args.size == 1
             when "Integer"
-              dispatch_integer_binary_from_arg(method_name, args.first) if args.size == 1
+              integer_nominal_projection(method_name, args)
+            when "Float"
+              float_to_s_projection(method_name, args)
             when "Array"
               case method_name
               when :flatten then array_nominal_flatten(nominal, args)
@@ -313,6 +305,65 @@ module Rigor
             end
           end
 
+          # `Integer#to_s` / `Integer#inspect` (#993) on a bare `Nominal[Integer]` receiver, ahead of the
+          # existing `:*` binary fold. `#inspect` takes no argument and matches `#to_s()` byte for byte, so
+          # it routes through the same no-arg branch.
+          def integer_nominal_projection(method_name, args)
+            case method_name
+            when :to_s then integer_to_s_projection(args)
+            when :inspect then args.empty? ? Type::Combinator.decimal_int_string : nil
+            else dispatch_integer_binary_from_arg(method_name, args.first) if args.size == 1
+            end
+          end
+
+          # `decimal-int-string`'s predicate (`/\A-?\d+\z/`) admits the optional sign, so — unlike the
+          # `IntegerRange#to_s` tier above, which declines a signed range because it cannot yet prove the
+          # sign is absent — a bare `Integer` (sign completely unknown) still reaches it for the base-10
+          # case: base 10 is Ruby's default sign-and-digits grammar for every Integer. Any other base,
+          # known or not statically known, drops to `non-empty-string`: `to_s(base)` never returns `""`,
+          # but a non-decimal base's digits (`255.to_s(16)` is `"ff"`, not the `0xff` literal) match no
+          # registered refinement.
+          def integer_to_s_projection(args)
+            return Type::Combinator.decimal_int_string if args.empty?
+            return nil unless args.size == 1
+
+            decimal_base?(args.first) ? Type::Combinator.decimal_int_string : Type::Combinator.non_empty_string
+          end
+
+          def decimal_base?(arg)
+            arg.is_a?(Type::Constant) && arg.value == 10
+          end
+
+          # `Float#to_s` / `Float#inspect` (#993) on a bare `Nominal[Float]` receiver. No finiteness proof
+          # is available here — a bare `Float` admits `Infinity` / `-Infinity` / `NaN`, none of which are
+          # Ruby numeric literals — so the floor is `non-empty-string` (Ruby's conversion is total and
+          # never returns `""`). A `FloatRange` receiver with proven-finite bounds reaches `numeric-string`
+          # instead; see {#dispatch_float_range}.
+          def float_to_s_projection(method_name, args)
+            return nil unless %i[to_s inspect].include?(method_name)
+            return nil unless args.empty?
+
+            Type::Combinator.non_empty_string
+          end
+
+          # `Float#to_s` / `Float#inspect` (#993) on a `FloatRange` receiver. `min` / `canonical_max` both
+          # finite (Ruby's own `Float#finite?`, the same check {MethodDispatcher::ConstantFolding}'s
+          # `float_range_finite` fold uses) is exactly a finiteness proof: no bounded range contains `NaN`,
+          # and finite bounds rule out both infinities too. `finite-float` satisfies it, as does any
+          # narrower bounded sub-range and the `f.finite?` truthy-edge narrowing (ADR-109 WD5) that
+          # produces `finite-float` — but `Float[0.0..]` does NOT, because its endless upper bound is
+          # `Float::INFINITY`.
+          def dispatch_float_range(range, method_name, args)
+            return nil unless args.empty?
+            return nil unless %i[to_s inspect].include?(method_name)
+
+            if range.min.finite? && range.canonical_max.finite?
+              Type::Combinator.numeric_string
+            else
+              Type::Combinator.non_empty_string
+            end
+          end
+
           # `Array[T]#compact` — `compact` removes every `nil` element, so the result element type is `T`
           # with its `nil` constituent stripped (`Array[Node?]#compact` → `Array[Node]`). Mirrors the
           # `Tuple#compact` constant fold for the generic element case. Declines when the receiver carries
@@ -418,10 +469,18 @@ module Rigor
 
           # `IntegerRange#to_s` precision (v0.1.1 Track 1 slice 5b). When the range's lower bound is
           # `>= 0`, every member is a non-negative integer and `to_s(base)` returns a digit-string with no
-          # leading sign. The result lifts to the matching imported refinement (`decimal-int-string` for
-          # base 10, `octal-int-string` for 8, `hex-int-string` for 16). Signed ranges fall through (the
-          # result could carry a `-` sign that no Rigor refinement currently captures), as do bases
-          # without a digit-only refinement.
+          # leading sign. Base 10 is Ruby's decimal-literal grammar, so the result lifts to
+          # `decimal-int-string`. Signed ranges fall through entirely (the result could carry a `-` sign
+          # that `decimal-int-string` alone would need a sign proof for, matching the
+          # `Nominal[Integer]` tier's own signed-base-10 carve-out below).
+          #
+          # #1004 — every other base (a different literal, such as 8 or 16, or a value that is not
+          # statically known) does NOT lift to `octal-int-string` / `hex-int-string`: those refinements'
+          # predicates REQUIRE the `0o` / `0x` prefix Ruby's own `to_s(base)` never emits
+          # (`64.to_s(8)` is `"100"`, `255.to_s(16)` is `"ff"` — neither has a prefix), so a producer
+          # that claimed them was unsound. The floor is `non-empty-string`, same as the bare
+          # `Nominal[Integer]` path (#993 / #1001) reaches for the identical reason: `to_s(base)` is
+          # total and never returns `""`.
           def dispatch_integer_range(range, method_name, args)
             return nil unless method_name == :to_s
             return nil unless range.lower >= 0
@@ -429,10 +488,7 @@ module Rigor
             base = base_argument(args)
             return nil if base.nil?
 
-            refinement = TO_S_BASE_REFINEMENTS[base]
-            return nil if refinement.nil?
-
-            Type::Combinator.public_send(refinement)
+            base == 10 ? Type::Combinator.decimal_int_string : Type::Combinator.non_empty_string
           end
 
           # `to_s` with no argument defaults to base 10. With one argument, the value MUST be a
@@ -1556,14 +1612,18 @@ module Rigor
             Type::Combinator.constant_of(found)
           end
 
-          # `shape.default` / `default_proc` — a literal `HashShape` carries no default value or proc, so
-          # both fold to `Constant[nil]`. `default` accepts an optional key argument (still returns the
+          # `shape.default` / `default_proc` — a closed literal `HashShape` carries no default value or proc,
+          # so both fold to `Constant[nil]`. `default` accepts an optional key argument (still returns the
           # default), `default_proc` takes none — the `args.size <= 1` guard covers both.
-          def hash_default(shape, _method_name, args)
+          #
+          # An open shape's `default` is `untyped`. The default is what an unseen key reads, which the known
+          # values do not bound — the RBS answer `V?` would bound it by them, so `h = { a: 1 }; h.default = 0`
+          # (which opens the shape, see `HashLookupMutation`) read `h.default` as `1?`. `default_proc` defers.
+          def hash_default(shape, method_name, args)
             return nil unless args.size <= 1
-            return nil unless shape.closed?
+            return Type::Combinator.constant_of(nil) if shape.closed?
 
-            Type::Combinator.constant_of(nil)
+            Type::Combinator.untyped if method_name == :default
           end
 
           # `shape < other` / `<=` / `>` / `>=` — Hash containment comparison. Both sides must be closed
@@ -1772,17 +1832,23 @@ module Rigor
           #
           # On an `:open` shape neither applies — the key is unknown rather than missing, so both methods
           # answer the `untyped` step from {#hash_dig_step}.
+          #
+          # `[]` takes whatever step {#hash_dig_step} gives a computed key. `fetch` answers only literal keys
+          # none of which can miss — a required declared key, or an undeclared one on an open shape — and
+          # defers otherwise: a miss raises instead of reading nil, so the projection's nil-free value union
+          # is already the sound answer.
           def hash_lookup(shape, method_name, args)
             return nil unless args.size == 1
 
             step = hash_dig_step(shape, args.first)
             return nil if step.nil?
-            return nil if method_name == :fetch && optional_key_step?(shape, args.first)
-            return step unless missing_key_step?(shape, args.first)
-
             return step if method_name == :[]
 
-            nil
+            keys = literal_keys(args.first)
+            return nil if keys.nil?
+            return nil if keys.any? { |key| shape.optional_key?(key) || (shape.closed? && !shape.pairs.key?(key)) }
+
+            step
           end
 
           # `shape.dig(:a, :b, ...)` with a chain of static keys. Same recursion semantics as Tuple#`dig`:
@@ -1799,20 +1865,45 @@ module Rigor
           end
 
           # Returns the per-step value type for a HashShape lookup (or `Constant[nil]` for a known-missing
-          # key). Returns `nil` when the argument is not a value-pinned scalar key so the caller can fall
-          # through to the projection answer.
+          # key), or `nil` so the caller falls through to the projection answer.
           #
           # A key outside `pairs` only resolves to `Constant[nil]` on a CLOSED shape, where `pairs` is the
           # whole key set and the runtime read provably returns nil. On an `:open` shape the key set is by
           # definition not exhausted, so an undeclared key is *unknown*, not absent — it may hold a value
           # of any type. Typing it `Constant[nil]` there would put `call.undefined-method` on the next line
           # of correct code (`payload[:undeclared].upcase`), so the open case answers `untyped`.
+          #
+          # A union of value-pinned keys that the shape all declares answers the union of their steps, which
+          # is exact. Any other key is computed — including a union with an undeclared member, whose per-member
+          # answer on a stale shape is the same lone `Constant[nil]` the empty-shape rule below refuses. On a
+          # closed shape a computed key may match any declared key or none, so the step is every value plus
+          # `Constant[nil]`. Deferring it instead let the projection answer the value union alone — nil-free,
+          # since `RbsDispatch` reads past `Hash#[]`'s `%a{implicitly-returns-nil}` — and
+          # `o = { a: 1 }; o[name] == 1` folded always-truthy. An open shape still defers: its undeclared keys
+          # may hold any value. So does the empty shape: a hash read by a computed key while it looks empty is
+          # one filled where the analysis did not see — a loop body's earlier iteration
+          # (`h = {}; xs.each { |x| h[x] = h[x] ? h[x] + 1 : 1 }`), a cache (`(@cache ||= {})[key]`), an
+          # `instance_eval`ed file — and answering `Constant[nil]` there folds its own guard always-falsey.
           def hash_dig_step(shape, arg)
-            return nil unless arg.is_a?(Type::Constant)
+            keys = literal_keys(arg)
+            if keys && (keys.size == 1 || keys.all? { |key| shape.pairs.key?(key) })
+              return Type::Combinator.union(*keys.map { |key| static_key_step(shape, key) })
+            end
+            return nil if shape.open? || shape.pairs.empty?
 
-            key = arg.value
-            return nil unless static_shape_key?(key)
+            Type::Combinator.union(*shape.pairs.values, Type::Combinator.constant_of(nil))
+          end
+
+          # The value-pinned keys `arg` can take — one for a scalar `Constant`, one per member for a union of
+          # them — or `nil` when it can take any other value.
+          def literal_keys(arg)
+            members = arg.is_a?(Type::Union) ? arg.members : [arg]
+            return nil unless members.all? { |member| member.is_a?(Type::Constant) && static_shape_key?(member.value) }
 
+            members.map(&:value)
+          end
+
+          def static_key_step(shape, key)
             if shape.pairs.key?(key)
               value = shape.pairs[key]
               return value unless shape.optional_key?(key)
@@ -1825,26 +1916,10 @@ module Rigor
             Type::Combinator.constant_of(nil)
           end
 
-          def optional_key_step?(shape, arg)
-            return false unless arg.is_a?(Type::Constant)
-
-            shape.optional_key?(arg.value)
-          end
-
-          # Whether the key is provably ABSENT — which only a closed shape can establish. An open shape
-          # permits keys outside `pairs`, so a key it does not declare is unknown rather than missing, and
-          # `fetch` must not be deferred on the theory that Ruby would raise `KeyError`: the key may well
-          # be there. {#hash_dig_step} has already answered `untyped` for that case.
-          def missing_key_step?(shape, arg)
-            return false unless arg.is_a?(Type::Constant)
-            return false if shape.open?
-
-            !shape.pairs.key?(arg.value)
-          end
-
           # `shape.values_at(:a, :b, ...)` with a list of static keys. Returns a `Tuple` whose per-position
           # values are the per-key value types (`Constant[nil]` for missing keys, mirroring Ruby's runtime
-          # behaviour). Falls through when any argument is not a value-pinned scalar key.
+          # behaviour). A computed key takes the nil-bearing step {#hash_dig_step} gives it; the call falls
+          # through when any step does (a computed key on an open shape).
           def hash_values_at(shape, _method_name, args)
             return nil if args.empty?
 

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

@@ -364,7 +364,7 @@ module Rigor
             members: widen_unowned_emptiness(current.members.merge(member => assigned_type)),
             class_name: current.class_name
           )
-          scope.with_local(receiver.name, rebound)
+          scope.with_mutated_local(receiver.name, rebound)
         end
       end
     end