rigortype 0.0.8 → 0.1.0

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Proc` / `Method` / `UnboundMethod` catalog. Singleton —
+      # load once, consult during dispatch.
+      #
+      # The three callable carriers are imported together because
+      # `Init_Proc` registers them in a single C init block. They
+      # share the same fundamental hazard at the catalog tier:
+      # most of their public methods invoke the wrapped Ruby code
+      # (the proc body, the bound method's receiver, …) and that
+      # code can do anything — read mutable state, call I/O, return
+      # different values on successive calls. The static C-body
+      # classifier marks these `:leaf` because the C functions
+      # themselves do not call `rb_funcall*` / `rb_yield` directly
+      # (they delegate through the VM's optimised call paths and
+      # method-entry table), but folding any of them at compile
+      # time would freeze a value the runtime never actually
+      # produces twice.
+      #
+      # The blocklist below errs aggressively on the side of
+      # caution: a hypothetical future `Constant<Proc>` /
+      # `Constant<Method>` / `Constant<UnboundMethod>` carrier
+      # would have very little to gain from these folds and a
+      # great deal to lose if user code ran behind the analyzer's
+      # back. Reflective readers (`#arity`, `#parameters`,
+      # `#source_location`, `#name`, `#owner`, `#receiver`) remain
+      # foldable; the RBS tier still resolves return types for
+      # the blocklisted methods so callers do not lose precision.
+      PROC_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/proc.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Proc" => Set[
+            # `#call` / `#[]` / `#===` / `#yield` invoke the proc
+            # body. The C body routes through
+            # `OPTIMIZED_METHOD_TYPE_CALL` (a VM fast path the
+            # classifier cannot see into); the proc body can do
+            # anything — read globals, mutate captured locals,
+            # raise. MUST decline to fold.
+            :call,
+            :[],
+            :===,
+            :yield,
+            # `#curry` / `#<<` / `#>>` allocate a fresh `Proc`
+            # that closes over the receiver (and, for `<<` /
+            # `>>`, over the argument). Folding would freeze a
+            # specific `Proc` instance whose identity the runtime
+            # never actually produces (object_id differs every
+            # call), so the catalog tier declines.
+            :curry,
+            :<<,
+            :>>,
+            # `#to_proc` returns `self` for `Proc` (cheap), but
+            # blocking it keeps the rule shape uniform across the
+            # three callable carriers (Method#to_proc allocates a
+            # fresh `Proc`).
+            :to_proc,
+            # Identity-based equality and hashing: `#hash` is
+            # derived from the underlying ISeq pointer; `#==` /
+            # `#eql?` compare ISeq + binding. Folding to a
+            # `Constant<Integer>` / `Constant<bool>` would freeze
+            # an answer that depends on memory layout. Defensive.
+            :hash,
+            :==,
+            :eql?,
+            # `initialize_copy` is blocklisted by convention so a
+            # hypothetical future `Constant<Proc>` carrier cannot
+            # fold an aliasing copy through the catalog.
+            :initialize_copy
+          ],
+          "Method" => Set[
+            # `#call` / `#[]` / `#===` invoke the bound method.
+            # Same hazard as `Proc#call`: arbitrary user code,
+            # arbitrary side effects.
+            :call,
+            :[],
+            :===,
+            # `#curry` / `#<<` / `#>>` allocate a fresh `Proc`
+            # that closes over the bound method.
+            :curry,
+            :<<,
+            :>>,
+            # `#to_proc` allocates a fresh `Proc` wrapping the
+            # bound method — folding would freeze its object_id.
+            # The classifier already marks it `:block_dependent`,
+            # but the explicit entry keeps the intent obvious.
+            :to_proc,
+            # `#unbind` allocates a fresh `UnboundMethod` whose
+            # identity differs every call.
+            :unbind,
+            # Identity-based equality and hashing.
+            :hash,
+            :==,
+            :eql?,
+            # `initialize_copy` is blocklisted by convention.
+            :initialize_copy
+          ],
+          "UnboundMethod" => Set[
+            # `#bind` allocates a fresh `Method` whose object_id
+            # differs every call; `#bind_call` invokes the bound
+            # method (already classified `:block_dependent`).
+            :bind,
+            :bind_call,
+            # Identity-based equality and hashing.
+            :hash,
+            :==,
+            :eql?,
+            # `initialize_copy` is blocklisted by convention.
+            :initialize_copy
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Random` catalog. Singleton — load once, consult during
+      # dispatch.
+      #
+      # The static classifier marks most Random methods `:leaf`
+      # because their C bodies do not call `rb_funcall*` /
+      # `rb_yield` / `rb_check_frozen` directly. Random is the
+      # canonical case where that heuristic under-counts: every
+      # call to `#rand` / `#bytes` / `Random.rand` / `Random.bytes`
+      # advances the receiver's Mersenne-Twister state through a
+      # helper (`rand_random` -> `random_real` / `random_ulong_limited`),
+      # so folding any of them statically is unsound.
+      # `Random.new_seed` and `Random.urandom` are non-deterministic
+      # (different output every call); even though they are
+      # functionally pure they would produce a misleading constant
+      # at fold time. The whole class is conservative-by-default
+      # at the catalog tier; precision flows through the RBS layer.
+      RANDOM_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/random.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Random" => Set[
+            # `rand_random` -> `random_real` / `random_ulong_limited`
+            # advance the MT state on the receiver (instance #rand)
+            # and on `Random::DEFAULT` (singleton .rand). The
+            # classifier misses the indirect mutator.
+            :rand,
+            # `random_bytes` / `random_s_bytes` consume MT output
+            # the same way #rand does — every call mutates the
+            # underlying generator.
+            :bytes,
+            # Non-deterministic: each call produces a fresh seed
+            # via `with_random_seed` reading platform entropy. Folding
+            # to a constant would freeze a value that the runtime
+            # never actually returns twice.
+            :new_seed,
+            # Non-deterministic: reads from platform CSPRNG (e.g.
+            # /dev/urandom). Folding is unsound for the same reason
+            # as `new_seed`.
+            :urandom,
+            # `initialize_copy` is blocklisted by convention so a
+            # hypothetical future `Constant<Random>` carrier
+            # cannot fold an aliasing copy through the catalog.
+            :initialize_copy
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Regexp` / `MatchData` catalog. Singleton — load once,
+      # consult during dispatch.
+      #
+      # `Init_Regexp` in `references/ruby/re.c` registers BOTH
+      # classes in a single C init block, so the catalog carries
+      # both — `Regexp` (the pattern carrier) plus `MatchData`
+      # (the result-of-match carrier produced by `Regexp#match` /
+      # `String#match` and consulted via `$~`). The catalog wiring
+      # therefore mostly governs:
+      #
+      # 1. The reader surface on each class (`Regexp#source`,
+      #    `Regexp#options`, `Regexp#casefold?`, `MatchData#size`,
+      #    `MatchData#captures`, etc.) — RBS-declared returns are
+      #    preserved through dispatch.
+      # 2. The blocklist below, which keeps methods that touch
+      #    process-global state (the `$~` backref) from being
+      #    folded. Regexp matching is observably stateful:
+      #    `Regexp#=~`, `#===` and `#~` all call `rb_backref_set`
+      #    (writing `$~` and the `$1..$N` / `$&` / `` $` `` / `$'`
+      #    aliases). A constant-fold that dropped those calls
+      #    would silently change the visible state of the program,
+      #    so they MUST decline through to the RBS tier.
+      #
+      # `Regexp.last_match` and `Regexp.timeout` / `Regexp.timeout=`
+      # are class-level (singleton) methods that also touch
+      # process-global state, but the dispatcher's catalog lookup
+      # only consults `:instance` entries today — class-method calls
+      # on a `Singleton` receiver type take the `meta_*` path in
+      # `MethodDispatcher` rather than walking `CATALOG_BY_CLASS` —
+      # so listing them here would be dead code. Their RBS-tier
+      # signatures already widen the answer enough to keep the
+      # behaviour sound; revisit if the dispatcher ever grows a
+      # singleton-aware catalog path.
+      REGEXP_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/re.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Regexp" => Set[
+            # Defensive: aliasing-copy semantics already covered
+            # by the `:mutates_self` classifier, listed here for
+            # symmetry with String / Array / Hash / Range / Set.
+            :initialize_copy,
+            # `=~`, `===`, `~` all run `rb_reg_search` (or call
+            # `rb_backref_set(Qnil)` directly) — every successful
+            # OR failing match writes `$~` and the
+            # `$1..$N` / `$&` / `` $` `` / `$'` aliases. Folding
+            # would discard the visible side effect.
+            :=~,
+            :"===",
+            :~,
+            # `match` is already `:block_dependent` (the C body
+            # yields), but it ALSO writes `$~` regardless of the
+            # block. Listed here so a future extractor that
+            # reclassifies it as `:leaf` (because the yield is
+            # behind a helper) does not silently fold it.
+            :match
+          ],
+          "MatchData" => Set[
+            # Defensive entry mirroring the other catalogs.
+            # `match_init_copy` is already `:leaf` per the
+            # extractor (it copies the regs slot in place but
+            # uses no helper the C-body regex flags as a
+            # mutator); blocked so a future
+            # `Constant<MatchData>` carrier never folds an
+            # aliasing copy through the catalog.
+            :initialize_copy
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # `Struct` catalog. Singleton — load once, consult during
+      # dispatch.
+      #
+      # `Struct` is a meta-class: `Struct.new(*members)` returns a
+      # fresh anonymous subclass — never a `Struct` value. Today
+      # Rigor never produces a `Constant<Struct>` carrier (a literal
+      # struct instance), so the catalog is defensive: it documents
+      # the shape and forbids unsafe folds in case a future tier
+      # learns to lift literal struct instances into the value
+      # lattice.
+      #
+      # Subclasses define their own writers (`name=`) at class-build
+      # time, so per-instance member accessors do not appear in this
+      # YAML — only the generic `[]` / `[]=` pair on the base class.
+      # `[]=` is already classified `:mutates_self`; `[]` reads a
+      # member but the answer depends on the subclass's member
+      # definition, which the catalog does not see, so we blocklist
+      # it defensively.
+      STRUCT_CATALOG = MethodCatalog.new(
+        path: File.expand_path(
+          "../../../../data/builtins/ruby_core/struct.yml",
+          __dir__
+        ),
+        mutating_selectors: {
+          "Struct" => Set[
+            # Defensive: aliasing-copy semantics on a hypothetical
+            # `Constant<Struct>` carrier. Convention across the
+            # other catalogs (Range, Random, Pathname).
+            :initialize_copy,
+            # `rb_struct_hash` mixes member values via
+            # `rb_hash` -> `rb_funcall(:hash, ...)`. The classifier
+            # sees no direct dispatch because the recursion goes
+            # through `rb_hash` (a helper), but the answer depends
+            # on the member values' `#hash` — user-redefinable.
+            # Block to avoid folding a hash that would diverge
+            # from the runtime once a member overrides `#hash`.
+            :hash,
+            # `rb_struct_aref` reads a member by name or index; the
+            # answer depends on the subclass's member layout, which
+            # the catalog does not carry. Folding without knowing
+            # the layout would be unsound.
+            :[]
+          ]
+        }
+      )
+    end
+  end
+end

data/lib/rigor/inference/expression_typer.rb

@@ -65,6 +65,7 @@ module Rigor
         Prism::NilNode => :type_of_nil,
         # Locals
         Prism::LocalVariableReadNode => :local_read,
+        Prism::ItLocalVariableReadNode => :it_read,
         Prism::LocalVariableWriteNode => :type_of_assignment_write,
         # Containers and pass-throughs
         Prism::ArrayNode => :array_type_for,
@@ -171,9 +172,11 @@ module Rigor
         Prism::WhileNode => :type_of_loop,
         Prism::UntilNode => :type_of_loop,
         Prism::ForNode => :type_of_dynamic_top,
-        Prism::DefinedNode => :type_of_dynamic_top,
-        Prism::MatchPredicateNode => :type_of_dynamic_top,
-        Prism::MatchRequiredNode => :type_of_dynamic_top,
+        Prism::DefinedNode => :type_of_defined,
+        Prism::NumberedReferenceReadNode => :type_of_string_or_nil,
+        Prism::BackReferenceReadNode => :type_of_string_or_nil,
+        Prism::MatchPredicateNode => :type_of_match_predicate,
+        Prism::MatchRequiredNode => :type_of_match_required,
         Prism::MatchWriteNode => :type_of_dynamic_top,
         # Literal containers
         Prism::LambdaNode => :type_of_lambda,
@@ -298,6 +301,45 @@ module Rigor
         dynamic_top
       end
 
+      # `defined?(expr)` returns `String | nil` per Ruby semantics —
+      # a description of the expression's category (`"local-variable"`,
+      # `"method"`, ...) when defined, or `nil` when not. The argument
+      # is not evaluated (it is statically inspected by the runtime),
+      # so the typer does not recurse into it.
+      def type_of_defined(_node)
+        Type::Combinator.union(
+          Type::Combinator.nominal_of("String"),
+          Type::Combinator.constant_of(nil)
+        )
+      end
+
+      # `$1`, `$&`, `$'`, `$+`, `$\`` — the regex back-reference and
+      # numbered-capture globals each carry `String | nil`. They share
+      # the typer because the typing rule is identical regardless of
+      # which back-reference shape Prism emitted.
+      def type_of_string_or_nil(_node)
+        Type::Combinator.union(
+          Type::Combinator.nominal_of("String"),
+          Type::Combinator.constant_of(nil)
+        )
+      end
+
+      # `expr in pattern` — pattern-match predicate. Returns `true`
+      # when the pattern matches, `false` otherwise.
+      def type_of_match_predicate(_node)
+        Type::Combinator.union(
+          Type::Combinator.constant_of(true),
+          Type::Combinator.constant_of(false)
+        )
+      end
+
+      # `expr => pattern` — one-line pattern-match assertion. Raises
+      # `NoMatchingPatternError` on mismatch; on success the expression
+      # itself evaluates to `nil`.
+      def type_of_match_required(_node)
+        Type::Combinator.constant_of(nil)
+      end
+
       # The expression `Foo` evaluates to the *class object* `Foo`, not
       # an instance. From Slice 4 phase 2b on we therefore type a
       # bare-constant reference as `Singleton[Foo]`; method dispatch on
@@ -472,10 +514,35 @@ module Rigor
         [keys, values]
       end
 
-      def type_of_interpolated_string(_node)
+      # An interpolated string `"#{a}b#{c}"` is `literal-string`
+      # when every part contributes literal-bearing material:
+      # plain text segments are literal by construction, embedded
+      # expressions count when their type is itself literal-string-
+      # compatible (a `Constant<String>`, the `literal-string`
+      # carrier, an `Intersection` containing it, or a `Union`
+      # whose members all qualify). Otherwise the result widens to
+      # plain `Nominal[String]` as before.
+      def type_of_interpolated_string(node)
+        return Type::Combinator.literal_string if interpolation_parts_literal?(node.parts)
+
         Type::Combinator.nominal_of(String)
       end
 
+      def interpolation_parts_literal?(parts)
+        parts.all? { |part| interpolation_part_literal?(part) }
+      end
+
+      def interpolation_part_literal?(part)
+        case part
+        when Prism::StringNode
+          true
+        when Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode
+          Type::Combinator.literal_string_compatible?(type_of(part))
+        else
+          false
+        end
+      end
+
       def type_of_interpolated_symbol(_node)
         Type::Combinator.nominal_of(Symbol)
       end
@@ -698,9 +765,38 @@ module Rigor
       def type_of_range(node)
         left_static, left = static_range_endpoint(node.left)
         right_static, right = static_range_endpoint(node.right)
-        return Type::Combinator.nominal_of(Range) unless left_static && right_static
+        return Type::Combinator.constant_of(Range.new(left, right, node.exclude_end?)) if left_static && right_static
+
+        nominal_range_for_endpoints(node.left, node.right)
+      end
+
+      # Derives `Nominal[Range, [T]]` from the endpoint expression
+      # types when at least one endpoint is statically typeable. The
+      # element parameter is the union of the endpoint types (lifted
+      # from `Constant<v>` to `Nominal<v.class>` so the carrier matches
+      # what `Range#each` would yield). Falls back to bare
+      # `Nominal[Range]` when no endpoint contributes a typable shape.
+      def nominal_range_for_endpoints(left_node, right_node)
+        endpoints = [left_node, right_node].compact.map { |n| range_endpoint_element_type(n) }
+        endpoints.reject! { |t| t.equal?(Type::Combinator.untyped) }
+        return Type::Combinator.nominal_of("Range") if endpoints.empty?
+
+        Type::Combinator.nominal_of("Range", type_args: [Type::Combinator.union(*endpoints)])
+      end
+
+      def range_endpoint_element_type(node)
+        type = type_of(node)
+        case type
+        when Type::Constant
+          value = type.value
+          return Type::Combinator.untyped if value.nil?
 
-        Type::Combinator.constant_of(Range.new(left, right, node.exclude_end?))
+          Type::Combinator.nominal_of(value.class.name)
+        when Type::IntegerRange
+          Type::Combinator.nominal_of("Integer")
+        else
+          type
+        end
       end
 
       # v0.0.7 — non-interpolated regex literals lift to
@@ -721,6 +817,7 @@ module Rigor
       def static_range_endpoint(node)
         return [true, nil] if node.nil?
         return [true, node.value] if node.is_a?(Prism::IntegerNode)
+        return [true, node.unescaped] if node.is_a?(Prism::StringNode) && node.respond_to?(:unescaped)
 
         [false, nil]
       end
@@ -780,6 +877,13 @@ module Rigor
         scope.local(node.name) || dynamic_top
       end
 
+      # `it` (Ruby 3.4) — `ItLocalVariableReadNode` carries no `name`
+      # field; the implicit name is always `:it`, matching the binding
+      # `BlockParameterBinder` installs for `Prism::ItParametersNode`.
+      def it_read(_node)
+        scope.local(:it) || dynamic_top
+      end
+
       # Slice 5 phase 1 upgrades array literals to `Tuple[T1..Tn]`
       # when every element is a non-splat value. Splatted entries
       # (`[*xs, 1]`) preserve the Slice 4 phase 2d behavior: we union

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

@@ -14,6 +14,12 @@ require_relative "../builtins/enumerable_catalog"
 require_relative "../builtins/rational_catalog"
 require_relative "../builtins/complex_catalog"
 require_relative "../builtins/pathname_catalog"
+require_relative "../builtins/random_catalog"
+require_relative "../builtins/struct_catalog"
+require_relative "../builtins/encoding_catalog"
+require_relative "../builtins/re_catalog"
+require_relative "../builtins/proc_catalog"
+require_relative "../builtins/exception_catalog"
 
 module Rigor
   module Inference
@@ -1077,7 +1083,16 @@ module Rigor
           [Date,     [Builtins::DATE_CATALOG,   "Date"]],
           [Rational, [Builtins::RATIONAL_CATALOG, "Rational"]],
           [Complex,  [Builtins::COMPLEX_CATALOG,  "Complex"]],
-          [Pathname, [Builtins::PATHNAME_CATALOG, "Pathname"]]
+          [Pathname, [Builtins::PATHNAME_CATALOG, "Pathname"]],
+          [Random, [Builtins::RANDOM_CATALOG, "Random"]],
+          [Struct, [Builtins::STRUCT_CATALOG, "Struct"]],
+          [Encoding, [Builtins::ENCODING_CATALOG, "Encoding"]],
+          [Regexp, [Builtins::REGEXP_CATALOG, "Regexp"]],
+          [MatchData, [Builtins::REGEXP_CATALOG, "MatchData"]],
+          [Proc, [Builtins::PROC_CATALOG, "Proc"]],
+          [Method, [Builtins::PROC_CATALOG, "Method"]],
+          [UnboundMethod, [Builtins::PROC_CATALOG, "UnboundMethod"]],
+          [Exception, [Builtins::EXCEPTION_CATALOG, "Exception"]]
         ].freeze
         private_constant :CATALOG_BY_CLASS