necropsy 0.1.0 → 0.2.0

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

@@ -6,7 +6,7 @@ module Necropsy
       class CHA < Analyzer
         def analyze(graph, _project)
           edge_evidences = graph.call_sites.flat_map do |site|
-            resolve(graph, site).map do |candidate|
+            candidates(graph, site).map do |candidate|
               EdgeEvidence.new(
                 caller_id: site.caller_id,
                 callee_id: candidate.id,
@@ -36,9 +36,7 @@ module Necropsy
           )
         end
 
-        private
-
-        def resolve(graph, site)
+        def candidates(graph, site)
           case site.receiver_kind
           when :constant
             constant_targets(graph, site)
@@ -47,15 +45,21 @@ module Necropsy
           when :self, :implicit
             self_targets(graph, site)
           else
-            graph.candidate_nodes(site.message)
+            graph.resolve_call_site(site)
           end.uniq(&:id)
         end
 
+        private
+
         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|
+            targets = owners_for_lookup(graph, owner, include_descendants: false).filter_map do |candidate_owner|
               graph.nodes["#{candidate_owner}.#{site.message}"]
             end
+            extended = Array(graph.class_info(owner)&.extends).filter_map do |mod|
+              graph.nodes["#{mod}##{site.message}"]
+            end
+            targets + extended
           end
         end
 

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

@@ -5,24 +5,19 @@ 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 = []
+          uncertainties = {}
+          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)
           end
 
           AnalyzerResult.new(
             edge_evidences: edge_evidences,
             alive_evidences: [],
-            uncertainties: unresolved_uncertainties(graph),
+            uncertainties: uncertainties,
             observation: {}
           )
         end
@@ -38,15 +33,29 @@ module Necropsy
 
         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
-
-            memo[site.caller_id] ||= []
-            memo[site.caller_id] << "Unknown receiver for #{site.message} at #{site.file}:#{site.line}"
+        def edge_evidences_for(site, candidates, fallback)
+          candidates.map do |candidate|
+            EdgeEvidence.new(
+              caller_id: site.caller_id,
+              callee_id: candidate.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
+              )
+            )
           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
+
+          uncertainties[site.caller_id] ||= []
+          uncertainties[site.caller_id] <<
+            "Unknown receiver for #{site.message} at #{site.file}:#{site.line}; dispatch may be ambiguous"
+        end
       end
     end
   end

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

@@ -13,8 +13,9 @@ module Necropsy
         COMPARISON_MESSAGES = %w[< <= > >= between? clamp sort sort_by max min].freeze
 
         def analyze(graph, _project)
-          edge_evidences = expanded_call_sites(graph).flat_map do |site|
-            graph.resolve_call_site(site, rta: true).map do |candidate|
+          sites = expanded_call_sites(graph)
+          edge_evidences = sites.flat_map do |site|
+            rta_candidates(graph, site).map do |candidate|
               EdgeEvidence.new(
                 caller_id: site.caller_id,
                 callee_id: candidate.id,
@@ -31,7 +32,7 @@ module Necropsy
             edge_evidences: edge_evidences,
             alive_evidences: [],
             uncertainties: {},
-            observation: {}
+            observation: { 'rta' => { 'analyzed_sites' => sites.map(&:to_h) } }
           )
         end
 
@@ -73,6 +74,21 @@ module Necropsy
           messages << 'to_s' if %w[puts print warn].include?(message)
           messages
         end
+
+        private
+
+        def rta_candidates(graph, site)
+          candidates = Analyzers::Static::CHA.new.candidates(graph, site)
+          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
+          return [] unless graph.ambiguous_resolution?
+
+          graph.ambiguous_fallback_candidates(site.message)
+        end
       end
     end
   end

data/lib/necropsy/ast_scanner/call_recording.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class AstScanner
+    private
+
+    def build_call_site(node, context)
+      message = node.name&.to_s
+      dynamic = false
+      receiver = classify_receiver(node.receiver, context)
+      metadata = { 'original_message' => message, 'receiver_candidates' => receiver[:candidates] }
+
+      if DYNAMIC_SENDS.include?(node.name)
+        literal = first_symbol_argument(node) || first_string_argument(node)
+        dynamic = literal.nil?
+        message = literal
+        metadata['dynamic_dispatch'] = true
+      end
+
+      return nil unless message
+
+      CallSite.new(
+        caller_id: context.current_caller_id,
+        message: message,
+        receiver_kind: receiver.fetch(:kind),
+        receiver_name: receiver[:name],
+        file: context.relative_file,
+        line: node.location.start_line,
+        test: context.test,
+        dynamic: dynamic,
+        metadata: metadata
+      )
+    end
+
+    def record_instantiation(node, context)
+      return record_factory_instantiation(node, context) unless %i[new []].include?(node.name)
+
+      receiver = classify_receiver(node.receiver, context)
+      receiver = implicit_self_constructor(context) if implicit_constructor?(receiver, context)
+      return unless receiver && receiver[:kind] == :constant
+
+      Array(receiver[:candidates] || receiver[:name]).each { |name| instantiated_classes << name }
+      record_initialize_call(node, context, receiver)
+    end
+
+    def implicit_constructor?(receiver, context)
+      return false unless %i[implicit self].include?(receiver[:kind])
+      return false unless context.owner
+
+      context.current_kind == :singleton_method || context.current_caller_id == context.root_id
+    end
+
+    def implicit_self_constructor(context)
+      { kind: :constant, name: context.owner, candidates: [context.owner] }
+    end
+
+    def record_initialize_call(node, context, receiver)
+      return unless node.name == :new
+
+      call_sites << CallSite.new(
+        caller_id: context.current_caller_id,
+        message: 'initialize',
+        receiver_kind: :instance,
+        receiver_name: receiver[:name],
+        file: context.relative_file,
+        line: node.location.start_line,
+        test: context.test,
+        dynamic: false,
+        metadata: { 'original_message' => 'new', 'receiver_candidates' => receiver[:candidates],
+                    'implicit_from' => 'new' }
+      )
+    end
+
+    def record_factory_instantiation(node, context)
+      return unless @factory_methods.include?(node.name.to_s)
+
+      receiver = classify_receiver(node.receiver, context)
+      return unless receiver[:kind] == :constant
+
+      Array(receiver[:candidates] || receiver[:name]).each do |name|
+        instantiated_classes << name
+      end
+    end
+
+    def record_uncertainty(site)
+      uncertainties[site.caller_id] << "Dynamic dispatch at #{site.file}:#{site.line}"
+    end
+
+    def record_uncertainty_at(node, context)
+      uncertainties[context.current_caller_id] << "Dynamic dispatch at #{context.relative_file}:#{node.location.start_line}"
+    end
+
+    def unresolved_dynamic_dispatch?(node)
+      DYNAMIC_SENDS.include?(node.name) && first_symbol_argument(node).nil? && first_string_argument(node).nil?
+    end
+
+    def record_parse_errors(root_id, result)
+      result.errors.each do |error|
+        uncertainties[root_id] << "Parse warning at line #{error.location.start_line}: #{error.message}"
+      end
+    end
+
+    def definition_owner(node, context)
+      return context.owner unless node.receiver
+      return context.owner if node.receiver.is_a?(Prism::SelfNode)
+
+      receiver = classify_receiver(node.receiver, context)
+      receiver[:name]
+    end
+
+    def definition_owner_for_call(node, context)
+      return context.owner unless node.receiver
+      return context.owner if node.receiver.is_a?(Prism::SelfNode)
+
+      classify_receiver(node.receiver, context)[:name]
+    end
+
+    def eval_owner(node, context)
+      return context.owner unless node.receiver
+
+      definition_owner_for_call(node, context)
+    end
+
+    def method_kind_and_separator(context)
+      context.singleton_scope ? [:singleton_method, '.'] : [:instance_method, '#']
+    end
+
+    def update_method_visibility(context, name, visibility, singleton: false)
+      separator = singleton ? '.' : method_kind_and_separator(context).last
+      id = "#{context.owner}#{separator}#{name}"
+      index = nodes.rindex { |candidate| candidate.id == id }
+      nodes[index] = nodes[index].with(visibility: visibility) if index
+    end
+
+    def promote_module_function(context, name, location)
+      instance_id = "#{context.owner}##{name}"
+      index = nodes.rindex { |candidate| candidate.id == instance_id }
+      return unless index
+
+      instance_node = nodes[index]
+      nodes[index] = instance_node.with(visibility: :private)
+      nodes << Node.new(
+        id: "#{context.owner}.#{name}",
+        kind: :singleton_method,
+        file: context.relative_file,
+        line: location.start_line,
+        end_line: location.end_line,
+        defined_via: :module_function,
+        owner: context.owner,
+        name: name,
+        test: context.test,
+        visibility: :public
+      )
+    end
+  end
+end

data/lib/necropsy/ast_scanner/dsl_macros.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class AstScanner
+    private
+
+    def handle_module_relation(node, context)
+      return unless MODULE_RELATION_MACROS.include?(node.name)
+      return unless context.owner
+
+      class_record(context.owner)[:extends] << [context.owner] if node.name == :extend && arguments(node).any?(Prism::SelfNode)
+
+      constants = arguments(node).filter_map { |argument| constant_name(argument) }
+      return if constants.empty?
+
+      data = class_record(context.owner)
+      key = :"#{node.name}s"
+      constants.each { |constant| data[key] << constant_candidates(constant, context.namespace) }
+    end
+
+    def handle_rails_callback(node, context)
+      return unless context.owner
+      return if context.test
+
+      if RAILS_CALLBACK_MACROS.include?(node.name)
+        callback_names(node).each do |method_name|
+          entrypoint_hints << EntryPoint.new(node_id: "#{context.owner}##{method_name}", reason: :callback_registered)
+        end
+      elsif node.name == :validates
+        custom_validator_names(node).each do |validator|
+          constant_candidates("#{validator}Validator", context.namespace).each do |owner|
+            entrypoint_hints << EntryPoint.new(node_id: "#{owner}#validate_each", reason: :callback_registered)
+          end
+        end
+      elsif node.name == :validates_with
+        arguments(node).filter_map { |argument| constant_name(argument) }.each do |validator|
+          constant_candidates(validator, context.namespace).each do |owner|
+            entrypoint_hints << EntryPoint.new(node_id: "#{owner}#validate", reason: :callback_registered)
+          end
+        end
+      end
+    end
+
+    def handle_attr_macro(node, context)
+      return false unless ATTR_MACROS.include?(node.name)
+      return false unless context.owner
+
+      symbol_arguments(node).each do |name|
+        kind, separator = method_kind_and_separator(context)
+        nodes << Node.new(
+          id: "#{context.owner}#{separator}#{name}",
+          kind: kind,
+          file: context.relative_file,
+          line: node.location.start_line,
+          end_line: node.location.end_line,
+          defined_via: node.name,
+          owner: context.owner,
+          name: name,
+          test: context.test,
+          visibility: context.visibility
+        )
+        next unless %i[attr_writer attr_accessor].include?(node.name)
+
+        nodes << Node.new(
+          id: "#{context.owner}#{separator}#{name}=",
+          kind: kind,
+          file: context.relative_file,
+          line: node.location.start_line,
+          end_line: node.location.end_line,
+          defined_via: node.name,
+          owner: context.owner,
+          name: "#{name}=",
+          test: context.test,
+          visibility: context.visibility
+        )
+      end
+      true
+    end
+
+    def handle_delegate(node, context)
+      return false unless node.name == :delegate
+      return false unless context.owner
+
+      target = keyword_value(node, 'to')
+      prefix = keyword_value(node, 'prefix')
+      symbol_arguments(node).each do |name|
+        generated_name = delegated_method_name(name, target, prefix)
+        kind, separator = method_kind_and_separator(context)
+        id = "#{context.owner}#{separator}#{generated_name}"
+        nodes << Node.new(
+          id: id,
+          kind: kind,
+          file: context.relative_file,
+          line: node.location.start_line,
+          end_line: node.location.end_line,
+          defined_via: :delegate,
+          owner: context.owner,
+          name: generated_name,
+          test: context.test,
+          visibility: context.visibility
+        )
+        record_delegate_target(id, target, node, context) if target
+        record_delegated_message(id, name, node, context)
+      end
+      true
+    end
+
+    def handle_forwardable(node, context)
+      return false unless %i[def_delegator def_delegators].include?(node.name)
+      return false unless context.owner
+
+      symbols = symbol_arguments(node)
+      return false if symbols.length < 2
+
+      target = symbols.shift
+      definitions = if node.name == :def_delegator
+                      [[symbols[1] || symbols[0], symbols[0]]]
+                    else
+                      symbols.map { |name| [name, name] }
+                    end
+      definitions.each do |generated_name, delegated_name|
+        kind, separator = method_kind_and_separator(context)
+        id = "#{context.owner}#{separator}#{generated_name}"
+        nodes << Node.new(
+          id: id,
+          kind: kind,
+          file: context.relative_file,
+          line: node.location.start_line,
+          end_line: node.location.end_line,
+          defined_via: node.name,
+          owner: context.owner,
+          name: generated_name,
+          test: context.test,
+          visibility: context.visibility
+        )
+        record_delegate_target(id, target, node, context)
+        record_delegated_message(id, delegated_name, node, context)
+      end
+      true
+    end
+  end
+end

data/lib/necropsy/ast_scanner/method_definitions.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class AstScanner
+    private
+
+    def handle_define_method(node, context)
+      return false unless node.name == :define_method
+      return false unless context.owner
+
+      method_name = first_symbol_argument(node)
+      return false unless method_name
+
+      kind, separator = method_kind_and_separator(context)
+      id = "#{context.owner}#{separator}#{method_name}"
+      nodes << Node.new(
+        id: id,
+        kind: kind,
+        file: context.relative_file,
+        line: node.location.start_line,
+        end_line: node.location.end_line,
+        defined_via: :define_method,
+        owner: context.owner,
+        name: method_name,
+        test: context.test,
+        visibility: context.visibility
+      )
+      record_module_function_copy(node, context, context.owner, method_name) if context.module_function
+
+      if node.block
+        block_context = context.dup
+        block_context.current_caller_id = id
+        block_context.current_kind = kind
+        block_context.singleton_scope = false
+        block_context.visibility = :public
+        block_context.module_function = false
+        visit(node.block.body, block_context)
+      end
+      true
+    end
+
+    def handle_define_singleton_method(node, context)
+      return false unless node.name == :define_singleton_method
+
+      owner = definition_owner_for_call(node, context)
+      method_name = first_symbol_argument(node) || first_string_argument(node)
+      return false unless owner && method_name
+
+      id = "#{owner}.#{method_name}"
+      nodes << Node.new(
+        id: id,
+        kind: :singleton_method,
+        file: context.relative_file,
+        line: node.location.start_line,
+        end_line: node.location.end_line,
+        defined_via: :define_singleton_method,
+        owner: owner,
+        name: method_name,
+        test: context.test,
+        visibility: :public
+      )
+      if node.block
+        block_context = context.dup
+        block_context.owner = owner
+        block_context.current_caller_id = id
+        block_context.current_kind = :singleton_method
+        block_context.singleton_scope = false
+        block_context.visibility = :public
+        block_context.module_function = false
+        visit(node.block.body, block_context)
+      end
+      true
+    end
+
+    def handle_eval(node, context)
+      return false unless %i[class_eval module_eval].include?(node.name)
+      return false unless node.block
+
+      owner = eval_owner(node, context)
+      return false unless owner
+
+      block_context = context.dup
+      block_context.namespace = owner
+      block_context.owner = owner
+      block_context.singleton_scope = false
+      block_context.visibility = :public
+      block_context.module_function = false
+      visit(node.block.body, block_context)
+      true
+    end
+
+    def handle_visibility(node, context)
+      return false unless VISIBILITY_MACROS.include?(node.name)
+      return false unless context.owner
+
+      names = symbol_arguments(node)
+      class_method = node.name.to_s.end_with?('_class_method')
+      visibility = node.name.to_s.delete_suffix('_class_method').to_sym
+      if names.empty?
+        unless class_method
+          context.visibility = visibility
+          context.module_function = false
+        end
+      else
+        names.each { |name| update_method_visibility(context, name, visibility, singleton: class_method) }
+      end
+      true
+    end
+
+    def handle_module_function(node, context)
+      return false unless node.name == :module_function
+      return false unless context.owner
+
+      names = symbol_arguments(node)
+      if names.empty?
+        context.module_function = true
+        context.visibility = :private
+      else
+        names.each { |name| promote_module_function(context, name, node.location) }
+      end
+      true
+    end
+
+    def record_module_function_copy(node, context, _owner, method_name = node.name.to_s)
+      promote_module_function(context, method_name, node.location)
+    end
+
+    def handle_alias_method(node, context)
+      return false unless node.name == :alias_method
+      return false unless context.owner
+
+      new_name, old_name = symbol_arguments(node)
+      return false unless new_name && old_name
+
+      record_alias_method(context, node.location, new_name, old_name)
+      true
+    end
+
+    def visit_alias_method_node(node, context)
+      return visit_children(node, context) unless context.owner
+
+      new_name = node.new_name.unescaped.to_s
+      old_name = node.old_name.unescaped.to_s
+      record_alias_method(context, node.location, new_name, old_name)
+    end
+
+    def record_alias_method(context, location, new_name, old_name)
+      kind = context.singleton_scope ? :singleton_method : :instance_method
+      separator = kind == :singleton_method ? '.' : '#'
+      id = "#{context.owner}#{separator}#{new_name}"
+      nodes << Node.new(
+        id: id,
+        kind: kind,
+        file: context.relative_file,
+        line: location.start_line,
+        end_line: location.end_line,
+        defined_via: :alias_method,
+        owner: context.owner,
+        name: new_name,
+        test: context.test,
+        visibility: context.visibility
+      )
+      call_sites << CallSite.new(
+        caller_id: id,
+        message: old_name,
+        receiver_kind: :self,
+        receiver_name: context.owner,
+        file: context.relative_file,
+        line: location.start_line,
+        test: context.test,
+        dynamic: false,
+        metadata: { 'original_message' => old_name, 'alias_method' => true }
+      )
+    end
+  end
+end