rigortype 0.3.5 → 0.3.7

data/lib/rigor/inference/method_dispatcher.rb

@@ -29,7 +29,10 @@ require_relative "method_dispatcher/regexp_folding"
 require_relative "method_dispatcher/cgi_folding"
 require_relative "method_dispatcher/uri_folding"
 require_relative "method_dispatcher/set_folding"
+require_relative "method_dispatcher/json_folding"
 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"
 
 module Rigor
@@ -119,6 +122,11 @@ module Rigor
         # skip this tier.
         plugin_result = try_plugin_contribution(call_node, scope, receiver_type)
         if plugin_result
+          # Issue #653 — this tier answering is what makes the site's type the plugin's rather than the
+          # RBS's, and `call.undefined-method` reads that record instead of re-deciding from the receiver's
+          # (possibly partial) signature. Recorded for EVERY plugin answer, dynamic or precise: the
+          # incoherence the record closes is about which subsystem typed the call, not about the type.
+          scope&.record_plugin_typed_call(call_node)
           if plugin_result.is_a?(Type::Dynamic)
             scope&.record_dynamic_origin(call_node, DynamicOrigin::FRAMEWORK_DSL_BOUNDARY)
           end
@@ -144,6 +152,12 @@ module Rigor
         static_refinement = try_static_refinement(receiver_type, method_name, arg_types)
         return static_refinement if static_refinement
 
+        # `Foo.instance` for a class that includes the stdlib `Singleton` mixin. Ruby grows that method through
+        # an `included` hook and the upstream RBS leaves `Singleton::SingletonClassMethods` empty, so nothing
+        # below can answer it. See {SingletonMixinDispatch} for why the value matters more than the site count.
+        singleton_mixin = SingletonMixinDispatch.try_dispatch(context)
+        return singleton_mixin if singleton_mixin
+
         rbs_result = RbsDispatch.try_dispatch(context)
         if rbs_result
           record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
@@ -218,6 +232,15 @@ module Rigor
         stub_result = try_synthesized_stub_type(receiver_type, environment)
         return stub_result if stub_result
 
+        # The receiver-independent `BasicObject` / `Object` / `Kernel` selectors, for a receiver no tier
+        # above could name. `x.nil?` is `bool` whatever `x` is; without this tier it was `Dynamic[Top]`
+        # like every other call on an untyped receiver. Sits here, below every real resolution tier, so a
+        # nameable receiver always answers from its own signature first — this only ever replaces a
+        # `Dynamic[Top]` the typer was about to produce. See {UniversalObjectDispatch} for the table and
+        # for the selectors deliberately left out of it.
+        universal_result = UniversalObjectDispatch.try_dispatch(context)
+        return universal_result if universal_result
+
         # Slice 7 phase 10 — user-class ancestor fallback. When the receiver is `Nominal[T]` or
         # `Singleton[T]` for a class not in the RBS environment (typically a user-defined class),
         # retry the dispatch against the implicit ancestor: `Nominal[Object]` for instance
@@ -305,9 +328,13 @@ module Rigor
       # on. `Nominal[X]` looks up instance methods on X; `Singleton[X]` looks up singleton
       # methods on X. Other carriers return `[nil, nil]` so the tier declines.
       def discovered_method_lookup(receiver_type)
+        # #525 — the ADR-48 member carriers name their class too: a `Line = Struct.new(...) do ... end`
+        # value is a StructInstance whose block-def methods are discovered under "Line".
         case receiver_type
-        when Type::Nominal then [receiver_type.class_name, :instance]
-        when Type::Singleton then [receiver_type.class_name, :singleton]
+        when Type::Nominal, Type::StructInstance, Type::DataInstance
+          [receiver_type.class_name, :instance]
+        when Type::Singleton, Type::StructClass, Type::DataClass
+          [receiver_type.class_name, :singleton]
         else [nil, nil]
         end
       end
@@ -711,7 +738,7 @@ module Rigor
       #
       # The precise-tier folders, consulted in order via the uniform `_DispatchTier` interface
       # (`try_dispatch(CallContext) -> Type?`). Order is significant: ConstantFolding's
-      # exact-value folds win first, the eight stdlib singleton folders sit in the middle (each
+      # exact-value folds win first, the stdlib singleton folders sit in the middle (each
       # gates on a distinct `Singleton` receiver, so their relative order is immaterial), and
       # BlockFolding runs last because its rules only apply to block-taking calls — the cheaper
       # arity folds above it filter the common cases first. Adding a precise tier is a one-line
@@ -721,13 +748,13 @@ module Rigor
       ].freeze)
       private_constant :PRECISE_TIERS_HEAD
 
-      # ADR-53 re-review follow-up (gate-by-held-key applied to the built-in tiers): the eight
-      # stdlib singleton folders are mutually exclusive — each fires only on `Singleton[<its
+      # ADR-53 re-review follow-up (gate-by-held-key applied to the built-in tiers): the stdlib
+      # singleton folders are mutually exclusive — each fires only on `Singleton[<its
       # class>]`, the first check in every `try_dispatch` — so at most one can match a given
       # receiver and their relative trial order was never observable. Compiling them into a
-      # class-name table turns eight no-op trials per call into one Hash read, skipped entirely
+      # class-name table turns nine no-op trials per call into one Hash read, skipped entirely
       # when the receiver is not a `Singleton` (the overwhelmingly common case). The table sits
-      # where the eight sat in the old flat list: after ShapeDispatch, before KernelDispatch.
+      # where the original eight sat in the old flat list: after ShapeDispatch, before KernelDispatch.
       STDLIB_SINGLETON_FOLDERS = Ractor.make_shareable({
         "File" => FileFolding,
         "Shellwords" => ShellwordsFolding,
@@ -736,7 +763,8 @@ module Rigor
         "Regexp" => RegexpFolding,
         "CGI" => CGIFolding,
         "URI" => URIFolding,
-        "Set" => SetFolding
+        "Set" => SetFolding,
+        "JSON" => JSONFolding
       }.freeze)
       private_constant :STDLIB_SINGLETON_FOLDERS
 
@@ -975,7 +1003,9 @@ module Rigor
         return nil unless arg_types.size == 1
 
         parent = arg_types.first
-        return parent if parent.is_a?(Type::Singleton)
+        factory_parent = parent.is_a?(Type::StructClass) || parent.is_a?(Type::DataClass)
+        return nil if factory_parent && context&.call_node&.block
+        return parent if parent.is_a?(Type::Singleton) || factory_parent
 
         nil
       end
@@ -1022,8 +1052,8 @@ module Rigor
 
       # `Array.new(n, value)` and `Array.new(n)` (no value, default `nil`) lift to a per-position
       # `Tuple[…]` when `n` is a small `Constant<Integer>`. Cap at `ARRAY_NEW_TUPLE_LIMIT` (16)
-      # so a `Array.new(1_000_000)` does not balloon the carrier; oversize calls fall back to
-      # `Nominal[Array]`.
+      # so a `Array.new(1_000_000)` does not balloon the carrier; oversize calls fall through to
+      # the element-parameter seed below.
       #
       # #317 — `Array.new(n) { |i| ... }` fills every slot from the BLOCK's return type instead
       # of the two-arg `(n, default_value)` overload's `nil` fill. The block and the trailing
@@ -1039,10 +1069,121 @@ module Rigor
         return nil if arg_types.empty? || arg_types.size > 2
 
         size = array_new_size(arg_types.first)
-        return nil if size.nil? || size.negative? || size > ARRAY_NEW_TUPLE_LIMIT
+        if size && !size.negative? && size <= ARRAY_NEW_TUPLE_LIMIT
+          return Type::Combinator.tuple_of(*Array.new(size, block_type || array_new_fill(arg_types[1])))
+        end
+
+        array_new_seed(arg_types, block_type)
+      end
+
+      # The carrier for a constructor whose size is not a small literal — `Array.new(n)`,
+      # `Array.new(n, v)`, `Array.new(n) { … }`.
+      #
+      # This must never be a BARE `Array`. A nominal with no type argument carries no element
+      # arm, and the ADR-56 block/loop seams read exactly that as an ELEMENTLESS seed — a fresh
+      # accumulator whose every store the seam saw — so they CLOSE the carrier over the block's
+      # own stores. `acc = Array.new(n); [1].each { acc.push(1) }` then read `Array[1]` for an
+      # array whose other `n` slots hold `nil`, and `acc = Array.new(n, "x")` read `Array[1]` and
+      # drew `undefined method 'upcase'` on the correct `acc.first.upcase` (issue #615). Handing
+      # the seams a real element arm is what puts the constructor under the #586 rule, which
+      # keeps every seed arm through the join.
+      #
+      # The element itself is the fill value's / block result's type, value-pin widened for the
+      # reason `hash_new_lift` widens its default: the slots are rewritten over the array's
+      # lifetime, so pinning the parameter to the literal would let a later `a[i] == "x"`
+      # constant-fold.
+      #
+      # **The no-fill form seeds the GRADUAL element, not `nil`.** `Array.new(n)` really does put
+      # a `nil` in every slot, but a `Nominal` seed gets DECLARED-carrier semantics downstream:
+      # the #586 join keeps a seed arm forever, and `MutationWidening#widen_for_mutator` declines
+      # a `Nominal` outright, so no whole-array rewrite — `[]=`, `fill`, `map!`, `replace`,
+      # `concat` — can ever retract it. The placeholder would become a permanent nil possibility
+      # over the allocate-then-fill idiom that is the whole point of the constructor:
+      #
+      #     dp = Array.new(xs.size); dp[0] = 1
+      #     (1...n).each { |i| dp[i] = dp[i - 1] + xs[i] }   # `undefined method '+' for nil`
+      #
+      #     buf = Array.new(256); 256.times { |i| buf[i] = i.to_s }
+      #     buf.each { |c| c.upcase }                        # possible nil receiver
+      #
+      # Both are correct Ruby, and both went from quiet to an ERROR on the `nil` seed. The true
+      # positive the `nil` would buy — `Array.new(n).first.upcase` on an array nothing ever wrote
+      # — is not worth the dominant idiom, so the no-fill form stays gradual whatever the size
+      # argument reads as. (That also happens to absorb Ruby's array-convertible COPY overload:
+      # `Array.new([1, 2])` is `[1, 2]`, not two nils.)
+      def array_new_seed(arg_types, block_type)
+        fill = block_type || arg_types[1]
+        return array_seed_of(Type::Combinator.untyped) if fill.nil?
+
+        element = array_new_element(fill)
+        # `Array.new(n, nil)` is the same allocate-then-fill idiom as `Array.new(n)`, spelled with the
+        # placeholder made explicit — concurrent-ruby writes `@Resolutions = ::Array.new(count, nil)` and
+        # fills it by index. A nil-only element would be a PERMANENT nil arm (a Nominal carrier's element is
+        # never widened by a later `[]=` / `fill` / `replace`), so every read of a filled slot would draw
+        # `undefined method '…' for nil` on correct code. Same trade as the no-fill form above: the seam
+        # needs an arm, not a precise one.
+        element = Type::Combinator.untyped if nil_only_element?(element)
+        array_seed_of(element)
+      end
 
-        fill = block_type || array_new_fill(arg_types[1])
-        Type::Combinator.tuple_of(*Array.new(size, fill))
+      # Whether the widened fill leaves nothing but `nil` behind — see {#array_new_seed}.
+      def nil_only_element?(element)
+        members = element.is_a?(Type::Union) ? element.members : [element]
+        members.all? do |member|
+          (member.is_a?(Type::Constant) && member.value.nil?) ||
+            (member.is_a?(Type::Nominal) && member.class_name == "NilClass")
+        end
+      end
+
+      def array_seed_of(element)
+        Type::Combinator.nominal_of("Array", type_args: [element])
+      end
+
+      # A fill / block result as an element PARAMETER. Value pinning is dropped, and a literal
+      # container widens to its nominal: `Array.new(n) { [] }` builds n INDEPENDENT arrays that
+      # the program then appends to, and `Array[Tuple[]]` claims every one of them stays empty —
+      # the adjacency-list idiom would read `adj[i].first` as `nil`. Both conversions go through
+      # {MutationWidening}'s own helpers, the single owner of "literal container → parameterised
+      # nominal" that `MemberShapeProjection` already borrows.
+      #
+      # The walk is **recursive**, through `Union` members and through a container's own elements /
+      # values alike. Every one of those positions is a fresh object per constructed slot that the
+      # program goes on to mutate, so stopping at the outermost level only moved the wrong-precise
+      # answer one level in: `a = Array.new(n) { [[1]] }; a[0][0] << 5` left `Array[Array[[1]]]`
+      # and folded `a[0][0].last == 5` always-falsey on correct code. Judging a `Union` wholesale
+      # was the same defect one axis over — `Array.new(n) { flag ? [1] : [2] }` kept both arms as
+      # fixed-arity tuples.
+      #
+      # `depth` is defensive only. A `Type` carrier is an immutable value object assembled
+      # bottom-up (`Tuple.new(elements)`, `HashShape.new(pairs)`), so it cannot contain itself and
+      # this walk is bounded by the source literal's own nesting; the cap costs nothing on any
+      # literal a person writes and stops a malformed carrier from recursing forever.
+      ARRAY_NEW_FILL_DEPTH_LIMIT = 8
+      private_constant :ARRAY_NEW_FILL_DEPTH_LIMIT
+
+      def array_new_element(type, depth = 0)
+        return Type::Combinator.untyped if depth > ARRAY_NEW_FILL_DEPTH_LIMIT
+
+        case type
+        when Type::Tuple then MutationWidening.widen_tuple(recursed_tuple(type, depth))
+        when Type::HashShape then MutationWidening.widen_hash_shape(recursed_hash_shape(type, depth))
+        when Type::Union then Type::Combinator.union(*type.members.map { |m| array_new_element(m, depth + 1) })
+        else Type::Combinator.widen_value_pinned(type)
+        end
+      end
+
+      # The same tuple / hash shape with every element / value already widened, so the
+      # {MutationWidening} helper that consumes it sees nominals where the literal had pins. The
+      # rebuilt carrier is a throwaway argument — never surfaced — and the helpers read only
+      # `elements` / `pairs`, so no policy field rides on it.
+      def recursed_tuple(type, depth)
+        Type::Combinator.tuple_of(*type.elements.map { |e| array_new_element(e, depth + 1) })
+      end
+
+      def recursed_hash_shape(type, depth)
+        Type::Combinator.hash_shape_of(
+          type.pairs.transform_values { |v| array_new_element(v, depth + 1) }
+        )
       end
 
       def array_new_size(type)

data/lib/rigor/inference/method_parameter_binder.rb

@@ -332,8 +332,7 @@ module Rigor
         when :rest_positional
           Type::Combinator.nominal_of("Array", type_args: [translated])
         when :rest_keyword
-          symbol_nominal = Type::Combinator.nominal_of("Symbol")
-          Type::Combinator.nominal_of("Hash", type_args: [symbol_nominal, translated])
+          Type::Combinator.nominal_of("Hash", type_args: [Type::Combinator.nominal_of("Symbol"), translated])
         else
           translated
         end
@@ -344,7 +343,8 @@ module Rigor
         RbsTypeTranslator.translate(
           rbs_type,
           self_type: self_type,
-          instance_type: instance_type
+          instance_type: instance_type,
+          alias_expander: @environment&.rbs_loader
         )
       rescue StandardError
         Type::Combinator.untyped