rigortype 0.1.7 → 0.1.9

data/lib/rigor/inference/expression_typer.rb

@@ -1025,11 +1025,15 @@ module Rigor
         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).
+          return local_inference if local_inference && adoptable_self_call_result?(local_inference)
+
+          # The local def matches by name but the inference
+          # was disqualified — either the parameter shape is
+          # too complex for the first-iteration binder
+          # (kwargs / optionals / rest), or ADR-24 slice 1's
+          # conservative gate declined the resolved return
+          # type inside a class body (see
+          # `adoptable_self_call_result?`).
           # Returning `Dynamic[Top]` is the safest answer:
           # we know RBS dispatch would be wrong (the
           # method is user-defined and shadows whatever
@@ -1052,6 +1056,9 @@ module Rigor
         per_element = try_per_element_block_fold(node, receiver)
         return per_element if per_element
 
+        hash_transform = try_hash_shape_block_fold(node, receiver)
+        return hash_transform if hash_transform
+
         result = MethodDispatcher.dispatch(
           receiver_type: receiver,
           method_name: node.name,
@@ -1069,7 +1076,11 @@ module Rigor
         # the body with the call's argument types bound and
         # return the body's last-expression type.
         user_inference = try_user_method_inference(receiver, node, arg_types)
-        return user_inference if user_inference
+        if user_inference
+          return user_inference if adoptable_self_call_result?(user_inference)
+
+          return dynamic_top
+        end
 
         # Dynamic-origin propagation: when the receiver is Dynamic[T] and
         # no positive rule resolves the call, the result inherits the
@@ -1112,10 +1123,39 @@ module Rigor
         nil
       end
 
+      # ADR-24 slice 1 — implicit-self method-call resolution.
+      # `discovered_def_nodes` is now carried into method /
+      # class body scopes (see `StatementEvaluator#build_fresh_body_scope`),
+      # so a call written with no explicit receiver inside a
+      # method body resolves against the enclosing class's own
+      # definitions and the file's top-level defs. Before
+      # slice 1 every such call typed `Dynamic[top]`.
+      #
+      # The adoption of the resolved return type is gated:
+      #
+      # - At top-level / inside a DSL block (`scope.self_type`
+      #   is nil) the result is adopted unchanged — this is
+      #   the pre-slice-1 surface (the v0.0.3 A local-`def`
+      #   shortcut) and MUST keep working.
+      # - Inside a class body / method body (`self_type` set)
+      #   the result is adopted ONLY when it is `Bot`. A `Bot`
+      #   return is an always-diverging guard helper; adopting
+      #   it can only ever enable correct terminating-branch
+      #   narrowing, never a new `undefined-method` /
+      #   argument-type false positive. A non-`Bot` resolved
+      #   return is kept as `Dynamic[top]` (WD3) — adopting
+      #   precise non-`Bot` returns project-wide awaits the
+      #   callee-return-inference precision a later slice
+      #   brings (measured: unconditional adoption regressed
+      #   `rigor check lib` by 16 diagnostics).
+      def adoptable_self_call_result?(type)
+        scope.self_type.nil? || type.is_a?(Type::Bot)
+      end
+
       def try_user_method_inference(receiver, call_node, arg_types)
         return nil unless receiver.is_a?(Type::Nominal)
 
-        def_node = scope.user_def_for(receiver.class_name, call_node.name)
+        def_node = resolve_user_def_through_ancestors(receiver.class_name, call_node.name)
         return nil if def_node.nil?
 
         infer_user_method_return(def_node, receiver, arg_types)
@@ -1123,6 +1163,81 @@ module Rigor
         nil
       end
 
+      # ADR-24 slice 2 — resolves `method_name` against
+      # `class_name`'s own `def`s, then walks the user-class
+      # ancestor chain: included / prepended modules (transitive)
+      # and the superclass chain. RBS-known ancestors are NOT
+      # walked here — the `MethodDispatcher` RBS tier runs before
+      # `try_user_method_inference` and already covers them; an
+      # ancestor name that resolves to no project-discovered
+      # class/module ends that branch. Cross-file: the chain is
+      # followed through `Scope#discovered_superclasses` /
+      # `#discovered_includes` / `#discovered_def_nodes`, which
+      # the runner seeds from the project-wide pre-pass. The walk
+      # is breadth-first, cycle-guarded, and node-count-capped.
+      ANCESTOR_WALK_LIMIT = 100
+      private_constant :ANCESTOR_WALK_LIMIT
+
+      def resolve_user_def_through_ancestors(class_name, method_name)
+        queue = [class_name.to_s]
+        seen = {}
+        visited = 0
+        until queue.empty?
+          current = queue.shift
+          next if current.nil? || seen[current]
+
+          seen[current] = true
+          visited += 1
+          return nil if visited > ANCESTOR_WALK_LIMIT
+
+          found = scope.user_def_for(current, method_name)
+          return found if found
+
+          enqueue_ancestors(current, queue)
+        end
+        nil
+      end
+
+      # Pushes `current`'s direct ancestors onto the BFS queue:
+      # included / prepended modules first (Ruby places mixins
+      # nearer than the superclass), then the superclass. Each
+      # as-written name is resolved against `current`'s lexical
+      # nesting; names that resolve to no project class/module
+      # are dropped (RBS-known / third-party ancestors).
+      def enqueue_ancestors(current, queue)
+        scope.includes_of(current).each do |raw|
+          resolved = resolve_ancestor_class_name(current, raw)
+          queue.push(resolved) if resolved
+        end
+        raw_super = scope.superclass_of(current)
+        return if raw_super.nil?
+
+        resolved_super = resolve_ancestor_class_name(current, raw_super)
+        queue.push(resolved_super) if resolved_super
+      end
+
+      # Resolves a superclass name AS WRITTEN (`"Base"`, or a
+      # qualified `"A::B"`) to a project-discovered class,
+      # following Ruby's `Module.nesting` constant lookup: try
+      # the raw name under each enclosing namespace of the
+      # subclass, innermost first, then bare. Returns nil when
+      # no candidate names a discovered user class (e.g. the
+      # superclass is an RBS-known or third-party class).
+      def resolve_ancestor_class_name(subclass_qualified, raw_superclass)
+        segments = subclass_qualified.split("::")
+        (segments.length - 1).downto(0) do |i|
+          candidate = (segments[0, i] + [raw_superclass]).join("::")
+          return candidate if known_user_class?(candidate)
+        end
+        nil
+      end
+
+      def known_user_class?(name)
+        scope.discovered_superclasses.key?(name) ||
+          scope.discovered_def_nodes.key?(name) ||
+          scope.discovered_includes.key?(name)
+      end
+
       INFERENCE_GUARD_KEY = :__rigor_user_method_inference_stack__
       private_constant :INFERENCE_GUARD_KEY
 
@@ -1132,11 +1247,20 @@ module Rigor
         body_scope = build_user_method_body_scope(def_node, receiver, arg_types)
         return nil if body_scope.nil?
 
-        # 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) }]
+        # Recursion-guard signature. Keyed on `(receiver,
+        # method)` only — NOT the argument types. ADR-24 WD5:
+        # a method whose summary is still being computed
+        # resolves to `Dynamic[top]` for that cycle. Keying on
+        # arg types would let mutual recursion through a
+        # `module_function` module (`Acceptance#accepts` →
+        # `accepts_one` → `accepts_dynamic` → `accepts`)
+        # recurse unboundedly whenever the carried argument
+        # types differ at each level — observed as a
+        # `SystemStackError` once implicit-self calls began
+        # resolving during the main walk. `describe(:short)`
+        # keeps non-Nominal receivers (the implicit `Object`
+        # carrier for top-level / DSL-block defs) printable.
+        signature = [receiver.describe(:short), def_node.name]
         stack = (Thread.current[INFERENCE_GUARD_KEY] ||= [])
         return Type::Combinator.untyped if stack.include?(signature)
 
@@ -1174,6 +1298,8 @@ module Rigor
                      .with_program_globals(scope.program_globals)
                      .with_discovered_methods(scope.discovered_methods)
                      .with_discovered_def_nodes(scope.discovered_def_nodes)
+                     .with_discovered_superclasses(scope.discovered_superclasses)
+                     .with_discovered_includes(scope.discovered_includes)
                      .with_self_type(receiver)
 
         required.each_with_index do |param, index|
@@ -1332,10 +1458,17 @@ module Rigor
       # the dispatch chain untouched.
       PER_ELEMENT_TUPLE_METHODS = Set[
         :map, :collect, :filter_map, :flat_map,
+        :select, :filter, :reject,
         :find, :detect, :find_index, :index
       ].freeze
       private_constant :PER_ELEMENT_TUPLE_METHODS
 
+      HASH_SHAPE_TRANSFORM_METHODS = Set[
+        :transform_keys, :transform_keys!,
+        :transform_values, :transform_values!
+      ].freeze
+      private_constant :HASH_SHAPE_TRANSFORM_METHODS
+
       # Cardinality cap for per-element block fold over
       # finite-bound `Constant<Range>` receivers. Walking
       # `(1..1_000_000).map { … }` element-wise would balloon
@@ -1352,15 +1485,50 @@ module Rigor
         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 = per_element_block_results(call_node.block, element_types)
+        return nil if per_position.nil? || per_position.any?(&:nil?)
 
-        per_position = element_types.map do |element_type|
-          type_block_body_with_param(block_node, [element_type])
+        assemble_per_element_result(call_node.name, per_position, element_types)
+      end
+
+      # Evaluates the call's block once per receiver element.
+      # Two block shapes are supported:
+      #
+      # - `Prism::BlockNode` — a full `do … end` / `{ … }` block;
+      #   the body is re-typed per position with the element
+      #   bound to the block parameter.
+      # - `Prism::BlockArgumentNode` wrapping a `SymbolNode` —
+      #   the `&:predicate` shorthand; the symbol is dispatched
+      #   as a zero-arg method on each element type.
+      #
+      # Any other shape (`&proc_local`, `&method(:foo)`, no
+      # block) returns `nil` so the fold declines.
+      def per_element_block_results(block, element_types)
+        case block
+        when Prism::BlockNode
+          element_types.map { |element_type| type_block_body_with_param(block, [element_type]) }
+        when Prism::BlockArgumentNode
+          per_element_symbol_results(block, element_types)
         end
-        return nil if per_position.any?(&:nil?)
+      end
 
-        assemble_per_element_result(call_node.name, per_position, element_types)
+      def per_element_symbol_results(block_arg, element_types)
+        expression = block_arg.expression
+        return nil unless expression.is_a?(Prism::SymbolNode)
+
+        method_name = expression.unescaped.to_sym
+        element_types.map do |element_type|
+          MethodDispatcher.dispatch(
+            receiver_type: element_type,
+            method_name: method_name,
+            arg_types: [],
+            block_type: nil,
+            environment: scope.environment,
+            scope: scope
+          )
+        end
+      rescue StandardError
+        nil
       end
 
       # Returns the per-position element types for a finite,
@@ -1409,11 +1577,37 @@ module Rigor
         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 :select, :filter
+          assemble_filter_result(per_position, element_types, keep_on_truthy: true)
+        when :reject
+          assemble_filter_result(per_position, element_types, keep_on_truthy: false)
         when :find, :detect then assemble_find_result(per_position, element_types)
         when :find_index, :index then assemble_find_index_result(per_position)
         end
       end
 
+      # `select` / `filter` / `reject`: keeps each receiver
+      # element whose per-position predicate result folds to a
+      # decisive `Constant` — Ruby-truthy for `select` / `filter`,
+      # Ruby-falsey for `reject`. The surviving elements assemble
+      # into a `Tuple`, strictly tighter than the RBS-projected
+      # `Array[Elem]`.
+      #
+      # Folds tightly only when EVERY position is a `Constant`:
+      # a single non-`Constant` position leaves the result
+      # cardinality unknown (the element might or might not
+      # survive), so the dispatcher declines and the RBS tier
+      # widens to `Array[Elem]`. `[].select` style empty results
+      # are sound — an empty `Tuple` is the empty-array carrier.
+      def assemble_filter_result(per_position, element_types, keep_on_truthy:)
+        return nil unless per_position.all?(Type::Constant)
+
+        kept = element_types.each_index.filter_map do |index|
+          element_types[index] if truthy_constant?(per_position[index]) == keep_on_truthy
+        end
+        Type::Combinator.tuple_of(*kept)
+      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.
@@ -1488,6 +1682,94 @@ module Rigor
         type.is_a?(Type::Constant) && type.value && type.value != false
       end
 
+      # Per-pair block fold for `HashShape#transform_keys` and
+      # `HashShape#transform_values` (and their bang variants).
+      #
+      # When the receiver is a closed `HashShape` with no optional
+      # keys, applies the call's block (a `Prism::BlockNode` or
+      # `Prism::BlockArgumentNode`) to each key/value pair
+      # independently and assembles a new `HashShape`:
+      #
+      # - `transform_values` / `transform_values!`: re-types
+      #   each VALUE by binding it to the block parameter; keys
+      #   are preserved unchanged.
+      # - `transform_keys` / `transform_keys!`: re-types each
+      #   KEY by wrapping it in `Constant[k]` and passing it to
+      #   the block; values are preserved unchanged. The result
+      #   key must be a `Constant[Symbol | String]` — otherwise
+      #   the tier declines (the new key cannot be used as a
+      #   static HashShape index). Collisions (two old keys
+      #   mapping to the same new key) also decline.
+      #
+      # Returns `nil` on any decline so the dispatcher falls
+      # through to `RbsDispatch` and gets the widened `Hash[K, V]`
+      # answer.
+      def try_hash_shape_block_fold(call_node, receiver_type)
+        return nil unless HASH_SHAPE_TRANSFORM_METHODS.include?(call_node.name)
+        return nil unless receiver_type.is_a?(Type::HashShape)
+        return nil unless receiver_type.closed?
+        return nil unless receiver_type.optional_keys.empty?
+
+        block_arg = call_node.block
+        return nil if block_arg.nil?
+
+        if %i[transform_values transform_values!].include?(call_node.name)
+          fold_hash_shape_transform_values(receiver_type, block_arg)
+        else
+          fold_hash_shape_transform_keys(receiver_type, block_arg)
+        end
+      end
+
+      def fold_hash_shape_transform_values(shape, block_arg)
+        new_pairs = {}
+        shape.pairs.each do |key, value|
+          new_value = apply_hash_block(block_arg, value)
+          return nil if new_value.nil?
+
+          new_pairs[key] = new_value
+        end
+        Type::Combinator.hash_shape_of(new_pairs)
+      end
+
+      def fold_hash_shape_transform_keys(shape, block_arg)
+        new_pairs = {}
+        shape.pairs.each do |key, value|
+          key_type = Type::Combinator.constant_of(key)
+          new_key_type = apply_hash_block(block_arg, key_type)
+          return nil unless new_key_type.is_a?(Type::Constant)
+
+          new_key = new_key_type.value
+          return nil unless new_key.is_a?(Symbol) || new_key.is_a?(String)
+          return nil if new_pairs.key?(new_key)
+
+          new_pairs[new_key] = value
+        end
+        Type::Combinator.hash_shape_of(new_pairs)
+      end
+
+      # Applies a single-argument block (either a full BlockNode
+      # or a `&:symbol` BlockArgumentNode) to `param_type` and
+      # returns the resulting type, or `nil` on failure.
+      def apply_hash_block(block_arg, param_type)
+        case block_arg
+        when Prism::BlockNode
+          type_block_body_with_param(block_arg, [param_type])
+        when Prism::BlockArgumentNode
+          expression = block_arg.expression
+          return nil unless expression.is_a?(Prism::SymbolNode)
+
+          MethodDispatcher.dispatch(
+            receiver_type: param_type,
+            method_name: expression.unescaped.to_sym,
+            arg_types: [],
+            block_type: nil,
+            environment: scope.environment,
+            call_node: block_arg,
+            scope: scope
+          )
+        end
+      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) }

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cgi/util"
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `CGI` module-function calls on statically known
+      # string constants.
+      #
+      # `CGI.escapeHTML` / `CGI.unescapeHTML` and related methods
+      # are pure, deterministic functions over their string inputs.
+      # When the argument is a `Constant[String]`, the analyzer can
+      # evaluate the call at inference time and return the concrete
+      # `Constant[String]` result.
+      #
+      # === Supported methods
+      #
+      # * `escapeHTML(str)` / `escape_html(str)` / `h(str)` —
+      #   HTML-escape. Returns `Constant[String]`.
+      # * `unescapeHTML(str)` / `unescape_html(str)` —
+      #   HTML-unescape. Returns `Constant[String]`.
+      # * `escape(str)` / `unescape(str)` —
+      #   URL-encode / decode (`application/x-www-form-urlencoded`).
+      #   Returns `Constant[String]`.
+      # * `escapeURIComponent(str)` / `escape_uri_component(str)`,
+      #   `unescapeURIComponent(str)` / `unescape_uri_component(str)` —
+      #   URI-component percent-encode / decode. Returns `Constant[String]`.
+      # * `escapeElement(str, *elements)` / `escape_element(str, *elements)`,
+      #   `unescapeElement(str, *elements)` / `unescape_element(str, *elements)` —
+      #   element-level escape / unescape (first arg is the string,
+      #   remaining args are element names). Returns `Constant[String]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Returns `nil` (deferring to the next dispatcher tier) when:
+      # - the receiver is not `Singleton[CGI]`,
+      # - the first argument is not a `Constant[String]`,
+      # - the method is not in the supported set.
+      module CGIFolding
+        CGI_HTML_ESCAPE_METHODS = Set[:escapeHTML, :escape_html, :h].freeze
+        CGI_HTML_UNESCAPE_METHODS = Set[:unescapeHTML, :unescape_html].freeze
+        CGI_URL_ESCAPE_METHODS = Set[:escape, :unescape].freeze
+        CGI_URI_ESCAPE_METHODS = Set[
+          :escapeURIComponent, :escape_uri_component,
+          :unescapeURIComponent, :unescape_uri_component
+        ].freeze
+        CGI_ELEMENT_ESCAPE_METHODS = Set[
+          :escapeElement, :escape_element,
+          :unescapeElement, :unescape_element
+        ].freeze
+        CGI_ALL_ESCAPE_METHODS = (
+          CGI_HTML_ESCAPE_METHODS | CGI_HTML_UNESCAPE_METHODS |
+          CGI_URL_ESCAPE_METHODS | CGI_URI_ESCAPE_METHODS |
+          CGI_ELEMENT_ESCAPE_METHODS
+        ).freeze
+
+        private_constant :CGI_HTML_ESCAPE_METHODS, :CGI_HTML_UNESCAPE_METHODS,
+                         :CGI_URL_ESCAPE_METHODS, :CGI_URI_ESCAPE_METHODS,
+                         :CGI_ELEMENT_ESCAPE_METHODS, :CGI_ALL_ESCAPE_METHODS
+
+        module_function
+
+        # @return [Rigor::Type, nil] folded result, or nil to defer.
+        def try_dispatch(receiver:, method_name:, args:)
+          return nil unless dispatch_target?(receiver)
+          return nil unless CGI_ALL_ESCAPE_METHODS.include?(method_name)
+
+          fold_cgi_call(method_name, args)
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "CGI"
+        end
+
+        def fold_cgi_call(method_name, args)
+          return nil if args.empty?
+          return nil unless args.first.is_a?(Type::Constant) && args.first.value.is_a?(String)
+
+          str = args.first.value
+
+          if CGI_ELEMENT_ESCAPE_METHODS.include?(method_name)
+            fold_cgi_element(method_name, str, args.drop(1))
+          else
+            Type::Combinator.constant_of(CGI.public_send(method_name, str))
+          end
+        rescue StandardError
+          nil
+        end
+
+        # `CGI.escapeElement(str, "elem1", "elem2", ...)` — element-
+        # level escape / unescape. The remaining args after the first
+        # must be `Constant[String]` element names.
+        def fold_cgi_element(method_name, str, element_args)
+          elements = element_args.map do |arg|
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+
+            arg.value
+          end
+
+          Type::Combinator.constant_of(CGI.public_send(method_name, str, *elements))
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end