ruby-lsp 0.22.1 → 0.23.10

data/lib/ruby_lsp/setup_bundler.rb

@@ -57,6 +57,7 @@ module RubyLsp
       @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
       @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
       @error_path = T.let(@custom_dir + "install_error", Pathname)
+      @already_composed_path = T.let(@custom_dir + "bundle_is_composed", Pathname)
 
       dependencies, bundler_version = load_dependencies
       @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
@@ -71,6 +72,23 @@ module RubyLsp
     def setup!
       raise BundleNotLocked if !@launcher && @gemfile&.exist? && !@lockfile&.exist?
 
+      # If the bundle was composed ahead of time using our custom `rubyLsp/composeBundle` request, then we can skip the
+      # entire process and just return the composed environment
+      if @already_composed_path.exist?
+        $stderr.puts("Ruby LSP> Composed bundle was set up ahead of time. Skipping...")
+        @already_composed_path.delete
+
+        env = bundler_settings_as_env
+        env["BUNDLE_GEMFILE"] = @custom_gemfile.exist? ? @custom_gemfile.to_s : @gemfile.to_s
+
+        if env["BUNDLE_PATH"]
+          env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
+        end
+
+        env["BUNDLER_VERSION"] = @bundler_version.to_s if @bundler_version
+        return env
+      end
+
       # Automatically create and ignore the .ruby-lsp folder for users
       @custom_dir.mkpath unless @custom_dir.exist?
       ignore_file = @custom_dir + ".gitignore"
@@ -152,7 +170,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 +220,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
@@ -217,8 +241,7 @@ module RubyLsp
 
       # If either the Gemfile or the lockfile have been modified during the process of setting up the bundle, retry
       # composing the bundle from scratch
-
-      if @gemfile && @lockfile
+      if @gemfile&.exist? && @lockfile&.exist?
         current_gemfile_hash = Digest::SHA256.hexdigest(@gemfile.read)
         current_lockfile_hash = Digest::SHA256.hexdigest(@lockfile.read)
 
@@ -235,12 +258,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 +282,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 +297,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 = (!Gem.win_platform? && 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 +320,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 +430,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/store.rb

@@ -13,8 +13,9 @@ module RubyLsp
     sig { returns(String) }
     attr_accessor :client_name
 
-    sig { void }
-    def initialize
+    sig { params(global_state: GlobalState).void }
+    def initialize(global_state)
+      @global_state = global_state
       @state = T.let({}, T::Hash[String, Document[T.untyped]])
       @features_configuration = T.let(
         {
@@ -61,17 +62,16 @@ module RubyLsp
         source: String,
         version: Integer,
         language_id: Document::LanguageId,
-        encoding: Encoding,
       ).returns(Document[T.untyped])
     end
-    def set(uri:, source:, version:, language_id:, encoding: Encoding::UTF_8)
+    def set(uri:, source:, version:, language_id:)
       @state[uri.to_s] = case language_id
       when Document::LanguageId::ERB
-        ERBDocument.new(source: source, version: version, uri: uri, encoding: encoding)
+        ERBDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
       when Document::LanguageId::RBS
-        RBSDocument.new(source: source, version: version, uri: uri, encoding: encoding)
+        RBSDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
       else
-        RubyDocument.new(source: source, version: version, uri: uri, encoding: encoding)
+        RubyDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
       end
     end
 

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
 
@@ -77,7 +80,7 @@ module RubyLsp
         # When the receiver is a constant reference, we have to try to resolve it to figure out the right
         # receiver. But since the invocation is directly on the constant, that's the singleton context of that
         # class/module
-        receiver_name = constant_name(receiver)
+        receiver_name = RubyIndexer::Index.constant_name(receiver)
         return unless receiver_name
 
         resolved_receiver = @index.resolve(receiver_name, node_context.nesting)
@@ -88,29 +91,45 @@ module RubyLsp
         return Type.new("#{last}::<Class:#{last}>") if parts.empty?
 
         Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
-      else
+      when Prism::CallNode
+        raw_receiver = receiver.message
 
-        raw_receiver = if receiver.is_a?(Prism::CallNode)
-          receiver.message
-        else
-          receiver.slice
-        end
+        if raw_receiver == "new"
+          # When invoking `new`, we recursively infer the type of the receiver to get the class type its being invoked
+          # on and then return the attached version of that type, since it's being instantiated.
+          type = infer_receiver_for_call_node(receiver, node_context)
+
+          return unless type
+
+          # If the method `new` was overridden, then we cannot assume that it will return a new instance of the class
+          new_method = @index.resolve_method("new", type.name)&.first
+          return if new_method && new_method.owner&.name != "Class"
 
-        if raw_receiver
-          guessed_name = raw_receiver
-            .delete_prefix("@")
-            .delete_prefix("@@")
-            .split("_")
-            .map(&:capitalize)
-            .join
-
-          entries = @index.resolve(guessed_name, node_context.nesting) || @index.first_unqualified_const(guessed_name)
-          name = entries&.first&.name
-          GuessedType.new(name) if name
+          type.attached
+        elsif raw_receiver
+          guess_type(raw_receiver, node_context.nesting)
         end
+      else
+        guess_type(receiver.slice, node_context.nesting)
       end
     end
 
+    sig { params(raw_receiver: String, nesting: T::Array[String]).returns(T.nilable(GuessedType)) }
+    def guess_type(raw_receiver, nesting)
+      guessed_name = raw_receiver
+        .delete_prefix("@")
+        .delete_prefix("@@")
+        .split("_")
+        .map(&:capitalize)
+        .join
+
+      entries = @index.resolve(guessed_name, nesting) || @index.first_unqualified_const(guessed_name)
+      name = entries&.first&.name
+      return unless name
+
+      GuessedType.new(name)
+    end
+
     sig { params(node_context: NodeContext).returns(Type) }
     def self_receiver_handling(node_context)
       nesting = node_context.nesting
@@ -128,19 +147,23 @@ module RubyLsp
       Type.new("#{parts.join("::")}::<Class:#{parts.last}>")
     end
 
-    sig do
-      params(
-        node: T.any(
-          Prism::ConstantPathNode,
-          Prism::ConstantReadNode,
-        ),
-      ).returns(T.nilable(String))
-    end
-    def constant_name(node)
-      node.full_name
-    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
-           Prism::ConstantPathNode::MissingNodesInConstantPathError
-      nil
+    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
@@ -154,6 +177,12 @@ module RubyLsp
       def initialize(name)
         @name = name
       end
+
+      # Returns the attached version of this type by removing the `<Class:...>` part from its name
+      sig { returns(Type) }
+      def attached
+        Type.new(T.must(@name.split("::")[..-2]).join("::"))
+      end
     end
 
     # A type that was guessed based on the receiver raw name

data/lib/ruby_lsp/utils.rb

@@ -25,7 +25,7 @@ module RubyLsp
     end,
     String,
   )
-  GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/design-and-roadmap.html#guessed-types"
+  GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/#guessed-types"
 
   # Request delegation for embedded languages is not yet standardized into the language server specification. Here we
   # use this custom error class as a way to return a signal to the client that the request should be delegated to the
@@ -37,6 +37,8 @@ module RubyLsp
     CODE = -32900
   end
 
+  BUNDLE_COMPOSE_FAILED_CODE = -33000
+
   # A notification to be sent to the client
   class Message
     extend T::Sig
@@ -142,19 +144,72 @@ module RubyLsp
           ),
         )
       end
+
+      sig do
+        params(
+          uri: String,
+          diagnostics: T::Array[Interface::Diagnostic],
+          version: T.nilable(Integer),
+        ).returns(Notification)
+      end
+      def publish_diagnostics(uri, diagnostics, version: nil)
+        new(
+          method: "textDocument/publishDiagnostics",
+          params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: diagnostics, version: version),
+        )
+      end
     end
 
     extend T::Sig
 
     sig { override.returns(T::Hash[Symbol, T.untyped]) }
     def to_hash
-      { method: @method, params: T.unsafe(@params).to_hash }
+      hash = { method: @method }
+      hash[:params] = T.unsafe(@params).to_hash if @params
+      hash
     end
   end
 
   class Request < Message
     extend T::Sig
 
+    class << self
+      extend T::Sig
+
+      sig do
+        params(
+          id: Integer,
+          pattern: T.any(Interface::RelativePattern, String),
+          kind: Integer,
+          registration_id: T.nilable(String),
+        ).returns(Request)
+      end
+      def register_watched_files(
+        id,
+        pattern,
+        kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
+        registration_id: nil
+      )
+        new(
+          id: id,
+          method: "client/registerCapability",
+          params: Interface::RegistrationParams.new(
+            registrations: [
+              Interface::Registration.new(
+                id: registration_id || SecureRandom.uuid,
+                method: "workspace/didChangeWatchedFiles",
+                register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
+                  watchers: [
+                    Interface::FileSystemWatcher.new(glob_pattern: pattern, kind: kind),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        )
+      end
+    end
+
     sig { params(id: T.any(Integer, String), method: String, params: Object).void }
     def initialize(id:, method:, params:)
       @id = id
@@ -163,7 +218,9 @@ module RubyLsp
 
     sig { override.returns(T::Hash[Symbol, T.untyped]) }
     def to_hash
-      { id: @id, method: @method, params: T.unsafe(@params).to_hash }
+      hash = { id: @id, method: @method }
+      hash[:params] = T.unsafe(@params).to_hash if @params
+      hash
     end
   end
 
@@ -173,6 +230,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.10
 platform: ruby
 authors:
 - Shopify
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-22 00:00:00.000000000 Z
+date: 2025-02-10 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,14 @@ 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/lib/ruby_indexer/visibility_scope.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 +121,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 +158,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 +204,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 +218,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.3
 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