necropsy 0.2.0 → 0.3.0

data/lib/necropsy/analyzers/static/name_resolution.rb

@@ -6,19 +6,38 @@ module Necropsy
       class NameResolution < Analyzer
         def analyze(graph, _project)
           edge_evidences = []
+          resolutions = []
           uncertainties = {}
+          blockers = []
           graph.call_sites.each do |site|
-            candidates = graph.resolve_call_site(site)
-            fallback = graph.fallback_resolution?(site, resolved: candidates)
-            edge_evidences.concat(edge_evidences_for(site, candidates, fallback))
-            record_unresolved_uncertainty(graph, site, candidates, uncertainties)
+            lookup = graph.method_lookup(site)
+            candidates = lookup.targets
+            fallback = %w[dynamic_message unknown_receiver unknown_self_owner self_lookup_fallback].include?(
+              lookup.reason
+            )
+            site_edges = edge_evidences_for(site, candidates, fallback, lookup)
+            edge_evidences.concat(site_edges)
+            resolutions << resolution_record(
+              site,
+              candidates,
+              site_edges,
+              status: lookup.status,
+              rejected_targets: lookup.rejected_targets,
+              unknown_scope: graph.residual_scope_for(site)
+            )
+            record_unresolved_uncertainty(graph, site, lookup, uncertainties)
+            blocker = unresolved_blocker(graph, site, lookup)
+            blockers << blocker if blocker
           end
 
           AnalyzerResult.new(
             edge_evidences: edge_evidences,
             alive_evidences: [],
             uncertainties: uncertainties,
-            observation: {}
+            observation: {},
+            blockers: blockers,
+            resolutions: resolutions,
+            evidences: result_evidences(edge_evidences)
           )
         end
 
@@ -27,35 +46,137 @@ module Necropsy
             name: :name_resolution,
             kind: :static,
             soundness: :unsound,
-            description: 'Resolves Ruby call sites by exact receiver and method name, falling back to same-name candidates.'
+            description: 'Resolves Ruby call sites by exact receiver and method name, falling back to same-name candidates.',
+            version: Necropsy::VERSION,
+            assumptions: %w[bounded_same_name_fallback scanned_receiver_hints]
           )
         end
 
+        def capabilities
+          [:complete_resolution].freeze
+        end
+
         private
 
-        def edge_evidences_for(site, candidates, fallback)
+        def edge_evidences_for(site, candidates, fallback, lookup)
           candidates.map do |candidate|
+            grade = if lookup.complete?
+                      :exact
+                    elsif fallback
+                      :heuristic
+                    else
+                      :conservative
+                    end
             EdgeEvidence.new(
               caller_id: site.caller_id,
-              callee_id: candidate.id,
+              callee_id: candidate.graph_id,
               evidence: evidence(
                 kind: :call_edge,
                 details: "Name resolution#{' fallback' if fallback} at #{site.file}:#{site.line}",
                 weight: fallback ? 0.35 : 1.0,
-                metadata: site.to_h
+                metadata: site.to_h.merge(
+                  'target_definition_id' => candidate.graph_id,
+                  'lookup_status' => lookup.status.to_s,
+                  'lookup_chain' => lookup.lookup_chain
+                ),
+                grade: grade,
+                relation: :call_edge,
+                source: call_site_evidence_source(site).merge('target_definition_id' => candidate.graph_id),
+                scope: call_site_evidence_scope(site).merge('target_definition_id' => candidate.graph_id)
               )
             )
           end
         end
 
-        def record_unresolved_uncertainty(graph, site, candidates, uncertainties)
-          return if site.dynamic || candidates.any?
-          return if graph.candidate_nodes(site.message).empty? && site.receiver_kind != :unknown
+        def record_unresolved_uncertainty(graph, site, lookup, uncertainties)
+          return if site.dynamic || lookup.targets.any? || lookup.complete?
+
+          domain = site.test ? :test : :runtime
+          return if graph.candidate_nodes(site.message, domain: domain).empty? && site.receiver_kind != :unknown
 
           uncertainties[site.caller_id] ||= []
           uncertainties[site.caller_id] <<
             "Unknown receiver for #{site.message} at #{site.file}:#{site.line}; dispatch may be ambiguous"
         end
+
+        def unresolved_blocker(graph, site, lookup)
+          return if lookup.targets.any? || lookup.complete?
+
+          domain = site.test ? :test : :runtime
+          candidate_count = graph.candidate_nodes(site.message, domain: domain).size
+          limit_exceeded = graph.ambiguity_exceeded?(site.message, domain: domain)
+          return unless limit_exceeded || site.receiver_kind == :unknown
+
+          reason_code = limit_exceeded ? :ambiguity_limit_exceeded : :unknown_receiver
+          scope_kind, scope_value = blocker_scope(graph, site)
+          Blocker.new(
+            kind: :unknown_dispatch,
+            scope_kind: scope_kind,
+            scope_value: scope_value,
+            source: :name_resolution,
+            reason: blocker_reason(site, candidate_count, reason_code),
+            suggested_action: :review_receiver_flow,
+            metadata: blocker_metadata(graph, site, candidate_count, reason_code)
+          )
+        end
+
+        def blocker_scope(graph, site)
+          return [:message, site.message] if site.receiver_kind == :unknown
+
+          owners = receiver_hints(site)
+          owners = [graph.nodes[site.caller_id]&.owner].compact if owners.empty?
+          owners.empty? ? [:message, site.message] : [:owner, owners.sort]
+        end
+
+        def blocker_reason(site, candidate_count, reason_code)
+          if reason_code == :ambiguity_limit_exceeded
+            "Dispatch #{site.message} has #{candidate_count} candidates, exceeding the configured ambiguity limit"
+          else
+            "Receiver for #{site.message} is unknown and no candidate target could be materialized"
+          end
+        end
+
+        def blocker_metadata(graph, site, candidate_count, reason_code)
+          caller = graph.nodes[site.caller_id]
+          owner_scope = receiver_hints(site)
+          owner_scope = [caller&.owner].compact if owner_scope.empty? && site.receiver_kind != :unknown
+          metadata = {
+            'caller_id' => site.caller_id,
+            'caller_kind' => caller&.kind&.to_s,
+            'caller_domain' => site.test ? 'test' : 'runtime',
+            'message' => site.message,
+            'receiver_kind' => site.receiver_kind.to_s,
+            'receiver_name' => site.receiver_name,
+            'receiver_hints' => receiver_hints(site),
+            'owner_scope' => owner_scope,
+            'namespace_scope' => namespace_scope(owner_scope, caller&.owner),
+            'file' => site.file,
+            'line' => site.line,
+            'candidate_count' => candidate_count,
+            'ambiguity_limit' => finite_limit(graph.ambiguity_limit),
+            'reason_code' => reason_code.to_s,
+            'original_message' => site.metadata['original_message'] || site.metadata[:original_message]
+          }
+          return metadata unless site.metadata.key?('include_private') || site.metadata.key?(:include_private)
+
+          metadata.merge('include_private' => site.metadata.fetch('include_private') { site.metadata[:include_private] })
+        end
+
+        def receiver_hints(site)
+          candidates = site.metadata['receiver_candidates'] || site.metadata[:receiver_candidates]
+          values = Array(candidates).compact
+          values = [site.receiver_name].compact if values.empty?
+          values.map(&:to_s).uniq
+        end
+
+        def namespace_scope(owner_scope, caller_owner)
+          values = owner_scope.empty? ? [caller_owner].compact : owner_scope
+          values.filter_map { |owner| owner.to_s.split('::')[0...-1].then { |parts| parts.join('::') unless parts.empty? } }.uniq
+        end
+
+        def finite_limit(limit)
+          limit.finite? ? limit : 'unlimited'
+        end
       end
     end
   end

data/lib/necropsy/analyzers/static/rta.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 module Necropsy
   module Analyzers
     module Static
@@ -11,83 +13,289 @@ module Necropsy
           reverse_each select sort sort_by take take_while to_a to_h
         ].freeze
         COMPARISON_MESSAGES = %w[< <= > >= between? clamp sort sort_by max min].freeze
+        CORE_ENUMERABLE_RECEIVERS = %w[Array Enumerator Hash Range Set].freeze
+        CORE_COMPARISON_RECEIVERS = %w[Array].freeze
+        KERNEL_OUTPUT_MESSAGES = %w[print puts warn].freeze
+        REFLECTION_HOOK_MESSAGES = %w[method respond_to?].freeze
+        BLOCK_DEPENDENT_ENUMERABLE_MESSAGES = %w[
+          all? any? chunk collect cycle detect drop_while each_cons each_entry each_slice
+          each_with_index each_with_object filter find find_all flat_map group_by
+          map none? one? partition reject reverse_each select sort_by take_while
+        ].freeze
+        BLOCK_COMPARISON_MESSAGES = %w[max min sort].freeze
+
+        attr_reader :pruning, :emit_redundant_edges
+
+        def initialize(pruning: :rank_only, emit_redundant_edges: true)
+          mode = pruning.to_s
+          unless Configuration::RTA_PRUNING_MODES.include?(mode)
+            raise Error, "RTA pruning must be one of: #{Configuration::RTA_PRUNING_MODES.join(', ')}"
+          end
+
+          @pruning = mode.to_sym
+          @emit_redundant_edges = emit_redundant_edges == true
+        end
+
+        def with_pruning(mode, emit_redundant_edges: @emit_redundant_edges)
+          self.class.new(pruning: mode, emit_redundant_edges: emit_redundant_edges)
+        end
+
+        def without_redundant_edges
+          self.class.new(pruning: pruning, emit_redundant_edges: false)
+        end
 
         def analyze(graph, _project)
           sites = expanded_call_sites(graph)
-          edge_evidences = sites.flat_map do |site|
-            rta_candidates(graph, site).map do |candidate|
+          original_call_site_ids = graph.call_sites.to_set(&:call_site_id)
+          derived_sites = sites.reject { |site| original_call_site_ids.include?(site.call_site_id) }
+          instantiated_metadata = instantiated_classes_metadata(graph)
+          analyses = sites.map do |site|
+            targets = rta_candidates(graph, site)
+            site_edges = targets.filter_map do |candidate|
+              # In rank-only mode CHA/name resolution already materialize the
+              # same conservative edge. Keep the RTA resolution record, but
+              # avoid allocating a duplicate evidence object for an edge that
+              # cannot change reachability. Legacy pruning still emits every
+              # candidate because reconciliation uses those edge identities.
+              next if pruning == :rank_only && !emit_redundant_edges &&
+                      graph.edge_present?(site.caller_id, candidate.graph_id)
+
               EdgeEvidence.new(
                 caller_id: site.caller_id,
-                callee_id: candidate.id,
+                callee_id: candidate.graph_id,
                 evidence: evidence(
                   kind: :call_edge,
                   details: "RTA candidate at #{site.file}:#{site.line}",
-                  metadata: site.to_h.merge('instantiated_classes' => graph.instantiated_classes.to_a.sort)
+                  metadata: site.to_h.merge(instantiated_metadata).merge('target_definition_id' => candidate.graph_id),
+                  grade: :heuristic,
+                  relation: :call_edge,
+                  source: call_site_evidence_source(site).merge('target_definition_id' => candidate.graph_id),
+                  scope: call_site_evidence_scope(site).merge('target_definition_id' => candidate.graph_id)
                 )
               )
             end
+            [site, targets, site_edges]
+          end
+          edge_evidences = analyses.flat_map(&:last)
+          analyses_by_call_site_id = analyses.to_h { |site, targets, edges| [site.call_site_id, [targets, edges]] }
+          resolutions = sites.map do |site|
+            targets, edges = analyses_by_call_site_id.fetch(site.call_site_id)
+            resolution_record(site, targets, edges, unknown_scope: graph.residual_scope_for(site))
           end
 
           AnalyzerResult.new(
             edge_evidences: edge_evidences,
             alive_evidences: [],
             uncertainties: {},
-            observation: { 'rta' => { 'analyzed_sites' => sites.map(&:to_h) } }
+            observation: { 'rta' => { 'pruning' => pruning.to_s, 'analyzed_sites' => sites.map(&:to_h) } },
+            resolutions: resolutions,
+            evidences: result_evidences(edge_evidences),
+            derived_call_sites: derived_sites
           )
         end
 
         def profile
+          description = if pruning == :legacy
+                          'RTA pruning mode legacy removes static candidates without scanned construction evidence.'
+                        else
+                          'RTA pruning mode rank_only records constructed-class hints without removing static edges.'
+                        end
           AnalyzerProfile.new(
             name: :rta,
             kind: :static,
             soundness: :partial,
-            description: 'Narrows instance dispatch to classes that are constructed in the scanned program.'
+            description: description,
+            version: Necropsy::VERSION,
+            assumptions: ['scanned_allocations', "pruning=#{pruning}"]
           )
         end
 
+        def capabilities
+          [:complete_resolution].freeze
+        end
+
         def expanded_call_sites(graph)
           graph.call_sites.flat_map do |site|
-            [site, *implicit_sites(site)]
+            [site, *implicit_sites(site, graph: graph)]
           end
         end
 
-        def implicit_sites(site)
-          implicit_messages(site.message).map do |message|
-            CallSite.new(
-              caller_id: site.caller_id,
-              message: message,
-              receiver_kind: site.receiver_kind,
-              receiver_name: site.receiver_name,
-              file: site.file,
-              line: site.line,
-              test: site.test,
-              dynamic: site.dynamic,
-              metadata: site.metadata.merge('implicit_from' => site.message)
-            )
+        def implicit_sites(site, graph: nil)
+          summaries = []
+          summaries << ['each', :same_receiver] if core_enumerable_receiver?(site) && enumerable_protocol?(site)
+          summaries.concat(comparison_summaries(site)) if core_comparison_receiver?(site)
+          summaries.concat(output_summaries(site)) if kernel_output_call?(site, graph)
+          summaries << ['respond_to_missing?', :same_receiver] if reflection_hook_call?(site, graph)
+          summaries.map.with_index do |(message, receiver), index|
+            derived_protocol_site(site, message, receiver, index: index)
           end
         end
 
-        def implicit_messages(message)
-          messages = []
-          messages << 'each' if ENUMERABLE_MESSAGES.include?(message) && message != 'each'
-          messages << '<=>' if COMPARISON_MESSAGES.include?(message)
-          messages << 'to_s' if %w[puts print warn].include?(message)
-          messages
+        def implicit_messages(site, graph: nil)
+          implicit_sites(site, graph: graph).map(&:message)
         end
 
         private
 
+        def derived_protocol_site(site, message, receiver, index: 0)
+          receiver_kind, receiver_name, receiver_metadata = protocol_receiver(site, receiver)
+          receiver_label = protocol_receiver_label(receiver)
+          CallSite.new(
+            call_site_id: CallSiteIdentity.derived_id(
+              parent_call_site_id: site.call_site_id,
+              derivation: :rta_implicit,
+              caller_definition_id: site.caller_id,
+              message: message,
+              discriminator: index.positive? ? "#{receiver_label}:#{index}" : nil
+            ),
+            caller_id: site.caller_id,
+            message: message,
+            receiver_kind: receiver_kind,
+            receiver_name: receiver_name,
+            file: site.file,
+            line: site.line,
+            test: site.test,
+            dynamic: false,
+            metadata: site.metadata.except('receiver_candidates', 'receiver_value_fact').merge(
+              receiver_metadata,
+              'implicit_from' => site.message,
+              'protocol_receiver' => receiver_label,
+              'derived_from_call_site_id' => site.call_site_id,
+              'derived_via' => 'rta_implicit'
+            ).tap do |metadata|
+              metadata['implicit_private_dispatch'] = true if message == 'respond_to_missing?'
+            end
+          )
+        end
+
+        def protocol_receiver(site, receiver)
+          if receiver == :same_receiver
+            metadata = site.metadata.slice('receiver_candidates', 'receiver_value_fact')
+            return [site.receiver_kind, site.receiver_name, metadata]
+          end
+
+          argument_index = receiver[1] if receiver.is_a?(Array) && receiver.first == :argument
+          fact = Array(site.metadata['argument_value_facts'])[argument_index] if argument_index
+          fact = site.metadata.dig('receiver_value_fact', 'summary', 'element_fact') if receiver == :element_receiver
+          return receiver_from_fact(fact) if fact
+
+          [:unknown, nil, { 'receiver_candidates' => [] }]
+        end
+
+        def receiver_from_fact(fact)
+          return [:unknown, nil, { 'receiver_candidates' => [] }] unless fact.is_a?(Hash)
+          return [:unknown, nil, { 'receiver_candidates' => [] }] unless fact['kind'].to_s == 'instance_types'
+          return [:unknown, nil, { 'receiver_candidates' => [] }] unless fact['exact'] == true
+
+          values = Array(fact['values']).map(&:to_s).reject(&:empty?).uniq.sort
+          return [:unknown, nil, { 'receiver_candidates' => [] }] if values.empty?
+
+          [:instance, values.first, { 'receiver_candidates' => values, 'receiver_value_fact' => fact }]
+        end
+
+        def core_enumerable_receiver?(site)
+          receiver_owners(site).intersect?(CORE_ENUMERABLE_RECEIVERS)
+        end
+
+        def core_comparison_receiver?(site)
+          receiver_owners(site).intersect?(CORE_COMPARISON_RECEIVERS)
+        end
+
+        def enumerable_protocol?(site)
+          return false unless ENUMERABLE_MESSAGES.include?(site.message) && site.message != 'each'
+          return true unless BLOCK_DEPENDENT_ENUMERABLE_MESSAGES.include?(site.message)
+
+          site.metadata['block_kind'] != 'none'
+        end
+
+        def comparison_protocol?(site)
+          return false unless COMPARISON_MESSAGES.include?(site.message)
+          return true unless BLOCK_COMPARISON_MESSAGES.include?(site.message)
+
+          !site.metadata.key?('block_kind') || %w[none nil dynamic].include?(site.metadata['block_kind'])
+        end
+
+        def comparison_summaries(site)
+          if site.message == 'sort_by'
+            return [] if %w[none nil].include?(site.metadata['block_kind'])
+
+            return [['<=>', :block_result_receiver]]
+          end
+
+          comparison_protocol?(site) ? [['<=>', :element_receiver]] : []
+        end
+
+        def output_summaries(site)
+          facts = Array(site.metadata['argument_value_facts'])
+          count = [facts.length, site.metadata.dig('arguments', 'positional_count').to_i].max
+          count = 1 if count.zero? && !site.metadata.key?('arguments')
+          count.times.map { |index| ['to_s', [:argument, index]] }
+        end
+
+        def protocol_receiver_label(receiver)
+          return 'first_argument' if receiver == [:argument, 0]
+          return "argument_#{receiver[1]}" if receiver.is_a?(Array) && receiver.first == :argument
+
+          receiver.to_s
+        end
+
+        def receiver_owners(site)
+          values = Array(site.metadata['receiver_candidates'])
+          values = [container_receiver_owner(site.metadata['receiver_value_fact'])] if values.empty?
+          values = [site.receiver_name] if values.empty?
+          values.compact.map(&:to_s)
+        end
+
+        def container_receiver_owner(fact)
+          return unless fact.is_a?(Hash) && fact['kind'].to_s == 'container' && fact['exact'] == true
+
+          { 'array' => 'Array', 'hash' => 'Hash' }[fact.dig('summary', 'type').to_s]
+        end
+
+        def kernel_output_call?(site, graph)
+          return false unless KERNEL_OUTPUT_MESSAGES.include?(site.message)
+          return false unless %i[implicit self].include?(site.receiver_kind)
+          return true unless graph
+
+          graph.method_lookup(site).targets.empty?
+        end
+
+        def reflection_hook_call?(site, graph)
+          return false unless REFLECTION_HOOK_MESSAGES.include?(site.message)
+          return true unless graph
+
+          graph.cha_method_lookup(site).targets.none? { |target| target.name == site.message }
+        end
+
         def rta_candidates(graph, site)
-          candidates = Analyzers::Static::CHA.new.candidates(graph, site)
+          candidates = graph.cha_method_lookup(site).targets
           candidates = fallback_candidates(graph, site) if candidates.empty?
           graph.retain_rta_candidates(candidates, site)
         end
 
         def fallback_candidates(graph, site)
-          return graph.candidate_nodes(site.message) if site.receiver_kind == :unknown
+          domain = site.test ? :test : :runtime
+          return graph.candidate_nodes(site.message, domain: domain) if site.receiver_kind == :unknown
           return [] unless graph.ambiguous_resolution?
 
-          graph.ambiguous_fallback_candidates(site.message)
+          graph.ambiguous_fallback_candidates(site.message, domain: domain)
+        end
+
+        # A full allocation list in every RTA evidence record makes evidence
+        # identity canonicalization quadratic for a repository with many
+        # scanned constructors. Keep the complete list for small fixtures
+        # (preserving the existing diagnostic shape), and use a deterministic
+        # bounded sample plus digest for larger projects.
+        def instantiated_classes_metadata(graph)
+          classes = graph.instantiated_classes.to_a.sort
+          return { 'instantiated_classes' => classes } if classes.length <= 64
+
+          {
+            'instantiated_classes' => classes.first(16),
+            'instantiated_classes_count' => classes.length,
+            'instantiated_classes_truncated' => true,
+            'instantiated_classes_sha256' => Digest::SHA256.hexdigest(classes.join("\0"))
+          }
         end
       end
     end