rigortype 0.4.0 → 0.4.2

data/lib/rigor/inference/project_patched_scanner.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "project_patched_methods"
 require_relative "../analysis/dependency_source_inference/return_type_heuristic"
+require_relative "../source/alias_names"
 require_relative "../source/constant_path"
 require_relative "../source/node_children"
 
@@ -11,7 +12,8 @@ module Rigor
   module Inference
     # ADR-17 slice 2 — pre-pass scanner. Walks every file the user listed under `pre_eval:` and
     # harvests every `def` / `def self.` declaration inside a class / module body into a
-    # {ProjectPatchedMethods} registry the dispatcher consults below the plugin tier.
+    # {ProjectPatchedMethods} registry the dispatcher consults below the plugin tier, together with every
+    # `alias new old` / `alias_method :new, :old` there (issue #1702, read through {Source::AliasNames}).
     #
     # The walker is intentionally a strict subset of {Rigor::Inference::ScopeIndexer}'s machinery: it
     # only needs `class C; def m; end; end` shape recognition, not full inference. Parse errors degrade
@@ -29,6 +31,10 @@ module Rigor
         end
       end
 
+      # An alias the walk met, before {resolve_aliases} knows whether its old name is one the patch files define.
+      PendingAlias = Data.define(:class_name, :new_name, :old_name, :kind, :source_path, :source_line)
+      private_constant :PendingAlias
+
       module_function
 
       # @param paths — absolute paths to the pre-eval files. The runner has already
@@ -39,10 +45,11 @@ module Rigor
       #   users editing a monkey-patch file see the in-flight version in their analysis.
       # @return the populated registry plus any per-file warnings.
       def scan(paths, buffer: nil)
-        entries = []
+        collected = []
         diagnostics = []
         census = Set.new
-        paths.each { |path| scan_file(path, entries, diagnostics, buffer, census) }
+        paths.each { |path| scan_file(path, collected, diagnostics, buffer, census) }
+        entries = resolve_aliases(collected)
         diagnostics.concat(duplicate_declaration_diagnostics(entries))
         Result.new(
           registry: ProjectPatchedMethods.new(entries: entries, write_census: census.freeze),
@@ -78,6 +85,46 @@ module Rigor
       end
       private_class_method :duplicate_declaration_diagnostics
 
+      # Turns each {PendingAlias} into the entry it publishes, walking the bindings in configuration-then-source
+      # order as Ruby runs them. An alias binds to the body its old name has WHEN IT RUNS, so only a `def` or alias
+      # earlier in that order may supply its return type: `alias to_m to_modint` after `def to_modint` answers what
+      # `to_modint` does, while `alias_method :orig_succ, :succ` ahead of a patch's `def succ` is the method
+      # Integer already had. An alias whose old name nothing earlier binds records that name as `alias_of`, for the
+      # dispatcher to answer with the class's existing method (`alias old_plus +` on Integer), or with
+      # `Dynamic[top]` when nothing knows the name: the alias is still published, since a call to it is not the
+      # undefined method a dropped entry would report.
+      #
+      # Within one file the later binding of a name replaces the earlier, as at runtime: the alias-method-chain
+      # idiom (`def foo`, `alias_method :foo_without_x, :foo`, `alias_method :foo, :foo_with_x`) leaves `foo` the
+      # alias. Bindings of one name in DIFFERENT files are what `pre-eval.duplicate-declaration` reports, and the
+      # registry keeps the first of those, as it always has for `def`s.
+      def resolve_aliases(collected)
+        bound = {}
+        per_file = collected.group_by(&:source_path).values.map do |items|
+          final = {}
+          items.each do |item|
+            entry = item.is_a?(PendingAlias) ? alias_entry(item, bound) : item
+            key = [entry.class_name, entry.method_name, entry.kind]
+            bound[key] = entry
+            final.delete(key)
+            final[key] = entry
+          end
+          final.values
+        end
+        per_file.flatten(1)
+      end
+      private_class_method :resolve_aliases
+
+      def alias_entry(item, bound)
+        target = bound[[item.class_name, item.old_name, item.kind]]
+        ProjectPatchedMethods::Entry.new(
+          class_name: item.class_name, method_name: item.new_name, kind: item.kind,
+          source_path: item.source_path, source_line: item.source_line,
+          return_type: target&.return_type, alias_of: target ? target.alias_of : item.old_name
+        )
+      end
+      private_class_method :alias_entry
+
       def scan_file(path, entries, diagnostics, buffer = nil, census = Set.new)
         physical = buffer ? buffer.resolve(path) : path
         parse_result =
@@ -139,6 +186,13 @@ module Rigor
           descend_singleton_class(node, qualified_prefix, source_path, entries)
         when Prism::DefNode
           record_def_node(node, qualified_prefix, in_singleton_class, source_path, entries)
+        when Prism::AliasMethodNode
+          record_alias(node, Source::AliasNames.keyword_names(node), qualified_prefix, in_singleton_class,
+                       source_path, entries)
+        when Prism::CallNode
+          record_alias(node, Source::AliasNames.alias_method_call_names(node), qualified_prefix,
+                       in_singleton_class, source_path, entries)
+          walk_children(node, qualified_prefix, in_singleton_class, source_path, entries)
         else
           walk_children(node, qualified_prefix, in_singleton_class, source_path, entries)
         end
@@ -186,6 +240,20 @@ module Rigor
         )
       end
       private_class_method :record_def_node
+
+      # `names` is the alias's `[new_name, old_name]`, or nil for a computed name or a call that is not an alias.
+      # The side follows the body it is written in, as a `def`'s does: `alias` and `alias_method` inside
+      # `class << self` both bind on the singleton.
+      def record_alias(node, names, qualified_prefix, in_singleton_class, source_path, entries)
+        return if names.nil? || qualified_prefix.empty?
+
+        entries << PendingAlias.new(
+          class_name: qualified_prefix.join("::"), new_name: names.first, old_name: names.last,
+          kind: in_singleton_class ? :singleton : :instance,
+          source_path: source_path, source_line: node.location&.start_line || 1
+        )
+      end
+      private_class_method :record_alias
     end
   end
 end

data/lib/rigor/inference/refine_census.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../source/alias_names"
+require_relative "../source/node_children"
+
+module Rigor
+  module Inference
+    # ADR-121 WD7 (issues #1796, #1799) — what a `refine` body tells the refinement table, read the one way the project
+    # walk (`ScopeIndexer#record_refinement_defs`) and the gem source walker
+    # (`Analysis::DependencySourceInference::Walker#walk_refine_body`) both use, so the two cannot drift. The table is
+    # `{refined class => {method => [refining modules]}}`; `Scope::DiscoveryIndex::REFINEMENT_WILDCARD` stands for
+    # what could not be read.
+    #
+    # A body is fully read when every call on its own `self` (the refinement module) is one that defines a name the
+    # walk can spell, or one that defines nothing: a `def`, an `alias` or `alias_method` of two literal names, a
+    # `define_method` of a literal name, an `attr_*` of literal names, an `undef`, a visibility call, or
+    # `Refinement#target`. Anything
+    # else (`import_methods`, `send`, a computed `define_method`, `include`, a nested `refine`, any other call on
+    # `self`) may define a name the walk cannot spell, so the body's names are incomplete and the table gets a
+    # names-wildcard row for each target. A call on another receiver cannot define a method on the refinement, and
+    # a call inside a `def` or `define_method` body runs on an instance of the refined class, so neither counts.
+    module RefineCensus
+      # `names`, every name the body is read to define, in textual order; `complete`, whether those are all of them;
+      # `defs`, the typed refined arm's bodies in textual order: `[name, Prism::DefNode]` for a `def` or an alias of
+      # an earlier `def`, and `[name, nil]` for any other definer (`define_method`, `attr_*`, `undef`, an alias of a
+      # name the body did not define earlier). A later definer replaces an earlier one, as Ruby's method table
+      # keeps the last, so a name whose last definer has no `DefNode` types as `Dynamic[top]`.
+      BodyReading = Struct.new(:names, :complete, :defs)
+
+      # Calls on the refinement that define nothing: visibility, with no argument, literal names, a `def`, or an
+      # allowlisted definer call.
+      VISIBILITY_CALLS = Set[:private, :public, :protected, :module_function, :private_constant].freeze
+      # `Refinement#target`, a reader of the refined class (the other `Refinement` method on Ruby 4.0.5 is
+      # `import_methods`).
+      READER_CALLS = Set[:target].freeze
+      # `attr_*` and whether each defines the reader and the writer.
+      ATTR_CALLS = {
+        attr_reader: [true, false].freeze, attr_writer: [false, true].freeze, attr_accessor: [true, true].freeze,
+        attr: [true, false].freeze
+      }.freeze
+
+      # A3 — the calls whose String argument may hold `refine` as code or as a method name, and the two families
+      # whose `self` is their receiver (so `M.send(:refine, …)` runs `refine` on `M`).
+      SEND_CALLS = Set[:send, :__send__, :public_send].freeze
+      SELF_EVAL_CALLS = Set[:instance_eval, :class_eval, :module_eval, :instance_exec, :class_exec, :module_exec].freeze
+      NAMING_CALLS = Set[
+        :method, :public_method, :singleton_method, :instance_method, :public_instance_method, :define_method,
+        :define_singleton_method, :alias_method
+      ].freeze
+      REFINE_WORD = /\brefine\b/
+
+      private_constant :VISIBILITY_CALLS, :READER_CALLS, :ATTR_CALLS, :REFINE_WORD
+
+      module_function
+
+      def wildcard = Scope::DiscoveryIndex::REFINEMENT_WILDCARD
+
+      # §2.2 — what `body` (a refine block's body, or nil) defines on the refined class.
+      def read_body(body)
+        reading = BodyReading.new([], true, [])
+        scan_body(body, reading, {}, true) if body
+        reading.names.uniq!
+        reading
+      end
+
+      # Records `reading`'s names for each of `targets` under `refining` into `table` (nil starts one), plus a
+      # names-wildcard row per target when the body's names are incomplete. Returns the table.
+      def record_rows(table, targets, reading, refining)
+        table ||= {}
+        targets.each do |class_name|
+          reading.names.each { |name| add_row(table, class_name, name, refining) }
+          add_row(table, class_name, wildcard, refining) unless reading.complete
+        end
+        table
+      end
+
+      # One `{class_name => {method_key => [refining]}}` entry, `refining` once.
+      def add_row(table, class_name, method_key, refining)
+        modules = ((table[class_name] ||= {})[method_key] ||= [])
+        modules << refining unless modules.include?(refining)
+        table
+      end
+
+      # A3 — a `:refine` Symbol literal: it may name `Module#refine` for `send`, `alias_method`, `method`, ….
+      def refine_symbol?(node) = node.is_a?(Prism::SymbolNode) && node.unescaped == "refine"
+
+      # A3 — a String literal (or a heredoc's literal part) holding the word `refine`, as code an eval runs or as a
+      # method name.
+      def refine_string?(node)
+        case node
+        # As bytes: a literal whose bytes are not valid in its encoding (`"\xff …"`) must not raise.
+        when Prism::StringNode then REFINE_WORD.match?(node.unescaped.b)
+        when Prism::InterpolatedStringNode then node.parts.any? { |part| refine_string?(part) }
+        else false
+        end
+      end
+
+      # A3 — does a String argument of `call` count: an eval, `send` or method-naming call?
+      def string_literal_call?(call)
+        name = call.name
+        name == :eval || SELF_EVAL_CALLS.include?(name) || SEND_CALLS.include?(name) || NAMING_CALLS.include?(name)
+      end
+
+      # A3 — the `self` a refine literal argument of `call` runs `refine` on: `:receiver` for a `send` or `*_eval`
+      # / `*_exec` call (the receiver, or the caller's `self` when it has none or it is `self`), `:unknown` for an
+      # `eval` on a binding, `:self` for everything else (the caller's `self`).
+      def literal_target(call)
+        receiver = call.receiver
+        self_receiver = receiver.nil? || receiver.is_a?(Prism::SelfNode)
+        if SEND_CALLS.include?(call.name) || SELF_EVAL_CALLS.include?(call.name)
+          self_receiver ? :self : :receiver
+        elsif call.name == :eval
+          self_receiver ? :self : :unknown
+        else
+          :self
+        end
+      end
+
+      # An implicit- or `self`-receiver call: one whose `self` is the walk's `self`.
+      def self_call?(node) = node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+
+      # `classify` is false inside a `define_method` block or its arguments, whose calls run on an instance of the
+      # refined class (or before the method exists), so they define nothing on the refinement. `latest` maps each
+      # name to the last `def` the body wrote for it so far, which an alias copies.
+      def scan_body(node, reading, latest, classify)
+        case node
+        when Prism::DefNode
+          record_def(node, reading, latest) if node.receiver.nil?
+          return
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode
+          return
+        when Prism::AliasMethodNode
+          return record_alias(Source::AliasNames.keyword_names(node), reading, latest)
+        when Prism::UndefNode
+          return record_undef(node, reading, latest)
+        when Prism::CallNode
+          if classify && self_call?(node)
+            classify_call(node, reading, latest)
+            classify = node.name != :define_method
+          end
+        end
+
+        node.rigor_each_child { |child| scan_body(child, reading, latest, classify) }
+      end
+
+      def record_def(node, reading, latest)
+        reading.names << node.name
+        reading.defs << [node.name, node]
+        latest[node.name] = node
+      end
+
+      # `alias new old` / `alias_method :new, :old`: `new` is defined; it copies `old`'s body when the refine body
+      # wrote `old` earlier (Ruby copies at the alias, so a later `def old` does not move it), and otherwise it
+      # copies the refined class's own method, whose body the walk does not hold.
+      def record_alias(pair, reading, latest)
+        return reading.complete = false if pair.nil?
+
+        new_name, old_name = pair
+        reading.names << new_name
+        def_node = latest[old_name]
+        return record_bodiless(new_name, reading, latest) if def_node.nil?
+
+        reading.defs << [new_name, def_node]
+        latest[new_name] = def_node
+      end
+
+      # A name a definer with no `DefNode` defines: it replaces any earlier `def` of the name, so the typed arm
+      # finds no body for it (`refine(String) { def center(a) = 1; define_method(:center) { |a| "dm" } }` answers
+      # `"dm"` on Ruby 4.0.5), and an alias of it copies no body either.
+      def record_bodiless(name, reading, latest)
+        reading.names << name
+        reading.defs << [name, nil]
+        latest.delete(name)
+      end
+
+      def record_undef(node, reading, latest)
+        node.names.each do |name|
+          symbol = literal_name(name)
+          symbol ? record_bodiless(symbol, reading, latest) : reading.complete = false
+        end
+      end
+
+      # Classifies a call on the refinement.
+      def classify_call(node, reading, latest)
+        name = node.name
+        arguments = node.arguments&.arguments || []
+        if (attr = ATTR_CALLS[name])
+          record_attr(arguments, attr, reading, latest)
+        elsif name == :define_method
+          record_define_method(arguments, reading, latest)
+        elsif name == :alias_method
+          record_alias(Source::AliasNames.alias_method_call_names(node), reading, latest)
+        else
+          reading.complete = false unless defines_nothing?(node, arguments)
+        end
+      end
+
+      # A visibility call with no argument, literal names, a `def` or a call; `Refinement#target` with none.
+      def defines_nothing?(node, arguments)
+        return arguments.all? { |argument| visibility_argument?(argument) } if VISIBILITY_CALLS.include?(node.name)
+
+        READER_CALLS.include?(node.name) && arguments.empty? && node.block.nil?
+      end
+
+      def record_attr(arguments, (reader, writer), reading, latest)
+        arguments.each do |argument|
+          name = literal_name(argument)
+          next reading.complete = false if name.nil?
+
+          record_bodiless(name, reading, latest) if reader
+          record_bodiless(:"#{name}=", reading, latest) if writer
+        end
+      end
+
+      def record_define_method(arguments, reading, latest)
+        name = arguments.first && literal_name(arguments.first)
+        name ? record_bodiless(name, reading, latest) : reading.complete = false
+      end
+
+      # `private`, `private :a, "b"`, `private def x`, `private attr_reader :x`: the nested call is classified on
+      # its own when the walk descends into it.
+      def visibility_argument?(argument)
+        argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode) || argument.is_a?(Prism::DefNode) ||
+          argument.is_a?(Prism::CallNode)
+      end
+
+      # A literal's name, or nil for none and for bytes no Symbol holds: `define_method("\xff")` raises
+      # EncodingError on Ruby 4.0.5, so the body is not read.
+      def literal_name(node)
+        return nil unless node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+
+        name = node.unescaped
+        name.to_sym if name&.valid_encoding?
+      end
+    end
+  end
+end