ruby-lsp 0.23.1 → 0.23.2

data/lib/ruby_lsp/erb_document.rb

@@ -19,8 +19,8 @@ module RubyLsp
     end
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
       # This has to be initialized before calling super because we call `parse` in the parent constructor, which
       # overrides this with the proper virtual host language source
       @host_language_source = T.let("", String)
@@ -63,9 +63,11 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
+      char_position, _ = find_index_by_position(position)
+
       RubyDocument.locate(
         @parse_result.value,
-        create_scanner.find_char_position(position),
+        char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,
       )

data/lib/ruby_lsp/global_state.rb

@@ -29,6 +29,9 @@ module RubyLsp
     sig { returns(ClientCapabilities) }
     attr_reader :client_capabilities
 
+    sig { returns(URI::Generic) }
+    attr_reader :workspace_uri
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
@@ -53,6 +56,12 @@ module RubyLsp
       )
       @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
       @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
+      @mutex = T.let(Mutex.new, Mutex)
+    end
+
+    sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def synchronize(&block)
+      @mutex.synchronize(&block)
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }

data/lib/ruby_lsp/rbs_document.rb

@@ -8,8 +8,8 @@ module RubyLsp
 
     ParseResultType = type_member { { fixed: T::Array[RBS::AST::Declarations::Base] } }
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
       @syntax_error = T.let(false, T::Boolean)
       super
     end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -92,9 +92,7 @@ module RubyLsp
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
-        scanner = @document.create_scanner
-        start_index = scanner.find_char_position(source_range[:start])
-        end_index = scanner.find_char_position(source_range[:end])
+        start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest statements node, so that we place the refactor in a valid position
@@ -192,9 +190,7 @@ module RubyLsp
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
-        scanner = @document.create_scanner
-        start_index = scanner.find_char_position(source_range[:start])
-        end_index = scanner.find_char_position(source_range[:end])
+        start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position

data/lib/ruby_lsp/requests/completion.rb

@@ -40,7 +40,8 @@ module RubyLsp
         @dispatcher = dispatcher
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
-        char_position = document.create_scanner.find_char_position(params[:position]) - 1
+        char_position, _ = document.find_index_by_position(params[:position])
+        char_position -= 1
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/definition.rb

@@ -29,7 +29,7 @@ module RubyLsp
         )
         @dispatcher = dispatcher
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -25,7 +25,7 @@ module RubyLsp
       end
       def initialize(global_state, document, position, dispatcher)
         super()
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/hover.rb

@@ -34,7 +34,7 @@ module RubyLsp
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/prepare_rename.rb

@@ -24,7 +24,7 @@ module RubyLsp
 
       sig { override.returns(T.nilable(Interface::Range)) }
       def perform
-        char_position = @document.create_scanner.find_char_position(@position)
+        char_position, _ = @document.find_index_by_position(@position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,

data/lib/ruby_lsp/requests/references.rb

@@ -30,7 +30,7 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::Location]) }
       def perform
         position = @params[:position]
-        char_position = @document.create_scanner.find_char_position(position)
+        char_position, _ = @document.find_index_by_position(position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,

data/lib/ruby_lsp/requests/rename.rb

@@ -40,7 +40,7 @@ module RubyLsp
 
       sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
       def perform
-        char_position = @document.create_scanner.find_char_position(@position)
+        char_position, _ = @document.find_index_by_position(@position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -31,10 +31,7 @@ module RubyLsp
       sig { returns(String) }
       def ast_for_range
         range = T.must(@range)
-
-        scanner = @document.create_scanner
-        start_char = scanner.find_char_position(range[:start])
-        end_char = scanner.find_char_position(range[:end])
+        start_char, end_char = @document.find_index_by_position(range[:start], range[:end])
 
         queue = @tree.statements.body.dup
         found_nodes = []

data/lib/ruby_lsp/requests/signature_help.rb

@@ -36,7 +36,7 @@ module RubyLsp
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/ruby_document.rb

@@ -8,6 +8,22 @@ module RubyLsp
 
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
 
+    METHODS_THAT_CHANGE_DECLARATIONS = [
+      :private_constant,
+      :attr_reader,
+      :attr_writer,
+      :attr_accessor,
+      :alias_method,
+      :include,
+      :prepend,
+      :extend,
+      :public,
+      :protected,
+      :private,
+      :module_function,
+      :private_class_method,
+    ].freeze
+
     class SorbetLevel < T::Enum
       enums do
         None = new("none")
@@ -142,8 +158,8 @@ module RubyLsp
     end
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
       super
       @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
         T.proc.params(arg0: Integer).returns(Integer),
@@ -198,9 +214,8 @@ module RubyLsp
       ).returns(T.nilable(Prism::Node))
     end
     def locate_first_within_range(range, node_types: [])
-      scanner = create_scanner
-      start_position = scanner.find_char_position(range[:start])
-      end_position = scanner.find_char_position(range[:end])
+      start_position, end_position = find_index_by_position(range[:start], range[:end])
+
       desired_range = (start_position...end_position)
       queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
 
@@ -232,12 +247,66 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
+      char_position, _ = find_index_by_position(position)
+
       RubyDocument.locate(
         @parse_result.value,
-        create_scanner.find_char_position(position),
+        char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,
       )
     end
+
+    sig { returns(T::Boolean) }
+    def last_edit_may_change_declarations?
+      # This method controls when we should index documents. If there's no recent edit and the document has just been
+      # opened, we need to index it
+      return true unless @last_edit
+
+      case @last_edit
+      when Delete
+        # Not optimized yet. It's not trivial to identify that a declaration has been removed since the source is no
+        # longer there and we don't remember the deleted text
+        true
+      when Insert, Replace
+        position_may_impact_declarations?(@last_edit.range[:start])
+      else
+        false
+      end
+    end
+
+    private
+
+    sig { params(position: T::Hash[Symbol, Integer]).returns(T::Boolean) }
+    def position_may_impact_declarations?(position)
+      node_context = locate_node(position)
+      node_at_edit = node_context.node
+
+      # Adjust to the parent when editing the constant of a class/module declaration
+      if node_at_edit.is_a?(Prism::ConstantReadNode) || node_at_edit.is_a?(Prism::ConstantPathNode)
+        node_at_edit = node_context.parent
+      end
+
+      case node_at_edit
+      when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode,
+          Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
+          Prism::ConstantPathAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantWriteNode,
+          Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode,
+          Prism::GlobalVariableWriteNode, Prism::InstanceVariableWriteNode, Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableTargetNode, Prism::AliasMethodNode
+        true
+      when Prism::MultiWriteNode
+        [*node_at_edit.lefts, *node_at_edit.rest, *node_at_edit.rights].any? do |node|
+          node.is_a?(Prism::ConstantTargetNode) || node.is_a?(Prism::ConstantPathTargetNode)
+        end
+      when Prism::CallNode
+        receiver = node_at_edit.receiver
+        (!receiver || receiver.is_a?(Prism::SelfNode)) && METHODS_THAT_CHANGE_DECLARATIONS.include?(node_at_edit.name)
+      else
+        false
+      end
+    end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -107,7 +107,7 @@ module RubyLsp
           ),
         )
       when "$/cancelRequest"
-        @mutex.synchronize { @cancelled_requests << message[:params][:id] }
+        @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
         process_response(message) if message[:result]
       end
@@ -298,29 +298,11 @@ module RubyLsp
 
       # Not every client supports dynamic registration or file watching
       if @global_state.client_capabilities.supports_watching_files
-        send_message(
-          Request.new(
-            id: @current_request_id,
-            method: "client/registerCapability",
-            params: Interface::RegistrationParams.new(
-              registrations: [
-                # Register watching Ruby files
-                Interface::Registration.new(
-                  id: "workspace/didChangeWatchedFiles",
-                  method: "workspace/didChangeWatchedFiles",
-                  register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
-                    watchers: [
-                      Interface::FileSystemWatcher.new(
-                        glob_pattern: "**/*.rb",
-                        kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
-                      ),
-                    ],
-                  ),
-                ),
-              ],
-            ),
-          ),
-        )
+        send_message(Request.register_watched_files(@current_request_id, "**/*.rb"))
+        send_message(Request.register_watched_files(
+          @current_request_id,
+          Interface::RelativePattern.new(base_uri: @global_state.workspace_uri.to_s, pattern: ".rubocop.yml"),
+        ))
       end
 
       process_indexing_configuration(options.dig(:initializationOptions, :indexing))
@@ -377,58 +359,48 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_did_open(message)
-      @mutex.synchronize do
-        text_document = message.dig(:params, :textDocument)
-        language_id = case text_document[:languageId]
-        when "erb", "eruby"
-          Document::LanguageId::ERB
-        when "rbs"
-          Document::LanguageId::RBS
-        else
-          Document::LanguageId::Ruby
-        end
+      text_document = message.dig(:params, :textDocument)
+      language_id = case text_document[:languageId]
+      when "erb", "eruby"
+        Document::LanguageId::ERB
+      when "rbs"
+        Document::LanguageId::RBS
+      else
+        Document::LanguageId::Ruby
+      end
 
-        document = @store.set(
-          uri: text_document[:uri],
-          source: text_document[:text],
-          version: text_document[:version],
-          encoding: @global_state.encoding,
-          language_id: language_id,
-        )
+      document = @store.set(
+        uri: text_document[:uri],
+        source: text_document[:text],
+        version: text_document[:version],
+        language_id: language_id,
+      )
 
-        if document.past_expensive_limit? && text_document[:uri].scheme == "file"
-          log_message = <<~MESSAGE
-            The file #{text_document[:uri].path} is too long. For performance reasons, semantic highlighting and
-            diagnostics will be disabled.
-          MESSAGE
+      if document.past_expensive_limit? && text_document[:uri].scheme == "file"
+        log_message = <<~MESSAGE
+          The file #{text_document[:uri].path} is too long. For performance reasons, semantic highlighting and
+          diagnostics will be disabled.
+        MESSAGE
 
-          send_message(
-            Notification.new(
-              method: "window/logMessage",
-              params: Interface::LogMessageParams.new(
-                type: Constant::MessageType::WARNING,
-                message: log_message,
-              ),
+        send_message(
+          Notification.new(
+            method: "window/logMessage",
+            params: Interface::LogMessageParams.new(
+              type: Constant::MessageType::WARNING,
+              message: log_message,
             ),
-          )
-        end
+          ),
+        )
       end
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_did_close(message)
-      @mutex.synchronize do
-        uri = message.dig(:params, :textDocument, :uri)
-        @store.delete(uri)
+      uri = message.dig(:params, :textDocument, :uri)
+      @store.delete(uri)
 
-        # Clear diagnostics for the closed file, so that they no longer appear in the problems tab
-        send_message(
-          Notification.new(
-            method: "textDocument/publishDiagnostics",
-            params: Interface::PublishDiagnosticsParams.new(uri: uri.to_s, diagnostics: []),
-          ),
-        )
-      end
+      # Clear diagnostics for the closed file, so that they no longer appear in the problems tab
+      send_message(Notification.publish_diagnostics(uri.to_s, []))
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -436,9 +408,7 @@ module RubyLsp
       params = message[:params]
       text_document = params[:textDocument]
 
-      @mutex.synchronize do
-        @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
-      end
+      @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -493,7 +463,22 @@ module RubyLsp
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
       inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
-      dispatcher.dispatch(parse_result.value)
+
+      if document.is_a?(RubyDocument) && document.last_edit_may_change_declarations?
+        # Re-index the file as it is modified. This mode of indexing updates entries only. Require path trees are only
+        # updated on save
+        @global_state.synchronize do
+          send_log_message("Detected that last edit may have modified declarations. Re-indexing #{uri}")
+
+          @global_state.index.handle_change(uri) do |index|
+            index.delete(uri, skip_require_paths_tree: true)
+            RubyIndexer::DeclarationListener.new(index, dispatcher, parse_result, uri, collect_comments: true)
+            dispatcher.dispatch(parse_result.value)
+          end
+        end
+      else
+        dispatcher.dispatch(parse_result.value)
+      end
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
       # we actually received
@@ -1011,26 +996,55 @@ module RubyLsp
         uri = URI(change[:uri])
         file_path = uri.to_standardized_path
         next if file_path.nil? || File.directory?(file_path)
-        next unless file_path.end_with?(".rb")
 
-        load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
-        uri.add_require_path_from_load_entry(load_path_entry) if load_path_entry
+        if file_path.end_with?(".rb")
+          handle_ruby_file_change(index, file_path, change[:type])
+          next
+        end
 
-        content = File.read(file_path)
+        file_name = File.basename(file_path)
 
-        case change[:type]
-        when Constant::FileChangeType::CREATED
-          index.index_single(uri, content)
-        when Constant::FileChangeType::CHANGED
-          index.handle_change(uri, content)
-        when Constant::FileChangeType::DELETED
-          index.delete(uri)
+        if file_name == ".rubocop.yml" || file_name == ".rubocop"
+          handle_rubocop_config_change(uri)
         end
       end
 
       Addon.file_watcher_addons.each { |addon| T.unsafe(addon).workspace_did_change_watched_files(changes) }
     end
 
+    sig { params(index: RubyIndexer::Index, file_path: String, change_type: Integer).void }
+    def handle_ruby_file_change(index, file_path, change_type)
+      load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
+      uri = URI::Generic.from_path(load_path_entry: load_path_entry, path: file_path)
+
+      content = File.read(file_path)
+
+      case change_type
+      when Constant::FileChangeType::CREATED
+        index.index_single(uri, content)
+      when Constant::FileChangeType::CHANGED
+        index.handle_change(uri, content)
+      when Constant::FileChangeType::DELETED
+        index.delete(uri)
+      end
+    end
+
+    sig { params(uri: URI::Generic).void }
+    def handle_rubocop_config_change(uri)
+      return unless defined?(Requests::Support::RuboCopFormatter)
+
+      send_log_message("Reloading RuboCop since #{uri} changed")
+      @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
+
+      # Clear all existing diagnostics since the config changed. This has to happen under a mutex because the `state`
+      # hash cannot be mutated during iteration or that will throw an error
+      @global_state.synchronize do
+        @store.each do |uri, _document|
+          send_message(Notification.publish_diagnostics(uri.to_s, []))
+        end
+      end
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_symbol(message)
       send_message(

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,18 @@ 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)
-      @state[uri.to_s] = case language_id
-      when Document::LanguageId::ERB
-        ERBDocument.new(source: source, version: version, uri: uri, encoding: encoding)
-      when Document::LanguageId::RBS
-        RBSDocument.new(source: source, version: version, uri: uri, encoding: encoding)
-      else
-        RubyDocument.new(source: source, version: version, uri: uri, encoding: encoding)
+    def set(uri:, source:, version:, language_id:)
+      @global_state.synchronize do
+        @state[uri.to_s] = case language_id
+        when Document::LanguageId::ERB
+          ERBDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
+        when Document::LanguageId::RBS
+          RBSDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
+        else
+          RubyDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
+        end
       end
     end
 
@@ -92,7 +94,9 @@ module RubyLsp
 
     sig { params(uri: URI::Generic).void }
     def delete(uri)
-      @state.delete(uri.to_s)
+      @global_state.synchronize do
+        @state.delete(uri.to_s)
+      end
     end
 
     sig { params(uri: URI::Generic).returns(T::Boolean) }

data/lib/ruby_lsp/type_inferrer.rb

@@ -91,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)
 
-        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
+          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"
+
+          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
@@ -176,6 +192,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