ruby-lsp 0.23.7 → 0.23.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46b72d1b9ba142496f64035b6b1ad54d096c0a28ae52311612bd118bc49e2956
-  data.tar.gz: 525dc46dcfc71ee57da51955a4034ceace3bbdd1eca7942b542ab2cd32d42ad4
+  metadata.gz: 149e7978a6f85c9349fa3922283a151f2e2129d12eb14e29d665ad35a3b909e7
+  data.tar.gz: a931c7b049810fe304eaa93ae4a7a8bdd499951fa9f3ca21b6da9df91cc24e12
 SHA512:
-  metadata.gz: '06690b76d284ca6abc05fc0e836af32a54c0a3cedea1fd53071648330a3b3b6e6d1a59ef205127f54a88e8cd3ca07c3840f25f1293e37737d705b2ea41719cb1'
-  data.tar.gz: bd6104ef180f122d0bb9d6d751213c43f0d19d0f203deb50e5d94583ff0aaf85559a040ca0371fc24506ff11a0d2742c14f1277226cc34d3a09d02730d46aed7
+  metadata.gz: 6fae90263d8e037d3e58a0f20de4e6eaa671d739f28fa1af90a013a9d0ade3a43fa118b5fe15c3e2a3de025a9c3e4a53dc4584426678619896b98d38cca2dcbc
+  data.tar.gz: c634542b0ec26e9df418222b8eab459f42d3f65e42c196c6a3769139073c94f98bfb0da8cb61b18f055629aa9fbf58d6516d13a40b453f27fbc4a6f1514d3d9d

data/VERSION

@@ -1 +1 @@
-0.23.7
+0.23.9

data/exe/ruby-lsp-launcher

@@ -51,7 +51,7 @@ end
 
 begin
   # Wait until the composed Bundle is finished
-  Process.wait(pid)
+  _, status = Process.wait2(pid)
 rescue Errno::ECHILD
   # In theory, the child process can finish before we even get to the wait call, but that is not an error
 end
@@ -105,7 +105,7 @@ end
 # flow, we are not booting the LSP yet, just checking if the bundle is valid before rebooting
 if reboot
   # Use the exit status to signal to the server if composing the bundle succeeded
-  exit(install_error || setup_error ? 1 : 0)
+  exit(install_error || setup_error ? 1 : status&.exitstatus || 0)
 end
 
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already

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:
@@ -120,8 +159,16 @@ module RubyIndexer
       )]))
     end
     def first_unqualified_const(name)
+      # Look for an exact match first
       _name, entries = @entries.find do |const_name, _entries|
-        const_name.end_with?(name)
+        const_name == name || const_name.end_with?("::#{name}")
+      end
+
+      # If an exact match is not found, then try to find a constant that ends with the name
+      unless entries
+        _name, entries = @entries.find do |const_name, _entries|
+          const_name.end_with?(name)
+        end
       end
 
       T.cast(
@@ -593,7 +640,7 @@ module RubyIndexer
       entries = self[variable_name]&.grep(Entry::ClassVariable)
       return unless entries&.any?
 
-      ancestors = linearized_ancestors_of(owner_name)
+      ancestors = linearized_attached_ancestors(owner_name)
       return if ancestors.empty?
 
       entries.select { |e| ancestors.include?(e.owner&.name) }
@@ -601,12 +648,33 @@ module RubyIndexer
 
     # Returns a list of possible candidates for completion of instance variables for a given owner name. The name must
     # include the `@` prefix
-    sig { params(name: String, owner_name: String).returns(T::Array[Entry::InstanceVariable]) }
+    sig do
+      params(name: String, owner_name: String).returns(T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+    end
     def instance_variable_completion_candidates(name, owner_name)
-      entries = T.cast(prefix_search(name).flatten, T::Array[Entry::InstanceVariable])
+      entries = T.cast(prefix_search(name).flatten, T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+      # Avoid wasting time linearizing ancestors if we didn't find anything
+      return entries if entries.empty?
+
       ancestors = linearized_ancestors_of(owner_name)
 
-      variables = entries.select { |e| ancestors.any?(e.owner&.name) }
+      instance_variables, class_variables = entries.partition { |e| e.is_a?(Entry::InstanceVariable) }
+      variables = instance_variables.select { |e| ancestors.any?(e.owner&.name) }
+
+      # Class variables are only owned by the attached class in our representation. If the owner is in a singleton
+      # context, we have to search for ancestors of the attached class
+      if class_variables.any?
+        name_parts = owner_name.split("::")
+
+        if name_parts.last&.start_with?("<Class:")
+          attached_name = T.must(name_parts[0..-2]).join("::")
+          attached_ancestors = linearized_ancestors_of(attached_name)
+          variables.concat(class_variables.select { |e| attached_ancestors.any?(e.owner&.name) })
+        else
+          variables.concat(class_variables.select { |e| ancestors.any?(e.owner&.name) })
+        end
+      end
+
       variables.uniq!(&:name)
       variables
     end
@@ -614,8 +682,10 @@ module RubyIndexer
     sig { params(name: String, owner_name: String).returns(T::Array[Entry::ClassVariable]) }
     def class_variable_completion_candidates(name, owner_name)
       entries = T.cast(prefix_search(name).flatten, T::Array[Entry::ClassVariable])
-      ancestors = linearized_ancestors_of(owner_name)
+      # Avoid wasting time linearizing ancestors if we didn't find anything
+      return entries if entries.empty?
 
+      ancestors = linearized_attached_ancestors(owner_name)
       variables = entries.select { |e| ancestors.any?(e.owner&.name) }
       variables.uniq!(&:name)
       variables
@@ -717,6 +787,20 @@ module RubyIndexer
 
     private
 
+    # Always returns the linearized ancestors for the attached class, regardless of whether `name` refers to a singleton
+    # or attached namespace
+    sig { params(name: String).returns(T::Array[String]) }
+    def linearized_attached_ancestors(name)
+      name_parts = name.split("::")
+
+      if name_parts.last&.start_with?("<Class:")
+        attached_name = T.must(name_parts[0..-2]).join("::")
+        linearized_ancestors_of(attached_name)
+      else
+        linearized_ancestors_of(name)
+      end
+    end
+
     # Runs the registered included hooks
     sig { params(fully_qualified_name: String, nesting: T::Array[String]).void }
     def run_included_hooks(fully_qualified_name, nesting)

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/index_test.rb

@@ -1561,6 +1561,23 @@ module RubyIndexer
       assert_equal("Foo::Bar", entry.name)
     end
 
+    def test_first_unqualified_const_prefers_exact_matches
+      index(<<~RUBY)
+        module Foo
+          class ParseResultType
+          end
+        end
+
+        module Namespace
+          class Type
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.first_unqualified_const("Type")&.first)
+      assert_equal("Namespace::Type", entry.name)
+    end
+
     def test_completion_does_not_duplicate_overridden_methods
       index(<<~RUBY)
         class Foo
@@ -2092,5 +2109,57 @@ module RubyIndexer
       refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
       assert_equal("I added this comment!", entry.comments)
     end
+
+    def test_instance_variable_completion_returns_class_variables_too
+      index(<<~RUBY)
+        class Parent
+          @@abc = 123
+        end
+
+        class Child < Parent
+          @@adf = 123
+
+          def self.do
+          end
+        end
+      RUBY
+
+      abc, adf = @index.instance_variable_completion_candidates("@", "Child::<Class:Child>")
+
+      refute_nil(abc)
+      refute_nil(adf)
+
+      assert_equal("@@abc", abc.name)
+      assert_equal("@@adf", adf.name)
+    end
+
+    def test_class_variable_completion_from_singleton_context
+      index(<<~RUBY)
+        class Foo
+          @@hello = 123
+
+          def self.do
+          end
+        end
+      RUBY
+
+      candidates = @index.class_variable_completion_candidates("@@", "Foo::<Class:Foo>")
+      refute_empty(candidates)
+
+      assert_equal("@@hello", candidates.first&.name)
+    end
+
+    def test_resolve_class_variable_in_singleton_context
+      index(<<~RUBY)
+        class Foo
+          @@hello = 123
+        end
+      RUBY
+
+      candidates = @index.resolve_class_variable("@@hello", "Foo::<Class:Foo>")
+      refute_empty(candidates)
+
+      assert_equal("@@hello", candidates.first&.name)
+    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

@@ -22,6 +22,8 @@ require "prism/visitor"
 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/on_type_formatting.rb

@@ -170,7 +170,7 @@ module RubyLsp
 
       sig { params(line: Integer, character: Integer).void }
       def move_cursor_to(line, character)
-        return unless @client_name.start_with?("Visual Studio Code")
+        return unless /Visual Studio Code|Cursor/.match?(@client_name)
 
         position = Interface::Position.new(
           line: line,

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
@@ -1036,6 +1050,10 @@ module RubyLsp
       when Constant::FileChangeType::DELETED
         index.delete(uri)
       end
+    rescue Errno::ENOENT
+      # If a file is created and then delete immediately afterwards, we will process the created notification before we
+      # receive the deleted one, but the file no longer exists. This may happen when running a test suite that creates
+      # and deletes files automatically.
     end
 
     sig { params(uri: URI::Generic).void }
@@ -1127,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
@@ -1141,7 +1164,7 @@ module RubyLsp
             }
           end
         end
-      else
+      rescue Bundler::GemNotFound
         []
       end
 
@@ -1286,25 +1309,40 @@ module RubyLsp
       addon.handle_window_show_message_response(result[:title])
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    # NOTE: all servers methods are void because they can produce several messages for the client. The only reason this
+    # method returns the created thread is to that we can join it in tests and avoid flakiness. The implementation is
+    # not supposed to rely on the return of this method
+    sig { params(message: T::Hash[Symbol, T.untyped]).returns(T.nilable(Thread)) }
     def compose_bundle(message)
       already_composed_path = File.join(@global_state.workspace_path, ".ruby-lsp", "bundle_is_composed")
-      command = "#{Gem.ruby} #{File.expand_path("../../exe/ruby-lsp-launcher", __dir__)} #{@global_state.workspace_uri}"
       id = message[:id]
 
       begin
-        Bundler::LockfileParser.new(Bundler.default_lockfile.read)
+        Bundler.with_original_env do
+          Bundler::LockfileParser.new(Bundler.default_lockfile.read)
+        end
       rescue Bundler::LockfileError => e
         send_message(Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: e.message))
         return
+      rescue Bundler::GemfileNotFound, Errno::ENOENT
+        # We still compose the bundle if there's no Gemfile or if the lockfile got deleted
       end
 
       # We compose the bundle in a thread so that the LSP continues to work while we're checking for its validity. Once
       # we return the response back to the editor, then the restart is triggered
       Thread.new do
         send_log_message("Recomposing the bundle ahead of restart")
-        pid = Process.spawn(command)
-        _, status = Process.wait2(pid)
+
+        _stdout, stderr, status = Bundler.with_unbundled_env do
+          Open3.capture3(
+            Gem.ruby,
+            "-I",
+            File.dirname(T.must(__dir__)),
+            File.expand_path("../../exe/ruby-lsp-launcher", __dir__),
+            @global_state.workspace_uri.to_s,
+            chdir: @global_state.workspace_path,
+          )
+        end
 
         if status&.exitstatus == 0
           # Create a signal for the restart that it can skip composing the bundle and launch directly
@@ -1313,7 +1351,9 @@ module RubyLsp
         else
           # This special error code makes the extension avoid restarting in case we already know that the composed
           # bundle is not valid
-          send_message(Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle"))
+          send_message(
+            Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle\n#{stderr}"),
+          )
         end
       end
     end

data/lib/ruby_lsp/setup_bundler.rb

@@ -241,8 +241,7 @@ module RubyLsp
 
       # If either the Gemfile or the lockfile have been modified during the process of setting up the bundle, retry
       # composing the bundle from scratch
-
-      if @gemfile && @lockfile
+      if @gemfile&.exist? && @lockfile&.exist?
         current_gemfile_hash = Digest::SHA256.hexdigest(@gemfile.read)
         current_lockfile_hash = Digest::SHA256.hexdigest(@lockfile.read)
 

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.7
+  version: 0.23.9
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-28 00:00:00.000000000 Z
+date: 2025-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol