ruby-lsp 0.23.8 → 0.23.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 918079e906832b0289a053cd4bfe849422082c25bd0f4bdada25cab3a532005f
-  data.tar.gz: 7935b2bdc52a2bb83264376fb98f7ef8d3bfc3c5cb9dadd23642a1ebafbca013
+  metadata.gz: 3a0d78055f2f6bf861e581a5b5a2d1321d3a8452b23d638becb6e64da925d842
+  data.tar.gz: '0397aa5a123ed08757606db1be3690b50cba847a372f52da25fb64a6fb5816ce'
 SHA512:
-  metadata.gz: 9fb084d322308bb2e69c2c0d5cfed2d275fe53f5df40aa2a49a848aab4c771858dfa1b5d5df913516c1f1c90ce5101b2f461865093f5e6787c79886cadc40bdb
-  data.tar.gz: 06206026d180e9d044edda0a83018ae31895cce3e6d91cb9ae4bdb3c365565a27881dd17ffd6d8861d8126441e327cb8fdf91c41e6003c1d84a4038c8b9003ea
+  metadata.gz: a14d101646bd32467724aeedb60892c5c06e775a57d749623cc1e76dbc42ee6d82eca10e2fa1149900365eff59ee57c20300bb043a3fdcf1330961b6bbd94918
+  data.tar.gz: 23b339c5854620771e7b505381dad64cf3e8d89ed2850a19c7a299e72d2363202e1e74327c05d27d8fb7fae508abb7141e5a858319b2841c8c914233e28e076e

data/VERSION

@@ -1 +1 @@
-0.23.8
+0.23.10

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -91,7 +91,7 @@ module RubyIndexer
     def on_class_node_enter(node)
       constant_path = node.constant_path
       superclass = node.superclass
-      nesting = actual_nesting(constant_path.slice)
+      nesting = Index.actual_nesting(@stack, constant_path.slice)
 
       parent_class = case superclass
       when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -144,7 +144,7 @@ module RubyIndexer
       if current_owner
         expression = node.expression
         name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{last_name_in_stack}>" : "<Class:#{expression.slice}>")
-        real_nesting = actual_nesting(name)
+        real_nesting = Index.actual_nesting(@stack, name)
 
         existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
 
@@ -516,7 +516,7 @@ module RubyIndexer
       name_loc = Location.from_prism_location(name_location, @code_units_cache)
 
       entry = Entry::Module.new(
-        actual_nesting(name),
+        Index.actual_nesting(@stack, name),
         @uri,
         location,
         name_loc,
@@ -536,7 +536,7 @@ module RubyIndexer
       ).void
     end
     def add_class(name_or_nesting, full_location, name_location, parent_class_name: nil, comments: nil)
-      nesting = name_or_nesting.is_a?(Array) ? name_or_nesting : actual_nesting(name_or_nesting)
+      nesting = name_or_nesting.is_a?(Array) ? name_or_nesting : Index.actual_nesting(@stack, name_or_nesting)
       entry = Entry::Class.new(
         nesting,
         @uri,
@@ -1104,20 +1104,6 @@ module RubyIndexer
       end
     end
 
-    sig { params(name: String).returns(T::Array[String]) }
-    def actual_nesting(name)
-      nesting = @stack + [name]
-      corrected_nesting = []
-
-      nesting.reverse_each do |name|
-        corrected_nesting.prepend(name.delete_prefix("::"))
-
-        break if name.start_with?("::")
-      end
-
-      corrected_nesting
-    end
-
     sig { params(short_name: String, entry: Entry::Namespace).void }
     def advance_namespace_stack(short_name, entry)
       @visibility_stack.push(VisibilityScope.public_scope)

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -15,6 +15,45 @@ module RubyIndexer
     sig { returns(Configuration) }
     attr_reader :configuration
 
+    class << self
+      extend T::Sig
+
+      # Returns the real nesting of a constant name taking into account top level
+      # references that may be included anywhere in the name or nesting where that
+      # constant was found
+      sig { params(stack: T::Array[String], name: String).returns(T::Array[String]) }
+      def actual_nesting(stack, name)
+        nesting = stack + [name]
+        corrected_nesting = []
+
+        nesting.reverse_each do |name|
+          corrected_nesting.prepend(name.delete_prefix("::"))
+
+          break if name.start_with?("::")
+        end
+
+        corrected_nesting
+      end
+
+      # Returns the unresolved name for a constant reference including all parts of a constant path, or `nil` if the
+      # constant contains dynamic or incomplete parts
+      sig do
+        params(
+          node: T.any(
+            Prism::ConstantPathNode,
+            Prism::ConstantReadNode,
+            Prism::ConstantPathTargetNode,
+          ),
+        ).returns(T.nilable(String))
+      end
+      def constant_name(node)
+        node.full_name
+      rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+             Prism::ConstantPathNode::MissingNodesInConstantPathError
+        nil
+      end
+    end
+
     sig { void }
     def initialize
       # Holds all entries in the index using the following format:

data/lib/ruby_indexer/lib/ruby_indexer/location.rb

@@ -44,5 +44,17 @@ module RubyIndexer
       @start_column = start_column
       @end_column = end_column
     end
+
+    sig do
+      params(
+        other: T.any(Location, Prism::Location),
+      ).returns(T::Boolean)
+    end
+    def ==(other)
+      start_line == other.start_line &&
+        end_line == other.end_line &&
+        start_column == other.start_column &&
+        end_column == other.end_column
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -75,12 +75,14 @@ module RubyIndexer
         target: Target,
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
+        uri: URI::Generic,
         include_declarations: T::Boolean,
       ).void
     end
-    def initialize(target, index, dispatcher, include_declarations: true)
+    def initialize(target, index, dispatcher, uri, include_declarations: true)
       @target = target
       @index = index
+      @uri = uri
       @include_declarations = include_declarations
       @stack = T.let([], T::Array[String])
       @references = T.let([], T::Array[Reference])
@@ -126,15 +128,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
-      constant_path = node.constant_path
-      name = constant_path.slice
-      nesting = actual_nesting(name)
-
-      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
-        @references << Reference.new(name, constant_path.location, declaration: true)
-      end
-
-      @stack << name
+      @stack << node.constant_path.slice
     end
 
     sig { params(node: Prism::ClassNode).void }
@@ -144,15 +138,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ModuleNode).void }
     def on_module_node_enter(node)
-      constant_path = node.constant_path
-      name = constant_path.slice
-      nesting = actual_nesting(name)
-
-      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
-        @references << Reference.new(name, constant_path.location, declaration: true)
-      end
-
-      @stack << name
+      @stack << node.constant_path.slice
     end
 
     sig { params(node: Prism::ModuleNode).void }
@@ -175,7 +161,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ConstantPathNode).void }
     def on_constant_path_node_enter(node)
-      name = constant_name(node)
+      name = Index.constant_name(node)
       return unless name
 
       collect_constant_references(name, node.location)
@@ -183,7 +169,7 @@ module RubyIndexer
 
     sig { params(node: Prism::ConstantReadNode).void }
     def on_constant_read_node_enter(node)
-      name = constant_name(node)
+      name = Index.constant_name(node)
       return unless name
 
       collect_constant_references(name, node.location)
@@ -204,7 +190,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -215,7 +201,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -226,7 +212,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -237,7 +223,7 @@ module RubyIndexer
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
 
-      name = constant_name(target)
+      name = Index.constant_name(target)
       return unless name
 
       collect_constant_references(name, target.location)
@@ -320,20 +306,6 @@ module RubyIndexer
 
     private
 
-    sig { params(name: String).returns(T::Array[String]) }
-    def actual_nesting(name)
-      nesting = @stack + [name]
-      corrected_nesting = []
-
-      nesting.reverse_each do |name|
-        corrected_nesting.prepend(name.delete_prefix("::"))
-
-        break if name.start_with?("::")
-      end
-
-      corrected_nesting
-    end
-
     sig { params(name: String, location: Prism::Location).void }
     def collect_constant_references(name, location)
       return unless @target.is_a?(ConstTarget)
@@ -341,17 +313,26 @@ module RubyIndexer
       entries = @index.resolve(name, @stack)
       return unless entries
 
-      previous_reference = @references.last
-
-      entries.each do |entry|
-        next unless entry.name == @target.fully_qualified_name
+      # Filter down to all constant declarations that match the expected name and type
+      matching_entries = entries.select do |e|
+        [
+          Entry::Namespace,
+          Entry::Constant,
+          Entry::ConstantAlias,
+          Entry::UnresolvedConstantAlias,
+        ].any? { |klass| e.is_a?(klass) } &&
+          e.name == @target.fully_qualified_name
+      end
 
-        # When processing a class/module declaration, we eagerly handle the constant reference. To avoid duplicates,
-        # when we find the constant node defining the namespace, then we have to check if it wasn't already added
-        next if previous_reference&.location == location
+      return if matching_entries.empty?
 
-        @references << Reference.new(name, location, declaration: false)
+      # If any of the matching entries have the same location as the constant and were
+      # defined in the same file, then it is that constant's declaration
+      declaration = matching_entries.any? do |e|
+        e.uri == @uri && e.name_location == location
       end
+
+      @references << Reference.new(name, location, declaration: declaration)
     end
 
     sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
@@ -360,21 +341,5 @@ module RubyIndexer
 
       @references << Reference.new(name, location, declaration: declaration)
     end
-
-    sig do
-      params(
-        node: T.any(
-          Prism::ConstantPathNode,
-          Prism::ConstantReadNode,
-          Prism::ConstantPathTargetNode,
-        ),
-      ).returns(T.nilable(String))
-    end
-    def constant_name(node)
-      node.full_name
-    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
-           Prism::ConstantPathNode::MissingNodesInConstantPathError
-      nil
-    end
   end
 end

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -274,6 +274,30 @@ module RubyIndexer
       assert_equal(8, refs[1].location.start_line)
     end
 
+    def test_accounts_for_reopened_classes
+      refs = find_const_references("Foo", <<~RUBY)
+        class Foo
+        end
+        class Foo
+          class Bar
+          end
+        end
+
+        Foo.new
+      RUBY
+
+      assert_equal(3, refs.size)
+
+      assert_equal("Foo", refs[0].name)
+      assert_equal(1, refs[0].location.start_line)
+
+      assert_equal("Foo", refs[1].name)
+      assert_equal(3, refs[1].location.start_line)
+
+      assert_equal("Foo", refs[2].name)
+      assert_equal(8, refs[2].location.start_line)
+    end
+
     private
 
     def find_const_references(const_name, source)
@@ -293,11 +317,12 @@ module RubyIndexer
 
     def find_references(target, source)
       file_path = "/fake.rb"
+      uri = URI::Generic.from_path(path: file_path)
       index = Index.new
-      index.index_single(URI::Generic.from_path(path: file_path), source)
+      index.index_single(uri, source)
       parse_result = Prism.parse(source)
       dispatcher = Prism::Dispatcher.new
-      finder = ReferenceFinder.new(target, index, dispatcher)
+      finder = ReferenceFinder.new(target, index, dispatcher, uri)
       dispatcher.visit(parse_result.value)
       finder.references
     end

data/lib/ruby_lsp/global_state.rb

@@ -32,6 +32,9 @@ module RubyLsp
     sig { returns(URI::Generic) }
     attr_reader :workspace_uri
 
+    sig { returns(T.nilable(String)) }
+    attr_reader :telemetry_machine_id
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
@@ -57,6 +60,7 @@ 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)
+      @telemetry_machine_id = T.let(nil, T.nilable(String))
     end
 
     sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
@@ -175,6 +179,7 @@ module RubyLsp
       enabled_flags = options.dig(:initializationOptions, :enabledFeatureFlags)
       @enabled_feature_flags = enabled_flags if enabled_flags
 
+      @telemetry_machine_id = options.dig(:initializationOptions, :telemetryMachineId)
       notifications
     end
 

data/lib/ruby_lsp/internal.rb

@@ -23,6 +23,7 @@ require "language_server-protocol"
 require "rbs"
 require "fileutils"
 require "open3"
+require "securerandom"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -286,7 +286,7 @@ module RubyLsp
         when Prism::StringNode
           first_argument.content
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          constant_name(first_argument)
+          RubyIndexer::Index.constant_name(first_argument)
         end
 
         return unless name

data/lib/ruby_lsp/listeners/completion.rb

@@ -113,7 +113,7 @@ module RubyLsp
         # no sigil, Sorbet will still provide completion for constants
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
-        name = constant_name(node)
+        name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
         range = range_from_location(node.location)
@@ -162,7 +162,7 @@ module RubyLsp
           if (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) &&
               node.call_operator == "::"
 
-            name = constant_name(receiver)
+            name = RubyIndexer::Index.constant_name(receiver)
 
             if name
               start_loc = node.location
@@ -471,6 +471,9 @@ module RubyLsp
             path_node_to_complete,
           )
         end
+      rescue Errno::EPERM
+        # If the user writes a relative require pointing to a path that the editor has no permissions to read, then glob
+        # might fail with EPERM
       end
 
       sig { params(node: Prism::CallNode, name: String).void }

data/lib/ruby_lsp/listeners/definition.rb

@@ -118,7 +118,7 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        name = constant_name(node)
+        name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
         find_in_index(name)
@@ -126,7 +126,7 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        name = constant_name(node)
+        name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
         find_in_index(name)

data/lib/ruby_lsp/listeners/document_link.rb

@@ -124,7 +124,16 @@ module RubyLsp
         match = comment.location.slice.match(%r{source://.*#\d+$})
         return unless match
 
-        uri = T.cast(URI(T.must(match[0])), URI::Source)
+        uri = T.cast(
+          begin
+            URI(T.must(match[0]))
+          rescue URI::Error
+            nil
+          end,
+          T.nilable(URI::Source),
+        )
+        return unless uri
+
         gem_version = resolve_version(uri)
         return if gem_version.nil?
 

data/lib/ruby_lsp/listeners/hover.rb

@@ -114,7 +114,7 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
-        name = constant_name(node)
+        name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
         generate_hover(name, node.location)
@@ -131,7 +131,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
-        name = constant_name(node)
+        name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
         generate_hover(name, node.location)

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -42,6 +42,10 @@ module RubyLsp
           refactor_method
         when CodeActions::TOGGLE_BLOCK_STYLE_TITLE
           switch_block_style
+        when CodeActions::CREATE_ATTRIBUTE_READER,
+             CodeActions::CREATE_ATTRIBUTE_WRITER,
+             CodeActions::CREATE_ATTRIBUTE_ACCESSOR
+          create_attribute_accessor
         else
           Error::UnknownCodeAction
         end
@@ -325,6 +329,90 @@ module RubyLsp
 
         indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
       end
+
+      sig { returns(T.any(Interface::CodeAction, Error)) }
+      def create_attribute_accessor
+        source_range = @code_action.dig(:data, :range)
+
+        node = if source_range[:start] != source_range[:end]
+          @document.locate_first_within_range(
+            @code_action.dig(:data, :range),
+            node_types: CodeActions::INSTANCE_VARIABLE_NODES,
+          )
+        end
+
+        if node.nil?
+          node_context = @document.locate_node(
+            source_range[:start],
+            node_types: CodeActions::INSTANCE_VARIABLE_NODES,
+          )
+          node = node_context.node
+
+          return Error::EmptySelection unless CodeActions::INSTANCE_VARIABLE_NODES.include?(node.class)
+        end
+
+        node = T.cast(
+          node,
+          T.any(
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
+          ),
+        )
+
+        node_context = @document.locate_node(
+          {
+            line: node.location.start_line,
+            character: node.location.start_character_column,
+          },
+          node_types: [
+            Prism::ClassNode,
+            Prism::ModuleNode,
+            Prism::SingletonClassNode,
+          ],
+        )
+        closest_node = node_context.node
+        return Error::InvalidTargetRange if closest_node.nil?
+
+        attribute_name = node.name[1..]
+        indentation = " " * (closest_node.location.start_column + 2)
+        attribute_accessor_source = T.must(
+          case @code_action[:title]
+          when CodeActions::CREATE_ATTRIBUTE_READER
+            "#{indentation}attr_reader :#{attribute_name}\n\n"
+          when CodeActions::CREATE_ATTRIBUTE_WRITER
+            "#{indentation}attr_writer :#{attribute_name}\n\n"
+          when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
+            "#{indentation}attr_accessor :#{attribute_name}\n\n"
+          end,
+        )
+
+        target_start_line = closest_node.location.start_line
+        target_range = {
+          start: { line: target_start_line, character: 0 },
+          end: { line: target_start_line, character: 0 },
+        }
+
+        Interface::CodeAction.new(
+          title: @code_action[:title],
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: @code_action.dig(:data, :uri),
+                  version: nil,
+                ),
+                edits: [
+                  create_text_edit(target_range, attribute_accessor_source),
+                ],
+              ),
+            ],
+          ),
+        )
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -12,6 +12,21 @@ module RubyLsp
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
       TOGGLE_BLOCK_STYLE_TITLE = "Refactor: Toggle block style"
+      CREATE_ATTRIBUTE_READER = "Create Attribute Reader"
+      CREATE_ATTRIBUTE_WRITER = "Create Attribute Writer"
+      CREATE_ATTRIBUTE_ACCESSOR = "Create Attribute Accessor"
+
+      INSTANCE_VARIABLE_NODES = T.let(
+        [
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableReadNode,
+          Prism::InstanceVariableTargetNode,
+          Prism::InstanceVariableWriteNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
 
       class << self
         extend T::Sig
@@ -66,9 +81,50 @@ module RubyLsp
             data: { range: @range, uri: @uri.to_s },
           )
         end
+        code_actions.concat(attribute_actions)
 
         code_actions
       end
+
+      private
+
+      sig { returns(T::Array[Interface::CodeAction]) }
+      def attribute_actions
+        return [] unless @document.is_a?(RubyDocument)
+
+        node = if @range.dig(:start) != @range.dig(:end)
+          @document.locate_first_within_range(
+            @range,
+            node_types: INSTANCE_VARIABLE_NODES,
+          )
+        end
+
+        if node.nil?
+          node_context = @document.locate_node(
+            @range[:start],
+            node_types: CodeActions::INSTANCE_VARIABLE_NODES,
+          )
+          return [] unless INSTANCE_VARIABLE_NODES.include?(node_context.node.class)
+        end
+
+        [
+          Interface::CodeAction.new(
+            title: CREATE_ATTRIBUTE_READER,
+            kind: Constant::CodeActionKind::EMPTY,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+          Interface::CodeAction.new(
+            title: CREATE_ATTRIBUTE_WRITER,
+            kind: Constant::CodeActionKind::EMPTY,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+          Interface::CodeAction.new(
+            title: CREATE_ATTRIBUTE_ACCESSOR,
+            kind: Constant::CodeActionKind::EMPTY,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+        ]
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/references.rb

@@ -124,7 +124,7 @@ module RubyLsp
       def create_reference_target(target_node, node_context)
         case target_node
         when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
-          name = constant_name(target_node)
+          name = RubyIndexer::Index.constant_name(target_node)
           return unless name
 
           entries = @global_state.index.resolve(name, node_context.nesting)
@@ -158,6 +158,7 @@ module RubyLsp
           target,
           @global_state.index,
           dispatcher,
+          uri,
           include_declarations: @params.dig(:context, :includeDeclaration) || true,
         )
         dispatcher.visit(parse_result.value)

data/lib/ruby_lsp/requests/rename.rb

@@ -65,7 +65,7 @@ module RubyLsp
           T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
         )
 
-        name = constant_name(target)
+        name = RubyIndexer::Index.constant_name(target)
         return unless name
 
         entries = @global_state.index.resolve(name, node_context.nesting)
@@ -179,7 +179,7 @@ module RubyLsp
       end
       def collect_changes(target, parse_result, name, uri)
         dispatcher = Prism::Dispatcher.new
-        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher)
+        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher, uri)
         dispatcher.visit(parse_result.value)
 
         finder.references.map do |reference|

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

@@ -145,10 +145,7 @@ module RubyLsp
           ).returns(T.nilable(String))
         end
         def constant_name(node)
-          node.full_name
-        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
-               Prism::ConstantPathNode::MissingNodesInConstantPathError
-          nil
+          RubyIndexer::Index.constant_name(node)
         end
 
         sig { params(node: T.any(Prism::ModuleNode, Prism::ClassNode)).returns(T.nilable(String)) }

data/lib/ruby_lsp/ruby_document.rb

@@ -258,11 +258,18 @@ module RubyLsp
     end
 
     sig { returns(T::Boolean) }
-    def last_edit_may_change_declarations?
+    def should_index?
       # 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
 
+      last_edit_may_change_declarations?
+    end
+
+    private
+
+    sig { returns(T::Boolean) }
+    def last_edit_may_change_declarations?
       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
@@ -275,8 +282,6 @@ module RubyLsp
       end
     end
 
-    private
-
     sig { params(position: T::Hash[Symbol, Integer]).returns(T::Boolean) }
     def position_may_impact_declarations?(position)
       node_context = locate_node(position)

data/lib/ruby_lsp/server.rb

@@ -13,7 +13,7 @@ module RubyLsp
     def process_message(message)
       case message[:method]
       when "initialize"
-        send_log_message("Initializing Ruby LSP v#{VERSION}...")
+        send_log_message("Initializing Ruby LSP v#{VERSION} https://github.com/Shopify/ruby-lsp/releases/tag/v#{VERSION}....")
         run_initialize(message)
       when "initialized"
         send_log_message("Finished initializing Ruby LSP!") unless @test_mode
@@ -301,10 +301,19 @@ module RubyLsp
 
       # Not every client supports dynamic registration or file watching
       if @global_state.client_capabilities.supports_watching_files
-        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"),
+          "**/*.rb",
+          registration_id: "workspace-watcher",
+        ))
+
+        send_message(Request.register_watched_files(
+          @current_request_id,
+          Interface::RelativePattern.new(
+            base_uri: @global_state.workspace_uri.to_s,
+            pattern: "{.rubocop.yml,.rubocop}",
+          ),
+          registration_id: "rubocop-watcher",
         ))
       end
 
@@ -473,11 +482,11 @@ module RubyLsp
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
       inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
 
-      if document.is_a?(RubyDocument) && document.last_edit_may_change_declarations?
+      if document.is_a?(RubyDocument) && document.should_index?
         # 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}")
+          send_log_message("Determined that document should be indexed: #{uri}")
 
           @global_state.index.handle_change(uri) do |index|
             index.delete(uri, skip_require_paths_tree: true)
@@ -999,6 +1008,11 @@ module RubyLsp
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_did_change_watched_files(message)
       changes = message.dig(:params, :changes)
+      # We allow add-ons to register for watching files and we have no restrictions for what they register for. If the
+      # same pattern is registered more than once, the LSP will receive duplicate change notifications. Receiving them
+      # is fine, but we shouldn't process the same file changes more than once
+      changes.uniq!
+
       index = @global_state.index
       changes.each do |change|
         # File change events include folders, but we're only interested in files
@@ -1018,7 +1032,14 @@ module RubyLsp
         end
       end
 
-      Addon.file_watcher_addons.each { |addon| T.unsafe(addon).workspace_did_change_watched_files(changes) }
+      Addon.file_watcher_addons.each do |addon|
+        T.unsafe(addon).workspace_did_change_watched_files(changes)
+      rescue => e
+        send_log_message(
+          "Error in #{addon.name} add-on while processing watched file notifications: #{e.full_message}",
+          type: Constant::MessageType::ERROR,
+        )
+      end
     end
 
     sig { params(index: RubyIndexer::Index, file_path: String, change_type: Integer).void }
@@ -1030,9 +1051,13 @@ module RubyLsp
 
       case change_type
       when Constant::FileChangeType::CREATED
-        index.index_single(uri, content)
+        # If we receive a late created notification for a file that has already been claimed by the client, we want to
+        # handle change for that URI so that the require path tree is updated
+        @store.key?(uri) ? index.handle_change(uri, content) : index.index_single(uri, content)
       when Constant::FileChangeType::CHANGED
-        index.handle_change(uri, content)
+        # We only handle changes on file watched notifications if the client is not the one managing this URI.
+        # Otherwise, these changes are handled when running the combined requests
+        index.handle_change(uri, content) unless @store.key?(uri)
       when Constant::FileChangeType::DELETED
         index.delete(uri)
       end
@@ -1131,7 +1156,12 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_dependencies(message)
-      response = if @global_state.top_level_bundle
+      unless @global_state.top_level_bundle
+        send_message(Result.new(id: message[:id], response: []))
+        return
+      end
+
+      response = begin
         Bundler.with_original_env do
           definition = Bundler.definition
           dep_keys = definition.locked_deps.keys.to_set
@@ -1145,7 +1175,7 @@ module RubyLsp
             }
           end
         end
-      else
+      rescue Bundler::GemNotFound
         []
       end
 

data/lib/ruby_lsp/type_inferrer.rb

@@ -80,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)
@@ -147,21 +147,6 @@ 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
-    end
-
     sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
     def infer_receiver_for_class_variables(node_context)
       nesting_parts = node_context.nesting.dup

data/lib/ruby_lsp/utils.rb

@@ -176,11 +176,19 @@ module RubyLsp
     class << self
       extend T::Sig
 
-      sig { params(id: Integer, pattern: T.any(Interface::RelativePattern, String), kind: Integer).returns(Request) }
+      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
+        kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
+        registration_id: nil
       )
         new(
           id: id,
@@ -188,7 +196,7 @@ module RubyLsp
           params: Interface::RegistrationParams.new(
             registrations: [
               Interface::Registration.new(
-                id: "workspace/didChangeWatchedFiles",
+                id: registration_id || SecureRandom.uuid,
                 method: "workspace/didChangeWatchedFiles",
                 register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
                   watchers: [

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.8
+  version: 0.23.10
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-31 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol