rubocop-callbacksystems 0.1.0

data/lib/rubocop/callbacksystems/project_index/diagnostics.rb

@@ -0,0 +1,60 @@
+class RuboCop::Callbacksystems::ProjectIndex::Diagnostics
+  extend RuboCop::Callbacksystems::ProjectIndex::Cache
+
+  def initialize(project_index)
+    @by_rule_name = {}
+    @by_rule_name_and_uri = {}
+    project_index.diagnostics.each { index(it) }
+  end
+
+  def any_named?(*rule_names)
+    diagnostics_named(rule_names).any?
+  end
+
+  def within_definitions?(definitions, named:)
+    definitions.any? do |definition|
+      diagnostics_named_in(definition.location.uri, named).any? do |diagnostic|
+        LocationContainment.new(definition.location, diagnostic.location).contained?
+      end
+    end
+  end
+
+  private
+    attr_reader :by_rule_name, :by_rule_name_and_uri
+
+    def index(diagnostic)
+      rule_name = diagnostic.rule.rule_name
+      (by_rule_name[rule_name] ||= []) << diagnostic
+      (by_rule_name_and_uri[[ rule_name, diagnostic.location.uri ]] ||= []) << diagnostic
+    end
+
+    def diagnostics_named(rule_names)
+      rule_names.flat_map { by_rule_name.fetch(it) { [] } }
+    end
+
+    def diagnostics_named_in(uri, rule_names)
+      rule_names.flat_map { by_rule_name_and_uri.fetch([ it, uri ]) { [] } }
+    end
+
+    class LocationContainment
+      def initialize(outer, inner)
+        @outer = outer
+        @inner = inner
+      end
+
+      def contained?
+        outer.uri == inner.uri && starts_before? && ends_after?
+      end
+
+      private
+        attr_reader :outer, :inner
+
+        def starts_before?
+          ([ outer.start_line, outer.start_column ] <=> [ inner.start_line, inner.start_column ]) <= 0
+        end
+
+        def ends_after?
+          ([ outer.end_line, outer.end_column ] <=> [ inner.end_line, inner.end_column ]) >= 0
+        end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/freshness.rb

@@ -0,0 +1,104 @@
+require "digest"
+
+# The source revisions held by a project index while RuboCop autocorrects in memory. RuboCop builds one graph before
+# inspecting the project, then may run several corrected versions of a file before writing it. Each accepted revision
+# replaces that document in Rubydex; only revisions descended from the indexed disk source are trusted.
+class RuboCop::Callbacksystems::ProjectIndex::Freshness
+  class << self
+    def update(project_index, processed_source, new_source)
+      mutex.synchronize do
+        RevisionChain.new(
+          processed_source, state_for(project_index), project_index:, new_source:
+        ).update
+      end
+    rescue SystemCallError
+      false
+    end
+
+    def current_source?(project_index, processed_source)
+      mutex.synchronize do
+        RevisionChain.new(processed_source, state_for(project_index)).current?
+      end || false
+    rescue SystemCallError
+      false
+    end
+
+    def reliable?(project_index)
+      mutex.synchronize { state_for(project_index).reliable }
+    end
+
+    def generation(project_index)
+      mutex.synchronize { state_for(project_index).generation }
+    end
+
+    private
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      def state_for(project_index)
+        states[project_index] ||= State.new(0, true, {})
+      end
+
+      def states
+        @states ||= ObjectSpace::WeakKeyMap.new
+      end
+  end
+
+  private
+    State = Struct.new(:generation, :reliable, :revisions)
+    Revision = Data.define(:source, :backing_checksum)
+
+    class RevisionChain
+      def initialize(processed_source, state, project_index: nil, new_source: nil)
+        @file = RuboCop::Callbacksystems::ProjectIndex::SourceFile.new(processed_source.file_path)
+        @source = processed_source.raw_source.b
+        @state = state
+        @project_index = project_index
+        @new_source = new_source
+      end
+
+      def update
+        backing_checksum ? update_index : false
+      end
+
+      def current?
+        current_revision? && revision.backing_checksum == disk_checksum
+      end
+
+      private
+        attr_reader :file, :source, :state, :project_index, :new_source
+
+        def backing_checksum
+          @backing_checksum ||= disk_checksum if source_on_disk? || current?
+        end
+
+        def source_on_disk?
+          disk_checksum == Digest::SHA256.hexdigest(source)
+        end
+
+        def disk_checksum
+          @disk_checksum ||= Digest::SHA256.file(file.path).hexdigest
+        end
+
+        def update_index
+          project_index.index_source(file.uri, new_source, "ruby")
+          project_index.resolve
+          state.revisions[file.path] = Revision.new(new_source.b.dup.freeze, backing_checksum)
+          state.generation += 1
+          true
+        rescue
+          state.reliable = false
+          state.generation += 1
+          false
+        end
+
+        def current_revision?
+          revision&.source == source
+        end
+
+        def revision
+          state.revisions[file.path]
+        end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/loader.rb

@@ -0,0 +1,9 @@
+module RuboCop::Callbacksystems::ProjectIndex::Loader
+  def build_index(paths)
+    super.tap do |project_index|
+      if project_index
+        RuboCop::Callbacksystems::ProjectIndex::Coverage.register(project_index, paths:)
+      end
+    end
+  end
+end

data/lib/rubocop/callbacksystems/project_index/location.rb

@@ -0,0 +1,29 @@
+# One source location expressed in Rubydex's zero-based lines and byte columns, so parser ranges and graph locations can
+# be compared without confusing a character column for a byte column.
+class RuboCop::Callbacksystems::ProjectIndex::Location < Data.define \
+  :uri, :start_line, :start_column, :end_line, :end_column
+  class << self
+    def for_ast(range, uri:)
+      new \
+        uri:,
+        start_line: range.line.pred,
+        start_column: byte_column_of(range, line: range.line, at: range.column),
+        end_line: range.last_line.pred,
+        end_column: byte_column_of(range, line: range.last_line, at: range.last_column)
+    end
+
+    def for_rubydex(location)
+      new \
+        uri: location.uri,
+        start_line: location.start_line,
+        start_column: location.start_column,
+        end_line: location.end_line,
+        end_column: location.end_column
+    end
+
+    private
+      def byte_column_of(range, line:, at:)
+        range.source_buffer.source_line(line).slice(0, at).bytesize
+      end
+  end
+end

data/lib/rubocop/callbacksystems/project_index/nested_class_confinement.rb

@@ -0,0 +1,297 @@
+# Whether every visible use of a nested class and every instance it constructs stays within the file.
+class RuboCop::Callbacksystems::ProjectIndex::NestedClassConfinement
+  include RuboCop::Callbacksystems::Helpers
+
+  CONSTRUCTION_METHODS = %i[ allocate new ]
+  MIXIN_METHODS = %i[ extend include prepend ]
+  CLASS_BODY_PRIMITIVES = %i[
+    alias_method attr attr_accessor attr_reader attr_writer deprecate_constant module_function
+    private private_class_method private_constant protected public public_class_method public_constant
+    remove_method ruby2_keywords undef_method
+  ]
+  VALUE_EXPOSURE_METHODS = %i[
+    __send__ binding clone dup enum_for freeze instance_eval instance_exec itself method public_method public_send
+    send singleton_class singleton_method tap then to_enum yield_self
+  ]
+  HANDOFF_TYPES = %i[
+    array hash pair splat kwsplat block_pass yield return super break next def defs
+    and or case when rescue resbody ensure for match_pattern match_pattern_p irange erange
+    lvasgn ivasgn cvasgn gvasgn casgn masgn or_asgn and_asgn op_asgn
+  ].to_set.merge(RuboCop::Callbacksystems::Helpers::NodeTypes::BLOCK_NODE_TYPES)
+
+  def initialize(nested_class, declaration:, project_index:)
+    @nested_class = nested_class
+    @declaration = declaration
+    @project_index = project_index
+  end
+
+  def confined?
+    return @confined if defined?(@confined)
+
+    @confined = definition_confined? && values_confined?
+  end
+
+  private
+    attr_reader :nested_class, :declaration, :project_index
+
+    def definition_confined?
+      nested_class.parent_class.nil? && !mixin_used? && !singleton_callback_defined? &&
+        references_in_definition_file? && all_references_located? && reference_nodes.all? { safe_reference?(it) }
+    end
+
+    def mixin_used?
+      sends.any? do |send_node|
+        call_on_self?(send_node) && MIXIN_METHODS.include?(send_node.method_name)
+      end
+    end
+
+    def sends
+      @sends ||= nodes_in(nested_class.body, :send, :csend)
+    end
+
+    def singleton_callback_defined?
+      direct_method_nodes.any? do |definition|
+        RuboCop::Callbacksystems::Methods::ImplicitInvocations::RUNTIME_METHODS.include?(definition.method_name) &&
+          singleton_definition?(definition)
+      end
+    end
+
+    def direct_method_nodes
+      @direct_method_nodes ||= direct_method_nodes_in(nested_class.body)
+    end
+
+    def singleton_definition?(definition)
+      RuboCop::Callbacksystems::Methods::Domain.new(definition).identity.then do |identity|
+        identity.present? && identity.all? { it == :self }
+      end
+    end
+
+    def references_in_definition_file?
+      definition_uris.one? && references.all? { definition_uris.include?(it.location.uri) }
+    end
+
+    def definition_uris
+      @definition_uris ||= declaration.definitions.to_set { it.location.uri }
+    end
+
+    def references
+      @references ||= declaration.references.to_a
+    end
+
+    def all_references_located?
+      reference_nodes.size == references.size
+    end
+
+    def reference_nodes
+      @reference_nodes ||= references.filter_map { const_node_at(it.location) }
+    end
+
+    def const_node_at(location)
+      SourceConstants.for(source_root, uri: location.uri).at(location)
+    end
+
+    def source_root
+      @source_root ||= nested_class.then do |node|
+        node = node.parent while node.parent
+        node
+      end
+    end
+
+    def safe_reference?(node)
+      namespace_prefix?(node) || locally_consumed_construction?(node)
+    end
+
+    def namespace_prefix?(node)
+      node.parent.const_type? && node.parent.namespace.equal?(node)
+    end
+
+    def locally_consumed_construction?(node)
+      node.parent.call_type? && node.parent.receiver.equal?(node) && construction?(node.parent) &&
+        !handed_off?(node.parent)
+    end
+
+    def construction?(send_node)
+      CONSTRUCTION_METHODS.include?(send_node.method_name)
+    end
+
+    def handed_off?(candidate)
+      CarriedValue.new(candidate).outermost.then do |value|
+        value.parent&.type?(*HANDOFF_TYPES) || passed_as_argument?(value)
+      end
+    end
+
+    def passed_as_argument?(value)
+      value.parent&.call_type? && !value.parent.receiver.equal?(value)
+    end
+
+    def values_confined?
+      !class_escapes? && !instance_escapes? && method_dispatch_confined? &&
+        implicit_constructions.none? { implicit_construction_escapes?(it) }
+    end
+
+    def class_escapes?
+      class_values.any? { handed_off?(it) } || opaque_class_body_call?
+    end
+
+    def class_values
+      explicit_class_values + implicit_class_values
+    end
+
+    def explicit_class_values
+      self_nodes.select do |self_node|
+        !structural_self?(self_node) && possible_class_side?(self_node)
+      end
+    end
+
+    def self_nodes
+      @self_nodes ||= nodes_in(nested_class.body, :self)
+    end
+
+    def possible_class_side?(node)
+      RuboCop::Callbacksystems::Methods::Domain.new(node).then do |domain|
+        if domain.container.equal?(nested_class)
+          domain.singleton?
+        else
+          opaque_block_in_nested_class?(domain.container)
+        end
+      end
+    end
+
+    def opaque_block_in_nested_class?(container)
+      any_block_type?(container) && enclosing_class_or_module_of(container).equal?(nested_class)
+    end
+
+    def implicit_class_values
+      sends.select do |send_node|
+        VALUE_EXPOSURE_METHODS.include?(send_node.method_name) && call_on_self?(send_node) &&
+          possible_class_side?(send_node)
+      end
+    end
+
+    def opaque_class_body_call?
+      sends.any? do |send_node|
+        direct_class_body_call?(send_node) && call_on_self?(send_node) &&
+          !trusted_class_body_call?(send_node)
+      end
+    end
+
+    def direct_class_body_call?(send_node)
+      enclosing_method_of(send_node).nil? && enclosing_class_or_module_of(send_node).equal?(nested_class)
+    end
+
+    def trusted_class_body_call?(send_node)
+      CLASS_BODY_PRIMITIVES.include?(send_node.method_name) && !class_method_redefined?(send_node.method_name)
+    end
+
+    def class_method_redefined?(method_name)
+      project_index["Class"].find_member("#{method_name}()")&.definitions&.any? || false
+    rescue
+      true
+    end
+
+    def instance_escapes?
+      instance_values.any? { handed_off?(it) }
+    end
+
+    def instance_values
+      explicit_instance_values + implicit_instance_values
+    end
+
+    def explicit_instance_values
+      self_nodes.select { possible_instance_side?(it) }
+    end
+
+    def possible_instance_side?(node)
+      RuboCop::Callbacksystems::Methods::Domain.new(node).then do |domain|
+        (domain.container.equal?(nested_class) && !domain.singleton?) ||
+          opaque_block_in_nested_class?(domain.container)
+      end
+    end
+
+    def implicit_instance_values
+      sends.select do |send_node|
+        VALUE_EXPOSURE_METHODS.include?(send_node.method_name) && call_on_self?(send_node) &&
+          possible_instance_side?(send_node)
+      end
+    end
+
+    def method_dispatch_confined?
+      RuboCop::Callbacksystems::ProjectIndex::NestedClassMethodDispatch.new(nested_class, declaration:).confined?
+    end
+
+    def implicit_constructions
+      sends.select do |send_node|
+        construction?(send_node) && call_on_self?(send_node) && possible_class_side?(send_node)
+      end
+    end
+
+    def implicit_construction_escapes?(construction)
+      opaque_block_in_nested_class?(RuboCop::Callbacksystems::Methods::Domain.new(construction).container) ||
+        handed_off?(construction)
+    end
+
+    class SourceConstants
+      class << self
+        def for(source_root, uri:)
+          context = Context.new(source_root, uri)
+
+          cached.then do |cached_context, constants|
+            if cached_context&.same_source?(context)
+              constants
+            else
+              new(context).tap { self.cached = [ context, it ] }
+            end
+          end
+        end
+
+        private
+          attr_accessor :cached
+      end
+
+      def initialize(context)
+        @by_location = context.source_root.each_node(:const).group_by do |node|
+          RuboCop::Callbacksystems::ProjectIndex::Location.for_ast(node.loc.name, uri: context.uri)
+        end
+      end
+
+      def at(location)
+        key = RuboCop::Callbacksystems::ProjectIndex::Location.for_rubydex(location)
+        by_location.fetch(key) { [] }.then { it.first if it.one? }
+      end
+
+      private
+        attr_reader :by_location
+
+        class Context < Data.define(:source_root, :uri)
+          def same_source?(other)
+            source_root.equal?(other.source_root) && uri == other.uri
+          end
+        end
+    end
+
+    class CarriedValue
+      def initialize(node)
+        @node = node
+      end
+
+      def outermost
+        node.then do |current|
+          current = current.parent while carries_value?(current.parent, child: current)
+          current
+        end
+      end
+
+      private
+        attr_reader :node
+
+        def carries_value?(parent, child:)
+          case parent&.type
+          when :begin, :kwbegin then parent.children.last.equal?(child)
+          when :if then parent.children.drop(1).any?(child)
+          when :send, :csend then parent.receiver.equal?(child)
+          when :class, :module, :sclass then parent.body.equal?(child)
+          else false
+          end
+        end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/nested_class_method_dispatch.rb

@@ -0,0 +1,50 @@
+# Whether self-dispatch inside a nested class stays on methods the class itself owns.
+class RuboCop::Callbacksystems::ProjectIndex::NestedClassMethodDispatch
+  include RuboCop::Callbacksystems::Helpers
+
+  def initialize(nested_class, declaration:)
+    @nested_class = nested_class
+    @declaration = declaration
+  end
+
+  def confined?
+    self_calls.all? { owned_method_call?(it) } && !super_dispatch?
+  end
+
+  private
+    attr_reader :nested_class, :declaration
+
+    def self_calls
+      nodes_in(nested_class.body, :send, :csend).select do |send_node|
+        call_on_self?(send_node) && enclosing_method_of(send_node) && method_owner_of(send_node)
+      end
+    end
+
+    def method_owner_of(send_node)
+      RuboCop::Callbacksystems::Methods::Domain.new(send_node).then do |domain|
+        owner_for(domain.identity) if domain.container.equal?(nested_class)
+      end
+    end
+
+    def owner_for(identity)
+      if identity.empty?
+        declaration
+      elsif identity.all? { it == :self }
+        declaration.singleton_class
+      end
+    end
+
+    def owned_method_call?(send_node)
+      method_owner_of(send_node).then do |owner|
+        owner.member("#{send_node.method_name}()").present?
+      end
+    rescue
+      false
+    end
+
+    def super_dispatch?
+      nodes_in(nested_class.body, :super, :zsuper).any? do |super_node|
+        enclosing_class_or_module_of(super_node).equal?(nested_class)
+      end
+    end
+end

data/lib/rubocop/callbacksystems/project_index/reading.rb

@@ -0,0 +1,129 @@
+require "digest"
+
+class RuboCop::Callbacksystems::ProjectIndex::Reading
+  extend RuboCop::Callbacksystems::ProjectIndex::Cache
+
+  INCOMPLETE_DIAGNOSTICS = %w[
+    ParseError DynamicConstantReference DynamicAncestor DynamicSingletonDefinition
+  ]
+  OPAQUE_CONSTANT_REFLECTIONS = %w[
+    const_get const_set remove_const autoload constantize safe_constantize
+    eval class_eval class_exec module_eval module_exec instance_eval instance_exec
+    each_object constants descendants subclasses unsafe_load unsafe_load_file
+  ].to_set
+  OPAQUE_DISPATCH_METHODS = %w[ send __send__ public_send method public_method ].to_set
+  OPAQUE_RECEIVER_METHODS = { "Marshal" => %w[ load restore ].to_set }
+  RECEIVER_SEPARATOR_WIDTHS = [ 1, 2 ]
+
+  def initialize(project_index)
+    @project_index = project_index
+  end
+
+  def checksum
+    @checksum ||= DocumentsChecksum.new(project_index).to_s
+  end
+
+  def reliable?
+    return @reliable if defined?(@reliable)
+
+    @reliable = RuboCop::Callbacksystems::ProjectIndex::Coverage.complete?(project_index) &&
+      !diagnostics.any_named?(*INCOMPLETE_DIAGNOSTICS) &&
+      !opaque_reflection?
+  end
+
+  private
+    attr_reader :project_index
+
+    def diagnostics
+      @diagnostics ||= RuboCop::Callbacksystems::ProjectIndex::Diagnostics.for(project_index)
+    end
+
+    def opaque_reflection?
+      return @opaque_reflection if defined?(@opaque_reflection)
+
+      @opaque_reflection = project_index.method_references.any? do |reference|
+        method_name = reference.name.delete_suffix("()")
+        OPAQUE_CONSTANT_REFLECTIONS.include?(method_name) ||
+          (OPAQUE_DISPATCH_METHODS.include?(method_name) && opaque_dispatch_receiver?(reference.receiver)) ||
+          opaque_receiver_method?(reference, method_name:)
+      end
+    end
+
+    def opaque_dispatch_receiver?(receiver)
+      receiver.nil? || receiver.is_a?(Rubydex::SingletonClass)
+    end
+
+    def opaque_receiver_method?(reference, method_name:)
+      receiver_names_of(reference).any? do |receiver_name|
+        OPAQUE_RECEIVER_METHODS.fetch(receiver_name) { [] }.include?(method_name)
+      end
+    end
+
+    def receiver_names_of(reference)
+      direct_receiver_name_of(reference).then do |name|
+        name ? Set[name] : constant_receiver_names.fetch(reference_location_key(reference)) { Set.new }
+      end
+    end
+
+    def direct_receiver_name_of(reference)
+      receiver = reference.receiver
+      receiver.attached_class.name if receiver.is_a?(Rubydex::SingletonClass)
+    end
+
+    def constant_receiver_names
+      @constant_receiver_names ||= project_index.constant_references.each_with_object({}) do |reference, names|
+        RECEIVER_SEPARATOR_WIDTHS.each do |separator_width|
+          key = location_key(reference.location, column: reference.location.end_column + separator_width)
+          (names[key] ||= Set.new) << constant_name_of(reference)
+        end
+      end
+    end
+
+    def location_key(location, column:)
+      [ location.uri, location.start_line, column ]
+    end
+
+    def constant_name_of(reference)
+      if reference.is_a?(Rubydex::ResolvedConstantReference)
+        reference.declaration.name
+      else
+        reference.name.delete_prefix("<").delete_suffix(">")
+      end
+    end
+
+    def reference_location_key(reference)
+      location_key(reference.location, column: reference.location.start_column)
+    end
+
+    class DocumentsChecksum
+      def initialize(project_index)
+        @project_index = project_index
+      end
+
+      def to_s
+        Digest::SHA256.new.tap do |digest|
+          documents.each do |document|
+            digest << document.uri << "\0" << checksum_for(document) << "\0"
+          end
+        end.hexdigest
+      end
+
+      private
+        attr_reader :project_index
+
+        def documents
+          project_index.documents.select { it.uri.start_with?(RuboCop::Cop::ProjectIndexHelp::FILE_URI_PREFIX) }
+            .sort_by(&:uri)
+        end
+
+        def checksum_for(document)
+          Digest::SHA256.file(path_for(document)).hexdigest
+        rescue SystemCallError => error
+          error.class.name
+        end
+
+        def path_for(document)
+          RuboCop::Callbacksystems::ProjectIndex::SourceFile.for_document(document).path
+        end
+    end
+end