rigortype 0.4.1 → 0.4.2

data/lib/rigor/inference/acceptance.rb

@@ -486,7 +486,17 @@ module Rigor
             )
           end
 
-          nil
+          project_sequence_to_enumerator(self_type, other_type)
+        end
+
+        # `Enumerator::ArithmeticSequence[E]` carries only the element of its `Enumerator[Numeric, void]` superclass
+        # (#1794), so against a two-argument `Enumerator` it projects to `Enumerator[E, top]`, `top` being what RBS
+        # `void` translates to: `Enumerator[Integer, void]` and `[Integer, untyped]` accept it, as RBS would.
+        def project_sequence_to_enumerator(self_type, other_type)
+          return nil unless self_type.class_name == "Enumerator" && self_type.type_args.size == 2
+          return nil unless other_type.class_name == "Enumerator::ArithmeticSequence" && other_type.type_args.size == 1
+
+          Type::Combinator.nominal_of("Enumerator", type_args: [other_type.type_args.first, Type::Combinator.top])
         end
 
         def project_tuple_to_nominal(tuple)
@@ -963,11 +973,14 @@ module Rigor
           end
         end
 
-        # Constant[v] accepts only Constant[v'] with structurally equal value. Any other type is rejected
-        # (modulo the universal Bot/Dynamic short-circuits already applied upstream).
+        # Constant[v] accepts Constant[v'] with structurally equal value, and the plain nominal of a class whose
+        # only instance is `v`. Any other type is rejected (modulo the universal Bot/Dynamic short-circuits
+        # already applied upstream).
         def accepts_constant(self_type, other_type, mode)
           if other_type.is_a?(Type::Constant) && self_type == other_type
             Type::AcceptsResult.yes(mode: mode, reasons: "structural literal match")
+          elsif sole_instance_nominal?(self_type, other_type)
+            Type::AcceptsResult.yes(mode: mode, reasons: "#{other_type.class_name} has no instance but the literal")
           else
             Type::AcceptsResult.no(
               mode: mode,
@@ -976,6 +989,18 @@ module Rigor
           end
         end
 
+        # `true`, `false` and `nil` are the only instances of their classes, so `FalseClass` holds exactly the
+        # values `false` holds. Read apart, `Array.new(n, false)`, typed `Array[FalseClass]` through the
+        # `[T] (Integer, T)` binding, failed a declared `-> Array[bool]` and fired `def.return-type-mismatch` on
+        # correct code.
+        SOLE_INSTANCE_CLASSES = { true => "TrueClass", false => "FalseClass", nil => "NilClass" }.freeze
+        private_constant :SOLE_INSTANCE_CLASSES
+
+        def sole_instance_nominal?(constant, other_type)
+          other_type.is_a?(Type::Nominal) && other_type.type_args.empty? &&
+            SOLE_INSTANCE_CLASSES.key?(constant.value) && SOLE_INSTANCE_CLASSES[constant.value] == other_type.class_name
+        end
+
         # Tuple[A1..An] accepts:
         # - Tuple[B1..Bn] when arities match and each Ai accepts Bi (covariant per-position).
         # - Anything else: no (we cannot prove the arity from a generic nominal alone).

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "method_catalog"
+
+module Rigor
+  module Inference
+    module Builtins
+      # Issue #1740 — which instance methods CRuby itself defines on a core class or module, read from the offline
+      # catalogues under `data/builtins/ruby_core/` (`tool/extract_builtin_catalog.rb` records each `rb_define_method`
+      # and prelude `def` of an `Init_*` function on the class it names, aliases included). A registration inside an
+      # `#if 0` block CRuby keeps for RDoc carries `rdoc_only: true` and is left out: `random.c`'s registers
+      # `Random#seed` on `Random`, though it runs on `Random::Base`.
+      # `spec/rigor/inference/builtins/c_ruby_definers_spec.rb` checks every listed method the running Ruby has
+      # against its runtime owner. RBS is not that record: core RBS redeclares some inherited methods on a subclass
+      # (`Integer#quo` and `File#to_path`, whose CRuby owners are `Numeric` and `IO`), and declares a few CRuby no
+      # longer defines (`Process::Status#&`). A class no catalogue covers answers false, as does a method its
+      # catalogue does not list: the caller reads both as "not proven". The catalogue is one CRuby snapshot.
+      module CRubyDefiners
+        module_function
+
+        # Does the catalogue prove CRuby defines `method_name` on `class_name` itself?
+        def defines?(class_name, method_name)
+          names = INDEX[class_name.to_s.delete_prefix("::")]
+          !names.nil? && names.include?(method_name.to_s)
+        end
+
+        def build_index
+          index = Hash.new { |hash, key| hash[key] = Set.new }
+          MethodCatalog.topic_paths.each do |path|
+            data = YAML.safe_load_file(path, permitted_classes: [Symbol])
+            classes = data.is_a?(Hash) ? data["classes"] : nil
+            next unless classes.is_a?(Hash)
+
+            classes.each do |name, klass|
+              next if klass["rdoc_only"]
+
+              names = index[name]
+              names.merge(defined_names(klass["instance_methods"]))
+              names.merge(defined_names(klass["aliases"]))
+            end
+          end
+          Ractor.make_shareable(index.to_h { |name, names| [name, names.freeze] })
+        rescue Psych::SyntaxError, SystemCallError
+          Ractor.make_shareable({})
+        end
+
+        # The names of `entries` CRuby defines at runtime: one the catalogue marks `rdoc_only` was registered only for
+        # RDoc, inside an `#if 0` block.
+        def defined_names(entries)
+          return [] unless entries.is_a?(Hash)
+
+          entries.filter_map { |method, entry| method unless entry.is_a?(Hash) && entry["rdoc_only"] }
+        end
+
+        INDEX = build_index
+        private_constant :INDEX
+      end
+    end
+  end
+end

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

@@ -48,6 +48,9 @@ module Rigor
           new(path: File.join(DATA_ROOT, "#{topic}.yml"), mutating_selectors: mutating_selectors)
         end
 
+        # Every catalogue file under {DATA_ROOT}, in a stable order.
+        def self.topic_paths = Dir[File.join(DATA_ROOT, "*.yml")]
+
         def initialize(path:, mutating_selectors: {})
           @path = path
           @mutating_selectors = mutating_selectors.transform_values(&:freeze).freeze

data/lib/rigor/inference/def_node_resolver.rb

@@ -33,7 +33,7 @@ module Rigor
       # ({.rehydrated_nesting}).
       def self.with_run
         previous = Thread.current[MEMO_KEY]
-        Thread.current[MEMO_KEY] = { nodes: {}, indexes: {}, nestings: {}.compare_by_identity }
+        Thread.current[MEMO_KEY] = { nodes: {}, indexes: {}, nestings: {}.compare_by_identity, refinement_queries: {} }
         yield
       ensure
         Thread.current[MEMO_KEY] = previous
@@ -113,6 +113,28 @@ module Rigor
       end
       private_class_method :record_nesting
 
+      # Issue #1664 — the {InEffectRefinements} over `path`'s own parse, once a run, or nil when the file cannot be
+      # read: the typed refined arm reads another file's refine body through it. The bodies' `Module.nesting`
+      # is recorded as a handle's is, so the re-typed body reads its constants where it is written.
+      def self.refinement_query(path)
+        memo = Thread.current[MEMO_KEY]
+        return build_refinement_query(path, nil) if memo.nil?
+
+        queries = memo[:refinement_queries]
+        return queries[path] if queries.key?(path)
+
+        queries[path] = build_refinement_query(path, memo)
+      end
+
+      def self.build_refinement_query(path, memo)
+        query = InEffectRefinements.new(Prism.parse(File.read(path)).value)
+        query.refine_def_nestings.each { |node, nesting| record_nesting(memo, node, nesting) } if memo
+        query
+      rescue StandardError
+        nil
+      end
+      private_class_method :build_refinement_query
+
       # Finds the node for `handle` using a per-file `{node_id => DefNode}` + `{name => DefNode}` index cache.
       def self.locate(handle, index_cache)
         index = index_cache[handle.path] ||= build_file_index(handle.path)

data/lib/rigor/inference/expression_typer.rb

@@ -28,6 +28,7 @@ require_relative "fallback"
 require_relative "flow_tracer"
 require_relative "index_write_widening"
 require_relative "indexed_narrowing"
+require_relative "key_presence_guard"
 require_relative "jump_targets"
 require_relative "define_method_block_self"
 require_relative "macro_block_self_type"
@@ -39,6 +40,7 @@ require_relative "optimistic_origin"
 require_relative "receiver_alias"
 require_relative "repeated_or_writes"
 require_relative "singleton_object_constant"
+require_relative "refined_dispatch"
 require_relative "stored_block_call"
 require_relative "struct_fold_safety"
 require_relative "unknown_store_widening"
@@ -648,7 +650,12 @@ module Rigor
       # `StatementEvaluator` at class-body and method-body boundaries) or `Dynamic[Top]` at the top level.
       # Class-body `self` is `Singleton[<class>]`; instance-method `self` is `Nominal[<class>]`;
       # singleton-method `self` is `Singleton[<class>]`.
+      #
+      # Issue #1763 — directly in a `refine X` block body `self` is the refinement module, which Rigor does not
+      # model; its `Singleton[X]` stand-in serves implicit-self calls only, so a value read of `self` is untyped.
       def type_of_self_node(_node)
+        return dynamic_top if scope.refinement_block_self?
+
         scope.self_type || dynamic_top
       end
 
@@ -1811,7 +1818,8 @@ module Rigor
       # that normal return is `untyped` — the result's declared type — so `loop { e.next }` is not `bot` and
       # `loop { x = e.next; break x if x }` keeps its arm beside it.
       def call_dispatch_type_for(node, receiver_override: nil)
-        result = loop_completion_type(node, call_result_type_for(node, receiver_override: receiver_override))
+        result = key_guarded_type(node, call_result_type_for(node, receiver_override: receiver_override))
+        result = loop_completion_type(node, result)
         arms = call_break_arm_types(node, receiver_override: receiver_override)
         if exactly_once_block_never_completes?(node, receiver_override)
           return arms.empty? ? Type::Combinator.bot : Type::Combinator.union(*arms)
@@ -1821,6 +1829,15 @@ module Rigor
         widen_optimistic_predicate_constant(node, combined)
       end
 
+      # Issue #1703 — `H[k]` under a true `H.key?(k)` with a non-literal key drops the miss `nil`
+      # ({KeyPresenceGuard.guarded_read}). Only inside the guarded re-walk `call.possible-nil-receiver` runs to
+      # decide whether to withhold a report; the analysis every other rule reads never records a guard.
+      def key_guarded_type(node, type)
+        return type unless node.name == :[]
+
+        KeyPresenceGuard.guarded_read(node, type, scope) || type
+      end
+
       # Issue #1172 — the nil-collapsing predicates (`nil?`, `!`, `x == nil`, …) answer a `Constant` that
       # encodes the receiver's nil-freeness. When that nil-freeness is only *optimistic* — an
       # `%a{implicitly-returns-nil}` read `RbsDispatch` deliberately reads past — the constant is a bet,
@@ -1896,6 +1913,9 @@ module Rigor
         # asks nothing further of dispatch. Off (the default) this is one integer read.
         Effects::Collector.record_call(node, receiver, scope) if Effects::Collector.active?
 
+        refined = try_refined_dispatch(node, receiver, arg_types, block_type)
+        return refined if refined
+
         literal_send = try_literal_send(node, receiver)
         return literal_send if literal_send
 
@@ -1927,6 +1947,155 @@ module Rigor
         dispatch_miss_result(node, receiver, arg_types, block_type)
       end
 
+      # ADR-121 WD2 (issue #1664) — a call through an in-effect Ruby refinement, typed from the winning refine body
+      # with the call's receiver as `self`, ahead of every tier below: each answers from the method the refinement
+      # replaces (a refined `String#upcase` must not fold, a refined `map` must not fold per element, a top-level
+      # `def` must not bind ahead of a refinement of `Object`, a plugin models the class's own method). An unreadable
+      # body, or a list that may hold any refinement, answers `Dynamic[top]`, never the replaced method's signature.
+      # A union receiver is decided per member; a `Dynamic` receiver, a class object and a call no refinement wins
+      # fall through. A call site no refinement is in effect at answers nil at once and records nothing: its answer
+      # cannot change without an edit to its own file.
+      #
+      # ADR-121 WD7 (A2) — inside the span of an activation that puts an opaque module in effect
+      # ({InEffectRefinements.opaque_module?}), any method of any instance may be replaced, so every instance-receiver
+      # call answers `Dynamic[top]`; a class object falls through, as it does below.
+      def try_refined_dispatch(node, receiver, arg_types, block_type)
+        list = scope.in_effect_refinements(node)
+        return nil if list.empty?
+
+        InEffectRefinements.record_refinement_names(node.name)
+        return dynamic_top if refined_instance_receiver?(receiver) && opaque_refinement_span?(node, list)
+        return nil if scope.discovered_refinements.empty?
+
+        refined_indirect_result(node, receiver, list) ||
+          refined_receiver_result(node, receiver, list, arg_types, block_type)
+      end
+
+      # ADR-121 WD4 — `send` / `__send__` / `public_send` with a literal name, `respond_to?` and `method` /
+      # `public_method` with one, and a `&:name` block argument honour refinements too (CRuby `test_refinement.rb`;
+      # probed on Ruby 4.0.5). When the name they reach is refined in effect for the receiver they answer
+      # `Dynamic[top]`: typing them through the arm is deferred, and `respond_to?` must never fold to `false`. A
+      # `&:name` block's receiver is the yielded element, which is not known here, so any in-effect refinement of the
+      # name answers. Only `methods` ignores refinements and keeps its answer.
+      def refined_indirect_result(node, receiver, list)
+        name = REFINED_NAMING_CALLS.include?(node.name) ? literal_method_name_argument(node) : nil
+        return dynamic_top if name && refined_name_for?(receiver, name, list)
+
+        block_name = symbol_block_argument(node)
+        dynamic_top if block_name && refined_anywhere?(block_name, list)
+      end
+
+      REFINED_NAMING_CALLS = Set[:send, :__send__, :public_send, :respond_to?, :method, :public_method].freeze
+      private_constant :REFINED_NAMING_CALLS
+
+      def literal_method_name_argument(node)
+        argument = node.arguments&.arguments&.first
+        name = argument.unescaped if argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+        return nil if name.nil?
+
+        name = name.to_sym
+        InEffectRefinements.record_refinement_names(name)
+        name
+      end
+
+      def symbol_block_argument(node)
+        block = node.block
+        return nil unless block.is_a?(Prism::BlockArgumentNode) && block.expression.is_a?(Prism::SymbolNode)
+
+        name = block.expression.unescaped.to_sym
+        InEffectRefinements.record_refinement_names(name)
+        name
+      end
+
+      def refined_name_for?(receiver, name, list)
+        members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+        members.any? do |member|
+          class_name = refined_receiver_class_name(member)
+          !class_name.nil? && !RefinedDispatch.winner(scope, class_name, name, list).nil?
+        end
+      end
+
+      # ADR-121 WD7 — a names-wildcard row counts as a refinement of every name.
+      def refined_anywhere?(name, list)
+        refinements = scope.discovered_refinements
+        wildcard = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
+        return true if list.include?(InEffectRefinements::UNKNOWN) &&
+                       refinements.any? { |_refined, methods| methods.key?(name) || methods.key?(wildcard) }
+
+        !RefinedDispatch.targets(refinements, name, list).nil? ||
+          !RefinedDispatch.targets(refinements, wildcard, list).nil?
+      end
+
+      # ADR-121 WD7 — does the call's lexical list (a plugin-declared module is the plugin's declaration and never
+      # opaque) hold an opaque module? `list` is the full list, which is the lexical one when nothing is declared.
+      def opaque_refinement_span?(node, list)
+        lexical = scope.declared_refinements.empty? ? list : scope.in_effect_refinements(node, InEffectRefinements::EMPTY)
+        InEffectRefinements.opaque_in?(scope, lexical)
+      end
+
+      # Does `receiver` (or a member of a union) have a class the refined arm answers for: an instance, not a class
+      # object or `Dynamic`?
+      def refined_instance_receiver?(receiver)
+        members = receiver.is_a?(Type::Union) ? receiver.members : [receiver]
+        members.any? { |member| !refined_receiver_class_name(member).nil? }
+      end
+
+      def refined_receiver_result(node, receiver, list, arg_types, block_type)
+        return refined_member_result(node, receiver, list, arg_types, block_type) unless receiver.is_a?(Type::Union)
+
+        answers = receiver.members.map { |member| refined_member_result(node, member, list, arg_types, block_type) }
+        return nil if answers.none?
+
+        members = receiver.members.each_with_index.map do |member, index|
+          answers[index] || call_result_type_for(node, receiver_override: member)
+        end
+        Type::Combinator.union(*members)
+      end
+
+      def refined_member_result(node, receiver, list, arg_types, block_type)
+        class_name = refined_receiver_class_name(receiver)
+        return nil if class_name.nil?
+
+        winner = RefinedDispatch.winner(scope, class_name, node.name, list)
+        return nil if winner.nil?
+        return dynamic_top if winner == RefinedDispatch::UNKNOWN
+
+        refined_body_return(winner, node.name, Type::Combinator.nominal_of(class_name), arg_types, block_type) ||
+          dynamic_top
+      end
+
+      # The winning refine body's inferred return, re-typed with the receiver's class as `self` and the call's
+      # argument types bound as an undeclared method's are; nil when the body is not readable here.
+      #
+      # A body another file wrote is re-typed with that file's in-effect refinements at the `def` (its own module
+      # among them), so a sibling override it calls answers from its refine body too.
+      def refined_body_return(winner, method_name, self_type, arg_types, block_type)
+        def_node, foreign =
+          InEffectRefinements.refinement_def_with_query(scope, winner.module_name, winner.refined_class, method_name)
+        return nil if def_node.nil?
+
+        refinements = foreign&.at(def_node.location.start_offset) do |name|
+          InEffectRefinements.activated_modules(scope, name)
+        end
+        infer_user_method_return(def_node, self_type, arg_types, yield_type: block_type, refinements: refinements)
+      rescue StandardError
+        nil
+      end
+
+      # The class an instance-side receiver is an instance of, or nil for one a refinement does not answer here: a
+      # class object (refinements of singleton classes are not recorded), `Dynamic`, `top`, or a shape with no class.
+      def refined_receiver_class_name(receiver)
+        case receiver
+        when Type::Nominal, Type::StructInstance, Type::DataInstance then receiver.class_name
+        when Type::Constant then receiver.value.class.name
+        when Type::Tuple then "Array"
+        when Type::HashShape then "Hash"
+        when Type::IntegerRange then "Integer"
+        when Type::FloatRange then "Float"
+        when Type::Refined, Type::Difference then refined_receiver_class_name(receiver.base)
+        end
+      end
+
       # The post-dispatch tiers for a call `MethodDispatcher` could not answer, in their historical
       # order; extracted from {#call_dispatch_type_for} whole.
       def dispatch_miss_result(node, receiver, arg_types, block_type = nil)
@@ -2959,14 +3128,37 @@ module Rigor
       # not observable on the body scope, so it does need its own memo-key slot. It is dropped for a def
       # that cannot reach a `yield` — nearly all of them — which keeps the key shape constant for the
       # methods the memo actually carries and confines the extra dimension to yielding callees.
-      def infer_user_method_return(def_node, receiver, arg_types, self_fold_safe: false, yield_type: nil)
+      # Issue #1703 — inside the guarded re-walk a callee's return summary is still computed with `key?` guards off
+      # ({KeyPresenceGuard.without_guards}): summaries are memoised for the whole run, and one computed with a guard
+      # would reach the analysis every rule reads.
+      #
+      # Issue #1664 — `refinements` are the modules in effect in a refine body another file wrote, which the body scope
+      # carries as declared refinements: its nodes are not this file's, so this file's lexical list cannot answer them.
+      # The return memo and the recursion guard do not key on them, which holds because such a node comes only from
+      # `DefNodeResolver.refinement_query`'s own parse and always carries that file's one list; a caller that types
+      # the same node under another list must add it to the key.
+      def infer_user_method_return(def_node, receiver, arg_types, self_fold_safe: false, yield_type: nil,
+                                   refinements: nil)
         return nil if def_node.body.nil?
+        unless KeyPresenceGuard.active?
+          return infer_user_method_return_unguarded(def_node, receiver, arg_types, self_fold_safe, yield_type,
+                                                    refinements)
+        end
 
+        KeyPresenceGuard.without_guards do
+          infer_user_method_return_unguarded(def_node, receiver, arg_types, self_fold_safe, yield_type, refinements)
+        end
+      end
+
+      def infer_user_method_return_unguarded(def_node, receiver, arg_types, self_fold_safe, yield_type,
+                                             refinements = nil)
         yield_type = nil unless yield_type && body_yields?(def_node)
         body_scope = build_user_method_body_scope(def_node, receiver, arg_types,
                                                   self_fold_safe: self_fold_safe)
         return nil if body_scope.nil?
 
+        body_scope = body_scope.with_declared_refinements(refinements) if refinements
+
         # 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` →
@@ -4021,12 +4213,13 @@ module Rigor
           method_name: call_node.name,
           arg_types: arg_types,
           environment: scope.environment,
-          scope: scope
+          scope: scope,
+          call_node: call_node
         )
         block_return_for(
           block_arg, expected,
           call_node: call_node,
-          narrowed_self_type: block_body_self_narrowing(call_node, receiver_type),
+          narrowing: block_body_self_narrowing(call_node, receiver_type),
           repeats: !BLOCK_VALUE_DISCARDING.include?(call_node.name) && block_may_repeat?(call_node, receiver_type)
         )
       rescue StandardError
@@ -4093,7 +4286,7 @@ module Rigor
         block_scope = block_entry_scope(
           block_node, param_types,
           call_node: call_node,
-          narrowed_self_type: block_body_self_narrowing(call_node, receiver),
+          narrowing: block_body_self_narrowing(call_node, receiver),
           captured: repeating_captured_bindings(block_node, param_types, block_may_repeat?(call_node, receiver))
         )
         _result, collected = StatementEvaluator.with_break_value_sink do
@@ -4102,10 +4295,12 @@ module Rigor
         collected.filter_map { |jump, type| type if targets.key?(jump) }
       end
 
-      # The block body's narrowed `self_type`, or `nil` to leave the scope contract unchanged.
+      # The block body's narrowing — a {MacroBlockSelfType::Match} carrying the narrowed `self_type` and the declared
+      # refinements — or `nil` to leave the scope contract unchanged.
       #
       # ADR-16 Tier A: a registered plugin's `block_as_methods` entry matching `(receiver_type,
-      # call_node.name)` narrows to the receiver class's instance type.
+      # call_node.name)` narrows to the receiver class's instance type, and puts its `refinements:` in effect in the
+      # body (issue #1667).
       #
       # Issue #963: `define_method(:name) { ... }` installs its block as an instance method and runs it with
       # `self` bound to the receiving instance, so the block body's `self` is the INSTANCE side of a class body's
@@ -4115,9 +4310,11 @@ module Rigor
       # matters wherever the block's value is observable, e.g. a project-declared generic `define_method`
       # signature that returns the block's own type.
       def block_body_self_narrowing(call_node, receiver_type)
-        MacroBlockSelfType.narrow_self_type_for(
-          scope: scope, call_node: call_node, receiver_type: receiver_type
-        ) || DefineMethodBlockSelf.narrow_self_type_for(scope: scope, call_node: call_node)
+        match = MacroBlockSelfType.match_for(scope: scope, call_node: call_node, receiver_type: receiver_type)
+        return match if match
+
+        defined = DefineMethodBlockSelf.narrow_self_type_for(scope: scope, call_node: call_node)
+        defined && MacroBlockSelfType::Match.new(self_type: defined, refinements: InEffectRefinements::EMPTY)
       end
 
       def break_arm_param_types(call_node, receiver)
@@ -4126,16 +4323,17 @@ module Rigor
           method_name: call_node.name,
           arg_types: call_arg_types(call_node),
           environment: scope.environment,
-          scope: scope
+          scope: scope,
+          call_node: call_node
         )
       end
 
-      def block_return_for(block_arg, expected, call_node: nil, narrowed_self_type: nil, repeats: false)
+      def block_return_for(block_arg, expected, call_node: nil, narrowing: nil, repeats: false)
         case block_arg
         when Prism::BlockNode
           captured = repeating_captured_bindings(block_arg, expected, repeats)
           entry = block_entry_scope(
-            block_arg, expected, call_node: call_node, narrowed_self_type: narrowed_self_type, captured: captured
+            block_arg, expected, call_node: call_node, narrowing: narrowing, captured: captured
           )
           type_block_body(block_arg, entry, captured: captured)
         when Prism::BlockArgumentNode
@@ -4151,13 +4349,14 @@ module Rigor
       # Issue #316 — mirrors `StatementEvaluator#build_block_entry_scope`: the block body's `self` is the
       # yielding method's business, so the return-typing pass must see the same unmodelled-self mark. Issue #1358
       # — and the same match-global view ({MatchRebinding.block_entry}), which reads the owning `call_node`.
-      def block_entry_scope(block_node, expected, call_node: nil, narrowed_self_type: nil, captured: nil)
+      def block_entry_scope(block_node, expected, call_node: nil, narrowing: nil, captured: nil)
         entry = MatchRebinding.block_entry(scope.entering_opaque_block, block_node, call_node)
         entry = captured.lay(entry) if captured
         block_scope = BlockParameterBinder.new(expected_param_types: expected).bind_onto(block_node, entry)
-        return block_scope unless narrowed_self_type
+        return block_scope unless narrowing
 
-        block_scope.with_self_type(narrowed_self_type)
+        keeps_unknown = call_node ? scope.block_self_narrowing_unknown?(call_node) : false
+        MacroBlockSelfType.apply(block_scope, narrowing, keeps_unknown: keeps_unknown)
       end
 
       # The #587 (b) captured binding when the call may run the block more than once ({#block_may_repeat?}), and

data/lib/rigor/inference/global_write_census.rb

@@ -82,7 +82,7 @@ module Rigor
 
       # A standalone walk, for a file no existing descent visits (a `pre_eval:` entry).
       def scan(root)
-        collector = Collector.new
+        collector = Collector.new(InEffectRefinements.new(root))
         walk(root, collector, true)
         collector.census.freeze
       end
@@ -98,13 +98,16 @@ module Rigor
 
       # Accumulates one file's census, fed each node of a pre-order descent. `top_level` says whether the node sits
       # outside every `class` / `module` body; it is the host walk's to track. `refine` blocks are remembered by
-      # offset as they are met, so a node inside one is known without the host walk tracking it.
+      # offset as they are met, so a node inside one is known without the host walk tracking it. `in_effect` is the
+      # file's {InEffectRefinements}: a `refine` it places where `self` is a class is the class's own method, so its
+      # block is not a refinement (issue #1689).
       class Collector
         attr_reader :census
 
-        def initialize
+        def initialize(in_effect)
           @census = Set.new
           @refine_ranges = []
+          @in_effect = in_effect
         end
 
         # A node the collector cannot read must not fail the analysis of its file, nor of every file the pre-pass
@@ -223,7 +226,7 @@ module Rigor
         def self_receiver?(node) = node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
 
         def remember_refine(node)
-          return unless node.name == :refine && self_receiver?(node) && node.block.is_a?(Prism::BlockNode)
+          return unless ScopeIndexer.refine_call?(node) && !@in_effect.class_body_refine?(node)
 
           location = node.block.location
           @refine_ranges << (location.start_offset...location.end_offset)

data/lib/rigor/inference/guard_rebinding.rb

@@ -406,7 +406,7 @@ module Rigor
           arguments = call_node.arguments&.arguments || []
           MethodDispatcher.expected_block_param_types(
             receiver_type: receiver, method_name: call_node.name, environment: scope.environment, scope: scope,
-            arg_types: arguments.map { |argument| scope.type_of(argument) }
+            arg_types: arguments.map { |argument| scope.type_of(argument) }, call_node: call_node
           )
         rescue StandardError
           []

data/lib/rigor/inference/in_effect_refinements/proc_literals.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Inference
+    class InEffectRefinements
+      # Issue #1666 — the Proc literals whose body a `.refined` receiver call applies to, recognised from syntax.
+      module ProcLiterals
+        # The `Kernel` calls whose literal block is the Proc they return.
+        BARE_PROC_CALLS = %i[proc lambda].freeze
+        private_constant :BARE_PROC_CALLS
+
+        # Copies that keep a refined Proc's refinements (`test_refined_preserved_by_dup`): a chain reads through them.
+        COPY_CALLS = %i[dup clone].freeze
+        private_constant :COPY_CALLS
+
+        module_function
+
+        # `[literal, refined calls]` for the outermost `.refined` call `node`: the Proc literal the chain starts from
+        # ({.refinable}, or nil), and every `.refined` call of the chain, innermost (first called) first. The chain
+        # reads through parentheses and through `dup` / `clone`.
+        def refined_chain(node)
+          calls = [node]
+          receiver = unwrap(node.receiver)
+          loop do
+            if refined_call?(receiver)
+              calls << receiver
+            elsif !copy_call?(receiver)
+              break
+            end
+            receiver = unwrap(receiver.receiver)
+          end
+          [refinable(receiver), calls.reverse]
+        end
+
+        def refined_call?(node) = node.is_a?(Prism::CallNode) && node.name == :refined
+
+        def copy_call?(node)
+          node.is_a?(Prism::CallNode) && COPY_CALLS.include?(node.name) && node.arguments.nil? && node.block.nil? &&
+            !node.receiver.nil?
+        end
+
+        # `( expr )` with one statement reads as `expr`.
+        def unwrap(node)
+          while node.is_a?(Prism::ParenthesesNode) && node.body.is_a?(Prism::StatementsNode) &&
+                node.body.body.size == 1
+            node = node.body.body.first
+          end
+          node
+        end
+
+        # The node whose span is the body `node.refined(…)` applies to: `node` itself for a lambda literal, or the
+        # literal block of a `proc` / `lambda` call on no receiver or on `Kernel`, or of `Proc.new`; nil for anything
+        # else. A Proc held in a variable, or one passed as `&blk`, is not one: which block it holds is not syntax.
+        def refinable(node)
+          case node
+          when Prism::LambdaNode then node
+          when Prism::CallNode
+            block = node.block
+            return nil unless block.is_a?(Prism::BlockNode)
+
+            block if bare_proc_call?(node) || proc_new_call?(node)
+          end
+        end
+
+        def bare_proc_call?(node)
+          BARE_PROC_CALLS.include?(node.name) && (node.receiver.nil? || top_constant?(node.receiver, :Kernel))
+        end
+
+        def proc_new_call?(node)
+          node.name == :new && top_constant?(node.receiver, :Proc)
+        end
+
+        # `Name` or `::Name`.
+        def top_constant?(node, name)
+          (node.is_a?(Prism::ConstantReadNode) || (node.is_a?(Prism::ConstantPathNode) && node.parent.nil?)) &&
+            node.name == name
+        end
+      end
+    end
+  end
+end