rigortype 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0af88abcc3dd912fd5c9d22440dc456b0418d6bd0de2cae58167f8538880c1a0
-  data.tar.gz: 2ef580ca7c24007313fd4b30e4e2f0dc1cd59e68ccdc4113f3fe060694880782
+  metadata.gz: 0aa63fadd57282a307bf4664cce576c1b955617b6643c64d436827595a751ccb
+  data.tar.gz: 4e7cc6e58c5fcb45eb201182cbb87f723a558972334add650aecdeb80ed7c502
 SHA512:
-  metadata.gz: 46bd06614cdbf530ada69f28fd5be8620b5e54d834c8af69663fdf0949f0592a7123e0f564d924046dbc9b3d9d04ffec96af593825c6b84cafebf1a6b1a60431
-  data.tar.gz: df1f86d712a8a081356917989a4c98c775180eb805d54300b671d652a2d87eee86a7624d9b8812f2e7a4b3b26364a668948aa8aa06481c53295908428ab0d4ae
+  metadata.gz: 9972f4ac5258340ab534ce5bd3aad4dfda7f23e080013f0f3fdc96d4ea0fb45c458cfa3c68e14b5e2b7ffdf273e7fa81f76d7d80761cd0a5b3b6291f903a5157
+  data.tar.gz: 3009bf4ab97ee163ec05fc262bbdc130dc5e5ebf877bea9b1e220f0607251d96bf81ad10e1f6505d2f2999e8f12bb6bb823577dd142645295e2fdc2fc7d29fe2

data/lib/rigor/analysis/check_rules.rb

@@ -2,6 +2,7 @@
 
 require "prism"
 
+require_relative "../reflection"
 require_relative "../source/node_walker"
 require_relative "../type"
 require_relative "diagnostic"
@@ -172,9 +173,7 @@ module Rigor
           kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
           return nil if scope.discovered_method?(class_name, call_node.name, kind)
 
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
-          return nil unless loader.class_known?(class_name)
+          return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
 
           # When the loader cannot build a class definition for a
           # name it nominally knows (constant-decl aliases such
@@ -182,9 +181,9 @@ module Rigor
           # malformed signatures), we cannot enumerate methods
           # so we MUST NOT emit a false positive. Skip the rule
           # in that case.
-          return nil unless definition_available?(loader, receiver_type, class_name)
+          return nil unless definition_available?(receiver_type, class_name, scope)
 
-          method_def = lookup_method(loader, receiver_type, class_name, call_node.name)
+          method_def = lookup_method(receiver_type, class_name, call_node.name, scope)
           return nil if method_def
 
           build_undefined_method_diagnostic(path, call_node, receiver_type)
@@ -219,27 +218,29 @@ module Rigor
           nil
         end
 
-        def definition_available?(loader, receiver_type, class_name)
+        def definition_available?(receiver_type, class_name, scope)
           if receiver_type.is_a?(Type::Singleton)
-            !loader.singleton_definition(class_name).nil?
+            !Rigor::Reflection.singleton_definition(class_name, scope: scope).nil?
           else
-            !loader.instance_definition(class_name).nil?
+            !Rigor::Reflection.instance_definition(class_name, scope: scope).nil?
           end
-        rescue StandardError
-          false
         end
 
-        def lookup_method(loader, receiver_type, class_name, method_name)
+        def lookup_method(receiver_type, class_name, method_name, scope)
           if receiver_type.is_a?(Type::Singleton)
-            loader.singleton_method(class_name: class_name, method_name: method_name)
+            Rigor::Reflection.singleton_method_definition(class_name, method_name, scope: scope)
           else
-            loader.instance_method(class_name: class_name, method_name: method_name)
+            Rigor::Reflection.instance_method_definition(class_name, method_name, scope: scope)
           end
         rescue StandardError
-          # The loader is best-effort and may raise on malformed
-          # RBS. Treat any failure as "method exists" so we do
-          # NOT emit a false positive when our knowledge of the
-          # receiver class is structurally incomplete.
+          # The Reflection facade catches loader exceptions and
+          # returns nil. The wrapper here treats failures as
+          # "method exists" so we do NOT emit a false positive
+          # when our knowledge of the receiver class is
+          # structurally incomplete (Reflection's own rescue
+          # already returns nil; this catch is a defensive
+          # double-net for any future call shape that might
+          # raise).
           true
         end
 
@@ -271,12 +272,10 @@ module Rigor
           kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
           return nil if scope.discovered_method?(class_name, call_node.name, kind)
 
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
-          return nil unless loader.class_known?(class_name)
-          return nil unless definition_available?(loader, receiver_type, class_name)
+          return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
+          return nil unless definition_available?(receiver_type, class_name, scope)
 
-          method_def = lookup_method(loader, receiver_type, class_name, call_node.name)
+          method_def = lookup_method(receiver_type, class_name, call_node.name, scope)
           return nil if method_def.nil? || method_def == true
 
           arity_envelope = compute_arity_envelope(method_def)
@@ -383,12 +382,14 @@ module Rigor
           receiver_type = scope.type_of(call_node.receiver)
           return nil unless receiver_type.is_a?(Type::Union)
 
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
+          # The rule only fires when the analyzer has access to
+          # an RBS loader; without it, the per-member method-
+          # presence checks below cannot rule out a sound call.
+          return nil unless Rigor::Reflection.rbs_class_known?("NilClass", scope: scope)
 
           return nil unless union_contains_nil?(receiver_type)
-          return nil unless union_method_present_on_non_nil?(receiver_type, call_node.name, loader, scope)
-          return nil if nil_class_has_method?(call_node.name, loader)
+          return nil unless union_method_present_on_non_nil?(receiver_type, call_node.name, scope)
+          return nil if nil_class_has_method?(call_node.name, scope)
 
           build_nil_receiver_diagnostic(path, call_node)
         end
@@ -409,27 +410,25 @@ module Rigor
         # that are unsound on the non-nil branch — that is the
         # `undefined_method_diagnostic` rule's job, and we want
         # exactly one diagnostic per offending call site.
-        def union_method_present_on_non_nil?(union, method_name, loader, scope)
+        def union_method_present_on_non_nil?(union, method_name, scope)
           non_nil_members = union.members.reject { |m| nil_member?(m) }
           return false if non_nil_members.empty?
 
-          non_nil_members.all? { |m| method_present_anywhere?(m, method_name, loader, scope) }
+          non_nil_members.all? { |m| method_present_anywhere?(m, method_name, scope) }
         end
 
-        def method_present_anywhere?(member, method_name, loader, scope)
+        def method_present_anywhere?(member, method_name, scope)
           class_name = concrete_class_name(member)
           return true if class_name.nil? # Dynamic / Top / Bot — be permissive.
           return true if scope.discovered_method?(class_name, method_name, :instance)
-          return true unless loader.class_known?(class_name)
-          return true unless definition_available?(loader, member, class_name)
+          return true unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
+          return true unless definition_available?(member, class_name, scope)
 
-          !lookup_method(loader, member, class_name, method_name).nil?
+          !lookup_method(member, class_name, method_name, scope).nil?
         end
 
-        def nil_class_has_method?(method_name, loader)
-          return false unless loader.class_known?("NilClass")
-
-          definition = loader.instance_definition("NilClass")
+        def nil_class_has_method?(method_name, scope)
+          definition = Rigor::Reflection.instance_definition("NilClass", scope: scope)
           return false if definition.nil?
 
           !definition.methods[method_name.to_sym].nil?
@@ -684,12 +683,10 @@ module Rigor
           # supplies BOTH a `def` and an RBS sig, the sig is
           # the authoritative parameter contract and we
           # should validate calls against it.
-          loader = scope.environment.rbs_loader
-          return nil if loader.nil?
-          return nil unless loader.class_known?(class_name)
-          return nil unless definition_available?(loader, receiver_type, class_name)
+          return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
+          return nil unless definition_available?(receiver_type, class_name, scope)
 
-          method_def = lookup_method(loader, receiver_type, class_name, call_node.name)
+          method_def = lookup_method(receiver_type, class_name, call_node.name, scope)
           return nil if method_def.nil? || method_def == true
           return nil unless method_def.method_types.size == 1
 

data/lib/rigor/builtins/imported_refinements.rb

@@ -78,6 +78,41 @@ module Rigor
           return nil unless args.size == 2
 
           Type::Combinator.non_empty_hash(args[0], args[1])
+        },
+        # v0.0.7 — `key_of[T]` and `value_of[T]` type functions.
+        # Each takes a single type argument and projects the
+        # known-keys (resp. known-values) union out of `T`. See
+        # `Type::Combinator.key_of` for the per-shape projection
+        # rules. Use `lower_snake` per the
+        # imported-built-in-types.md type-function naming rule.
+        "key_of" => lambda { |args|
+          return nil unless args.size == 1
+
+          Type::Combinator.key_of(args.first)
+        },
+        "value_of" => lambda { |args|
+          return nil unless args.size == 1
+
+          Type::Combinator.value_of(args.first)
+        },
+        # `int_mask[1, 2, 4]` — every integer representable by
+        # a bitwise OR over the listed flags. Each arg must be a
+        # `Constant<Integer>`; the parser wraps integer literals
+        # for this purpose. Builder declines on any non-integer
+        # arg.
+        "int_mask" => lambda { |args|
+          flags = args.map { |arg| arg.is_a?(Type::Constant) && arg.value.is_a?(Integer) ? arg.value : nil }
+          return nil if flags.any?(&:nil?)
+
+          Type::Combinator.int_mask(flags)
+        },
+        # `int_mask_of[T]` — derives the closure from a finite
+        # integer literal type (single Constant<Integer> or a
+        # Union of them).
+        "int_mask_of" => lambda { |args|
+          return nil unless args.size == 1
+
+          Type::Combinator.int_mask_of(args.first)
         }
       }.freeze
       private_constant :PARAMETERISED_TYPE_BUILDERS
@@ -145,7 +180,7 @@ module Rigor
       # soft (returns `nil` from `parse`) on any deviation so the
       # `RBS::Extended` directive site can fall back to the
       # RBS-declared type rather than crash on a typo.
-      class Parser
+      class Parser # rubocop:disable Metrics/ClassLength
         def initialize(input)
           @scanner = StringScanner.new(input.strip)
         end
@@ -153,6 +188,12 @@ module Rigor
         def parse
           type = parse_type
           return nil if type.nil?
+
+          # v0.0.7 — trailing `[K]` indexed-access projects
+          # into the parsed type. Multiple `[K]` segments
+          # chain (`Tuple[A, B, C][1][0]`).
+          type = parse_indexed_access_chain(type)
+          return nil if type.nil?
           return nil unless @scanner.eos?
 
           type
@@ -160,12 +201,21 @@ module Rigor
 
         private
 
-        SIMPLE_NAME = /[a-z][a-z0-9-]*/
+        # Refinement names use kebab-case (`non-empty-string`),
+        # type-function names use lower_snake (`key_of`,
+        # `value_of`, `int_mask`). The regex accepts both shapes;
+        # the registry lookup decides which family the name
+        # belongs to.
+        SIMPLE_NAME = /[a-z][a-z0-9_-]*/
         CLASS_NAME = /[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*/
         SIGNED_INT = /-?\d+/
         private_constant :SIMPLE_NAME, :CLASS_NAME, :SIGNED_INT
 
         def parse_type
+          if (class_name = @scanner.scan(CLASS_NAME))
+            return parse_class_arg_tail(class_name)
+          end
+
           name = @scanner.scan(SIMPLE_NAME)
           return nil if name.nil?
 
@@ -176,6 +226,25 @@ module Rigor
           end
         end
 
+        # `T[K]` — keep applying `[K]` indexes until no more
+        # opening brackets are present. Each index consumes one
+        # type argument; multi-arg `[K1, K2]` fails (the spec
+        # specifies a single key).
+        def parse_indexed_access_chain(type)
+          loop do
+            skip_ws
+            break unless @scanner.peek(1) == "["
+
+            @scanner.getch
+            args = parse_type_arg_list
+            return nil if args.nil? || args.size != 1
+            return nil unless @scanner.getch == "]"
+
+            type = Type::Combinator.indexed_access(type, args.first)
+          end
+          type
+        end
+
         def parse_parametric_type_args(name)
           builder = PARAMETERISED_TYPE_BUILDERS[name]
           return nil if builder.nil?
@@ -227,12 +296,33 @@ module Rigor
         def parse_type_arg
           skip_ws
           if (class_name = @scanner.scan(CLASS_NAME))
-            Type::Combinator.nominal_of(class_name)
+            parse_class_arg_tail(class_name)
+          elsif (literal = @scanner.scan(SIGNED_INT))
+            # Integer-literal arg, used by `int_mask[1, 2, 4]`.
+            # Wrapped as `Constant<Integer>` so type-arg builders
+            # see a uniform `Array<Type::t>`.
+            Type::Combinator.constant_of(Integer(literal))
           else
             parse_type
           end
         end
 
+        # Class-name-headed type argument with optional `[T_1,
+        # …]` type-args tail. Used so `key_of[Hash[Symbol,
+        # Integer]]` parses as the projection of a parameterised
+        # nominal carrier rather than rejecting the inner
+        # brackets.
+        def parse_class_arg_tail(class_name)
+          return Type::Combinator.nominal_of(class_name) unless @scanner.peek(1) == "["
+
+          @scanner.getch # consume '['
+          args = parse_type_arg_list
+          return nil if args.nil?
+          return nil unless @scanner.getch == "]"
+
+          Type::Combinator.nominal_of(class_name, type_args: args)
+        end
+
         def parse_int_bound
           skip_ws
           literal = @scanner.scan(SIGNED_INT)

data/lib/rigor/inference/expression_typer.rb

@@ -52,6 +52,12 @@ module Rigor
         # Literals
         Prism::IntegerNode => :type_of_literal_value,
         Prism::FloatNode => :type_of_literal_value,
+        # `1i` / `2.5ri` lift via `node.value` which is already a
+        # `Complex` Ruby value; same for `1r` / `1.5r` whose
+        # value is a `Rational`. `Type::Constant` accepts both
+        # via `SCALAR_CLASSES`.
+        Prism::ImaginaryNode => :type_of_literal_value,
+        Prism::RationalNode => :type_of_literal_value,
         Prism::SymbolNode => :symbol_type_for,
         Prism::StringNode => :string_type_for,
         Prism::TrueNode => :type_of_true,
@@ -401,7 +407,13 @@ module Rigor
       # so callers stay backward compatible.
       def type_of_hash(node)
         elements = node.respond_to?(:elements) ? node.elements : []
-        return Type::Combinator.nominal_of(Hash) if elements.empty?
+        # v0.0.7 — `{}` resolves to the empty `HashShape{}` carrier
+        # rather than `Nominal[Hash]`, mirroring the v0.0.6 empty-
+        # array literal change. Both forms erase to plain `Hash`,
+        # but `HashShape{}` pins the literal's known size (zero)
+        # so HashShape projections (`empty?`, `first`, `count`,
+        # …) fold against it.
+        return Type::Combinator.hash_shape_of({}) if elements.empty?
 
         shape = static_hash_shape_for(elements)
         return shape if shape
@@ -691,7 +703,18 @@ module Rigor
         Type::Combinator.constant_of(Range.new(left, right, node.exclude_end?))
       end
 
-      def type_of_regexp(_node)
+      # v0.0.7 — non-interpolated regex literals lift to
+      # `Constant<Regexp>` so `Constant<String>#scan(/regex/)`
+      # / `#match(/regex/)` etc. can fold through the catalog
+      # tier. Interpolated regexes (`/foo#{x}/`) reach the
+      # second `Prism::InterpolatedRegularExpressionNode` arm
+      # which keeps the conservative `Nominal[Regexp]` answer.
+      def type_of_regexp(node)
+        return Type::Combinator.nominal_of(Regexp) unless node.is_a?(Prism::RegularExpressionNode)
+
+        regex = Regexp.new(node.unescaped, node.options)
+        Type::Combinator.constant_of(regex)
+      rescue StandardError
         Type::Combinator.nominal_of(Regexp)
       end
 

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

@@ -109,6 +109,16 @@ module Rigor
 
         # @return [Rigor::Type::Constant, Rigor::Type::Union, Rigor::Type::IntegerRange, nil]
         def try_fold(receiver:, method_name:, args:)
+          # v0.0.7 — `String#%` against a `Tuple` / `HashShape`
+          # argument runs Ruby's format-string engine when both
+          # sides are statically constant. The standard
+          # `numeric_set_of` path bails on Tuple / HashShape
+          # arguments because they are not scalar-Constant
+          # carriers, so the special-case sits ahead of the
+          # numeric path.
+          format_lift = try_fold_string_format(receiver, method_name, args)
+          return format_lift if format_lift
+
           receiver_set = numeric_set_of(receiver)
           return nil unless receiver_set
 
@@ -118,6 +128,59 @@ module Rigor
           dispatch_by_arity(receiver_set, method_name, arg_sets)
         end
 
+        # `Constant<String> % …` — runs the actual `String#%`
+        # operation when both sides are statically known. The
+        # argument may be:
+        # - A `Type::Constant` whose value is a scalar (Integer
+        #   / Float / String / Symbol). Already handled by the
+        #   numeric path; this method declines so the standard
+        #   binary path picks it up.
+        # - A `Type::Tuple` whose elements are all `Constant`.
+        #   Materialises the elements as a Ruby Array and runs
+        #   the format.
+        # - A `Type::HashShape` with no optional keys whose
+        #   values are all `Constant`. Materialises a Ruby Hash
+        #   and runs the format. Symbol keys are kept as
+        #   Symbols (matching Ruby's `%{key}` resolution).
+        # Anything else declines so the RBS tier widens.
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def try_fold_string_format(receiver, method_name, args)
+          return nil unless method_name == :%
+          return nil unless args.size == 1
+          return nil unless receiver.is_a?(Type::Constant) && receiver.value.is_a?(String)
+
+          arg = args.first
+          ruby_arg = format_argument_value(arg)
+          return nil if ruby_arg.nil?
+
+          result = receiver.value % ruby_arg
+          return nil unless foldable_constant_value?(result)
+
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def format_argument_value(arg)
+          case arg
+          when Type::Tuple
+            return nil unless arg.elements.all?(Type::Constant)
+
+            arg.elements.map(&:value)
+          when Type::HashShape
+            hash_shape_format_value(arg)
+          end
+        end
+
+        def hash_shape_format_value(shape)
+          return nil unless shape.closed?
+          return nil unless shape.optional_keys.empty?
+          return nil unless shape.pairs.values.all?(Type::Constant)
+
+          shape.pairs.transform_values(&:value)
+        end
+
         def dispatch_by_arity(receiver_set, method_name, arg_sets)
           case arg_sets.size
           when 0 then try_fold_unary(receiver_set, method_name)
@@ -206,7 +269,17 @@ module Rigor
           [result]
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def try_fold_unary_set(receiver_values, method_name)
+          range_lift = try_fold_range_constant_unary(receiver_values, method_name)
+          return range_lift if range_lift
+
+          string_lift = try_fold_string_array_unary(receiver_values, method_name)
+          return string_lift if string_lift
+
+          pathname_lift = try_fold_pathname_unary(receiver_values, method_name)
+          return pathname_lift if pathname_lift
+
           # Type-level allow check on every receiver. If one member's
           # type does not have the method in its allow list (e.g.
           # `Union[String, nil].nil?` — `:nil?` is not in
@@ -220,8 +293,68 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        # v0.0.7 — `Constant<Range>#to_a` and the no-arg
+        # `first` / `last` / `min` / `max` short-circuit through a
+        # Range-specific arm that catalog dispatch cannot reach:
+        # - `to_a` returns an Array (not foldable through
+        #   `foldable_constant_value?`) — lift to `Tuple[Constant…]`
+        #   when the cardinality fits within `RANGE_TO_A_LIMIT`.
+        # - `first` / `last` / `min` / `max` are catalog-classified
+        #   `:block_dependent` because of the optional-block forms,
+        #   but the no-arg form is pure for finite integer ranges.
+        #
+        # Only fires on a single-receiver Range with finite integer
+        # endpoints; mixed unions fall through so the existing
+        # union-of-Constants path keeps the rest of the arms.
+        RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length].freeze
+        RANGE_TO_A_LIMIT = 16
+        private_constant :RANGE_FOLD_METHODS, :RANGE_TO_A_LIMIT
+
+        def try_fold_range_constant_unary(receiver_values, method_name)
+          return nil unless RANGE_FOLD_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
 
+          range = receiver_values.first
+          return nil unless range.is_a?(Range)
+          return nil unless range.begin.is_a?(Integer) && range.end.is_a?(Integer)
+
+          range_constant_unary(range, method_name)
+        end
+
+        def range_constant_unary(range, method_name)
+          case method_name
+          when :to_a then range_to_a_tuple(range)
+          when :first, :min then range_endpoint_constant(range, :first)
+          when :last, :max then range_endpoint_constant(range, :last)
+          when :count, :size, :length then Type::Combinator.constant_of(range.to_a.size)
+          end
+        end
+
+        def range_to_a_tuple(range)
+          values = range.to_a
+          return Type::Combinator.tuple_of if values.empty?
+          return nil if values.size > RANGE_TO_A_LIMIT
+
+          Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
+        end
+
+        def range_endpoint_constant(range, edge)
+          values = range.to_a
+          return Type::Combinator.constant_of(nil) if values.empty?
+
+          Type::Combinator.constant_of(edge == :first ? values.first : values.last)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def try_fold_binary_set(receiver_values, method_name, arg_values)
+          string_lift = try_fold_string_array_binary(receiver_values, method_name, arg_values)
+          return string_lift if string_lift
+
+          pathname_lift = try_fold_pathname_binary(receiver_values, method_name, arg_values)
+          return pathname_lift if pathname_lift
+
           return nil if receiver_values.size * arg_values.size > UNION_FOLD_INPUT_LIMIT
           return nil unless receiver_values.all? { |rv| binary_method_allowed?(rv, method_name) }
 
@@ -230,6 +363,119 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values + arg_values)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        # v0.0.7 — `Constant<String>#chars` / `bytes` / `lines` /
+        # `split` (no-arg) return a Ruby Array of foldable
+        # scalars; `foldable_constant_value?` rejects Array
+        # results, so the standard unary path declines. Lift the
+        # Array to a per-position `Tuple[Constant…]` directly,
+        # capped at `STRING_ARRAY_LIFT_LIMIT` to keep the result
+        # bounded for long strings.
+        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :lines, :split].freeze
+        STRING_ARRAY_BINARY_METHODS = Set[:split, :scan].freeze
+        STRING_ARRAY_LIFT_LIMIT = 32
+        private_constant :STRING_ARRAY_UNARY_METHODS,
+                         :STRING_ARRAY_BINARY_METHODS,
+                         :STRING_ARRAY_LIFT_LIMIT
+
+        # v0.0.7 — `Constant<Pathname>` delegates to a curated set
+        # of pure path-manipulation methods. Pathname is immutable
+        # in Ruby (per its docstring) and the catalog classifies
+        # most methods `:dispatch` because the C body delegates to
+        # File / Dir / FileTest. The methods listed here are
+        # filesystem-independent — they read only `@path` — so
+        # invoking them at fold time produces a deterministic
+        # result regardless of the host filesystem state.
+        #
+        # Filesystem-touching methods (`exist?`, `file?`, `read`,
+        # `stat`, …) are intentionally NOT folded: their answer
+        # depends on the analysis machine's filesystem, which is
+        # neither stable nor relevant to the analyzed program.
+        PATHNAME_PURE_UNARY = Set[
+          :to_s, :to_path, :to_str,
+          :basename, :dirname, :extname, :cleanpath,
+          :parent, :sub_ext, :root?, :absolute?, :relative?,
+          :hash, :inspect
+        ].freeze
+        PATHNAME_PURE_BINARY = Set[
+          :+, :join, :sub_ext, :<=>, :==, :eql?, :===,
+          :relative_path_from
+        ].freeze
+        private_constant :PATHNAME_PURE_UNARY, :PATHNAME_PURE_BINARY
+
+        def try_fold_pathname_unary(receiver_values, method_name)
+          return nil unless PATHNAME_PURE_UNARY.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Pathname)
+
+          result = receiver.public_send(method_name)
+          return nil unless foldable_constant_value?(result)
+
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          nil
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def try_fold_pathname_binary(receiver_values, method_name, arg_values)
+          return nil unless PATHNAME_PURE_BINARY.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          receiver = receiver_values.first
+          arg = arg_values.first
+          return nil unless receiver.is_a?(Pathname)
+          return nil unless arg.is_a?(Pathname) || arg.is_a?(String)
+
+          result = receiver.public_send(method_name, arg)
+          return nil unless foldable_constant_value?(result)
+
+          Type::Combinator.constant_of(result)
+        rescue StandardError
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def try_fold_string_array_unary(receiver_values, method_name)
+          return nil unless STRING_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(String)
+
+          lift_array_result(receiver.public_send(method_name))
+        rescue StandardError
+          nil
+        end
+
+        # `Constant<String>#split(arg)` / `#scan(arg)` — lift the
+        # Array result to a Tuple when both sides are statically
+        # known and the cardinality fits.
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def try_fold_string_array_binary(receiver_values, method_name, arg_values)
+          return nil unless STRING_ARRAY_BINARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1 && arg_values.size == 1
+
+          receiver = receiver_values.first
+          arg = arg_values.first
+          return nil unless receiver.is_a?(String)
+          return nil unless arg.is_a?(String) || arg.is_a?(Regexp)
+
+          lift_array_result(receiver.public_send(method_name, arg))
+        rescue StandardError
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def lift_array_result(result)
+          return nil unless result.is_a?(Array)
+          return nil if result.size > STRING_ARRAY_LIFT_LIMIT
+          return nil unless result.all? { |v| foldable_constant_value?(v) }
+
+          Type::Combinator.tuple_of(*result.map { |v| Type::Combinator.constant_of(v) })
+        end
 
         # 2-arg fold dispatch. Used by `Comparable#between?(min, max)`,
         # `Comparable#clamp(min, max)`, and `Integer#pow(exp, mod)` —
@@ -879,7 +1125,7 @@ module Rigor
         # round-trip through `Type::Combinator.constant_of`".
         def foldable_constant_value?(value)
           case value
-          when Integer, Float, String, Symbol, true, false, nil then true
+          when Integer, Float, Rational, Complex, String, Symbol, Regexp, Pathname, true, false, nil then true
           else false
           end
         end