rigortype 0.0.2 → 0.0.4

data/lib/rigor/inference/builtins/range_catalog.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Range` catalog. Singleton — load once, consult during
+      # dispatch.
+      #
+      # Range is largely immutable: `begin`, `end`, and `excl` are
+      # set at construction by `range_initialize` and never mutated
+      # afterwards. The blocklist below therefore stays small. The
+      # entries we DO need are the iteration methods whose C body
+      # routes through a helper the block/yield regex does not
+      # recognise, so the classifier mis-flags them as `:leaf`
+      # despite yielding to a block.
+      RANGE_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/range.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Range" => Set[
+            # `range_initialize` / `range_initialize_copy` write
+            # `begin`/`end`/`excl` slots on the receiver; classed
+            # `:leaf` because the writes go through the struct
+            # accessor not `rb_check_frozen`. Blocked for symmetry
+            # with String / Array.
+            :initialize, :initialize_copy,
+            # `range_reverse_each` yields to its block via
+            # `range_each_func` -> caller's block; the regex
+            # classifier follows direct `rb_yield*` calls only.
+            :reverse_each,
+            # `range_percent_step` returns an Enumerator unless a
+            # block is supplied, in which case it yields. Treated
+            # as block-dependent so the fold tier never invokes it
+            # against a literal Range and tries to materialise an
+            # Enumerator into a Constant.
+            :%
+          ]
+        }
+      )
+    end
+  end
+end

data/lib/rigor/inference/builtins/set_catalog.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Set` catalog. Singleton — load once, consult during dispatch.
+      #
+      # Set was rewritten in C and folded into CRuby for Ruby 3.2+;
+      # the reference branch (`ruby_4_0`) ships the implementation in
+      # `references/ruby/set.c` with `Init_Set` registering every
+      # method directly. There is no `set.rb` prelude — the trailing
+      # `rb_provide("set.rb")` makes `require "set"` a no-op against
+      # the built-in.
+      #
+      # The blocklist below catches the catalog `:leaf` entries the
+      # C-body classifier mis-attributes. Set's iteration helpers
+      # (`set_iter`, `RETURN_SIZED_ENUMERATOR`) and its identity-
+      # mode and reset paths drive into helpers the regex classifier
+      # does not yet recognise as block-yielding or mutating.
+      SET_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/set.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Set" => Set[
+            # Indirect mutators classified `:leaf` because the C
+            # classifier did not follow the helper functions:
+            #
+            # - `initialize_copy` calls `set_copy` to overwrite the
+            #   receiver's table.
+            # - `compare_by_identity` swaps the internal hash type
+            #   via `set_reset_table_with_type`.
+            # - `reset` rebuilds the internal table to dedup after
+            #   element mutation.
+            :initialize_copy, :compare_by_identity, :reset,
+            # Block-dependent methods classified `:leaf` because the
+            # C body uses `set_iter` / `RETURN_SIZED_ENUMERATOR`
+            # rather than calling `rb_yield` directly:
+            :each, :classify, :divide,
+            # `disjoint?` delegates into `set_i_intersect`, which
+            # for non-Set enumerables uses `rb_funcall(other,
+            # :any?, ...)` — that is user-redefinable dispatch the
+            # classifier missed because the call site is in a
+            # sibling function.
+            :disjoint?
+          ]
+        }
+      )
+    end
+  end
+end

data/lib/rigor/inference/builtins/string_catalog.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `String` and `Symbol` catalog. Singleton — load once,
+      # consult during dispatch.
+      #
+      # The blocklist below is the curated set of catalog `:leaf`
+      # entries the C-body classifier mis-attributes (the body of
+      # `rb_str_replace` calls `str_modifiable` / `str_discard`
+      # which the regex-based classifier does not recognise as
+      # mutation primitives). Adding to the blocklist is the
+      # corrective surface for false positives until the
+      # classifier learns the helper functions.
+      STRING_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/string.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "String" => Set[
+            :replace, :initialize, :initialize_copy, :clear, :<<, :concat, :insert,
+            :prepend, :force_encoding, :encode, :scrub, :unicode_normalize, :"[]=",
+            :upto, :each_byte, :each_char, :each_codepoint,
+            :each_grapheme_cluster, :each_line, :bytesplice
+          ],
+          "Symbol" => Set[
+            # Symbol is immutable in Ruby; the classifier mis-flags
+            # `inspect` because `rb_sym_inspect` builds a temporary
+            # mutable buffer. Allow it.
+          ]
+        }
+      )
+    end
+  end
+end

data/lib/rigor/inference/builtins/time_catalog.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Time` catalog. Singleton — load once, consult during dispatch.
+      #
+      # Time is a pure-C built-in: the Init block in
+      # `references/ruby/time.c` registers the bulk of the surface,
+      # and the Ruby-side prelude `references/ruby/timev.rb`
+      # contributes the class-side constructors (`Time.now`,
+      # `Time.at`, `Time.new`) through Primitive cexpr stubs.
+      #
+      # Time receivers are not lifted to a `Constant` carrier today
+      # (there is no `Time` literal node — the closest is
+      # `Time.now` / `Time.new(...)`, which produce `Nominal[Time]`).
+      # The catalog wiring therefore mostly governs:
+      #
+      # 1. The size-projection-equivalent reader surface (`#year`,
+      #    `#month`, `#hour`, `#sec`, `#wday`, …) — RBS-declared
+      #    `Integer` is preserved through dispatch.
+      # 2. The blocklist below, which keeps the indirect-mutator
+      #    methods that the C-body classifier mis-flagged as
+      #    `:leaf` from ever folding through a hypothetical future
+      #    `Constant<Time>` carrier.
+      #
+      # The blocklist captures the false-positive `:leaf` entries
+      # whose helper functions the regex classifier did not
+      # recognise as mutators.
+      TIME_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/time.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Time" => Set[
+            # `time_init_copy` writes the `timew` and `vtm` slots on
+            # the receiver via `time_set_timew` / `time_set_vtm`.
+            # Classed `:leaf` because those setters are not in the
+            # mutator regex's helper list. Blocked for symmetry with
+            # String / Array / Range / Set initialize_copy entries.
+            :initialize_copy,
+            # `time_localtime_m` -> `time_localtime` calls
+            # `time_modify(time)` to mark the receiver mutable
+            # before rewriting its `vtm` cache and `tzmode`. The
+            # docstring is explicit ("converts time to local time
+            # in place"). The C-body classifier mis-flagged it as
+            # `:leaf` because `time_modify` is not in its mutator
+            # regex.
+            :localtime,
+            # `time_gmtime` (registered as both `gmtime` and `utc`
+            # against `rb_cTime`) follows the same in-place pattern
+            # as `time_localtime`: `time_modify(time)` then a
+            # `time_set_vtm` write and `TZMODE_SET_UTC`. Both
+            # selectors share the cfunc, so both must be blocked.
+            :gmtime, :utc
+          ]
+        }
+      )
+    end
+  end
+end

data/lib/rigor/inference/expression_typer.rb

@@ -744,6 +744,33 @@ module Rigor
         arg_types = call_arg_types(node)
         block_type = block_return_type_for(node, receiver, arg_types)
 
+        # v0.0.3 A — implicit-self calls prefer a same-named
+        # top-level `def` over RBS dispatch. Without this,
+        # a helper like `def select(...)` defined inside an
+        # `RSpec.describe ... do ... end` block mis-routes
+        # through `Enumerable#select` / `Object#select` and
+        # the caller observes `Array[Elem]` instead of the
+        # helper's actual return type. The check fires only
+        # for `node.receiver.nil?` (true implicit self), so
+        # explicit-receiver dispatch is unaffected.
+        local_def = node.receiver.nil? ? scope.top_level_def_for(node.name) : nil
+        if local_def
+          local_inference = infer_top_level_user_method(local_def, receiver, arg_types)
+          return local_inference if local_inference
+
+          # The local def matches by name but the
+          # parameter shape is too complex for the first-
+          # iteration binder (kwargs / optionals / rest).
+          # Returning `Dynamic[Top]` is the safest answer:
+          # we know RBS dispatch would be wrong (the
+          # method is user-defined and shadows whatever
+          # ancestor method the dispatch would find), and
+          # `Dynamic[Top]` propagates correctly through
+          # downstream call chains without surfacing
+          # misleading false-positive diagnostics.
+          return dynamic_top
+        end
+
         result = MethodDispatcher.dispatch(
           receiver_type: receiver,
           method_name: node.name,
@@ -786,6 +813,22 @@ module Rigor
       # - the inference is already in progress for this
       #   (class, method, signature) tuple — recursion
       #   safety net.
+      # v0.0.3 A — re-types a top-level (or DSL-block-nested)
+      # `def` discovered by `ScopeIndexer` under the
+      # `TOP_LEVEL_DEF_KEY` sentinel. Mirrors the
+      # `infer_user_method_return` shape but uses the
+      # current `scope.self_type` (or implicit `Object`)
+      # as the receiver carrier so the body's own self is
+      # consistent with the call site's. Returns nil when
+      # the parameter shape disqualifies the def, when the
+      # body is empty, or when a recursion cycle is
+      # detected.
+      def infer_top_level_user_method(def_node, receiver, arg_types)
+        infer_user_method_return(def_node, receiver, arg_types)
+      rescue StandardError
+        nil
+      end
+
       def try_user_method_inference(receiver, call_node, arg_types)
         return nil unless receiver.is_a?(Type::Nominal)
 
@@ -806,7 +849,11 @@ module Rigor
         body_scope = build_user_method_body_scope(def_node, receiver, arg_types)
         return nil if body_scope.nil?
 
-        signature = [receiver.class_name, def_node.name, arg_types.map { |t| t.describe(:short) }]
+        # Recursion-guard signature. Uses `describe(:short)`
+        # so non-Nominal receivers (e.g. the implicit
+        # `Object` carrier used for top-level / DSL-block
+        # defs in v0.0.3 A) can participate without raising.
+        signature = [receiver.describe(:short), def_node.name, arg_types.map { |t| t.describe(:short) }]
         stack = (Thread.current[INFERENCE_GUARD_KEY] ||= [])
         return Type::Combinator.untyped if stack.include?(signature)