rigortype 0.3.8 → 0.4.0

data/lib/rigor/inference/project_method_ownership.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+require_relative "external_ancestor_resolution"
+
+module Rigor
+  module Inference
+    # Issue #1234 — does the PROJECT define the method a receiver answers a name with? The captured-binding
+    # pass reads a catalogued iterator name on an unclassified receiver as repetition
+    # ({ClosureEscapeAnalyzer.repeats_by_name?}), and that reading is wrong for a method the project wrote
+    # under the same name: `class Vault; def select(key) = yield(key.to_s); end` runs its block once. The
+    # ancestry step of {ClosureEscapeAnalyzer.classify} asks the same question, of the same call, to rule the
+    # project out as the method's owner.
+    #
+    # "Defines" is a `def`, `define_method` or `attr_*` anywhere in a project class's ancestry, on the
+    # instance side or on the singleton side for a class-object receiver, or a signature whose declaring
+    # owner is a project class or module.
+    module ProjectMethodOwnership
+      NO_TARGETS = [].freeze
+      private_constant :NO_TARGETS
+
+      MEMO_KEY = :__rigor_project_method_ownership_memo__
+      private_constant :MEMO_KEY
+
+      module_function
+
+      # The `[class_name, kind]` pairs the receiver's method is looked up on — `[]` for a receiver Rigor
+      # cannot see at all — or nil when the carrier names a class this cannot resolve, or is one it does not
+      # recognise, so a caller that cannot tell whether the project owns the method can decline. The audit,
+      # carrier by carrier:
+      #
+      # - `Dynamic`, `Top` — unseen: `[]`.
+      # - `Nominal`, `StructInstance`, `DataInstance` — their `class_name`, instance side.
+      # - `Singleton`, `StructClass`, `DataClass` — their `class_name`, singleton side.
+      # - `Tuple` → `Array`, `HashShape` → `Hash`, `IntegerRange` → `Integer`, `FloatRange` → `Float`,
+      #   `Constant` → its value's class, `BoundMethod` → `Method`: instance side of that core class, which a
+      #   project reopening may still define the method on.
+      # - `Union`, `Intersection` — every member's targets; a member it cannot resolve resolves the whole.
+      # - `Refined`, `Difference` — their `base`. `App` — its erasure `bound`.
+      # - A struct / data carrier with no `class_name` (an anonymous `Struct.new` value), `Bot`, `Maybe`,
+      #   `Result`, and any carrier added later — nil.
+      def targets(receiver_type)
+        case receiver_type
+        when Type::Dynamic, Type::Top then NO_TARGETS
+        when Type::Nominal, Type::StructInstance, Type::DataInstance
+          class_target(receiver_type.class_name, :instance)
+        when Type::Singleton, Type::StructClass, Type::DataClass
+          class_target(receiver_type.class_name, :singleton)
+        when Type::Union, Type::Intersection then member_targets(receiver_type.members)
+        when Type::Refined, Type::Difference then targets(receiver_type.base)
+        when Type::App then targets(receiver_type.bound)
+        else core_targets(receiver_type)
+        end
+      end
+
+      # Whether the project's source, or a signature whose declaring owner is a project class or module,
+      # defines `method_sym` on `class_name` or an ancestor the project declares. Memoised ({.memo}): the
+      # ancestry step and the name reading ask it of the same call, and every block call on the class asks
+      # it again.
+      def defines?(class_name, method_sym, kind, scope)
+        return false if scope.nil?
+
+        by_method = (memo(scope)[kind][class_name] ||= {})
+        return by_method[method_sym] if by_method.key?(method_sym)
+
+        by_method[method_sym] = compute_defines?(class_name, method_sym, kind, scope)
+      end
+
+      # One slot per thread, keyed on the identity of the scope's frozen discovery index and its environment —
+      # the only inputs {.defines?} and the ancestry step read — and replaced, not accumulated, when either
+      # changes: the shape of `ExpressionTyper#class_graph_buckets`, whose rationale applies unchanged. A
+      # `Scope` merges each file's discovery with the project pre-pass, so the slot turns over per file, and
+      # an ADR-46 dependency the first lookup recorded belongs to the file every later hit serves. Pool
+      # workers are separate processes, and a Ractor has its own `Thread.current`. The `:ancestry` bucket
+      # belongs to {ClosureEscapeAnalyzer}'s ancestry step.
+      def memo(scope)
+        discovery = scope.discovery
+        environment = scope.environment
+        slot = Thread.current[MEMO_KEY]
+        unless slot && slot[0].equal?(discovery) && slot[1].equal?(environment)
+          slot = [discovery, environment, { instance: {}, singleton: {}, ancestry: {} }]
+          Thread.current[MEMO_KEY] = slot
+        end
+        slot[2]
+      end
+
+      class << self
+        private
+
+        def class_target(class_name, kind)
+          class_name.nil? ? nil : [[class_name.to_s, kind]]
+        end
+
+        def member_targets(members)
+          members.each_with_object([]) do |member, out|
+            resolved = targets(member)
+            return nil if resolved.nil?
+
+            out.concat(resolved)
+          end
+        end
+
+        def core_targets(receiver_type)
+          case receiver_type
+          when Type::Tuple then class_target("Array", :instance)
+          when Type::HashShape then class_target("Hash", :instance)
+          when Type::IntegerRange then class_target("Integer", :instance)
+          when Type::FloatRange then class_target("Float", :instance)
+          when Type::Constant then class_target(receiver_type.value.class.name, :instance)
+          when Type::BoundMethod then class_target("Method", :instance)
+          end
+        end
+
+        def compute_defines?(class_name, method_sym, kind, scope)
+          return true if source_defines?(class_name, method_sym, kind, scope)
+
+          # `ExternalAncestorResolution.method_definition` owns the rescue for a malformed signature.
+          definition = ExternalAncestorResolution.method_definition(class_name, method_sym, kind, scope: scope)
+          owner = definition.respond_to?(:defined_in) ? definition.defined_in : nil
+          !owner.nil? && scope.known_user_class?(owner.to_s.delete_prefix("::"))
+        end
+
+        def source_defines?(class_name, method_sym, kind, scope)
+          return true if scope.discovered_method_through_ancestors?(class_name, method_sym, kind)
+
+          found, = if kind == :singleton
+                     scope.singleton_def_through_ancestors(class_name, method_sym)
+                   else
+                     scope.user_def_through_ancestors(class_name, method_sym)
+                   end
+          !found.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rigor/inference/project_patched_methods.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "global_write_census"
+
 module Rigor
   module Inference
     # ADR-17 § "Inference contract" — project-wide patched-method registry populated by the pre-eval
@@ -26,20 +28,23 @@ module Rigor
         end
       end
 
-      attr_reader :by_key
+      attr_reader :by_key, :write_census
 
-      # @param entries [Array<Entry>] flat list of declarations observed during the pre-pass.
+      # @param entries — flat list of declarations observed during the pre-pass.
       #   First-write-wins on `(class_name, method_name, kind)` duplicates so the
       #   `pre-eval.duplicate-declaration` diagnostic emission stays decoupled from registry behaviour.
-      def initialize(entries: [])
+      # @param write_census — issue #1367: the `pre_eval:` files' {GlobalWriteCensus}, which the `global.*` write
+      #   rules join with the project's, since a patch file is loaded ahead of the code it patches.
+      def initialize(entries: [], write_census: GlobalWriteCensus::EMPTY)
         @by_key = entries.each_with_object({}) do |entry, acc|
           key = [entry.class_name, entry.method_name, entry.kind]
           acc[key] ||= entry
         end.freeze
+        @write_census = write_census.frozen? ? write_census : write_census.dup.freeze
         freeze
       end
 
-      # @return [Entry, nil] the recorded entry for the given `(class_name, method_name, kind)` triple,
+      # @return the recorded entry for the given `(class_name, method_name, kind)` triple,
       #   or `nil` when no pre-eval file declared it.
       def lookup(class_name:, method_name:, kind:)
         @by_key[[class_name, method_name, kind]]

data/lib/rigor/inference/project_patched_scanner.rb

@@ -31,20 +31,21 @@ module Rigor
 
       module_function
 
-      # @param paths [Array<String>] absolute paths to the pre-eval files. The runner has already
+      # @param paths — absolute paths to the pre-eval files. The runner has already
       #   validated that each path exists (slice-1 `pre-eval.file-not-found` `:error` covers missing
       #   entries); the scanner does NOT re-check existence.
-      # @param buffer [Rigor::Analysis::BufferBinding, nil] editor-mode buffer binding. When set, the
+      # @param buffer — editor-mode buffer binding. When set, the
       #   scanner reads the buffer's physical bytes if a pre-eval entry matches the logical path, so
       #   users editing a monkey-patch file see the in-flight version in their analysis.
-      # @return [Result] the populated registry plus any per-file warnings.
+      # @return the populated registry plus any per-file warnings.
       def scan(paths, buffer: nil)
         entries = []
         diagnostics = []
-        paths.each { |path| scan_file(path, entries, diagnostics, buffer) }
+        census = Set.new
+        paths.each { |path| scan_file(path, entries, diagnostics, buffer, census) }
         diagnostics.concat(duplicate_declaration_diagnostics(entries))
         Result.new(
-          registry: ProjectPatchedMethods.new(entries: entries),
+          registry: ProjectPatchedMethods.new(entries: entries, write_census: census.freeze),
           diagnostics: diagnostics
         )
       end
@@ -77,7 +78,7 @@ module Rigor
       end
       private_class_method :duplicate_declaration_diagnostics
 
-      def scan_file(path, entries, diagnostics, buffer = nil)
+      def scan_file(path, entries, diagnostics, buffer = nil, census = Set.new)
         physical = buffer ? buffer.resolve(path) : path
         parse_result =
           if physical == path
@@ -91,6 +92,9 @@ module Rigor
         end
 
         walk_node(parse_result.value, [], false, path, entries)
+        # Issue #1367 — the file's `global.*` write facts: a patch file may alias a special or give a class the
+        # method a setter asks for, as any project file may.
+        census.merge(GlobalWriteCensus.scan(parse_result.value))
       rescue StandardError => e
         diagnostics << build_diagnostic(
           path: path, line: 1, column: 1,

data/lib/rigor/inference/protection_scanner.rb

@@ -37,8 +37,7 @@ module Rigor
         @scope = scope || Scope.empty
       end
 
-      # @param root [Prism::Node] the parsed AST
-      # @return [FileResult]
+      # @param root — the parsed AST
       def scan(root)
         index = ScopeIndexer.index(root, default_scope: @scope)
         protected_count = 0

data/lib/rigor/inference/range_constant.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../type"
+
+module Rigor
+  module Inference
+    # Reads the endpoints out of a `Constant<Range>`.
+    #
+    # A `Constant` normally carries a value and no generic instantiation, which is why acceptance
+    # ignores a nominal's `type_args` against one. A Range value is the exception: the engine only
+    # builds `Constant<Range>` when both endpoints are static (`ExpressionTyper#type_of_range`), so
+    # the element the range would yield IS known, and a `Range[T]` parameter can be judged against it.
+    #
+    # Two consumers share the reading so they cannot drift: `Acceptance` refutes a `Range[T]`
+    # parameter whose `T` rejects an endpoint (issue #833), and `RbsDispatch` binds a method-level
+    # `Range[A]` parameter's `A` from the endpoints (issue #834).
+    module RangeConstant
+      module_function
+
+      # The non-`nil` endpoints of the range `type` pins, or nil when there is nothing to read from.
+      #
+      # nil — meaning "no opinion, keep the answer you already had" — covers a carrier that is not a
+      # `Constant<Range>`, a range with no endpoint at all (`nil..nil` constrains nothing), and a
+      # range whose endpoints are not literals. The literal set is the one
+      # `ExpressionTyper#static_range_endpoint` pins; a value outside it reached the carrier by some
+      # other route and the caller has no lifting for it.
+      def literal_endpoints(type)
+        return nil unless type.is_a?(Type::Constant)
+
+        value = type.value
+        return nil unless value.is_a?(::Range)
+
+        endpoints = [value.begin, value.end].compact
+        return nil if endpoints.empty?
+        return nil unless endpoints.all? { |endpoint| literal_endpoint?(endpoint) }
+
+        endpoints
+      end
+
+      # The endpoints lifted to their own classes and unioned — the element type the range would
+      # yield. Lifting rather than pinning the values mirrors
+      # `ExpressionTyper#nominal_range_for_endpoints`: `1..9` yields Integers, not the two values 1
+      # and 9, so binding a `Range[A]` parameter's `A` to `Integer` states what the runtime can
+      # honour. Nil when {#literal_endpoints} has nothing to read.
+      def element_type(type)
+        endpoints = literal_endpoints(type)
+        return nil if endpoints.nil?
+
+        Type::Combinator.union(*endpoints.map { |endpoint| Type::Combinator.nominal_of(endpoint.class.name) })
+      end
+
+      def literal_endpoint?(value)
+        value.is_a?(::Integer) || value.is_a?(::Float) || value.is_a?(::String)
+      end
+    end
+  end
+end

data/lib/rigor/inference/rbs_type_translator.rb

@@ -100,17 +100,31 @@ module Rigor
       ALIAS_EXPANSION_LIMIT = 8
       private_constant :ALIAS_EXPANSION_LIMIT
 
+      # #775 — `TypeName#relative!` allocates a TypeName and a Namespace and `#to_s` joins the path: four
+      # objects per class-instance translation, ~380k of them on the lib self-check, for the same few
+      # hundred names. rbs compares a TypeName by namespace + name, so a value-keyed memo answers every
+      # repeat with one frozen String.
+      @relative_names = {}
+
+      # #775 — the translated form of a CLOSED alias expansion, keyed by the expansion. Closed means no
+      # `self`, `instance` or type variable anywhere inside, so the caller's context cannot change the
+      # answer; at expansion depth 0 the budget cannot either. rbs compares types by value, so the memo
+      # is per distinct expansion, not per loader (a re-parsed identical alias hits), and the weak keys
+      # let an entry go with the loader whose memo held the expansion. `Rigor::Type::t` on the self-check
+      # is a 21-member union that was re-translated ~13k times, each time re-normalising the union from
+      # scratch; every repeat now shares one Union.
+      @closed_alias_translations = ObjectSpace::WeakKeyMap.new
+
       class << self
-        # @param rbs_type [RBS::Types::Bases::Base, RBS::Types::ClassInstance, ...]
-        # @param self_type [Rigor::Type, nil] substitute for `Bases::Self`.
-        # @param instance_type [Rigor::Type, nil] substitute for `Bases::Instance`. Defaults to `nil`,
+        # @param self_type — substitute for `Bases::Self`.
+        # @param instance_type — substitute for `Bases::Instance`. Defaults to `nil`,
         #   which degrades to Dynamic[Top].
-        # @param type_vars [Hash{Symbol => Rigor::Type}] substitution map for `Bases::Variable`. Keys
+        # @param type_vars — substitution map for `Bases::Variable`. Keys
         #   are the RBS variable names (e.g., `:Elem`); values are Rigor types that replace the
         #   variable. Variables that are not bound in the map degrade to Dynamic[Top].
-        # @param alias_expander [#expand_type_alias, nil] resolves `RBS::Types::Alias` one level out —
-        #   in practice the environment's `RbsLoader`. When nil, aliases degrade to Dynamic[Top].
-        # @return [Rigor::Type]
+        # @param alias_expander — anything answering `expand_type_alias`, which resolves `RBS::Types::Alias`
+        #   one level out — in practice the environment's `RbsLoader`. When nil, aliases degrade to
+        #   Dynamic[Top].
         def translate(rbs_type, self_type: nil, instance_type: nil, type_vars: EMPTY_TYPE_VARS,
                       alias_expander: nil)
           translate_in(rbs_type, Context.new(self_type, instance_type, type_vars, alias_expander, 0))
@@ -180,11 +194,17 @@ module Rigor
         # `Nominal["Array", [Nominal["Integer"]]]`. Variables inside the args participate in
         # substitution through the same `type_vars:` map.
         def translate_class_instance(rbs_type, context)
-          name = rbs_type.name.relative!.to_s
+          name = relative_name(rbs_type.name)
+          return Type::Combinator.nominal_of(name) if rbs_type.args.empty?
+
           translated_args = rbs_type.args.map { |arg| translate_in(arg, context) }
           Type::Combinator.nominal_of(name, type_args: translated_args)
         end
 
+        def relative_name(type_name)
+          @relative_names[type_name] ||= type_name.relative!.to_s.freeze
+        end
+
         # Preserves tuple precision through the boundary. Each positional element type is translated
         # recursively under the caller's substitution context, and the resulting list is wrapped in a
         # `Rigor::Type::Tuple`.
@@ -218,8 +238,7 @@ module Rigor
         # `singleton(Foo)` is the type of the constant `Foo` itself (the class object). With the
         # dedicated Singleton type, we map directly to `Singleton[Foo]`.
         def translate_class_singleton(rbs_type, _context)
-          name = rbs_type.name.relative!.to_s
-          Type::Combinator.singleton_of(name)
+          Type::Combinator.singleton_of(relative_name(rbs_type.name))
         end
 
         # #529 — sees through a type alias instead of reading `untyped`. `expand_type_alias` resolves
@@ -232,8 +251,27 @@ module Rigor
 
           expanded = expander.expand_type_alias(rbs_type)
           return Type::Combinator.untyped if expanded.nil?
+          # A nested expansion is translated under its parent's budget, and `rigor trace` records every
+          # union merge as it happens, so neither consults the memo.
+          return translate_in(expanded, context.deeper) unless context.alias_depth.zero? && !FlowTracer.active?
+
+          cached = @closed_alias_translations[expanded]
+          return cached if cached
+
+          translated = translate_in(expanded, context.deeper)
+          @closed_alias_translations[expanded] = translated if closed_type?(expanded)
+          translated
+        end
+
+        # True when nothing in `rbs_type`'s tree reads the translation context: no `self`, no `instance`,
+        # no type variable. Every rbs type answers `each_type` (the leaves through `EmptyEachType`).
+        def closed_type?(rbs_type)
+          case rbs_type
+          when RBS::Types::Bases::Self, RBS::Types::Bases::Instance, RBS::Types::Variable then return false
+          end
 
-          translate_in(expanded, context.deeper)
+          rbs_type.each_type { |inner| return false unless closed_type?(inner) }
+          true
         end
 
         # #529 — `A & B` reads as its first member that carries static evidence. Every value of the

data/lib/rigor/inference/receiver_alias.rb

@@ -24,21 +24,53 @@ module Rigor
     # object no binding can be attributed to and yields `[]`, which is what every receiver form
     # outside the single-read case already contributed. The walk is depth-capped so a pathological
     # nest cannot make receiver classification unbounded.
+    #
+    # The `it` parameter (Ruby 3.4) is a local like any other, but Prism reads it through
+    # `Prism::ItLocalVariableReadNode`, which carries no `name`; {.read_name} answers `:it` for it, the
+    # binding `BlockParameterBinder` installs. A consumer names a read through {.read_name}, never `#name`.
+    #
+    # A local or instance-variable write evaluates to the variable it writes, so `(buf ||= []) << x`
+    # mutates `buf` and yields a read of it ({.read_of}). Issue #1223 made that binding visible: the
+    # statement evaluator threads a write in a receiver, and without the alias `buf` kept the `[]`
+    # the `||=` stored.
     module ReceiverAlias
       # Deep enough for any hand-written selection; a nest beyond it degrades to "names no binding".
       WALK_DEPTH_CAP = 6
 
+      NON_ALIASED_READS = [Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode].freeze
+      private_constant :NON_ALIASED_READS
+
+      LOCAL_WRITE_NODES = Set[
+        Prism::LocalVariableWriteNode, Prism::LocalVariableOrWriteNode,
+        Prism::LocalVariableAndWriteNode, Prism::LocalVariableOperatorWriteNode
+      ].freeze
+      INSTANCE_WRITE_NODES = Set[
+        Prism::InstanceVariableWriteNode, Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode
+      ].freeze
+      CLASS_VARIABLE_WRITE_NODES = Set[
+        Prism::ClassVariableWriteNode, Prism::ClassVariableOrWriteNode,
+        Prism::ClassVariableAndWriteNode, Prism::ClassVariableOperatorWriteNode
+      ].freeze
+      GLOBAL_WRITE_NODES = Set[
+        Prism::GlobalVariableWriteNode, Prism::GlobalVariableOrWriteNode,
+        Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode
+      ].freeze
+      private_constant :LOCAL_WRITE_NODES, :INSTANCE_WRITE_NODES, :CLASS_VARIABLE_WRITE_NODES, :GLOBAL_WRITE_NODES
+
       module_function
 
-      # @param node  [Prism::Node, nil] the receiver expression.
-      # @param depth [Integer] recursion depth, internal.
-      # @return [Array<Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode>] every variable
+      # @param node — the receiver expression.
+      # @param depth — recursion depth, internal.
+      # @return every variable
       #   read the expression can evaluate to; empty when it can evaluate to none.
       def candidates(node, depth = 0)
         return [] if node.nil? || depth > WALK_DEPTH_CAP
+        # Tested before the `case`: a `when *SET` arm would copy the set into an Array on every call.
+        return [read_of(node)] if variable_write?(node)
 
         case node
-        when Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode then [node]
+        when Prism::LocalVariableReadNode, Prism::ItLocalVariableReadNode, Prism::InstanceVariableReadNode then [node]
         when Prism::ParenthesesNode then candidates(node.body, depth + 1)
         when Prism::StatementsNode then candidates(node.body.last, depth + 1)
         when Prism::ElseNode then candidates(node.statements, depth + 1)
@@ -52,6 +84,63 @@ module Rigor
       def branches(first, second, depth)
         candidates(first, depth + 1) + candidates(second, depth + 1)
       end
+
+      # The variable reads an in-place mutation of `receiver` changes: {.candidates}' locals and instance
+      # variables, or the class variable or global the receiver reads or writes directly, parenthesised or not
+      # (`(@@c ||= []) << x` mutates `@@c`, as `(buf ||= []) << x` mutates `buf`). A class variable or global counts
+      # only as the receiver itself, not through a branch that selects it. This is the
+      # one answer the straight-line widening ({MutationWidening.widen_receiver_aliases}), the block-return
+      # threading gate that predicts it (`ExpressionTyper#prefix_statement_jump_free?`) and the per-element fold's
+      # content-mutation scan ({CapturedLocals.content_mutations}) all read, so "the scan says the body changed
+      # it" and "evaluating the body changes it" cannot disagree about which kinds of variable count.
+      def mutated_reads(receiver)
+        direct = receiver
+        direct = direct.body.body.last while direct.is_a?(Prism::ParenthesesNode) && direct.body.is_a?(Prism::StatementsNode)
+        return [direct] if NON_ALIASED_READS.include?(direct.class)
+        return [read_of(direct)] if non_aliased_write?(direct)
+
+        candidates(receiver)
+      end
+
+      # True when `node` is a class-variable or global write, which {.mutated_reads} answers only as the receiver
+      # itself, as it answers a class-variable or global read.
+      def non_aliased_write?(node)
+        CLASS_VARIABLE_WRITE_NODES.include?(node.class) || GLOBAL_WRITE_NODES.include?(node.class)
+      end
+
+      # The binding a read from {.candidates} or {.mutated_reads} names.
+      def read_name(read) = read.is_a?(Prism::ItLocalVariableReadNode) ? :it : read.name
+
+      # True when `read` is a local the innermost block around it owns: one Prism resolves at `depth == 0`, or an
+      # `it` read, which is always that block's own parameter and never a capture of an enclosing scope.
+      def block_local?(read)
+        read.is_a?(Prism::ItLocalVariableReadNode) || (read.is_a?(Prism::LocalVariableReadNode) && read.depth.zero?)
+      end
+
+      # True when `node` is a local or instance-variable write, whose value is the variable it leaves.
+      def variable_write?(node)
+        LOCAL_WRITE_NODES.include?(node.class) || INSTANCE_WRITE_NODES.include?(node.class)
+      end
+
+      # A read of the variable `write` writes, at the write's name, for the analysers that key a receiver on a
+      # read node — a local, instance-variable, class-variable or global write. `Prism` 1.x constructs every node
+      # from `source, node_id, location, flags` and its fields.
+      def read_of(write)
+        source = write.send(:source)
+        if LOCAL_WRITE_NODES.include?(write.class)
+          Prism::LocalVariableReadNode.new(source, write.node_id, write.name_loc, 0, write.name, write.depth)
+        else
+          named_read_class(write.class).new(source, write.node_id, write.name_loc, 0, write.name)
+        end
+      end
+
+      # The read node class for an instance-variable, class-variable or global write class.
+      def named_read_class(write_class)
+        if INSTANCE_WRITE_NODES.include?(write_class) then Prism::InstanceVariableReadNode
+        elsif CLASS_VARIABLE_WRITE_NODES.include?(write_class) then Prism::ClassVariableReadNode
+        else Prism::GlobalVariableReadNode
+        end
+      end
     end
   end
 end