rigortype 0.1.8 → 0.1.10

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds the zone-pinned `Time` class constructors on statically
+      # known arguments.
+      #
+      # Only `Time.utc` / `Time.gm` are folded. They pin the result
+      # to UTC, so the literal is machine-independent — every reader
+      # (`year`, `hour`, `utc_offset`, `strftime`, …) yields the same
+      # answer on any analysis host.
+      #
+      # `Time.now` (non-deterministic), `Time.at` / `Time.local` /
+      # `Time.mktime` / `Time.new` (local-zone — the result's wall
+      # clock and `utc_offset` depend on the analysis machine's
+      # timezone) are deliberately NOT folded; they keep their
+      # `Nominal[Time]` RBS answer. For the same reason `Time#getlocal`
+      # is blocklisted in `TIME_CATALOG` so a folded `Constant[Time]`
+      # cannot produce a machine-dependent local-zone copy.
+      module TimeFolding
+        TIME_UTC_METHODS = Set[:utc, :gm].freeze
+        private_constant :TIME_UTC_METHODS
+
+        # `Time.utc` accepts the 1–7 positional (year-first) form and
+        # a 10-arg (sec-first) form; cap the arity so a malformed
+        # call declines cheaply rather than reaching the constructor.
+        MAX_TIME_ARITY = 10
+        private_constant :MAX_TIME_ARITY
+
+        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 TIME_UTC_METHODS.include?(method_name)
+          return nil unless args.size.between?(1, MAX_TIME_ARITY)
+          return nil unless args.all?(Type::Constant)
+
+          values = args.map(&:value)
+          return nil unless values.all? { |v| v.is_a?(Integer) || v.is_a?(String) }
+
+          Type::Combinator.constant_of(Time.utc(*values))
+        rescue StandardError
+          nil
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "Time"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "../../type"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Folds `URI` module-function calls on statically known
+      # string constants.
+      #
+      # `URI.encode_www_form_component` / `decode_www_form_component`
+      # and the newer `encode_uri_component` / `decode_uri_component`
+      # 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
+      #
+      # * `encode_www_form_component(str)` / `decode_www_form_component(str)` —
+      #   RFC 3986 percent-encode / decode. Returns `Constant[String]`.
+      # * `encode_uri_component(str)` / `decode_uri_component(str)` —
+      #   Same encoding but may preserve additional reserved chars
+      #   (Ruby 3.2+). Returns `Constant[String]`.
+      #
+      # === Non-constant / unsupported cases
+      #
+      # Returns `nil` (deferring to the next dispatcher tier) when:
+      # - the receiver is not `Singleton[URI]`,
+      # - the first argument is not a `Constant[String]`,
+      # - the method is not in the supported set.
+      module URIFolding
+        URI_COMPONENT_METHODS = Set[
+          :encode_www_form_component, :decode_www_form_component,
+          :encode_uri_component, :decode_uri_component
+        ].freeze
+        private_constant :URI_COMPONENT_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 URI_COMPONENT_METHODS.include?(method_name)
+
+          fold_uri_call(method_name, args)
+        end
+
+        def dispatch_target?(receiver)
+          receiver.is_a?(Type::Singleton) && receiver.class_name == "URI"
+        end
+
+        def fold_uri_call(method_name, args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+
+          Type::Combinator.constant_of(URI.public_send(method_name, arg.value))
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/method_dispatcher.rb

@@ -13,6 +13,13 @@ require_relative "method_dispatcher/rbs_dispatch"
 require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/block_folding"
 require_relative "method_dispatcher/file_folding"
+require_relative "method_dispatcher/shellwords_folding"
+require_relative "method_dispatcher/math_folding"
+require_relative "method_dispatcher/time_folding"
+require_relative "method_dispatcher/regexp_folding"
+require_relative "method_dispatcher/cgi_folding"
+require_relative "method_dispatcher/uri_folding"
+require_relative "method_dispatcher/set_folding"
 require_relative "method_dispatcher/kernel_dispatch"
 require_relative "method_dispatcher/method_folding"
 
@@ -643,7 +650,7 @@ module Rigor
         ConstantFolding.try_fold(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           LiteralStringFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          dispatch_stdlib_module_tiers(receiver_type, method_name, arg_types) ||
           KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           MethodFolding.try_forward(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           BlockFolding.try_fold(
@@ -651,6 +658,21 @@ module Rigor
           )
       end
 
+      # Stdlib module singleton-folding tiers: File, Shellwords, Math,
+      # Time, Regexp, CGI, URI, Set. Extracted from
+      # `dispatch_precise_tiers` to keep the parent method within the
+      # cyclomatic-complexity limit.
+      def dispatch_stdlib_module_tiers(receiver_type, method_name, arg_types)
+        FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          ShellwordsFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          MathFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          TimeFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          RegexpFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          CGIFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          URIFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          SetFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types)
+      end
+
       def try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type, call_node = nil)
         return nil if environment.nil?
 
@@ -771,6 +793,18 @@ module Rigor
         array_lift = array_new_lift(receiver_type.class_name, arg_types)
         return array_lift if array_lift
 
+        range_lift = range_new_lift(receiver_type.class_name, arg_types)
+        return range_lift if range_lift
+
+        set_lift = set_new_lift(receiver_type.class_name, arg_types)
+        return set_lift if set_lift
+
+        regexp_lift = regexp_new_lift(receiver_type.class_name, arg_types)
+        return regexp_lift if regexp_lift
+
+        date_lift = date_new_lift(receiver_type.class_name, arg_types)
+        return date_lift if date_lift
+
         Type::Combinator.nominal_of(receiver_type.class_name)
       end
 
@@ -840,6 +874,119 @@ module Rigor
         type
       end
 
+      # `Range.new(b, e)` / `Range.new(b, e, excl)` — folds to
+      # `Constant[Range]` when both endpoints are `Constant[Integer]`
+      # or both are `Constant[String]`, and the optional third argument
+      # is a `Constant[true/false]`. Nil endpoints (beginless /
+      # endless ranges) are not folded because the useful instance
+      # methods (`to_a`, `first`, `last`) are not defined for them;
+      # the RBS tier answers `Nominal[Range]` for those forms.
+      def range_new_lift(class_name, arg_types)
+        return nil unless class_name == "Range"
+        return nil if arg_types.size < 2 || arg_types.size > 3
+
+        b_type = arg_types[0]
+        e_type = arg_types[1]
+
+        return nil unless b_type.is_a?(Type::Constant) && e_type.is_a?(Type::Constant)
+
+        b_val = b_type.value
+        e_val = e_type.value
+
+        # Only fold homogeneous Integer or String endpoint pairs.
+        return nil unless b_val.instance_of?(e_val.class)
+        return nil unless b_val.is_a?(Integer) || b_val.is_a?(String)
+
+        excl = range_new_excl(arg_types[2])
+        return nil if excl.nil?
+
+        Type::Combinator.constant_of(Range.new(b_val, e_val, excl))
+      rescue StandardError
+        nil
+      end
+
+      # Resolves the optional `exclude_end` argument for `range_new_lift`.
+      # Returns `false` (no arg), `true`/`false` (Constant[bool] arg),
+      # or `nil` to signal "decline" (wrong type / wrong value class).
+      def range_new_excl(excl_type)
+        case excl_type
+        when nil then false
+        when Type::Constant
+          excl_type.value if [true, false].include?(excl_type.value)
+        end
+      end
+
+      # `Set.new` / `Set.new(tuple_of_constants)` — folds to `Constant[Set]`
+      # when zero arguments are given or the single argument is a `Tuple`
+      # whose every element is a `Constant[T]`. Mirrors `SetFolding#fold_new`
+      # but lives here so the `:new` path in `try_meta_introspection` can
+      # reach it before the RBS tier answers `Nominal[Set]`.
+      def set_new_lift(class_name, arg_types)
+        return nil unless class_name == "Set"
+        return Type::Combinator.constant_of(::Set.new) if arg_types.empty?
+        return nil if arg_types.size > 1
+
+        arg = arg_types.first
+        return nil unless arg.is_a?(Type::Tuple)
+        return nil unless arg.elements.all?(Type::Constant)
+
+        values = arg.elements.map(&:value)
+        Type::Combinator.constant_of(::Set.new(values))
+      rescue StandardError
+        nil
+      end
+
+      # `Regexp.new(pattern)` / `Regexp.new(pattern, opts)` — folds to
+      # `Constant[Regexp]` when the pattern is a `Constant[String]`.
+      # Mirrors `RegexpFolding#fold_new` but lives here so the `:new` path
+      # in `try_meta_introspection` can reach it.
+      def regexp_new_lift(class_name, arg_types)
+        return nil unless class_name == "Regexp"
+        return nil if arg_types.empty? || arg_types.size > 2
+
+        pattern_arg = arg_types.first
+        return nil unless pattern_arg.is_a?(Type::Constant) && pattern_arg.value.is_a?(String)
+
+        opts = if arg_types.size == 2
+                 opt_type = arg_types[1]
+                 return nil unless opt_type.is_a?(Type::Constant)
+
+                 opt_type.value
+               else
+                 0
+               end
+
+        Type::Combinator.constant_of(Regexp.new(pattern_arg.value, opts))
+      rescue StandardError
+        nil
+      end
+
+      # `Date.new(y, m, d)` / `DateTime.new(y, m, d, h, min, s, off)`
+      # — folds to `Constant[Date]` / `Constant[DateTime]` when every
+      # argument is a `Constant` carrying an Integer (or, for the
+      # `DateTime` offset / `start` slots, a Rational or String).
+      # `Date.new` carries no timezone, and `DateTime.new`'s offset
+      # defaults to UTC, so the literal is machine-independent.
+      # `Date.today` / `Date.parse` are not constructors here — they
+      # are non-deterministic / string-dependent and stay
+      # `Nominal[Date]`.
+      DATE_NEW_CLASSES = %w[Date DateTime].freeze
+      private_constant :DATE_NEW_CLASSES
+
+      def date_new_lift(class_name, arg_types)
+        return nil unless DATE_NEW_CLASSES.include?(class_name)
+        return nil unless arg_types.size.between?(1, 8)
+        return nil unless arg_types.all?(Type::Constant)
+
+        values = arg_types.map(&:value)
+        return nil unless values.all? { |v| v.is_a?(Integer) || v.is_a?(Rational) || v.is_a?(String) }
+
+        klass = class_name == "Date" ? Date : DateTime
+        Type::Combinator.constant_of(klass.new(*values))
+      rescue StandardError
+        nil
+      end
+
       CONSTANT_METACLASSES = {
         Integer => "Integer", Float => "Float", String => "String",
         Symbol => "Symbol", Range => "Range",

data/lib/rigor/inference/method_parameter_binder.rb

@@ -43,10 +43,15 @@ module Rigor
       #   method (either `def self.foo` or a `def foo` inside
       #   `class << self`); routes the lookup through
       #   `RbsLoader#singleton_method`.
-      def initialize(environment:, class_path:, singleton:)
+      # @param source_path [String, nil] the project-relative path of
+      #   the file the method is defined in. Used to match ADR-28
+      #   path-scoped protocol contracts; `nil` (the default for
+      #   synthetic / probe scopes) disables the contract tier.
+      def initialize(environment:, class_path:, singleton:, source_path: nil)
         @environment = environment
         @class_path = class_path
         @singleton = singleton
+        @source_path = source_path
       end
 
       # @param def_node [Prism::DefNode]
@@ -58,15 +63,22 @@ module Rigor
         types = default_types_for(slots)
 
         rbs_method = lookup_rbs_method(def_node)
-        return types unless rbs_method
-
-        apply_rbs_overloads(types, slots, rbs_method.method_types) unless rbs_method.method_types.empty?
-        # `rigor:v1:param: <name> <refinement>` annotations
-        # tighten the bound type for matching slots. Applied
-        # after the RBS-overload pass so the override is the
-        # authoritative answer regardless of what the RBS
-        # signature declared.
-        apply_param_overrides(types, slots, rbs_method)
+        if rbs_method
+          apply_rbs_overloads(types, slots, rbs_method.method_types) unless rbs_method.method_types.empty?
+          # `rigor:v1:param: <name> <refinement>` annotations
+          # tighten the bound type for matching slots. Applied
+          # after the RBS-overload pass so the override is the
+          # authoritative answer regardless of what the RBS
+          # signature declared.
+          apply_param_overrides(types, slots, rbs_method)
+        end
+        # ADR-28 — a path-scoped protocol contract supplies the
+        # parameter type for a matching `def`. Applied last (most
+        # authoritative) and regardless of RBS presence: the
+        # methods a contract targets — controller actions and the
+        # like — typically have no RBS signature at all, so this
+        # tier must run even when `rbs_method` is nil.
+        apply_protocol_contract(types, slots, def_node)
         types
       end
 
@@ -75,6 +87,10 @@ module Rigor
       ParamSlot = Data.define(:kind, :name, :index)
       private_constant :ParamSlot
 
+      # Slot kinds a contract's positional `index` can address.
+      POSITIONAL_KINDS = %i[required_positional optional_positional].freeze
+      private_constant :POSITIONAL_KINDS
+
       # Walk the Prism `ParametersNode` and emit one slot per named
       # parameter, in declaration order. Anonymous slots (rest /
       # keyword-rest with no name) are skipped because we have no
@@ -187,6 +203,47 @@ module Rigor
         end
       end
 
+      # ADR-28 — when a path-scoped protocol contract targets this
+      # `def` (file path matches the contract's `path_glob`, method
+      # name + singleton-ness match), replace each contracted
+      # positional slot's binding with the contract's declared type.
+      # The type name resolves against the environment lazily here;
+      # an unresolvable name (the protocol's RBS not loaded) falls
+      # through to whatever the prior tiers bound, fail-soft.
+      def apply_protocol_contract(types, slots, def_node)
+        return if @source_path.nil?
+
+        registry = @environment.respond_to?(:plugin_registry) ? @environment.plugin_registry : nil
+        return if registry.nil?
+
+        contract = matching_contract(registry, def_node)
+        return if contract.nil?
+
+        contract.param_types.each do |param_type|
+          slot = positional_slot_at(slots, param_type.index)
+          next if slot.nil? || slot.name.nil?
+
+          resolved = @environment.nominal_for_name(param_type.type_name)
+          next if resolved.nil?
+
+          types[slot.name] = resolved
+        end
+      end
+
+      def matching_contract(registry, def_node)
+        contracts = registry.contracts_for_path(@source_path)
+        return nil if contracts.empty?
+
+        singleton = def_node.receiver.is_a?(Prism::SelfNode) || @singleton
+        contracts.find do |contract|
+          contract.method_name == def_node.name && contract.singleton == singleton
+        end
+      end
+
+      def positional_slot_at(slots, index)
+        slots.find { |slot| POSITIONAL_KINDS.include?(slot.kind) && slot.index == index }
+      end
+
       def collect_translated_types(method_types, slot)
         rbs_types = method_types.flat_map do |mt|
           t = rbs_type_for_slot(mt.type, slot)

data/lib/rigor/inference/narrowing.rb

@@ -386,8 +386,8 @@ module Rigor
           analyse_local_read(node, scope)
         when Prism::LocalVariableWriteNode
           analyse_local_write(node, scope)
-        when Prism::InstanceVariableWriteNode
-          analyse_ivar_write(node, scope)
+        when Prism::InstanceVariableReadNode, Prism::InstanceVariableWriteNode
+          analyse_ivar(node, scope)
         when Prism::ClassVariableWriteNode
           analyse_cvar_write(node, scope)
         when Prism::GlobalVariableWriteNode
@@ -767,7 +767,17 @@ module Rigor
           ]
         end
 
-        def analyse_ivar_write(node, scope)
+        # Truthy guard on an instance variable. Covers both the bare
+        # read — `if @ivar`, the left arm of `@ivar && @ivar.foo`,
+        # the receiver of `unless @ivar.nil?` once `!` reverses it —
+        # and the assignment-in-condition write `if @ivar = expr`.
+        # Mirrors `analyse_local_read` / `analyse_local_write`: the
+        # truthy edge narrows the ivar by `narrow_truthy` (dropping
+        # `nil` / `false`), the falsey edge by `narrow_falsey`. The
+        # narrowing is scoped to the guarded branch only, so it is
+        # purely additive — it never widens or re-narrows the ivar
+        # binding seen elsewhere.
+        def analyse_ivar(node, scope)
           current = scope.ivar(node.name)
           return nil if current.nil?
 
@@ -2024,15 +2034,24 @@ module Rigor
         end
 
         def analyse_nil_predicate(receiver, scope)
-          return nil unless receiver.is_a?(Prism::LocalVariableReadNode)
+          case receiver
+          when Prism::LocalVariableReadNode
+            current = scope.local(receiver.name)
+            return nil if current.nil?
 
-          current = scope.local(receiver.name)
-          return nil if current.nil?
+            [
+              scope.with_local(receiver.name, narrow_nil(current)),
+              scope.with_local(receiver.name, narrow_non_nil(current))
+            ]
+          when Prism::InstanceVariableReadNode
+            current = scope.ivar(receiver.name)
+            return nil if current.nil?
 
-          [
-            scope.with_local(receiver.name, narrow_nil(current)),
-            scope.with_local(receiver.name, narrow_non_nil(current))
-          ]
+            [
+              scope.with_ivar(receiver.name, narrow_nil(current)),
+              scope.with_ivar(receiver.name, narrow_non_nil(current))
+            ]
+          end
         end
 
         # `a && b` short-circuits: the truthy edge is the truthy edge

data/lib/rigor/inference/precision_scanner.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "../source/node_walker"
+require_relative "../scope"
+require_relative "scope_indexer"
+
+module Rigor
+  module Inference
+    # Measures the *type quality* of inferred expressions — not whether the
+    # engine recognises an AST node class (that is `CoverageScanner`'s job),
+    # but whether the type it produces carries useful static information.
+    #
+    # Each visited node is classified into one of eight precision tiers:
+    #
+    #   :constant         — Constant[T]: literal value known exactly
+    #   :nominal          — Nominal/Singleton: class identity known
+    #   :shaped           — Tuple/HashShape/IntegerRange/App: structure known
+    #   :refined          — Refined: narrowed by a predicate/assertion
+    #   :bot              — Bot: unreachable branch (definitively precise)
+    #   :dynamic_specific — Dynamic[X] where X is not Top: origin partial
+    #   :dynamic_top      — Dynamic[Top]: completely opaque (the "untyped" hole)
+    #   :top              — Top: universal supertype (no information)
+    #
+    # The summary exposes `precision_ratio` (constant+nominal+shaped+refined+bot
+    # over total) and `opaque_ratio` (dynamic_top+top over total).
+    #
+    # For Union types the *worst* member tier is used, since the union is only
+    # as precise as its least-precise constituent. Intersection uses the *best*
+    # member (the most specific side wins). Difference follows its base type.
+    class PrecisionScanner
+      TIERS = %i[
+        constant nominal shaped refined bot
+        dynamic_specific dynamic_top top
+      ].freeze
+
+      TIER_RANK = TIERS.each_with_index.to_h.freeze
+      private_constant :TIER_RANK
+
+      PRECISE_TIERS = %i[constant nominal shaped refined bot].to_set.freeze
+      private_constant :PRECISE_TIERS
+
+      # Per-file result. Immutable value object.
+      class FileResult < Data.define(:total, :tier_counts)
+        def precise_count
+          PRECISE_TIERS.sum { |t| tier_counts.fetch(t, 0) }
+        end
+
+        def dynamic_top_count
+          tier_counts.fetch(:dynamic_top, 0)
+        end
+
+        def dynamic_specific_count
+          tier_counts.fetch(:dynamic_specific, 0)
+        end
+
+        def dynamic_count
+          dynamic_top_count + dynamic_specific_count
+        end
+
+        def opaque_count
+          tier_counts.fetch(:dynamic_top, 0) + tier_counts.fetch(:top, 0)
+        end
+
+        def precision_ratio
+          return 1.0 if total.zero?
+
+          precise_count.fdiv(total)
+        end
+
+        def opaque_ratio
+          return 0.0 if total.zero?
+
+          opaque_count.fdiv(total)
+        end
+      end
+
+      # @param scope [Rigor::Scope] base scope for type inference.
+      def initialize(scope: nil)
+        @scope = scope || Scope.empty
+      end
+
+      # @param root [Prism::Node] the parsed AST
+      # @return [FileResult]
+      def scan(root)
+        scope_index = ScopeIndexer.index(root, default_scope: @scope)
+        tier_counts = TIERS.to_h { |t| [t, 0] }
+        total = 0
+
+        Source::NodeWalker.each(root) do |node|
+          type = scope_index[node].type_of(node)
+          tier = classify(type)
+          tier_counts[tier] += 1
+          total += 1
+        end
+
+        FileResult.new(total: total, tier_counts: tier_counts)
+      end
+
+      private
+
+      def classify(type)
+        case type
+        when Type::Bot                          then :bot
+        when Type::Top                          then :top
+        when Type::Constant                     then :constant
+        when Type::Nominal, Type::Singleton     then :nominal
+        when Type::Tuple, Type::HashShape,
+             Type::IntegerRange, Type::App      then :shaped
+        when Type::Refined                      then :refined
+        when Type::Dynamic                      then classify_dynamic(type)
+        when Type::Union                        then worst_of(type.members)
+        when Type::Intersection                 then best_of(type.members)
+        when Type::Difference                   then classify(type.base)
+        else                                         :dynamic_top
+        end
+      end
+
+      def classify_dynamic(type)
+        type.static_facet.is_a?(Type::Top) ? :dynamic_top : :dynamic_specific
+      end
+
+      def worst_of(members)
+        members.map { |m| classify(m) }.max_by { |t| TIER_RANK[t] } || :dynamic_top
+      end
+
+      def best_of(members)
+        members.map { |m| classify(m) }.min_by { |t| TIER_RANK[t] } || :dynamic_top
+      end
+    end
+  end
+end

data/lib/rigor/inference/statement_evaluator.rb

@@ -347,7 +347,20 @@ module Rigor
         # result type is precise (`Constant[:even]` instead of the
         # joined `Constant[:even] | Constant[:odd]`).
         live = live_branch_for_if(node, pred_type, post_pred)
-        return live if live
+        if live
+          live_type, _live_scope = live
+          # When the provably-live then-branch terminates and there is no
+          # else, apply the same falsey-scope narrowing as the standard
+          # early-return path below. Without this, `return if @ivar.nil?`
+          # with an ivar seeded as Constant[nil] (making nil? = Constant[true]
+          # and the then-branch "provably live") propagates the un-narrowed
+          # nil scope past the guard instead of Bot.
+          if branch_terminates?(node.statements, live_type) && node.subsequent.nil?
+            _, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
+            return [live_type, falsey_scope]
+          end
+          return live
+        end
 
         truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
         then_type, then_scope = eval_branch_or_nil(node.statements, truthy_scope)
@@ -376,7 +389,18 @@ module Rigor
         pred_type, post_pred = sub_eval(node.predicate, scope)
 
         live = live_branch_for_unless(node, pred_type, post_pred)
-        return live if live
+        if live
+          live_type, _live_scope = live
+          # Mirror of the eval_if fix: when the provably-live unless-body
+          # terminates and there is no else, apply the truthy-scope narrowing
+          # so `return unless @ivar` with a nil-seeded ivar doesn't propagate
+          # the nil scope past the guard.
+          if branch_terminates?(node.statements, live_type) && node.else_clause.nil?
+            truthy_scope, = Narrowing.predicate_scopes(node.predicate, post_pred)
+            return [live_type, truthy_scope]
+          end
+          return live
+        end
 
         truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
         then_type, then_scope = eval_branch_or_nil(node.statements, falsey_scope)
@@ -1421,7 +1445,8 @@ module Rigor
         binder = MethodParameterBinder.new(
           environment: scope.environment,
           class_path: current_class_path,
-          singleton: singleton
+          singleton: singleton,
+          source_path: scope.source_path
         )
         bindings = binder.bind(def_node)
 
@@ -1486,6 +1511,7 @@ module Rigor
       # remain reachable from inside nested bodies.
       def build_fresh_body_scope # rubocop:disable Metrics/AbcSize
         Scope.empty(environment: scope.environment)
+             .with_source_path(scope.source_path)
              .with_declared_types(scope.declared_types)
              .with_discovered_classes(scope.discovered_classes)
              .with_in_source_constants(scope.in_source_constants)