ruby-lsp 0.22.1 → 0.23.0

data/lib/ruby_lsp/requests/prepare_rename.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [prepare_rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_prepareRename)
+    # # request checks the validity of a rename operation at a given location.
+    class PrepareRename < Request
+      extend T::Sig
+      include Support::Common
+
+      sig do
+        params(
+          document: RubyDocument,
+          position: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(document, position)
+        super()
+        @document = document
+        @position = T.let(position, T::Hash[Symbol, Integer])
+      end
+
+      sig { override.returns(T.nilable(Interface::Range)) }
+      def perform
+        char_position = @document.create_scanner.find_char_position(@position)
+
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          char_position,
+          node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
+          code_units_cache: @document.code_units_cache,
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return if !target || target.is_a?(Prism::ProgramNode)
+
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            @position,
+          )
+        end
+
+        range_from_location(target.location)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -66,7 +66,7 @@ module RubyLsp
           Interface::TypeHierarchyItem.new(
             name: first_entry.name,
             kind: kind_for_entry(first_entry),
-            uri: URI::Generic.from_path(path: first_entry.file_path).to_s,
+            uri: first_entry.uri.to_s,
             range: range,
             selection_range: range,
           ),

data/lib/ruby_lsp/requests/rename.rb

@@ -12,6 +12,15 @@ module RubyLsp
 
       class InvalidNameError < StandardError; end
 
+      class << self
+        extend T::Sig
+
+        sig { returns(Interface::RenameOptions) }
+        def provider
+          Interface::RenameOptions.new(prepare_provider: true)
+        end
+      end
+
       sig do
         params(
           global_state: GlobalState,
@@ -106,7 +115,9 @@ module RubyLsp
 
         T.must(@global_state.index[fully_qualified_name]).each do |entry|
           # Do not rename files that are not part of the workspace
-          next unless entry.file_path.start_with?(@global_state.workspace_path)
+          uri = entry.uri
+          file_path = T.must(uri.full_path)
+          next unless file_path.start_with?(@global_state.workspace_path)
 
           case entry
           when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,
@@ -117,13 +128,12 @@ module RubyLsp
             if "#{file_name}.rb" == entry.file_name
               new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
 
-              old_uri = URI::Generic.from_path(path: entry.file_path).to_s
               new_uri = URI::Generic.from_path(path: File.join(
-                File.dirname(entry.file_path),
+                File.dirname(file_path),
                 "#{new_file_name}.rb",
               )).to_s
 
-              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: old_uri, new_uri: new_uri)
+              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: uri.to_s, new_uri: new_uri)
             end
           end
         end

data/lib/ruby_lsp/requests/support/common.rb

@@ -93,11 +93,7 @@ module RubyLsp
             # based, which is why instead of the usual subtraction of 1 to line numbers, we are actually adding 1 to
             # columns. The format for VS Code file URIs is
             # `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
-            uri = URI::Generic.from_path(
-              path: entry.file_path,
-              fragment: "L#{loc.start_line},#{loc.start_column + 1}-#{loc.end_line},#{loc.end_column + 1}",
-            )
-
+            uri = "#{entry.uri}#L#{loc.start_line},#{loc.start_column + 1}-#{loc.end_line},#{loc.end_column + 1}"
             definitions << "[#{entry.file_name}](#{uri})"
             content << "\n\n#{entry.comments}" unless entry.comments.empty?
           end

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -65,7 +65,7 @@ module RubyLsp
         Interface::TypeHierarchyItem.new(
           name: entry.name,
           kind: kind_for_entry(entry),
-          uri: URI::Generic.from_path(path: entry.file_path).to_s,
+          uri: entry.uri.to_s,
           range: range_from_location(entry.location),
           selection_range: range_from_location(entry.name_location),
           detail: entry.file_name,

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -21,7 +21,8 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
       def perform
         @index.fuzzy_search(@query).filter_map do |entry|
-          file_path = entry.file_path
+          uri = entry.uri
+          file_path = T.must(uri.full_path)
 
           # We only show symbols declared in the workspace
           in_dependencies = !not_in_dependencies?(file_path)
@@ -43,7 +44,7 @@ module RubyLsp
             container_name: container.join("::"),
             kind: kind,
             location: Interface::Location.new(
-              uri: URI::Generic.from_path(path: file_path).to_s,
+              uri: uri.to_s,
               range:  Interface::Range.new(
                 start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
                 end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -5,7 +5,7 @@ def compose(raw_initialize)
   require_relative "../setup_bundler"
   require "json"
   require "uri"
-  require_relative "../../core_ext/uri"
+  require "ruby_indexer/lib/ruby_indexer/uri"
 
   initialize_request = JSON.parse(raw_initialize, symbolize_names: true)
   workspace_uri = initialize_request.dig(:params, :workspaceFolders, 0, :uri)

data/lib/ruby_lsp/server.rb

@@ -71,6 +71,8 @@ module RubyLsp
         text_document_prepare_type_hierarchy(message)
       when "textDocument/rename"
         text_document_rename(message)
+      when "textDocument/prepareRename"
+        text_document_prepare_rename(message)
       when "textDocument/references"
         text_document_references(message)
       when "typeHierarchy/supertypes"
@@ -117,12 +119,24 @@ module RubyLsp
         # If a document is deleted before we are able to process all of its enqueued requests, we will try to read it
         # from disk and it raise this error. This is expected, so we don't include the `data` attribute to avoid
         # reporting these to our telemetry
-        if e.is_a?(Store::NonExistingDocumentError)
+        case e
+        when Store::NonExistingDocumentError
           send_message(Error.new(
             id: message[:id],
             code: Constant::ErrorCodes::INVALID_PARAMS,
             message: e.full_message,
           ))
+        when Document::LocationNotFoundError
+          send_message(Error.new(
+            id: message[:id],
+            code: Constant::ErrorCodes::REQUEST_FAILED,
+            message: <<~MESSAGE,
+              Request #{message[:method]} failed to find the target position.
+              The file might have been modified while the server was in the middle of searching for the target.
+              If you experience this regularly, please report any findings and extra information on
+              https://github.com/Shopify/ruby-lsp/issues/2446
+            MESSAGE
+          ))
         else
           send_message(Error.new(
             id: message[:id],
@@ -237,6 +251,7 @@ module RubyLsp
       completion_provider = Requests::Completion.provider if enabled_features["completion"]
       signature_help_provider = Requests::SignatureHelp.provider if enabled_features["signatureHelp"]
       type_hierarchy_provider = Requests::PrepareTypeHierarchy.provider if enabled_features["typeHierarchy"]
+      rename_provider = Requests::Rename.provider unless @global_state.has_type_checker
 
       response = {
         capabilities: Interface::ServerCapabilities.new(
@@ -263,7 +278,7 @@ module RubyLsp
           workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.has_type_checker,
           signature_help_provider: signature_help_provider,
           type_hierarchy_provider: type_hierarchy_provider,
-          rename_provider: !@global_state.has_type_checker,
+          rename_provider: rename_provider,
           references_provider: !@global_state.has_type_checker,
           document_range_formatting_provider: true,
           experimental: {
@@ -727,6 +742,24 @@ module RubyLsp
       send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::REQUEST_FAILED, message: e.message))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_prepare_rename(message)
+      params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: Requests::PrepareRename.new(document, params[:position]).perform,
+        ),
+      )
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_references(message)
       params = message[:params]
@@ -981,15 +1014,17 @@ module RubyLsp
         next unless file_path.end_with?(".rb")
 
         load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
-        indexable = RubyIndexer::IndexablePath.new(load_path_entry, file_path)
+        uri.add_require_path_from_load_entry(load_path_entry) if load_path_entry
+
+        content = File.read(file_path)
 
         case change[:type]
         when Constant::FileChangeType::CREATED
-          index.index_single(indexable)
+          index.index_single(uri, content)
         when Constant::FileChangeType::CHANGED
-          index.handle_change(indexable)
+          index.handle_change(uri, content)
         when Constant::FileChangeType::DELETED
-          index.delete(indexable)
+          index.delete(uri)
         end
       end
 
@@ -1088,7 +1123,7 @@ module RubyLsp
 
     sig { override.void }
     def shutdown
-      Addon.addons.each(&:deactivate)
+      Addon.unload_addons
     end
 
     sig { void }

data/lib/ruby_lsp/setup_bundler.rb

@@ -152,7 +152,13 @@ module RubyLsp
       end
 
       unless @dependencies["debug"]
-        parts << 'gem "debug", require: false, group: :development, platforms: :mri'
+        # The `mri` platform excludes Windows. We want to install the debug gem only on MRI for any operating system,
+        # but that constraint doesn't yet exist in Bundler. On Windows, we are manually checking if the engine is MRI
+        parts << if Gem.win_platform?
+          'gem "debug", require: false, group: :development, install_if: -> { RUBY_ENGINE == "ruby" }'
+        else
+          'gem "debug", require: false, group: :development, platforms: :mri'
+        end
       end
 
       if @rails_app && !@dependencies["ruby-lsp-rails"]
@@ -196,15 +202,15 @@ module RubyLsp
         env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
       end
 
-      return run_bundle_install_through_command(env) unless @launcher
-
-      # This same check happens conditionally when running through the command. For invoking the CLI directly, it's
-      # important that we ensure the Bundler version is set to avoid restarts
+      # Set the specific Bundler version used by the main app. This avoids issues with Bundler restarts, which clean the
+      # environment and lead to the `ruby-lsp` executable not being found
       if @bundler_version
         env["BUNDLER_VERSION"] = @bundler_version.to_s
         install_bundler_if_needed
       end
 
+      return run_bundle_install_through_command(env) unless @launcher
+
       begin
         run_bundle_install_directly(env)
         # If no error occurred, then clear previous errors
@@ -235,12 +241,16 @@ module RubyLsp
       env
     end
 
-    sig { params(env: T::Hash[String, String]).returns(T::Hash[String, String]) }
-    def run_bundle_install_directly(env)
+    sig { params(env: T::Hash[String, String], force_install: T::Boolean).returns(T::Hash[String, String]) }
+    def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
+
+      # The ENV can only be merged after checking if an update is required because we depend on the original value of
+      # ENV["BUNDLE_GEMFILE"], which gets overridden after the merge
+      should_update = should_bundle_update?
       T.unsafe(ENV).merge!(env)
 
-      unless should_bundle_update?
+      unless should_update && !force_install
         Bundler::CLI::Install.new({}).run
         correct_relative_remote_paths if @custom_lockfile.exist?
         return env
@@ -255,12 +265,13 @@ module RubyLsp
       correct_relative_remote_paths if @custom_lockfile.exist?
       @last_updated_path.write(Time.now.iso8601)
       env
+    rescue Bundler::GemNotFound, Bundler::GitError
+      # If a gem is not installed, skip the upgrade and try to install it with a single retry
+      @retry ? env : run_bundle_install_directly(env, force_install: true)
     end
 
     sig { params(env: T::Hash[String, String]).returns(T::Hash[String, String]) }
     def run_bundle_install_through_command(env)
-      base_bundle = base_bundle_command(env)
-
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
       # to upgrade them or else we'll produce undesired source control changes. If the composed bundle was just created
       # and any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
@@ -269,13 +280,20 @@ module RubyLsp
 
       # When not updating, we run `(bundle check || bundle install)`
       # When updating, we run `((bundle check && bundle update ruby-lsp debug) || bundle install)`
-      command = +"(#{base_bundle} check"
+      bundler_path = File.join(Gem.default_bindir, "bundle")
+      base_command = (File.exist?(bundler_path) ? "#{Gem.ruby} #{bundler_path}" : "bundle").dup
+
+      if env["BUNDLER_VERSION"]
+        base_command << " _#{env["BUNDLER_VERSION"]}_"
+      end
+
+      command = +"(#{base_command} check"
 
       if should_bundle_update?
         # If any of `ruby-lsp`, `ruby-lsp-rails` or `debug` are not in the Gemfile, try to update them to the latest
         # version
         command.prepend("(")
-        command << " && #{base_bundle} update "
+        command << " && #{base_command} update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
@@ -285,7 +303,7 @@ module RubyLsp
         @last_updated_path.write(Time.now.iso8601)
       end
 
-      command << " || #{base_bundle} install) "
+      command << " || #{base_command} install) "
 
       # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
       # responses
@@ -395,34 +413,6 @@ module RubyLsp
       /class .* < (::)?Rails::Application/.match?(application_contents)
     end
 
-    # Returns the base bundle command we should use for this project, which will be:
-    # - `bundle` if there's no locked Bundler version and no `bin/bundle` binstub in the $PATH
-    # - `bundle _<version>_` if there's a locked Bundler version
-    # - `bin/bundle` if there's a `bin/bundle` binstub in the $PATH
-    sig { params(env: T::Hash[String, String]).returns(String) }
-    def base_bundle_command(env)
-      path_parts = if Gem.win_platform?
-        ENV["Path"] || ENV["PATH"] || ENV["path"] || ""
-      else
-        ENV["PATH"] || ""
-      end.split(File::PATH_SEPARATOR)
-
-      bin_dir = File.expand_path("bin", @project_path)
-      bundle_binstub = File.join(@project_path, "bin", "bundle")
-
-      if File.exist?(bundle_binstub) && path_parts.any? { |path| File.expand_path(path, @project_path) == bin_dir }
-        return bundle_binstub
-      end
-
-      if @bundler_version
-        env["BUNDLER_VERSION"] = @bundler_version.to_s
-        install_bundler_if_needed
-        return "bundle _#{@bundler_version}_"
-      end
-
-      "bundle"
-    end
-
     sig { void }
     def patch_thor_to_print_progress_to_stderr!
       return unless defined?(Bundler::Thor::Shell::Basic)

data/lib/ruby_lsp/test_helper.rb

@@ -1,11 +1,16 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 # NOTE: This module is intended to be used by addons for writing their own tests, so keep that in mind if changing.
 
 module RubyLsp
   module TestHelper
+    class TestError < StandardError; end
+
     extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Kernel }
 
     sig do
       type_parameters(:T)
@@ -36,20 +41,49 @@ module RubyLsp
             },
           },
         })
+
+        server.global_state.index.index_single(uri, source)
       end
 
-      server.global_state.index.index_single(
-        RubyIndexer::IndexablePath.new(nil, T.must(uri.to_standardized_path)),
-        source,
-      )
       server.load_addons(include_project_addons: false) if load_addons
-      block.call(server, uri)
-    ensure
-      if load_addons
-        RubyLsp::Addon.addons.each(&:deactivate)
-        RubyLsp::Addon.addons.clear
+
+      begin
+        block.call(server, uri)
+      ensure
+        if load_addons
+          RubyLsp::Addon.addons.each(&:deactivate)
+          RubyLsp::Addon.addons.clear
+        end
+        server.run_shutdown
+      end
+    end
+
+    sig { params(server: RubyLsp::Server).returns(RubyLsp::Result) }
+    def pop_result(server)
+      result = server.pop_response
+      result = server.pop_response until result.is_a?(RubyLsp::Result) || result.is_a?(RubyLsp::Error)
+
+      if result.is_a?(RubyLsp::Error)
+        raise TestError, "Failed to execute request #{result.message}"
+      else
+        result
       end
-      T.must(server).run_shutdown
+    end
+
+    def pop_log_notification(message_queue, type)
+      log = message_queue.pop
+      return log if log.params.type == type
+
+      log = message_queue.pop until log.params.type == type
+      log
+    end
+
+    def pop_message(outgoing_queue, &block)
+      message = outgoing_queue.pop
+      return message if block.call(message)
+
+      message = outgoing_queue.pop until block.call(message)
+      message
     end
   end
 end

data/lib/ruby_lsp/type_inferrer.rb

@@ -23,6 +23,9 @@ module RubyLsp
         Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
         Prism::SuperNode, Prism::ForwardingSuperNode
         self_receiver_handling(node_context)
+      when Prism::ClassVariableAndWriteNode, Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode,
+        Prism::ClassVariableOrWriteNode, Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
+        infer_receiver_for_class_variables(node_context)
       end
     end
 
@@ -143,6 +146,25 @@ module RubyLsp
       nil
     end
 
+    sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
+    def infer_receiver_for_class_variables(node_context)
+      nesting_parts = node_context.nesting.dup
+
+      return Type.new("Object") if nesting_parts.empty?
+
+      nesting_parts.reverse_each do |part|
+        break unless part.include?("<Class:")
+
+        nesting_parts.pop
+      end
+
+      receiver_name = nesting_parts.join("::")
+      resolved_receiver = @index.resolve(receiver_name, node_context.nesting)&.first
+      return unless resolved_receiver&.name
+
+      Type.new(resolved_receiver.name)
+    end
+
     # A known type
     class Type
       extend T::Sig

data/lib/ruby_lsp/utils.rb

@@ -173,6 +173,9 @@ module RubyLsp
     sig { returns(String) }
     attr_reader :message
 
+    sig { returns(Integer) }
+    attr_reader :code
+
     sig { params(id: Integer, code: Integer, message: String, data: T.nilable(T::Hash[Symbol, T.untyped])).void }
     def initialize(id:, code:, message:, data: nil)
       @id = id

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.22.1
+  version: 0.23.0
 platform: ruby
 authors:
 - Shopify
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-22 00:00:00.000000000 Z
+date: 2025-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -94,7 +93,6 @@ files:
 - exe/ruby-lsp
 - exe/ruby-lsp-check
 - exe/ruby-lsp-launcher
-- lib/core_ext/uri.rb
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
 - lib/ruby-lsp.rb
@@ -103,12 +101,13 @@ files:
 - lib/ruby_indexer/lib/ruby_indexer/enhancement.rb
 - lib/ruby_indexer/lib/ruby_indexer/entry.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
-- lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
 - lib/ruby_indexer/lib/ruby_indexer/location.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
 - lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb
 - lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb
+- lib/ruby_indexer/lib/ruby_indexer/uri.rb
 - lib/ruby_indexer/ruby_indexer.rb
+- lib/ruby_indexer/test/class_variables_test.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
 - lib/ruby_indexer/test/configuration_test.rb
 - lib/ruby_indexer/test/constant_test.rb
@@ -121,6 +120,7 @@ files:
 - lib/ruby_indexer/test/rbs_indexer_test.rb
 - lib/ruby_indexer/test/reference_finder_test.rb
 - lib/ruby_indexer/test/test_case.rb
+- lib/ruby_indexer/test/uri_test.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
 - lib/ruby_lsp/client_capabilities.rb
@@ -157,6 +157,7 @@ files:
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
+- lib/ruby_lsp/requests/prepare_rename.rb
 - lib/ruby_lsp/requests/prepare_type_hierarchy.rb
 - lib/ruby_lsp/requests/range_formatting.rb
 - lib/ruby_lsp/requests/references.rb
@@ -202,7 +203,6 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   documentation_uri: https://shopify.github.io/ruby-lsp/
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -217,8 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []

data/lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb

@@ -1,29 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyIndexer
-  class IndexablePath
-    extend T::Sig
-
-    sig { returns(T.nilable(String)) }
-    attr_reader :require_path
-
-    sig { returns(String) }
-    attr_reader :full_path
-
-    # An IndexablePath is instantiated with a load_path_entry and a full_path. The load_path_entry is where the file can
-    # be found in the $LOAD_PATH, which we use to determine the require_path. The load_path_entry may be `nil` if the
-    # indexer is configured to go through files that do not belong in the $LOAD_PATH. For example,
-    # `sorbet/tapioca/require.rb` ends up being a part of the paths to be indexed because it's a Ruby file inside the
-    # project, but the `sorbet` folder is not a part of the $LOAD_PATH. That means that both its load_path_entry and
-    # require_path will be `nil`, since it cannot be required by the project
-    sig { params(load_path_entry: T.nilable(String), full_path: String).void }
-    def initialize(load_path_entry, full_path)
-      @full_path = full_path
-      @require_path = T.let(
-        load_path_entry ? full_path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb") : nil,
-        T.nilable(String),
-      )
-    end
-  end
-end