ruby-lsp 0.23.8 → 0.23.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 918079e906832b0289a053cd4bfe849422082c25bd0f4bdada25cab3a532005f
-  data.tar.gz: 7935b2bdc52a2bb83264376fb98f7ef8d3bfc3c5cb9dadd23642a1ebafbca013
+  metadata.gz: 149e7978a6f85c9349fa3922283a151f2e2129d12eb14e29d665ad35a3b909e7
+  data.tar.gz: a931c7b049810fe304eaa93ae4a7a8bdd499951fa9f3ca21b6da9df91cc24e12
 SHA512:
-  metadata.gz: 9fb084d322308bb2e69c2c0d5cfed2d275fe53f5df40aa2a49a848aab4c771858dfa1b5d5df913516c1f1c90ce5101b2f461865093f5e6787c79886cadc40bdb
-  data.tar.gz: 06206026d180e9d044edda0a83018ae31895cce3e6d91cb9ae4bdb3c365565a27881dd17ffd6d8861d8126441e327cb8fdf91c41e6003c1d84a4038c8b9003ea
+  metadata.gz: 6fae90263d8e037d3e58a0f20de4e6eaa671d739f28fa1af90a013a9d0ade3a43fa118b5fe15c3e2a3de025a9c3e4a53dc4584426678619896b98d38cca2dcbc
+  data.tar.gz: c634542b0ec26e9df418222b8eab459f42d3f65e42c196c6a3769139073c94f98bfb0da8cb61b18f055629aa9fbf58d6516d13a40b453f27fbc4a6f1514d3d9d

data/VERSION

@@ -1 +1 @@
-0.23.8
+0.23.9

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

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
@@ -1131,7 +1145,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 +1164,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.9
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-31 00:00:00.000000000 Z
+date: 2025-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol