rigortype 0.4.2 → 0.4.3

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/project_patched_definedness_guard.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../source/node_children"
+
+module Rigor
+  module Inference
+    module ProjectPatchedScanner
+      # Finds the `def`s of a `pre_eval:` file written under a definedness guard naming the same method
+      # (`def foo = 1 unless method_defined?(:foo)`): polyfills that run only when nothing bound the name before.
+      module DefinednessGuard
+        DEFINEDNESS_PREDICATES = %i[
+          method_defined? private_method_defined? public_method_defined? protected_method_defined? respond_to?
+        ].freeze
+        INSTANCE_METHOD_LISTS = %i[
+          instance_methods public_instance_methods private_instance_methods protected_instance_methods
+        ].freeze
+        private_constant :DEFINEDNESS_PREDICATES, :INSTANCE_METHOD_LISTS
+
+        module_function
+
+        # The `def` nodes (by identity) that sit on the "name not yet defined" side of a definedness guard naming the
+        # same method: `def foo = 1 unless method_defined?(:foo)`, or the same inside an `unless` / `if !` block.
+        def defs(root)
+          found = {}.compare_by_identity
+          collect_guarded(root, found)
+          found
+        end
+
+        def collect_guarded(node, found)
+          return unless node.is_a?(Prism::Node)
+
+          if node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+            name, negated = definedness_guard(node.predicate)
+            mark_guarded_defs(undefined_branch(node, negated), name, found) if name
+          end
+          node.rigor_each_child { |child| collect_guarded(child, found) }
+        end
+        private_class_method :collect_guarded
+
+        # `[method_name, negated]` for a predicate like `method_defined?(:m)` / `!respond_to?(:m)`, else nil.
+        def definedness_guard(predicate)
+          predicate = predicate.body if predicate.is_a?(Prism::ParenthesesNode) && predicate.body
+          predicate = predicate.body.first if predicate.is_a?(Prism::StatementsNode) && predicate.body.size == 1
+          if predicate.is_a?(Prism::CallNode) && predicate.name == :! && predicate.receiver
+            name, negated = definedness_guard(predicate.receiver)
+            return name && [name, !negated]
+          end
+          name = guard_method_name(predicate)
+          name && [name, false]
+        end
+        private_class_method :definedness_guard
+
+        def guard_method_name(call)
+          return unless call.is_a?(Prism::CallNode)
+
+          listed = %i[include? member?].include?(call.name)
+          listed &&= call.receiver.is_a?(Prism::CallNode) && INSTANCE_METHOD_LISTS.include?(call.receiver.name)
+          return unless listed || DEFINEDNESS_PREDICATES.include?(call.name)
+
+          arg = call.arguments&.arguments&.first
+          arg.unescaped.to_sym if arg.is_a?(Prism::SymbolNode) || arg.is_a?(Prism::StringNode)
+        end
+        private_class_method :guard_method_name
+
+        # The branch that runs when the guarded name is NOT defined yet.
+        def undefined_branch(node, negated)
+          branch_when_true = node.is_a?(Prism::IfNode) ? node.statements : node.else_clause
+          branch_when_false = node.is_a?(Prism::IfNode) ? node.subsequent : node.statements
+          # The predicate is true when the name is defined (unless negated).
+          negated ? branch_when_true : branch_when_false
+        end
+        private_class_method :undefined_branch
+
+        def mark_guarded_defs(node, name, found)
+          return unless node.is_a?(Prism::Node)
+
+          found[node] = true if node.is_a?(Prism::DefNode) && node.name == name
+          node.rigor_each_child { |child| mark_guarded_defs(child, name, found) } unless node.is_a?(Prism::DefNode)
+        end
+        private_class_method :mark_guarded_defs
+      end
+    end
+  end
+end

data/lib/rigor/inference/project_patched_methods.rb

@@ -36,14 +36,14 @@ module Rigor
       attr_reader :by_key, :write_census
 
       # @param entries — flat list of declarations observed during the pre-pass.
-      #   First-write-wins on `(class_name, method_name, kind)` duplicates so the
+      #   Last-write-wins on `(class_name, method_name, kind)` duplicates, as at runtime (ADR-17); the
       #   `pre-eval.duplicate-declaration` diagnostic emission stays decoupled from registry behaviour.
       # @param write_census — issue #1367: the `pre_eval:` files' {GlobalWriteCensus}, which the `global.*` write
       #   rules join with the project's, since a patch file is loaded ahead of the code it patches.
       def initialize(entries: [], write_census: GlobalWriteCensus::EMPTY)
         @by_key = entries.each_with_object({}) do |entry, acc|
           key = [entry.class_name, entry.method_name, entry.kind]
-          acc[key] ||= entry
+          acc[key] = entry
         end.freeze
         @write_census = write_census.frozen? ? write_census : write_census.dup.freeze
         freeze

data/lib/rigor/inference/project_patched_scanner.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "project_patched_methods"
+require_relative "project_patched_definedness_guard"
 require_relative "../analysis/dependency_source_inference/return_type_heuristic"
 require_relative "../source/alias_names"
 require_relative "../source/constant_path"
@@ -35,6 +36,13 @@ module Rigor
       PendingAlias = Data.define(:class_name, :new_name, :old_name, :kind, :source_path, :source_line)
       private_constant :PendingAlias
 
+      # A `def` written under a definedness guard (`def foo ... unless method_defined?(:foo)`): a polyfill that runs
+      # only when nothing bound the name before it, so it never replaces an earlier binding.
+      GuardedDef = Data.define(:entry) do
+        def source_path = entry.source_path
+      end
+      private_constant :GuardedDef
+
       module_function
 
       # @param paths — absolute paths to the pre-eval files. The runner has already
@@ -58,29 +66,28 @@ module Rigor
       end
 
       # ADR-17 § "Failure modes" — when two pre-eval entries declare the same `(class_name, method_name,
-      # kind)` triple, emit one `:info` `pre-eval.duplicate-declaration` diagnostic per collision. The
-      # registry's first-write-wins behaviour is unchanged; the diagnostic just makes the shadowing
-      # visible so users notice when a later patch is silently masked.
+      # kind)` triple, the last-listed one wins, as at runtime where the later `def` replaces the earlier. Emit
+      # one `:info` `pre-eval.duplicate-declaration` diagnostic per SHADOWED entry, reported on that earlier
+      # declaration (the declaration that never takes effect) and naming the
+      # winning declaration it yields to.
       def duplicate_declaration_diagnostics(entries)
-        seen = {}
-        entries.each_with_object([]) do |entry, acc|
-          key = [entry.class_name, entry.method_name, entry.kind]
-          if (first = seen[key])
-            acc << build_diagnostic(
-              path: entry.source_path,
-              line: entry.source_line,
-              column: 1,
-              severity: :info,
-              rule: "pre-eval.duplicate-declaration",
-              message: "pre-eval duplicate declaration: " \
-                       "#{entry.class_name}##{entry.method_name} " \
-                       "(#{entry.kind}) is already declared at " \
-                       "#{first.source_path}:#{first.source_line}. " \
-                       "The first declaration wins; this entry is shadowed."
-            )
-          else
-            seen[key] = entry
-          end
+        winners = entries.to_h { |entry| [[entry.class_name, entry.method_name, entry.kind], entry] }
+        entries.filter_map do |entry|
+          winner = winners[[entry.class_name, entry.method_name, entry.kind]]
+          next if winner.equal?(entry)
+
+          build_diagnostic(
+            path: entry.source_path,
+            line: entry.source_line,
+            column: 1,
+            severity: :info,
+            rule: "pre-eval.duplicate-declaration",
+            message: "pre-eval duplicate declaration: " \
+                     "#{entry.class_name}##{entry.method_name} " \
+                     "(#{entry.kind}) is declared again at " \
+                     "#{winner.source_path}:#{winner.source_line}. " \
+                     "The last-listed declaration wins; this entry is shadowed."
+          )
         end
       end
       private_class_method :duplicate_declaration_diagnostics
@@ -97,14 +104,17 @@ module Rigor
       # Within one file the later binding of a name replaces the earlier, as at runtime: the alias-method-chain
       # idiom (`def foo`, `alias_method :foo_without_x, :foo`, `alias_method :foo, :foo_with_x`) leaves `foo` the
       # alias. Bindings of one name in DIFFERENT files are what `pre-eval.duplicate-declaration` reports, and the
-      # registry keeps the first of those, as it always has for `def`s.
+      # registry keeps the last of those, as Ruby does.
       def resolve_aliases(collected)
         bound = {}
         per_file = collected.group_by(&:source_path).values.map do |items|
           final = {}
           items.each do |item|
             entry = item.is_a?(PendingAlias) ? alias_entry(item, bound) : item
+            entry = entry.entry if entry.is_a?(GuardedDef)
             key = [entry.class_name, entry.method_name, entry.kind]
+            next if item.is_a?(GuardedDef) && bound.key?(key)
+
             bound[key] = entry
             final.delete(key)
             final[key] = entry
@@ -138,6 +148,7 @@ module Rigor
           return
         end
 
+        Thread.current[:rigor_guarded_defs] = DefinednessGuard.defs(parse_result.value)
         walk_node(parse_result.value, [], false, path, entries)
         # Issue #1367 — the file's `global.*` write facts: a patch file may alias a special or give a class the
         # method a setter asks for, as any project file may.
@@ -151,6 +162,8 @@ module Rigor
                    "#{e.class}: #{e.message}. Pre-evaluation skipped for this file; " \
                    "the rest of the run proceeds."
         )
+      ensure
+        Thread.current[:rigor_guarded_defs] = nil
       end
       private_class_method :scan_file
 
@@ -233,11 +246,12 @@ module Rigor
         kind = node.receiver.is_a?(Prism::SelfNode) || in_singleton_class ? :singleton : :instance
         line = node.location&.start_line || 1
         return_type = Analysis::DependencySourceInference::ReturnTypeHeuristic.extract(node)
-        entries << ProjectPatchedMethods::Entry.new(
+        entry = ProjectPatchedMethods::Entry.new(
           class_name: class_name, method_name: node.name, kind: kind,
           source_path: source_path, source_line: line,
           return_type: return_type
         )
+        entries << (Thread.current[:rigor_guarded_defs]&.key?(node) ? GuardedDef.new(entry: entry) : entry)
       end
       private_class_method :record_def_node