necropsy 0.1.0 → 0.3.0

data/lib/necropsy/analyzers/legacy_result_adapter.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Necropsy
+  module Analyzers
+    class LegacyResultAdapter
+      MISSING = Object.new.freeze
+      private_constant :MISSING
+
+      def initialize(graph:, profile:)
+        @graph = graph
+        @profile = profile
+      end
+
+      def adapt(result)
+        return result unless legacy_static_result?(result)
+
+        edge_evidences = normalize_edge_evidences(result.edge_evidences)
+        alive_evidences = normalize_alive_evidences(result.alive_evidences)
+        wrapped_evidences = {}.compare_by_identity
+        result.edge_evidences.each { |edge| wrapped_evidences[edge.evidence] = true }
+        result.alive_evidences.each { |alive| wrapped_evidences[alive.evidence] = true }
+        evidences = result.evidences.reject { |record| wrapped_evidences.key?(record) }.map do |record|
+          normalize_evidence(
+            record,
+            relation: record.kind,
+            source: { 'type' => 'legacy_adapter', 'producer' => profile.name.to_s },
+            scope: {}
+          )
+        end
+        result.with(
+          edge_evidences: edge_evidences,
+          alive_evidences: alive_evidences,
+          resolutions: graph.call_sites.map { |site| resolution_for(site) },
+          evidences: EvidenceCollection.collect(evidences, edge_evidences, alive_evidences)
+        )
+      end
+
+      private
+
+      attr_reader :graph, :profile
+
+      def legacy_static_result?(result)
+        profile.kind.to_sym == :static && result.resolutions.nil?
+      end
+
+      def normalize_edge_evidences(edges)
+        @edges_by_call_site_id = Hash.new { |hash, key| hash[key] = [] }
+        edges.map do |edge|
+          site = matching_call_site(edge)
+          normalized = EdgeEvidence.new(
+            caller_id: edge.caller_id,
+            callee_id: edge.callee_id,
+            evidence: normalize_evidence(
+              edge.evidence,
+              relation: :call_edge,
+              source: legacy_edge_source(edge, site),
+              scope: legacy_edge_scope(edge, site)
+            )
+          )
+          @edges_by_call_site_id[site.call_site_id] << normalized if site
+          normalized
+        end
+      end
+
+      def normalize_alive_evidences(alive_evidences)
+        alive_evidences.map do |alive|
+          AliveEvidence.new(
+            node_id: alive.node_id,
+            evidence: normalize_evidence(
+              alive.evidence,
+              relation: :alive,
+              source: { 'type' => 'legacy_adapter', 'producer' => profile.name.to_s },
+              scope: { 'node_reference' => alive.node_id.to_s }
+            )
+          )
+        end
+      end
+
+      def normalize_evidence(record, relation:, source:, scope:)
+        normalized = if record.grade
+                       record
+                     else
+                       Evidence.new(
+                         analyzer: record.analyzer,
+                         kind: record.kind,
+                         weight: record.weight,
+                         details: record.details,
+                         metadata: record.metadata,
+                         producer: profile.name,
+                         producer_version: profile.version || 'unversioned',
+                         grade: legacy_evidence_grade,
+                         relation: relation,
+                         source: source,
+                         assumptions: profile.assumptions,
+                         scope: scope
+                       )
+                     end
+        return normalized if normalized.evidence_id
+
+        normalized.with(
+          evidence_id: EvidenceIdentity.generate(normalized.to_h.except('evidence_id'))
+        )
+      end
+
+      def legacy_evidence_grade
+        profile.soundness.to_sym == :conservative ? :conservative : :heuristic
+      end
+
+      def legacy_edge_source(edge, site)
+        {
+          'type' => 'legacy_adapter',
+          'producer' => profile.name.to_s,
+          'file' => site&.file,
+          'line' => site&.line,
+          'caller_reference' => edge.caller_id.to_s,
+          'callee_reference' => edge.callee_id.to_s
+        }.compact
+      end
+
+      def legacy_edge_scope(edge, site)
+        if site
+          return {
+            'call_site_id' => site.call_site_id,
+            'caller_definition_id' => site.caller_id,
+            'target_reference' => edge.callee_id.to_s
+          }
+        end
+
+        { 'caller_reference' => edge.caller_id.to_s, 'target_reference' => edge.callee_id.to_s }
+      end
+
+      def matching_call_site(edge)
+        metadata = edge.evidence.metadata
+        call_site_id = value(metadata, :call_site_id)
+        unless call_site_id.equal?(MISSING)
+          caller_id = physical_definition_id(edge.caller_id)
+          return unless caller_id
+
+          return unique_site do |site|
+            site.call_site_id == call_site_id.to_s && site.caller_id == caller_id
+          end
+        end
+
+        matching_legacy_call_site(edge, metadata)
+      end
+
+      def matching_legacy_call_site(edge, metadata)
+        caller_id = physical_definition_id(edge.caller_id)
+        return unless caller_id
+
+        metadata_caller = value(metadata, :caller_definition_id, :caller_id)
+        return if metadata_caller.equal?(MISSING)
+        return unless physical_definition_id(metadata_caller) == caller_id
+
+        signature = legacy_signature(metadata, caller_id)
+        return unless signature
+
+        unique_site do |site|
+          site.caller_id == caller_id && legacy_signature(site.to_h, caller_id) == signature
+        end
+      end
+
+      def legacy_signature(attributes, caller_id)
+        message = value(attributes, :message)
+        receiver_kind = value(attributes, :receiver_kind)
+        receiver_name = value(attributes, :receiver_name)
+        file = value(attributes, :file)
+        line = value(attributes, :line)
+        test = value(attributes, :test)
+        dynamic = value(attributes, :dynamic)
+        metadata = value(attributes, :metadata)
+        values = [message, receiver_kind, receiver_name, file, line, test, dynamic, metadata]
+        return if values.any? { |item| item.equal?(MISSING) }
+
+        CallSiteIdentity.legacy_id(
+          caller_definition_id: caller_id,
+          message: message,
+          receiver_kind: receiver_kind,
+          receiver_name: receiver_name,
+          file: file,
+          line: line,
+          test: test,
+          dynamic: dynamic,
+          metadata: metadata
+        )
+      end
+
+      def unique_site(&)
+        matches = graph.call_sites.select(&)
+        matches.first if matches.one?
+      end
+
+      def physical_definition_id(reference)
+        graph.nodes.lookup(reference.to_s).node&.graph_id
+      end
+
+      def resolution_for(site)
+        edges = @edges_by_call_site_id.fetch(site.call_site_id, [])
+        targets = edges.filter_map { |edge| physical_definition_id(edge.callee_id) }.uniq.sort
+        status = targets.empty? ? :unknown : :partial
+        ResolutionRecord.new(
+          resolution: Resolution.new(
+            call_site_id: site.call_site_id,
+            target_definition_ids: targets,
+            status: status,
+            unknown_scope: UnknownScope.new(scope_kind: :message, scope_value: site.message, match: :exact),
+            evidence_ids: edges.filter_map { |edge| edge.evidence.evidence_id }.uniq.sort
+          ),
+          producer: profile.name,
+          producer_version: profile.version || 'unversioned',
+          assumptions: profile.assumptions
+        )
+      end
+
+      def value(attributes, *keys)
+        return MISSING unless attributes.respond_to?(:key?)
+
+        keys.each do |key|
+          return attributes[key.to_s] if attributes.key?(key.to_s)
+          return attributes[key] if attributes.key?(key)
+        end
+        MISSING
+      end
+    end
+  end
+end

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

@@ -5,25 +5,48 @@ module Necropsy
     module Static
       class CHA < Analyzer
         def analyze(graph, _project)
-          edge_evidences = graph.call_sites.flat_map do |site|
-            resolve(graph, site).map do |candidate|
+          edge_evidences = []
+          resolutions = graph.call_sites.map do |site|
+            lookup = graph.cha_method_lookup(site)
+            targets = lookup.targets
+            site_edges = targets.map do |candidate|
               EdgeEvidence.new(
                 caller_id: site.caller_id,
-                callee_id: candidate.id,
+                callee_id: candidate.graph_id,
                 evidence: evidence(
                   kind: :call_edge,
                   details: "CHA candidate at #{site.file}:#{site.line}",
-                  metadata: site.to_h
+                  metadata: site.to_h.merge('target_definition_id' => candidate.graph_id),
+                  grade: :conservative,
+                  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
+            edge_evidences.concat(site_edges)
+            status = if lookup.complete?
+                       :complete
+                     else
+                       (targets.empty? ? :unknown : :partial)
+                     end
+            resolution_record(
+              site,
+              targets,
+              site_edges,
+              status: status,
+              rejected_targets: lookup.complete? ? lookup.rejected_targets : [],
+              unknown_scope: graph.residual_scope_for(site)
+            )
           end
 
           AnalyzerResult.new(
             edge_evidences: edge_evidences,
             alive_evidences: [],
             uncertainties: {},
-            observation: {}
+            observation: {},
+            resolutions: resolutions,
+            evidences: result_evidences(edge_evidences)
           )
         end
 
@@ -32,73 +55,14 @@ module Necropsy
             name: :cha,
             kind: :static,
             soundness: :conservative,
-            description: 'Expands call targets through class hierarchy, descendants, and included/prepended modules.'
+            description: 'Expands call targets through class hierarchy, descendants, and included/prepended modules.',
+            version: Necropsy::VERSION,
+            assumptions: %w[closed_scanned_hierarchy loaded_ancestry]
           )
         end
 
-        private
-
-        def resolve(graph, site)
-          case site.receiver_kind
-          when :constant
-            constant_targets(graph, site)
-          when :instance
-            instance_targets(graph, site)
-          when :self, :implicit
-            self_targets(graph, site)
-          else
-            graph.candidate_nodes(site.message)
-          end.uniq(&:id)
-        end
-
-        def constant_targets(graph, site)
-          receiver_candidates(site).flat_map do |owner|
-            owners_for_lookup(graph, owner, include_descendants: false).filter_map do |candidate_owner|
-              graph.nodes["#{candidate_owner}.#{site.message}"]
-            end
-          end
-        end
-
-        def instance_targets(graph, site)
-          receiver_candidates(site).flat_map do |owner|
-            owners_for_lookup(graph, owner, include_descendants: true).filter_map do |candidate_owner|
-              graph.nodes["#{candidate_owner}##{site.message}"]
-            end
-          end
-        end
-
-        def self_targets(graph, site)
-          caller = graph.nodes[site.caller_id]
-          return [] unless caller&.owner
-
-          separator = caller.kind == :singleton_method ? '.' : '#'
-          owners_for_lookup(graph, caller.owner, include_descendants: false).filter_map do |owner|
-            graph.nodes["#{owner}#{separator}#{site.message}"] || graph.nodes["#{owner}##{site.message}"]
-          end
-        end
-
-        def owners_for_lookup(graph, owner, include_descendants:)
-          owners = include_descendants ? graph.descendants_of(owner) : [owner]
-          owners.flat_map do |candidate|
-            info = graph.class_info(candidate)
-            modules = info ? info.prepends + info.includes + info.extends : []
-            [candidate, *modules, *ancestors(graph, candidate)]
-          end.uniq
-        end
-
-        def ancestors(graph, owner)
-          chain = []
-          current = graph.class_info(owner)&.superclass
-          while current && !chain.include?(current)
-            chain << current
-            current = graph.class_info(current)&.superclass
-          end
-          chain
-        end
-
-        def receiver_candidates(site)
-          candidates = site.metadata['receiver_candidates'] || site.metadata[:receiver_candidates]
-          Array(candidates).compact.empty? ? [site.receiver_name].compact : Array(candidates).compact
+        def capabilities
+          [:complete_resolution].freeze
         end
       end
     end

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

@@ -5,25 +5,39 @@ module Necropsy
     module Static
       class NameResolution < Analyzer
         def analyze(graph, _project)
-          edge_evidences = graph.call_sites.flat_map do |site|
-            graph.resolve_call_site(site).map do |candidate|
-              EdgeEvidence.new(
-                caller_id: site.caller_id,
-                callee_id: candidate.id,
-                evidence: evidence(
-                  kind: :call_edge,
-                  details: "Name resolution at #{site.file}:#{site.line}",
-                  metadata: site.to_h
-                )
-              )
-            end
+          edge_evidences = []
+          resolutions = []
+          uncertainties = {}
+          blockers = []
+          graph.call_sites.each do |site|
+            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: unresolved_uncertainties(graph),
-            observation: {}
+            uncertainties: uncertainties,
+            observation: {},
+            blockers: blockers,
+            resolutions: resolutions,
+            evidences: result_evidences(edge_evidences)
           )
         end
 
@@ -32,21 +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 unresolved_uncertainties(graph)
-          graph.call_sites.each_with_object({}) do |site, memo|
-            next if site.dynamic
-            next unless graph.resolve_call_site(site).empty? && site.receiver_kind == :unknown
+        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.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.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, lookup, uncertainties)
+          return if site.dynamic || lookup.targets.any? || lookup.complete?
 
-            memo[site.caller_id] ||= []
-            memo[site.caller_id] << "Unknown receiver for #{site.message} at #{site.file}:#{site.line}"
+          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