ruby-lsp 0.23.1 → 0.23.5

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))
@@ -357,7 +339,7 @@ module RubyLsp
         if defined?(Requests::Support::RuboCopFormatter)
           begin
             @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
-          rescue RuboCop::Error => e
+          rescue ::RuboCop::Error => e
             # The user may have provided unknown config switches in .rubocop or
             # is trying to load a non-existent config file.
             send_message(Notification.window_show_message(
@@ -377,7 +359,7 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_did_open(message)
-      @mutex.synchronize do
+      @global_state.synchronize do
         text_document = message.dig(:params, :textDocument)
         language_id = case text_document[:languageId]
         when "erb", "eruby"
@@ -392,7 +374,6 @@ module RubyLsp
           uri: text_document[:uri],
           source: text_document[:text],
           version: text_document[:version],
-          encoding: @global_state.encoding,
           language_id: language_id,
         )
 
@@ -417,17 +398,12 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_did_close(message)
-      @mutex.synchronize do
+      @global_state.synchronize do
         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: []),
-          ),
-        )
+        send_message(Notification.publish_diagnostics(uri.to_s, []))
       end
     end
 
@@ -436,7 +412,7 @@ module RubyLsp
       params = message[:params]
       text_document = params[:textDocument]
 
-      @mutex.synchronize do
+      @global_state.synchronize do
         @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
       end
     end
@@ -493,7 +469,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 +1002,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(
@@ -1240,10 +1260,10 @@ module RubyLsp
         return
       end
 
-      return unless indexing_options
-
       configuration = @global_state.index.configuration
       configuration.workspace_path = @global_state.workspace_path
+      return unless indexing_options
+
       # The index expects snake case configurations, but VS Code standardizes on camel case settings
       configuration.apply_config(indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase })
     end

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/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

data/lib/ruby_lsp/utils.rb

@@ -142,6 +142,20 @@ 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
@@ -155,6 +169,35 @@ module RubyLsp
   class Request < Message
     extend T::Sig
 
+    class << self
+      extend T::Sig
+
+      sig { params(id: Integer, pattern: T.any(Interface::RelativePattern, String), kind: Integer).returns(Request) }
+      def register_watched_files(
+        id,
+        pattern,
+        kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE
+      )
+        new(
+          id: id,
+          method: "client/registerCapability",
+          params: Interface::RegistrationParams.new(
+            registrations: [
+              Interface::Registration.new(
+                id: "workspace/didChangeWatchedFiles",
+                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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.1
+  version: 0.23.5
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-06 00:00:00.000000000 Z
+date: 2025-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -106,6 +106,7 @@ files:
 - 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