necropsy 0.2.0 → 0.3.0

data/lib/necropsy/ast_scanner/method_definitions.rb

@@ -8,121 +8,254 @@ module Necropsy
       return false unless node.name == :define_method
       return false unless context.owner
 
-      method_name = first_symbol_argument(node)
-      return false unless method_name
+      method_name = literal_argument(node, index: 0)
+      unless method_name
+        record_semantic_blocker(
+          :dynamic_definition,
+          node,
+          context,
+          'define_method name is not statically bounded',
+          suggested_action: :make_method_name_literal
+        )
+        visit_synthetic_body(node.block&.body, context, :dynamic_define_method)
+        return handled_call
+      end
 
       kind, separator = method_kind_and_separator(context)
       id = "#{context.owner}#{separator}#{method_name}"
-      nodes << Node.new(
-        id: id,
+      definition = add_definition(
+        symbol_id: id,
         kind: kind,
-        file: context.relative_file,
-        line: node.location.start_line,
-        end_line: node.location.end_line,
+        source_node: node,
+        context: context,
         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
+      record_module_function_copy(node, context, definition) if context.module_function
 
       if node.block
         block_context = context.dup
-        block_context.current_caller_id = id
+        block_context.current_caller_id = definition.graph_id
+        block_context.current_method_name = method_name
         block_context.current_kind = kind
         block_context.singleton_scope = false
         block_context.visibility = :public
         block_context.module_function = false
+        block_context.static_ancestry = false
         visit(node.block.body, block_context)
       end
-      true
+      handled_call
     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
+      method_name = literal_argument(node, index: 0)
+      unless owner && method_name
+        record_semantic_blocker(
+          :dynamic_singleton_definition,
+          node,
+          context,
+          'define_singleton_method receiver or name is not statically bounded',
+          suggested_action: :make_singleton_definition_static,
+          scope_owner: owner,
+          force_global: !owner
+        )
+        visit_synthetic_body(node.block&.body, context, :dynamic_define_singleton_method)
+        return handled_call
+      end
 
       id = "#{owner}.#{method_name}"
-      nodes << Node.new(
-        id: id,
+      definition = add_definition(
+        symbol_id: id,
         kind: :singleton_method,
-        file: context.relative_file,
-        line: node.location.start_line,
-        end_line: node.location.end_line,
+        source_node: node,
+        context: context,
         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_caller_id = definition.graph_id
+        block_context.current_method_name = method_name
         block_context.current_kind = :singleton_method
         block_context.singleton_scope = false
         block_context.visibility = :public
         block_context.module_function = false
+        block_context.static_ancestry = false
         visit(node.block.body, block_context)
       end
-      true
+      handled_call
     end
 
     def handle_eval(node, context)
-      return false unless %i[class_eval module_eval].include?(node.name)
-      return false unless node.block
+      return false unless %i[class_eval class_exec module_eval module_exec instance_eval instance_exec eval].include?(node.name)
 
       owner = eval_owner(node, context)
-      return false unless owner
+      unless node.block && owner && node.name != :eval
+        record_semantic_blocker(
+          :variable_eval,
+          node,
+          context,
+          'Eval receiver or source is not statically bounded',
+          suggested_action: :replace_variable_eval,
+          scope_owner: node.name == :eval ? nil : owner,
+          receiver_kind: %i[instance_eval instance_exec].include?(node.name) ? :constant : nil,
+          force_global: node.name == :eval
+        )
+        visit_synthetic_body(node.block&.body, context, :dynamic_eval)
+        return handled_call
+      end
 
       block_context = context.dup
       block_context.namespace = owner
       block_context.owner = owner
-      block_context.singleton_scope = false
+      block_context.singleton_scope = %i[instance_eval instance_exec].include?(node.name)
       block_context.visibility = :public
       block_context.module_function = false
+      block_context.static_ancestry = false
       visit(node.block.body, block_context)
-      true
+      handled_call
+    end
+
+    def handle_unsupported_semantics(node, context)
+      return false unless %i[refine using].include?(node.name)
+
+      record_semantic_blocker(
+        :unsupported_refinement,
+        node,
+        context,
+        "#{node.name} changes lexical method lookup and is not resolved",
+        suggested_action: :review_refinement_scope
+      )
+      handled_call
+    end
+
+    def record_semantic_blocker(kind, node, context, reason, suggested_action: :review,
+                                scope_owner: context.owner, receiver_kind: nil, force_global: false)
+      global = force_global || !scope_owner
+      scope_kind = global ? :global : :owner
+      scope_value = global ? '*' : scope_owner
+      metadata = {
+        'caller_domain' => context.test ? 'test' : 'runtime',
+        'caller_id' => context.current_caller_id,
+        'semantic_operation' => (node.respond_to?(:name) ? node.name : node.type).to_s,
+        'owner_scope' => Array(scope_owner).compact,
+        'file' => context.relative_file,
+        'line' => node.location.start_line,
+        'reason_code' => kind.to_s
+      }
+      metadata['receiver_kind'] = receiver_kind.to_s if receiver_kind
+      semantic_blockers << Blocker.new(
+        kind: kind,
+        scope_kind: scope_kind,
+        scope_value: scope_value,
+        source: 'ast_scanner',
+        reason: reason,
+        suggested_action: suggested_action,
+        metadata: metadata
+      )
     end
 
     def handle_visibility(node, context)
       return false unless VISIBILITY_MACROS.include?(node.name)
       return false unless context.owner
 
-      names = symbol_arguments(node)
+      modifier_definitions = arguments(node).grep(Prism::DefNode)
       class_method = node.name.to_s.end_with?('_class_method')
       visibility = node.name.to_s.delete_suffix('_class_method').to_sym
+      unless modifier_definitions.empty?
+        modifier_definitions.each do |definition|
+          definition_context = context.dup
+          definition_context.visibility = visibility
+          visit_def(definition, definition_context)
+        end
+        return handled_call(arguments: false)
+      end
+
+      modifier_calls = arguments(node).grep(Prism::CallNode)
+      unless modifier_calls.empty?
+        modifier_calls.each { |call| visit(call, context) }
+        names = [*symbol_arguments(node), *modifier_calls.flat_map { |call| visibility_result_names(call) }].uniq
+        names.each { |name| update_method_visibility(context, name, visibility, node, singleton: class_method) }
+        record_unknown_visibility_result(node, context, modifier_calls, visibility) if names.empty?
+        arguments(node).reject { |argument| argument.is_a?(Prism::CallNode) || argument.is_a?(Prism::DefNode) }
+                       .each { |argument| visit(argument, context) }
+        return handled_call(receiver: false, arguments: false)
+      end
+
+      names = symbol_arguments(node)
       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) }
+        names.each { |name| update_method_visibility(context, name, visibility, node, singleton: class_method) }
       end
-      true
+      handled_call
+    end
+
+    def visibility_result_names(call)
+      names = symbol_arguments(call)
+      case call.name
+      when :attr_reader
+        names
+      when :attr_writer
+        names.map { |name| "#{name}=" }
+      when :attr_accessor
+        names.flat_map { |name| [name, "#{name}="] }
+      else
+        []
+      end
+    end
+
+    def record_unknown_visibility_result(node, context, modifier_calls, visibility)
+      operations = modifier_calls.map(&:name).compact.map(&:to_s).uniq.sort
+      record_semantic_blocker(
+        :visibility_activation,
+        node,
+        context,
+        "#{visibility} receives runtime-computed method names from #{operations.join(', ')}",
+        suggested_action: :review_load_order
+      )
     end
 
     def handle_module_function(node, context)
       return false unless node.name == :module_function
       return false unless context.owner
 
+      modifier_definitions = arguments(node).grep(Prism::DefNode)
+      unless modifier_definitions.empty?
+        modifier_definitions.each do |definition|
+          definition_context = context.dup
+          definition_context.module_function = true
+          definition_context.visibility = :private
+          visit_def(definition, definition_context)
+        end
+        return handled_call(arguments: false)
+      end
+
       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) }
+        names.each { |name| defer_module_function(context, name, node) }
       end
-      true
+      handled_call
     end
 
-    def record_module_function_copy(node, context, _owner, method_name = node.name.to_s)
-      promote_module_function(context, method_name, node.location)
+    def record_module_function_copy(node, context, instance_node)
+      copy = add_module_function_definition(context, instance_node.name, node)
+      module_function_sources[copy.graph_id] = [instance_node.graph_id]
+      method_signatures[copy.graph_id] = method_signatures[instance_node.graph_id] if method_signatures[instance_node.graph_id]
     end
 
     def handle_alias_method(node, context)
@@ -132,8 +265,47 @@ module Necropsy
       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
+      record_alias_method(context, node, new_name, old_name)
+      handled_call
+    end
+
+    def handle_method_removal(node, context)
+      return false unless %i[remove_method undef_method].include?(node.name)
+      return false unless context.owner
+
+      names = symbol_arguments(node)
+      if names.empty?
+        record_semantic_blocker(
+          :dynamic_method_removal,
+          node,
+          context,
+          "#{node.name} target is not statically bounded",
+          suggested_action: :make_method_name_literal,
+          force_global: true
+        )
+        return handled_call
+      end
+
+      names.each do |name|
+        semantic_blockers << Blocker.new(
+          kind: node.name,
+          scope_kind: :message,
+          scope_value: name,
+          source: 'ast_scanner',
+          reason: "#{context.owner} #{node.name}s #{name}; activation order is not closed",
+          suggested_action: :review_method_activation,
+          metadata: {
+            'caller_domain' => context.test ? 'test' : 'runtime',
+            'caller_id' => context.current_caller_id,
+            'owner_scope' => [context.owner],
+            'file' => context.relative_file,
+            'line' => node.location.start_line,
+            'message' => name,
+            'reason_code' => node.name.to_s
+          }
+        )
+      end
+      handled_call
     end
 
     def visit_alias_method_node(node, context)
@@ -141,36 +313,46 @@ module Necropsy
 
       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)
+      record_alias_method(context, node, new_name, old_name)
     end
 
-    def record_alias_method(context, location, new_name, old_name)
+    def record_alias_method(context, source_node, 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,
+      physical_source = physical_alias_source(context, source_node, old_name, kind)
+      definition = add_definition(
+        symbol_id: id,
         kind: kind,
-        file: context.relative_file,
-        line: location.start_line,
-        end_line: location.end_line,
+        source_node: source_node,
+        context: context,
         defined_via: :alias_method,
         owner: context.owner,
         name: new_name,
-        test: context.test,
-        visibility: context.visibility
+        visibility: physical_source&.visibility || context.visibility
       )
-      call_sites << CallSite.new(
-        caller_id: id,
+      metadata = { 'original_message' => old_name, 'alias_method' => true }
+      metadata['physical_target_definition_id'] = physical_source.graph_id if physical_source
+      add_scanned_call_site(
+        source_node: source_node,
+        context: context,
+        role: :alias_target,
+        caller_id: definition.graph_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 }
+        metadata: metadata
       )
     end
+
+    def physical_alias_source(context, source_node, old_name, kind)
+      return unless context.static_ancestry
+
+      nodes.select do |definition|
+        definition.kind == kind && definition.owner == context.owner && definition.name == old_name &&
+          definition.file == context.relative_file && definition.line <= source_node.location.start_line
+      end.max_by { |definition| [definition.line, definition.ordinal] }
+    end
   end
 end

data/lib/necropsy/ast_scanner/references.rb

@@ -2,6 +2,15 @@
 
 module Necropsy
   class AstScanner
+    RESPOND_TO_TRUTHY_LITERAL_TYPES = %i[
+      array_node float_node hash_node imaginary_node integer_node
+      interpolated_match_last_line_node interpolated_regular_expression_node
+      interpolated_string_node interpolated_symbol_node interpolated_x_string_node
+      keyword_hash_node match_last_line_node range_node rational_node
+      regular_expression_node source_encoding_node source_file_node source_line_node
+      string_node symbol_node true_node x_string_node
+    ].freeze
+
     private
 
     def callback_names(node)
@@ -25,11 +34,14 @@ module Necropsy
     end
 
     def record_delegate_target(caller_id, target, node, context)
-      record_reference_call(caller_id, target.to_s.delete_prefix('@'), node, context, receiver_kind: :self)
+      record_reference_call(
+        caller_id, target.to_s.delete_prefix('@'), node, context,
+        role: :delegate_target, receiver_kind: :self
+      )
     end
 
     def record_delegated_message(caller_id, message, node, context)
-      record_reference_call(caller_id, message, node, context, receiver_kind: :unknown)
+      record_reference_call(caller_id, message, node, context, role: :delegate_message, receiver_kind: :unknown)
     end
 
     def record_symbol_reference(node, context)
@@ -44,9 +56,11 @@ module Necropsy
         message,
         node,
         context,
+        role: :symbol_reference,
         receiver_kind: receiver[:kind],
         receiver_name: receiver[:name],
-        candidates: receiver[:candidates]
+        candidates: receiver[:candidates],
+        metadata: symbol_reference_metadata(node)
       )
     end
 
@@ -60,22 +74,42 @@ module Necropsy
         block.expression.unescaped.to_s,
         node,
         context,
+        role: :symbol_to_proc,
         receiver_kind: :unknown
       )
     end
 
-    def record_reference_call(caller_id, message, node, context, receiver_kind:, receiver_name: nil, candidates: [])
-      call_sites << CallSite.new(
+    def record_reference_call(caller_id, message, node, context, role:, receiver_kind:, receiver_name: nil,
+                              candidates: [], metadata: {})
+      add_scanned_call_site(
+        source_node: node,
+        context: context,
+        role: role,
         caller_id: caller_id,
         message: message.to_s,
         receiver_kind: receiver_kind,
         receiver_name: receiver_name,
-        file: context.relative_file,
-        line: node.location.start_line,
-        test: context.test,
         dynamic: false,
-        metadata: { 'symbol_reference' => true, 'receiver_candidates' => Array(candidates) }
+        metadata: { 'symbol_reference' => true, 'receiver_candidates' => Array(candidates) }.merge(metadata)
       )
     end
+
+    def symbol_reference_metadata(node)
+      metadata = { 'original_message' => node.name.to_s }
+      return metadata unless node.name == :respond_to?
+
+      metadata['include_private'] = respond_to_include_private(arguments(node))
+      metadata
+    end
+
+    def respond_to_include_private(call_arguments)
+      return false unless call_arguments.length > 1
+
+      argument = call_arguments[1]
+      return false if %i[false_node nil_node].include?(argument.type)
+      return true if RESPOND_TO_TRUTHY_LITERAL_TYPES.include?(argument.type)
+
+      'unknown'
+    end
   end
 end

data/lib/necropsy/ast_scanner/ruby_semantics.rb

@@ -5,20 +5,20 @@ module Necropsy
     private
 
     def classify_receiver(receiver, context)
-      return { kind: :implicit, name: nil } unless receiver
-      return { kind: :self, name: context.owner } if receiver.is_a?(Prism::SelfNode)
+      return { kind: :implicit, name: context.owner, candidates: [context.owner].compact } unless receiver
+      return { kind: :self, name: context.owner, candidates: [context.owner].compact } if receiver.is_a?(Prism::SelfNode)
 
       constant = constant_name(receiver)
       if constant
-        candidates = constant_candidates(constant, context.namespace)
-        return { kind: :constant, name: candidates.first, candidates: candidates }
+        candidates = constant_candidates(constant, context.lexical_nesting)
+        return { kind: :constant, name: resolve_candidate_group(candidates), candidates: candidates }
       end
 
       if receiver.is_a?(Prism::CallNode) && receiver.name == :new
         receiver_constant = constant_name(receiver.receiver)
         if receiver_constant
-          candidates = constant_candidates(receiver_constant, context.namespace)
-          return { kind: :instance, name: candidates.first, candidates: candidates }
+          candidates = constant_candidates(receiver_constant, context.lexical_nesting)
+          return { kind: :instance, name: resolve_candidate_group(candidates), candidates: candidates }
         end
       end
 
@@ -33,6 +33,17 @@ module Necropsy
       arguments(node).find { |argument| argument.is_a?(Prism::StringNode) }&.unescaped
     end
 
+    def literal_argument(node, index:)
+      argument = arguments(node)[index]
+      return unless literal_name?(argument)
+
+      argument.unescaped.to_s
+    end
+
+    def literal_name?(node)
+      node.is_a?(Prism::SymbolNode) || node.is_a?(Prism::StringNode)
+    end
+
     def symbol_arguments(node)
       arguments(node).filter_map do |arg|
         next unless arg.is_a?(Prism::SymbolNode)
@@ -71,6 +82,53 @@ module Necropsy
       end
     end
 
+    def method_signature(parameters)
+      return { 'complete' => false } unless parameters
+
+      forwarding = parameters.child_nodes.compact.any? { |parameter| parameter.type == :forwarding_parameter_node }
+      keywords = Array(parameters.keywords)
+      keyword_rest = parameters.keyword_rest
+      no_keywords = !keyword_rest.nil? && keyword_rest.type == :no_keywords_parameter_node
+      accepts_keywords = keywords.any? || (!keyword_rest.nil? && !no_keywords)
+      {
+        'complete' => !forwarding,
+        'minimum_positionals' => Array(parameters.requireds).length + Array(parameters.posts).length,
+        'maximum_positionals' => if parameters.rest
+                                   nil
+                                 else
+                                   Array(parameters.requireds).length +
+                                     Array(parameters.optionals).length + Array(parameters.posts).length
+                                 end,
+        'required_keywords' => keywords.select do |parameter|
+          parameter.type == :required_keyword_parameter_node
+        end.map { |parameter| parameter.name.to_s }.sort,
+        'accepted_keywords' => keywords.map { |parameter| parameter.name.to_s }.sort,
+        'accepts_keywords' => accepts_keywords,
+        'no_keywords' => no_keywords,
+        'keyword_rest' => !keyword_rest.nil? && !no_keywords
+      }
+    end
+
+    def call_arguments(node, offset: 0)
+      values = Array(node.arguments&.arguments).drop(offset)
+      keyword_hash = values.find { |argument| argument.is_a?(Prism::KeywordHashNode) }
+      positional = values.grep_v(Prism::KeywordHashNode)
+      keyword_elements = Array(keyword_hash&.elements)
+      {
+        'complete' => positional.none? do |argument|
+          %i[splat_node forwarding_arguments_node].include?(argument.type)
+        end && keyword_elements.none? { |element| element.type == :assoc_splat_node },
+        'positional_count' => positional.length,
+        'keywords' => keyword_elements.filter_map do |element|
+          literal_value(element.key).to_s if element.is_a?(Prism::AssocNode)
+        end.sort
+      }
+    end
+
+    def incomplete_arguments
+      { 'complete' => false, 'positional_count' => 0, 'keywords' => [] }
+    end
+
     def constant_name(node)
       return nil unless node
 
@@ -100,8 +158,34 @@ module Necropsy
       data[:line] = node.location.start_line
       return unless node.respond_to?(:superclass)
 
+      unless node.superclass
+        data[:superclass_candidates] = implicit_superclass_candidates(namespace)
+        return
+      end
+
       superclass = constant_name(node.superclass)
-      data[:superclass_candidates] = constant_candidates(superclass, context.namespace) if superclass
+      if superclass
+        data[:superclass_candidates] = constant_candidates(superclass, context.lexical_nesting)
+        return
+      end
+
+      data[:superclass_candidates] = []
+      data[:dynamic] = true
+      record_semantic_blocker(
+        :dynamic_ancestry,
+        node.superclass,
+        context,
+        "#{namespace} has a runtime-computed superclass",
+        suggested_action: :make_superclass_static,
+        scope_owner: namespace
+      )
+    end
+
+    def implicit_superclass_candidates(namespace)
+      return [] if namespace == 'BasicObject'
+      return ['BasicObject'] if namespace == 'Object'
+
+      ['Object']
     end
 
     def class_record(namespace)
@@ -115,6 +199,8 @@ module Necropsy
         includes: [],
         prepends: [],
         extends: [],
+        singleton_includes: [],
+        singleton_prepends: [],
         dynamic: false
       }
     end
@@ -132,6 +218,8 @@ module Necropsy
           includes: resolve_candidate_groups(data.fetch(:includes)),
           prepends: resolve_candidate_groups(data.fetch(:prepends)),
           extends: resolve_candidate_groups(data.fetch(:extends)),
+          singleton_includes: resolve_candidate_groups(data.fetch(:singleton_includes)),
+          singleton_prepends: resolve_candidate_groups(data.fetch(:singleton_prepends)),
           dynamic: data.fetch(:dynamic)
         )
       end
@@ -145,18 +233,16 @@ module Necropsy
       group.find { |candidate| class_data.key?(candidate) } || group.first
     end
 
-    def constant_candidates(name, namespace)
+    def constant_candidates(name, lexical_nesting)
       return [name.delete_prefix('::')] if name.start_with?('::')
-      return [name] if namespace.nil? || namespace.empty?
+
+      nesting = Array(lexical_nesting).compact
+      return [name] if nesting.empty?
 
       head, *rest = name.split('::')
       suffix = rest.empty? ? '' : "::#{rest.join('::')}"
-      parts = namespace.split('::')
-      candidates = []
-      parts.length.downto(1) do |length|
-        candidates << "#{parts.first(length).join('::')}::#{head}#{suffix}"
-      end
-      inherited_namespaces(namespace).each do |ancestor|
+      candidates = nesting.map { |namespace| "#{namespace}::#{head}#{suffix}" }
+      inherited_namespaces(nesting.first).each do |ancestor|
         candidates << "#{ancestor}::#{head}#{suffix}"
       end
       candidates << name