rigortype 0.0.5 → 0.0.7

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
@@ -500,39 +512,99 @@ module Rigor
       # rebinding is the StatementEvaluator's job (Slice 3 phase 2).
       # Without an else clause the branch's implicit value is nil, which
       # is included in the union.
+      #
+      # v0.0.6 — when the predicate folds to a `Type::Constant` whose
+      # value is Ruby-truthy (resp. Ruby-falsey), the unreachable
+      # branch is elided so the if-expression's type is the live
+      # branch alone. Statement-level branch elision lives in
+      # `StatementEvaluator#eval_if`; this handler covers the
+      # expression-position ternary form (`a ? b : c`) and any
+      # `if`/`unless` reached through `type_of`.
       def type_of_if(node)
         then_type = statements_or_nil(node.statements)
-        else_type =
-          if node.subsequent
-            type_of(node.subsequent)
-          else
-            Type::Combinator.constant_of(nil)
-          end
-        Type::Combinator.union(then_type, else_type)
+        else_type = if_else_type(node.subsequent)
+        elide_or_union(node.predicate, then_type, else_type)
       end
 
       # `unless c; t; else; e; end`. Prism uses `else_clause` here (no
-      # `elsif` chain).
+      # `elsif` chain). Branch-elision logic mirrors `type_of_if`,
+      # inverted: a truthy predicate selects the else branch.
       def type_of_unless(node)
         then_type = statements_or_nil(node.statements)
-        else_type =
-          if node.else_clause
-            type_of(node.else_clause)
-          else
-            Type::Combinator.constant_of(nil)
-          end
-        Type::Combinator.union(then_type, else_type)
+        else_type = if_else_type(node.else_clause)
+        elide_or_union(node.predicate, else_type, then_type)
+      end
+
+      def if_else_type(subsequent)
+        return Type::Combinator.constant_of(nil) if subsequent.nil?
+
+        type_of(subsequent)
+      end
+
+      # Routes the predicate's typed value through branch elision.
+      # `live_when_truthy` and `live_when_falsey` are the branch
+      # types selected by the predicate's polarity; the names
+      # match `IfNode` semantics directly and invert at the
+      # `type_of_unless` call site.
+      def elide_or_union(predicate, live_when_truthy, live_when_falsey)
+        case constant_predicate_polarity(predicate)
+        when :truthy then live_when_truthy
+        when :falsey then live_when_falsey
+        else Type::Combinator.union(live_when_truthy, live_when_falsey)
+        end
+      end
+
+      # Returns `:truthy`, `:falsey`, or `nil` for an arbitrary
+      # predicate expression. Only `Type::Constant` answers
+      # decisively — `Union[true, false]`, `Nominal[bool]`, and
+      # `Dynamic[T]` keep both branches live.
+      def constant_predicate_polarity(predicate)
+        return nil if predicate.nil?
+
+        type = type_of(predicate)
+        return nil unless type.is_a?(Type::Constant)
+
+        type.value ? :truthy : :falsey
       end
 
       def type_of_else(node)
         statements_or_nil(node.statements)
       end
 
-      # `a && b` and `a || b` short-circuit. Without a truthy/falsy
-      # narrowing model (Slice 6), the result of either side is reachable
-      # so the type is the union of the operand types.
+      # `a && b` and `a || b` short-circuit at the value level:
+      # `a && b` returns `a` when `a` is falsey, else `b`.
+      # `a || b` returns `a` when `a` is truthy,  else `b`.
+      #
+      # v0.0.6 — when the left operand folds to a `Type::Constant`,
+      # we know which side actually flows through, so the result
+      # is one operand's type instead of a union. Otherwise the
+      # union-of-both-operands fallback is preserved.
       def type_of_and_or(node)
-        Type::Combinator.union(type_of(node.left), type_of(node.right))
+        left_type = type_of(node.left)
+        polarity = constant_value_polarity(left_type)
+        return short_circuit_for(node, left_type, polarity) if polarity
+
+        Type::Combinator.union(left_type, type_of(node.right))
+      end
+
+      def short_circuit_for(node, left_type, polarity)
+        and_node = node.is_a?(Prism::AndNode)
+        if polarity == :truthy
+          and_node ? type_of(node.right) : left_type
+        else
+          and_node ? left_type : type_of(node.right)
+        end
+      end
+
+      # Returns `:truthy` / `:falsey` for a `Type::Constant`,
+      # nil otherwise. Mirrors `constant_predicate_polarity` but
+      # operates on a typed value (already-type-of'd) rather
+      # than a Prism node, so the same predicate analysis can
+      # be reused in both contexts.
+      def constant_value_polarity(type)
+        return nil unless type.is_a?(Type::Constant)
+
+        type.value ? :truthy : :falsey
       end
 
       def type_of_case(node)
@@ -631,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
 
@@ -701,12 +784,17 @@ module Rigor
       # when every element is a non-splat value. Splatted entries
       # (`[*xs, 1]`) preserve the Slice 4 phase 2d behavior: we union
       # the contributed element types and emit
-      # `Nominal[Array, [union]]`. An empty literal stays as the raw
-      # `Array` (no element evidence to lock either an arity or an
-      # element type).
+      # `Nominal[Array, [union]]`.
+      #
+      # v0.0.6 — the empty literal `[]` resolves to the empty
+      # `Tuple[]` carrier rather than the raw `Nominal[Array]`.
+      # Both carriers erase to RBS `Array`, but `Tuple[]` pins
+      # the literal's known arity (zero), which lets the
+      # per-element block fold concatenate across all-empty
+      # positions like `[1, 2].flat_map { |_| [] }`.
       def array_type_for(node)
         elements = node.elements
-        return Type::Combinator.nominal_of(Array) if elements.empty?
+        return Type::Combinator.tuple_of if elements.empty?
 
         if elements.any?(Prism::SplatNode)
           element_types = elements.map { |e| type_of(e) }
@@ -739,6 +827,7 @@ module Rigor
       # for the CallNode itself (the inner type_of calls already record
       # their own fallbacks for unrecognised receivers/args, so the tracer
       # captures both the immediate dispatch miss and the deeper cause).
+      # rubocop:disable Metrics/CyclomaticComplexity
       def call_type_for(node)
         receiver = call_receiver_type_for(node)
         arg_types = call_arg_types(node)
@@ -771,6 +860,18 @@ module Rigor
           return dynamic_top
         end
 
+        # v0.0.6 phase 2 — per-element block fold for Tuple
+        # receivers. When `[a, b, c].map { |x| f(x) }` and the
+        # receiver is a `Tuple` carrier with finite elements,
+        # type the block body once per position with the
+        # corresponding element bound to the block parameter
+        # and assemble the results into a `Tuple[U_1..U_n]`.
+        # This sits ahead of `MethodDispatcher.dispatch` so
+        # the RBS tier does not re-widen the answer back to
+        # `Array[union]`.
+        per_element = try_per_element_block_fold(node, receiver)
+        return per_element if per_element
+
         result = MethodDispatcher.dispatch(
           receiver_type: receiver,
           method_name: node.name,
@@ -797,6 +898,7 @@ module Rigor
 
         fallback_for(node, family: :prism)
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       # v0.0.2 #5 — re-types the body of a user-defined
       # instance method with the call site's argument types
@@ -976,6 +1078,189 @@ module Rigor
 
         block_scope.type_of(body)
       end
+
+      # v0.0.6 phase 2 — per-element block fold for Tuple
+      # receivers under `:map` / `:collect`. Walks every Tuple
+      # position, binds the block parameter to that element's
+      # type, and re-types the block body. The per-position
+      # results are assembled into `Tuple[U_1..U_n]`, strictly
+      # tighter than the RBS-projected `Array[union]`.
+      #
+      # Declines (returns nil) when the receiver is not a
+      # `Tuple` with at least one element, when the call has
+      # no `Prism::BlockNode`, when the method is outside the
+      # supported set, when block typing raises mid-loop, or
+      # when the block has no body. The decline path leaves
+      # the dispatch chain untouched.
+      PER_ELEMENT_TUPLE_METHODS = Set[
+        :map, :collect, :filter_map, :flat_map,
+        :find, :detect, :find_index, :index
+      ].freeze
+      private_constant :PER_ELEMENT_TUPLE_METHODS
+
+      # Cardinality cap for per-element block fold over
+      # finite-bound `Constant<Range>` receivers. Walking
+      # `(1..1_000_000).map { … }` element-wise would balloon
+      # block-typing cost and explode the resulting Tuple, so
+      # only short ranges expand into per-position folds.
+      # Larger ranges decline so the RBS tier widens.
+      PER_ELEMENT_RANGE_LIMIT = 8
+      private_constant :PER_ELEMENT_RANGE_LIMIT
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def try_per_element_block_fold(call_node, receiver_type)
+        return nil unless PER_ELEMENT_TUPLE_METHODS.include?(call_node.name)
+        return nil if find_family_with_args?(call_node)
+
+        element_types = per_element_elements_of(receiver_type)
+        return nil if element_types.nil? || element_types.empty?
+
+        block_node = call_node.block
+        return nil unless block_node.is_a?(Prism::BlockNode)
+
+        per_position = element_types.map do |element_type|
+          type_block_body_with_param(block_node, [element_type])
+        end
+        return nil if per_position.any?(&:nil?)
+
+        assemble_per_element_result(call_node.name, per_position, element_types)
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      # Returns the per-position element types for a finite,
+      # statically-known receiver shape — or nil when the
+      # receiver does not pin a finite element list.
+      #
+      # `Tuple[A, B, …]`        → [A, B, …]
+      # `Constant<a..b>`        → [Constant[a], …, Constant[b]]
+      # everything else         → nil
+      #
+      # Note: `Type::IntegerRange` is the bounded-Integer
+      # carrier (`int<a, b>` represents "an Integer between
+      # a and b"), not a Range value. Calls like `.map` /
+      # `.find` on an `IntegerRange` receiver would resolve
+      # to `Integer#map` / `Integer#find` — neither exists —
+      # so IntegerRange does NOT participate in this fold.
+      def per_element_elements_of(receiver_type)
+        case receiver_type
+        when Type::Tuple then receiver_type.elements
+        when Type::Constant then constant_range_elements(receiver_type.value)
+        end
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def constant_range_elements(value)
+        return nil unless value.is_a?(Range)
+        return nil unless value.begin.is_a?(Integer) && value.end.is_a?(Integer)
+
+        cardinality = value.exclude_end? ? value.end - value.begin : value.end - value.begin + 1
+        return nil if cardinality <= 0 || cardinality > PER_ELEMENT_RANGE_LIMIT
+
+        value.to_a.map { |v| Type::Combinator.constant_of(v) }
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      # `index(value)` and `find_index(value)` carry a positional
+      # argument and search by `==` rather than running the block.
+      # Decline so the RBS tier owns those forms.
+      def find_family_with_args?(call_node)
+        return false unless %i[find_index index].include?(call_node.name)
+
+        args = call_node.arguments
+        !args.nil? && !args.arguments.empty?
+      end
+
+      def assemble_per_element_result(method_name, per_position, element_types)
+        case method_name
+        when :map, :collect then Type::Combinator.tuple_of(*per_position)
+        when :filter_map then assemble_filter_map_result(per_position)
+        when :flat_map then assemble_flat_map_result(per_position)
+        when :find, :detect then assemble_find_result(per_position, element_types)
+        when :find_index, :index then assemble_find_index_result(per_position)
+        end
+      end
+
+      # `filter_map` folds tightly only when every per-position
+      # result is a `Constant`: positions whose value is `nil`
+      # or `false` drop, the rest survive in declaration order.
+      # When any position is non-Constant the dispatcher
+      # declines (returns nil) so the RBS tier widens to
+      # `Array[U]`.
+      def assemble_filter_map_result(per_position)
+        return nil unless per_position.all?(Type::Constant)
+
+        kept = per_position.reject { |type| type.value.nil? || type.value == false }
+        Type::Combinator.tuple_of(*kept)
+      end
+
+      # `flat_map` flattens a single level: if the per-position
+      # result is a `Tuple`, its elements are concatenated; if
+      # it's a non-Array scalar carrier (`Constant<…>` over a
+      # non-Array literal) it contributes one element. We fold
+      # tightly only when every per-position result is one of
+      # those two recognisable shapes — `Nominal[Array[T]]`,
+      # `Union[…]`, and other opaque carriers decline so the
+      # RBS tier widens to `Array[U]`.
+      #
+      # `Type::Constant` only ever holds non-Array scalars (the
+      # carrier rejects Array literals), so a single `Constant`
+      # safely contributes itself as a single Tuple element.
+      def assemble_flat_map_result(per_position)
+        flattened = per_position.flat_map { |type| flat_map_contribution(type) }
+        return nil if flattened.nil? || flattened.any?(&:nil?)
+
+        Type::Combinator.tuple_of(*flattened)
+      end
+
+      def flat_map_contribution(type)
+        case type
+        when Type::Tuple then type.elements
+        when Type::Constant then [type]
+        else [nil]
+        end
+      end
+
+      # `find` / `detect`: returns the first receiver element
+      # whose block result is Ruby-truthy, or `nil` when no
+      # position folds to truthy.
+      #
+      # Folds tightly only when every per-position block result
+      # is a `Type::Constant` — otherwise we cannot decide which
+      # position (if any) is "the first matching one". When the
+      # first decisive truthy position is found, the answer is
+      # the corresponding receiver element. When every position
+      # folds to falsey, the answer is `Constant[nil]`.
+      def assemble_find_result(per_position, element_types)
+        return nil unless per_position.all?(Type::Constant)
+
+        first_truthy_index = per_position.index { |type| truthy_constant?(type) }
+        return Type::Combinator.constant_of(nil) if first_truthy_index.nil?
+
+        element_types[first_truthy_index]
+      end
+
+      # `find_index` / `index`: returns the index of the first
+      # truthy position, or `Constant[nil]` when nothing matches.
+      def assemble_find_index_result(per_position)
+        return nil unless per_position.all?(Type::Constant)
+
+        first_truthy_index = per_position.index { |type| truthy_constant?(type) }
+        return Type::Combinator.constant_of(nil) if first_truthy_index.nil?
+
+        Type::Combinator.constant_of(first_truthy_index)
+      end
+
+      def truthy_constant?(type)
+        type.is_a?(Type::Constant) && type.value && type.value != false
+      end
+
+      def type_block_body_with_param(block_node, expected_param_types)
+        bindings = BlockParameterBinder.new(expected_param_types: expected_param_types).bind(block_node)
+        block_scope = bindings.reduce(scope) { |acc, (name, type)| acc.with_local(name, type) }
+        type_block_body(block_node, block_scope)
+      rescue StandardError
+        nil
+      end
     end
     # rubocop:enable Metrics/ClassLength
   end