rigortype 0.3.9 → 0.4.0

data/lib/rigor/inference/last_line/self_evidence.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../../source/constant_path"
+require_relative "../../source/node_children"
+
+module Rigor
+  module Inference
+    module LastLine
+      # Issue #1415 (ADR-117 WD5) — what a file shows about the `self` its implicit-self and `self.` readers run with,
+      # read in one walk of the file the first time a reader condition asks ({ImplicitSelf.reader?}), and kept only
+      # once complete. The walk runs only for a file that holds such a condition. `Inference::ScopeIndexer` keeps one
+      # per file on the discovery index ({Scope::DiscoveryIndex#implicit_self_evidence}), so a callee body another
+      # file wrote finds none of its readers here and declines.
+      #
+      # Each reader is placed in the body whose `self` it runs with: `main` (the script body, a top-level method, a
+      # `class << self` at the top level), or a class or module body and its methods. A reader has none, and
+      # declines, where the file may give it another `self`:
+      #
+      # - in a block of `instance_eval`, `instance_exec`, `class_eval`, `module_eval`, `class_exec`, `module_exec`,
+      #   `define_method` or `define_singleton_method` (or a `send` that may name one), or of `Class.new`,
+      #   `Module.new`, `Struct.new` or `Data.define`, whose block is a class body;
+      # - in a method written inside a block or another method, whose owner is the block's or method's `self`, in a
+      #   module's instance method, whose `self` is whatever includes the module, and in `class << obj` for any `obj`
+      #   but `self`, or in a `class << self` a method runs, whose `self` is the method's receiver.
+      #
+      # A class or module is dirty ({#dirty?}), and every reader whose `self`'s ancestry reaches it declines, when a
+      # body of it may give it an ancestor the discovery tables do not record: a superclass that is not a constant
+      # (`DelegateClass(File)`, `Struct.new(:a)`), and an `include`, `extend` or `prepend` other than a statement of
+      # the body with no receiver naming constants (`self.include(M)`, one in a method, a block or `class << self`,
+      # `singleton_class.include(M)`, `include(*mods)`). Dirtiness is kept by the declaration's last name segment,
+      # so a reopening, a subclass and an includer of the class see it too, and a same-named class elsewhere
+      # declines with it.
+      #
+      # A name is tainted, and every reader of it in the file declines, when the file may change the method that name
+      # reaches from `main`, `Object` or an object the analyzer does not follow:
+      #
+      # - both names: a mixin into `main` (`include`, `extend` or `prepend` on implicit `self` outside a class or
+      #   module body, `class << self; include M; end` at the top level, `singleton_class.include(M)`), a mixin on
+      #   any explicit receiver (`Object.include(M)`, `TOPLEVEL_BINDING.receiver.extend(M)`, `obj.extend(M)`), any
+      #   mixin in an `Object`, `Kernel` or `BasicObject` body, a `send` that may name one, a method object taken
+      #   for a mixin or a `self`-rebinding call (`method(:extend)`, `Module.instance_method(:include)`), any
+      #   `using`, a proc handed to one of the `self`-rebinding calls above (`obj.instance_exec(&blk)`,
+      #   `X.send(:define_method, :m, blk)`), whose body may be a block the file wrote anywhere, an eval of a
+      #   String, whose code may do any of these, and a `const_set`, which may make a class a `class` body reopens;
+      # - one name: a `def` of it anywhere (`def self.gets` at the top level defines it on `main`, which
+      #   {BlockCallTiming.project_defines_anywhere?} does not record), and a Symbol or String literal naming it,
+      #   which a macro may define it through (`def_delegators :@io, :gets`, `attr_reader :gets`,
+      #   `undef_method :gets`), other than `&:gets` and the first argument of a call that only names a method
+      #   (`respond_to?(:gets)`, `send(:gets)`).
+      class SelfEvidence
+        # The context of a reader whose `self` is `main`.
+        MAIN = :main
+        UNKNOWN = :unknown
+        READER_NAMES = Set["gets", "readline"].freeze
+        MIXINS = Set[:include, :extend, :prepend].freeze
+        SENT_MIXINS = Set["include", "extend", "prepend", "using"].freeze
+        SENDS = Set[:send, :__send__, :public_send].freeze
+        REBINDERS = Set[
+          :instance_eval, :instance_exec, :class_eval, :module_eval, :class_exec, :module_exec, :define_method,
+          :define_singleton_method
+        ].freeze
+        REBINDER_NAMES = REBINDERS.to_set(&:to_s).freeze
+        # `using` refines for the rest of the file, and `const_set` may make a class a `class` body then reopens
+        # (`Object.const_set(:W, Class.new(CSV))`), whatever the receiver.
+        FILE_WIDE = Set[:using, :const_set].freeze
+        # The rebinders a proc argument can give a body to (`define_method(:m, blk)`).
+        BODY_DEFINERS = Set[:define_method, :define_singleton_method].freeze
+        BODY_DEFINER_NAMES = BODY_DEFINERS.to_set(&:to_s).freeze
+        CONSTRUCTORS = { Class: :new, Module: :new, Struct: :new, Data: :define }.freeze
+        # The calls that take a method object, which a later `call` or `bind_call` runs with any receiver.
+        METHOD_OBJECTS = Set[:method, :public_method, :singleton_method, :instance_method, :public_instance_method]
+                         .freeze
+        METHOD_OBJECT_NAMES = (SENT_MIXINS | REBINDER_NAMES).freeze
+        # Calls whose first argument names a method without putting one in place.
+        NAMING_CALLS = Set[:send, :__send__, :public_send, :respond_to?, :method, :public_method].freeze
+        ROOTS = Set["Object", "Kernel", "BasicObject"].freeze
+        private_constant :UNKNOWN, :READER_NAMES, :MIXINS, :SENT_MIXINS, :SENDS, :REBINDERS, :REBINDER_NAMES,
+                         :FILE_WIDE, :BODY_DEFINERS, :BODY_DEFINER_NAMES, :METHOD_OBJECTS, :METHOD_OBJECT_NAMES,
+                         :CONSTRUCTORS, :NAMING_CALLS, :ROOTS
+
+        def initialize(root)
+          @root = root
+          @scan = nil
+        end
+
+        # {MAIN}, the `Prism::ClassNode` or `Prism::ModuleNode` whose body the implicit-self reader `call_node` runs
+        # in, or nil: the file may give it another `self`, or it is not one of this file's readers.
+        def context(call_node) = scan.context(call_node)
+
+        # True when a class or module of `class_name`'s last name segment is dirty in this file.
+        def dirty?(class_name) = scan.dirty?(class_name)
+
+        private
+
+        def scan = (@scan ||= Scan.new(@root))
+
+        # One walk of the file, whose answers {SelfEvidence} keeps once the walk is complete.
+        class Scan
+          def initialize(root)
+            @contexts = {}.compare_by_identity
+            @dirty = Set.new
+            @tainted = Set.new
+            visit(root, MAIN, false, false, false)
+            @contexts.freeze
+            @dirty.freeze
+            @tainted.freeze
+          end
+
+          def context(call_node)
+            return nil if @tainted.include?(call_node.name)
+
+            context = @contexts[call_node]
+            context unless context.is_a?(Prism::Node) && @dirty.include?(segment(context))
+          end
+
+          def dirty?(class_name) = @dirty.include?(class_name.to_s.split("::").last)
+
+          private
+
+          # `context` is {MAIN}, a declaration node or {UNKNOWN}; `statement` is true for a statement of a class or
+          # module body itself; `block` is true inside a block or lambda of the body; `singleton` is true inside a
+          # `class << self` body.
+          def visit(node, context, statement, block, singleton)
+            case node
+            when Prism::ClassNode, Prism::ModuleNode then visit_declaration(node, context, block, singleton)
+            when Prism::SingletonClassNode then visit_singleton_class(node, context, block)
+            when Prism::DefNode then visit_def(node, context, block, singleton)
+            when Prism::CallNode then visit_call(node, context, statement, block, singleton)
+            when Prism::BlockNode, Prism::LambdaNode then visit_children(node, context, true, singleton)
+            when Prism::BlockArgumentNode then visit_block_argument(node, context, block, singleton)
+            when Prism::SymbolNode, Prism::StringNode then taint(node.unescaped)
+            else visit_children(node, context, block, singleton)
+            end
+          end
+
+          def visit_children(node, context, block, singleton)
+            node.rigor_each_child { |child| visit(child, context, false, block, singleton) }
+          end
+
+          def visit_declaration(node, context, block, singleton)
+            visit(node.constant_path, context, false, block, singleton)
+            superclass = node.is_a?(Prism::ClassNode) ? node.superclass : nil
+            if superclass
+              visit(superclass, context, false, block, singleton)
+              dirty(node) unless constant?(superclass)
+            end
+            visit_body(node.body, node)
+          end
+
+          def visit_body(body, declaration)
+            if body.is_a?(Prism::StatementsNode)
+              body.body.each { |statement| visit(statement, declaration, true, false, false) }
+            elsif body
+              visit(body, declaration, false, false, false)
+            end
+          end
+
+          # `class << self` keeps the body's `self` for the methods it defines; `class << obj` gives them `obj`, and
+          # so does `class << self` in a method or a block, whose `self` is the method's receiver or the block's.
+          def visit_singleton_class(node, context, block)
+            visit(node.expression, context, false, block, false)
+            inner = node.expression.is_a?(Prism::SelfNode) && !block ? context : UNKNOWN
+            visit(node.body, inner, false, false, true) if node.body
+          end
+
+          def visit_def(node, context, block, singleton)
+            taint(node.name.to_s)
+            receiver = node.receiver
+            visit(receiver, context, false, block, singleton) if receiver
+            inner = def_context(receiver, context, block, singleton)
+            visit(node.parameters, inner, false, true, false) if node.parameters
+            visit(node.body, inner, false, true, false) if node.body
+          end
+
+          def def_context(receiver, context, block, singleton)
+            return UNKNOWN if block || context == UNKNOWN
+            return context if receiver.is_a?(Prism::SelfNode)
+            return UNKNOWN unless receiver.nil?
+
+            context.is_a?(Prism::ModuleNode) && !singleton ? UNKNOWN : context
+          end
+
+          def visit_call(node, context, statement, block, singleton)
+            classify(node, context, statement)
+            @contexts[node] = context if implicit_reader?(node) && context != UNKNOWN
+            visit(node.receiver, context, false, block, singleton) if node.receiver
+            visit_arguments(node, context, block, singleton)
+            visit_call_block(node, context, block, singleton)
+          end
+
+          def visit_arguments(node, context, block, singleton)
+            arguments = node.arguments&.arguments
+            return if arguments.nil?
+
+            arguments.each_with_index do |argument, index|
+              next if index.zero? && NAMING_CALLS.include?(node.name) && literal?(argument)
+
+              visit(argument, context, false, block, singleton)
+            end
+          end
+
+          def visit_call_block(node, context, block, singleton)
+            call_block = node.block
+            case call_block
+            when Prism::BlockNode then visit(call_block, rebinder?(node) ? UNKNOWN : context, false, true, singleton)
+            when Prism::BlockArgumentNode
+              taint_all if rebinder?(node) && !call_block.expression.is_a?(Prism::SymbolNode)
+              visit(call_block, context, false, block, singleton)
+            end
+          end
+
+          # `&:gets` runs the element's own reader.
+          def visit_block_argument(node, context, block, singleton)
+            expression = node.expression
+            return if expression.nil? || expression.is_a?(Prism::SymbolNode)
+
+            visit(expression, context, false, block, singleton)
+          end
+
+          def classify(node, context, statement)
+            name = node.name
+            if MIXINS.include?(name) then mixin(node, context, statement)
+            elsif taints_file?(name, node.arguments&.arguments) then taint_all
+            end
+          end
+
+          # `using`, `const_set`, an eval of a String, which may run any of the shapes this walk reads, a proc handed
+          # to a definer, a `send` that may name a mixin, and a method object taken for a mixin or a rebinder.
+          def taints_file?(name, arguments)
+            return true if FILE_WIDE.include?(name)
+            return false if arguments.nil?
+            return true if EVALS.include?(name) || (BODY_DEFINERS.include?(name) && arguments.size > 1)
+            return sent_mixin?(arguments) if SENDS.include?(name)
+
+            METHOD_OBJECTS.include?(name) && literal?(arguments.first) &&
+              METHOD_OBJECT_NAMES.include?(arguments.first.unescaped)
+          end
+
+          def mixin(node, context, statement)
+            receiver = node.receiver
+            declaration = context.is_a?(Prism::ClassNode) || context.is_a?(Prism::ModuleNode)
+            if declaration && !root?(context) && (receiver.nil? || self_or_singleton_class?(receiver))
+              dirty(context) unless receiver.nil? && statement && constant_arguments?(node)
+            else
+              taint_all
+            end
+          end
+
+          def sent_mixin?(arguments)
+            first = arguments&.first
+            case first
+            when nil then false
+            when Prism::SymbolNode, Prism::StringNode
+              name = first.unescaped
+              SENT_MIXINS.include?(name) || (BODY_DEFINER_NAMES.include?(name) && arguments.size > 2)
+            when Prism::SplatNode then true
+            else arguments.size > 1
+            end
+          end
+
+          # A rebinder, a `send` that may name one (`obj.send(:instance_eval) { … }`), or a metaclass constructor.
+          def rebinder?(node)
+            name = node.name
+            return true if REBINDERS.include?(name)
+            return sent_rebinder?(node.arguments&.arguments&.first) if SENDS.include?(name)
+
+            receiver = node.receiver
+            constructor =
+              case receiver
+              when Prism::ConstantReadNode then receiver.name
+              when Prism::ConstantPathNode then receiver.name if receiver.parent.nil?
+              end
+            !constructor.nil? && CONSTRUCTORS[constructor] == name
+          end
+
+          def sent_rebinder?(first)
+            literal?(first) ? REBINDER_NAMES.include?(first.unescaped) : true
+          end
+
+          def implicit_reader?(node)
+            LastLine::READERS.include?(node.name) && node.block.nil? &&
+              (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode))
+          end
+
+          # `self.include(M)` and `singleton_class.include(M)`, which the discovery tables do not record.
+          def self_or_singleton_class?(receiver)
+            return true if receiver.is_a?(Prism::SelfNode)
+
+            receiver.is_a?(Prism::CallNode) && receiver.name == :singleton_class &&
+              (receiver.receiver.nil? || receiver.receiver.is_a?(Prism::SelfNode))
+          end
+
+          def dirty(declaration)
+            @dirty << segment(declaration)
+          end
+
+          def segment(declaration) = declaration.constant_path.slice.split("::").last
+
+          def root?(declaration) = ROOTS.include?(segment(declaration))
+
+          # `extend self` adds the module's own methods, which the program's `def`s already answer for.
+          def constant_arguments?(node)
+            arguments = node.arguments&.arguments
+            !arguments.nil? && !arguments.empty? &&
+              arguments.all? { |argument| constant?(argument) || argument.is_a?(Prism::SelfNode) }
+          end
+
+          def constant?(node)
+            (node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)) &&
+              !Source::ConstantPath.qualified_name_or_nil(node).nil?
+          end
+
+          def literal?(node) = node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+
+          def taint(name)
+            @tainted << name.to_sym if READER_NAMES.include?(name)
+          end
+
+          def taint_all
+            @tainted.merge(LastLine::READERS)
+          end
+        end
+        private_constant :Scan
+      end
+    end
+  end
+end

data/lib/rigor/inference/last_line.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../source/node_children"
+require_relative "../reflection"
+require_relative "../type"
+require_relative "block_call_timing"
+require_relative "fresh_frame_blocks"
+
+module Rigor
+  module Inference
+    # Issue #1359 — which code may set `$_`, the last line read, that a scope's narrowing speaks for. Ruby keeps it in
+    # the method frame's special-variable slot beside `$~`, so the frame rules are the match globals'
+    # ({MatchRebinding}): a `def`, class, module or file body has a slot of its own; a block, and a closure made in
+    # the body, shares it; a call into a method defined in Ruby writes that method's slot, never its caller's; and
+    # the root block of a thread, fiber or ractor has one of its own ({FreshFrameBlocks}). Only a C-implemented
+    # reader sets its caller's `$_`, to the line it returns: `Kernel#gets` / `#readline` and the same methods of
+    # `IO`, `StringIO`, `ARGF` and `Zlib::GzipReader`; `IO.foreach` sets it to each line it yields. `each_line` and
+    # `readlines` leave it alone.
+    #
+    # A call is read two ways, as the match globals' calls are:
+    #
+    # - {.reads_line?}: the call certainly is such a reader, run in this frame, so a condition on its value narrows
+    #   `$_` on both edges ({Narrowing}). Apart from a write, that is the only place `$_` is bound.
+    # - {.may_set?}: running the code may set `$_` in this frame, so a narrowing of it is forgotten: a reader's or
+    #   `foreach`'s name on any receiver (a `Dynamic` one, or one whose method turns out to be defined in Ruby, which
+    #   only costs the narrowing), a `send` that may name one, an eval of a String, a write, or a block argument that
+    #   may run one.
+    #
+    # A reader that is not a condition leaves `$_` unbound, not bound to its `String?`: nothing proves the line
+    # non-nil there, and a `String?` would report correct code that checks the reader's value another way before
+    # it reads `$_` (`line = gets; return unless line; $_.chomp`). The scans run only while `$_` is bound.
+    module LastLine
+      # The C readers' names.
+      READERS = Set[:gets, :readline].freeze
+      # Every name that may set its caller's `$_`, on any receiver: the readers, and `IO.foreach`, which sets it to
+      # each line before it yields the line and to nil once the input ends. Compared as Strings where a literal
+      # names one.
+      SETTERS = (READERS | Set[:foreach]).freeze
+      SETTER_NAMES = SETTERS.to_set(&:to_s).freeze
+      # The `Kernel` functions `ruby -n` / `-p` adds, which edit `$_` in place of an implicit-self receiver.
+      LINE_EDITORS = Set[:sub, :gsub, :chop, :chomp].freeze
+      # `$stdin`, and `$<`, which is `ARGF`, while the file binds them to nothing but a reader.
+      READER_GLOBALS = Set[:$stdin, :$<].freeze
+      # The RBS owners of a C reader. `Kernel`'s is not one: it is private, and RBS places there any reader it does not
+      # declare (`CSV#gets`, an alias of its Ruby `shift`, reads as `Kernel`'s). `Kernel.gets` itself is read by the
+      # receiver's type.
+      READER_OWNERS = Set["::IO", "::StringIO", "::RBS::Unnamed::ARGFClass", "::Zlib::GzipReader"].freeze
+      # RBS declares `Tempfile < File`, but its methods are `DelegateClass(File)`'s Ruby forwarders, so its `gets`
+      # sets the forwarder's `$_` and never its caller's.
+      DELEGATING_CLASSES = %w[Tempfile].freeze
+      DELEGATING_ORDERINGS = Set[:equal, :subclass].freeze
+      SENDS = Set[:send, :__send__, :public_send].freeze
+      # These run a String of code in the frame that calls them; their block form is a block, scanned as one.
+      EVALS = Set[:eval, :instance_eval, :class_eval, :module_eval].freeze
+      WRITES = Set[
+        Prism::GlobalVariableWriteNode, Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode,
+        Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableTargetNode
+      ].freeze
+      LAST_LINE = :$_
+      # The calls that put a method in place under the name they are given: the new name, for `alias_method`.
+      DEFINERS = Set[:define_method, :define_singleton_method, :alias_method].freeze
+      DEFINER_NAMES = DEFINERS.to_set(&:to_s).freeze
+      ALL_READERS = READERS.to_a.freeze
+      # Compared as Strings: a literal with an invalid byte (`define_method("\xff")`) cannot become a Symbol.
+      READER_STRINGS = READERS.to_set(&:to_s).freeze
+      private_constant :DEFINERS, :DEFINER_NAMES, :ALL_READERS, :READER_STRINGS
+      private_constant :SETTER_NAMES, :LINE_EDITORS, :READER_GLOBALS, :READER_OWNERS, :DELEGATING_CLASSES,
+                       :DELEGATING_ORDERINGS, :SENDS, :EVALS, :WRITES, :LAST_LINE
+
+      module_function
+
+      # True when `call_node` certainly is a C reader run in this frame, so `$_` holds what it returns: `gets` or
+      # `readline` without a block, on the `Kernel` module, on `$stdin` or `$<`, or on a receiver typed as a class
+      # whose reader RBS places in `IO`, `StringIO`, `ARGF` or `Zlib::GzipReader`, other than `Tempfile` (`STDIN` and
+      # `ARGF` read so by their types, and a project constant that shadows either reads by its own). A receiver typed
+      # `IO` or `File` that is a subclass instance at runtime is read as the class it is typed as.
+      #
+      # Issue #1415 (ADR-117 WD5) — an implicit-self or `self.` `gets` is one while the file shows no `self` whose
+      # reader may be Ruby's ({ImplicitSelf.reader?}). An implicit-self `readline` is not yet: it never returns
+      # falsey, so a `while readline` loop leaves only through a `break` or its `EOFError`, but the scope after the
+      # loop still joins the scope the body started from, where its narrowed line would report correct code.
+      #
+      # No reader is one whose name the program defines or patches in anywhere
+      # ({BlockCallTiming.project_defines_anywhere?}): a reopened `IO` or `Kernel`, or a project object bound to
+      # `$stdin` in another file, runs the program's Ruby method, which sets its own frame's `$_`.
+      def reads_line?(call_node, scope)
+        return false unless call_node.is_a?(Prism::CallNode) && READERS.include?(call_node.name)
+        return false unless call_node.block.nil?
+
+        name = call_node.name
+        return false if BlockCallTiming.project_defines_anywhere?(name, scope)
+        return false if scope.discovery.patched_line_readers.include?(name)
+
+        receiver = call_node.receiver
+        case receiver
+        when nil, Prism::SelfNode
+          name == :gets && ImplicitSelf.reader?(call_node, scope)
+        when Prism::GlobalVariableReadNode then reader_global?(receiver.name, name, scope)
+        else reader_receiver?(scope.type_of(receiver), name, scope)
+        end
+      rescue StandardError
+        false
+      end
+
+      # The edges of a condition whose value is `call_node`'s ({.reads_line?}): `pair`, the edges the condition
+      # narrows otherwise (nil for none), with `$_` bound on each to the line the call returned, narrowed as that
+      # value is — `String` where it is truthy and `nil` where it is not, for `gets`. The line is typed by the
+      # readers' RBS return, which every owner {.reads_line?} accepts declares alike (`String?` for `gets`, `String`
+      # for `readline`), rather than by the call's inferred type, which is `Dynamic[top]` on `$stdin`. A
+      # safe-navigation call answers nil without reading when its receiver is nil, so its falsey edge leaves `$_` as
+      # the call left it.
+      def predicate_scopes(call_node, scope, pair)
+        return pair unless reads_line?(call_node, scope)
+
+        line = line_type(call_node.name)
+        truthy, falsey = pair || [scope, scope]
+        truthy = truthy.with_global(LAST_LINE, Narrowing.narrow_truthy(line))
+        falsey = falsey.with_global(LAST_LINE, Narrowing.narrow_falsey(line)) unless call_node.safe_navigation?
+        [truthy, falsey]
+      end
+
+      # The reader names `node` patches in through the `define_method` family, on any receiver, or nil: a
+      # `define_method`, `define_singleton_method` or `alias_method` call (or a `send`, `__send__` or `public_send`
+      # naming one) and an `alias` whose new name is `gets` or `readline`, or is not a literal, which may be either.
+      # `Inference::ScopeIndexer` gathers them for the file ({Scope::DiscoveryIndex#patched_line_readers}).
+      def patched_readers(node)
+        case node
+        when Prism::AliasMethodNode then reader_named(node.new_name)
+        when Prism::CallNode
+          arguments = node.arguments&.arguments
+          if DEFINERS.include?(node.name)
+            reader_named(arguments&.first)
+          elsif SENDS.include?(node.name) && arguments && definer_name?(arguments.first)
+            reader_named(arguments[1])
+          end
+        end
+      end
+
+      # The readers a method-name argument may name: its own when it is a reader's literal, both when it is not a
+      # literal, and none for another literal or no argument at all.
+      def reader_named(name_node)
+        case name_node
+        when nil then nil
+        when Prism::SymbolNode, Prism::StringNode
+          name = name_node.unescaped
+          [name.to_sym] if READER_STRINGS.include?(name)
+        else ALL_READERS
+        end
+      end
+
+      def definer_name?(name_node)
+        (name_node.is_a?(Prism::SymbolNode) || name_node.is_a?(Prism::StringNode)) &&
+          DEFINER_NAMES.include?(name_node.unescaped)
+      end
+      private_class_method :reader_named, :definer_name?
+
+      # True when running `node` may set `$_` in the frame it runs in, anywhere in `node` but a nested `def`, class
+      # or module body or a root block ({FreshFrameBlocks.any_frame_child?}): a call {.call_may_set?} counts, a write
+      # to `$_`, or a block argument {.block_argument_may_set?} counts. A block or lambda inside `node` counts, since
+      # it runs in the same frame. Kept on `scope`'s frame as {MatchRebinding.may_match?} is.
+      def may_set?(node, scope = nil)
+        return false unless node.is_a?(Prism::Node)
+
+        MatchRebinding.remember(node, scope, :last_line) { scan(node, scope) }
+      end
+
+      def scan(node, scope)
+        return true if setting_node?(node, scope)
+        return false if MatchRebinding::OWN_FRAME_NODES.include?(node.class)
+
+        FreshFrameBlocks.any_frame_child?(node, scope) { |child| scan(child, scope) }
+      end
+
+      def setting_node?(node, scope)
+        case node
+        when Prism::CallNode then call_may_set?(node)
+        when Prism::BlockArgumentNode then block_argument_may_set?(node, scope)
+        else WRITES.include?(node.class) && node.name == LAST_LINE
+        end
+      end
+      private_class_method :scan, :setting_node?
+
+      # True when `call_node` itself may set its caller's `$_`: a {SETTERS} name on any receiver, a {LINE_EDITORS}
+      # name on implicit `self`, a `send` whose name is not a literal or names a setter, or an eval of a String.
+      def call_may_set?(call_node)
+        name = call_node.name
+        return true if SETTERS.include?(name) || (call_node.receiver.nil? && LINE_EDITORS.include?(name))
+
+        arguments = call_node.arguments&.arguments
+        return sent_reader?(arguments&.first) if SENDS.include?(name)
+
+        EVALS.include?(name) && !arguments.nil?
+      end
+
+      # True when a `&expr` block argument may pass a proc that sets `$_` in this frame: a `&:gets` or `&:readline`,
+      # which the method runs from C, or a proc made in this frame, as {MatchRebinding.block_argument_may_match?}
+      # reads one — not an anonymous `&`, nor the method's own `&block` it only forwards.
+      def block_argument_may_set?(block_argument, scope)
+        expression = block_argument.expression
+        case expression
+        when nil then false
+        when Prism::SymbolNode then SETTER_NAMES.include?(expression.unescaped)
+        when Prism::LocalVariableReadNode
+          frame = scope&.match_frame
+          frame.nil? || !frame.forwarded_block?(expression.name)
+        else true
+        end
+      end
+
+      # True when the block `call_node` passes may set `$_` while the call runs, as {MatchRebinding.block_may_match?}
+      # reads a block: a root block never does, though a root `&expr` argument's expression runs here first.
+      def block_may_set?(call_node, scope)
+        block = call_node.block
+        if FreshFrameBlocks.root_call?(call_node, scope)
+          return block.is_a?(Prism::BlockArgumentNode) && may_set?(block.expression, scope)
+        end
+
+        case block
+        when Prism::BlockNode then may_set?(block.body, scope)
+        when Prism::BlockArgumentNode then block_argument_may_set?(block, scope)
+        else false
+        end
+      end
+
+      # True when a call's receiver chain or arguments, which Ruby runs before the method, may set `$_`.
+      def operands_may_set?(call_node, scope)
+        may_set?(call_node.receiver, scope) || may_set?(call_node.arguments, scope)
+      end
+
+      # True when a statement's own call may set `$_` in this frame, once its operands ran: it may itself
+      # ({.call_may_set?}), its block may ({.block_may_set?}), the frame makes a closure that may, which any call
+      # can run ({.closure?}), or it is an implicit-self or `self.` call in a frame that hands `$_`'s slot to code the
+      # analyzer does not trace ({.fallback?}) or that no body stamped. A call into a method defined in Ruby sets
+      # that method's `$_`, so any other call keeps the narrowing.
+      def call_rebinds?(call_node, scope)
+        return true if call_may_set?(call_node) || block_may_set?(call_node, scope)
+
+        frame = scope.match_frame
+        implicit = call_node.receiver.nil? || call_node.receiver.is_a?(Prism::SelfNode)
+        return implicit if frame.nil?
+        return true if frame.last_line_closure?(scope)
+
+        implicit && frame.last_line_fallback?(scope)
+      end
+
+      # True when `node`, a frame's body or parameters, makes a lambda, or a block a call keeps to run later, whose
+      # body {.may_set?} ({MatchRebinding.makes_closure?}).
+      def closure?(node, scope)
+        MatchRebinding.makes_closure?(node, scope) { |body| may_set?(body, scope) }
+      end
+
+      # True when `node`, a frame's body or parameters, hands `$_`'s slot to code the analyzer does not trace: a block
+      # or lambda whose body {.may_set?}, which the method it is handed to may keep and run from a later call,
+      # `binding`, or a forward of the method's own block ({MatchRebinding.hands_out_slot?}).
+      def fallback?(node, block_name, scope)
+        MatchRebinding.hands_out_slot?(node, block_name, scope) { |body| may_set?(body, scope) }
+      end
+
+      # The scope a block or lambda body enters with, as {MatchRebinding.block_entry} gives the match globals': `$_`
+      # forgotten when the body may set it, which a later iteration then reads, when the frame makes a closure that
+      # may, or when the owning call may: its receiver chain and arguments run before the method yields, and
+      # `IO.foreach` sets `$_` to each line it yields.
+      def block_entry(scope, block_node, call_node = nil)
+        return scope unless scope.last_line_bound?
+        return scope unless scope.last_line_closure? || may_set?(block_node.body, scope) || call_sets?(call_node, scope)
+
+        scope.forget_last_line
+      end
+
+      def call_sets?(call_node, scope)
+        call_node.is_a?(Prism::CallNode) && (call_may_set?(call_node) || operands_may_set?(call_node, scope))
+      end
+      private_class_method :call_sets?
+
+      # `scope` with `$_` forgotten when any of `bodies` may set it: a loop body that runs again after it ran, a
+      # `begin` body a `rescue` clause reads after any prefix of it ran, or a `case` clause's tests.
+      def forget_if_set(scope, *bodies)
+        return scope unless scope.last_line_bound? && bodies.any? { |body| may_set?(body, scope) }
+
+        scope.forget_last_line
+      end
+
+      def line_type(reader)
+        string = Type::Combinator.nominal_of("String")
+        reader == :readline ? string : Type::Combinator.union(string, Type::Combinator.constant_of(nil))
+      end
+
+      def sent_reader?(name_node)
+        case name_node
+        when nil then false
+        when Prism::SymbolNode, Prism::StringNode then SETTER_NAMES.include?(name_node.unescaped)
+        else true
+        end
+      end
+      private_class_method :line_type, :sent_reader?
+
+      def reader_receiver?(type, name, scope)
+        return type.class_name == "Kernel" if type.is_a?(Type::Singleton)
+
+        reader_type?(type, name, scope)
+      end
+
+      # Issue #1362 (ADR-117 WD1) — a `$stdin` the file writes reads its declared `IO` joined with the written values,
+      # so a union whose every member is a reader's class (`IO | StringIO`) counts as one.
+      def reader_global?(global_name, name, scope)
+        return false unless READER_GLOBALS.include?(global_name)
+
+        bound = scope.global(global_name)
+        return true if bound.nil?
+
+        members = bound.is_a?(Type::Union) ? bound.members : [bound]
+        members.all? { |member| reader_type?(member, name, scope) }
+      end
+
+      def reader_type?(type, name, scope)
+        type.is_a?(Type::Nominal) && reader_class?(type.class_name, name, scope)
+      end
+
+      # A class RBS does not know answers false: its ancestry is the program's or a gem's, and may hold a Ruby reader.
+      def reader_class?(class_name, name, scope)
+        return false if delegating_class?(class_name, scope)
+
+        definition = Reflection.instance_method_definition(class_name, name, scope: scope)
+        !definition.nil? && READER_OWNERS.include?(definition.defined_in.to_s)
+      end
+
+      def delegating_class?(class_name, scope)
+        DELEGATING_CLASSES.any? do |delegating|
+          DELEGATING_ORDERINGS.include?(scope.environment.class_ordering(class_name, delegating))
+        end
+      end
+
+      private_class_method :reader_receiver?, :reader_global?, :reader_type?, :reader_class?, :delegating_class?
+    end
+  end
+end
+
+require_relative "last_line/implicit_self"