ruby-lsp 0.16.6 → 0.16.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d725a0a2fbd58820e2a87efae85564498221feb8410292055b0caafd889284e6
-  data.tar.gz: 5376ca8a9d08ca0883fca3aa19a1a178102eb60f49ab3fe5f07bb1a58ba63ddf
+  metadata.gz: ebc166637de670ea02144e74ccb2e99ae1a9824c9f99995380d81bed99ff6a29
+  data.tar.gz: 48b7ef9364f4d1a8044042c8476414e87da5b38ca4871683c16d06636fc8e411
 SHA512:
-  metadata.gz: 81fbb2e5018ad55d8888c98e277e7ac6ed8b45314627b1a3e3dabde2cb8aac0284dc70487a694226e5a08817feb82b64daadfcb955e9642b288e575189a56015
-  data.tar.gz: f32ef084e4412752cc32df55da0dd7b985d3826db110bf91ba3473773043c50345ceb597432483a0a75f1790cabfca796fa9581d3ba86edff96a8642fb2312f2
+  metadata.gz: 80c4f791e7dfef66623f5190eaba4dc76c745a27f74238d912c34711c408803ec952d5ec3e8041ebb6410b99c74d2f3d8274db5dffa8f187e48a7032a3960086
+  data.tar.gz: 941209321fb263b9a22cbe27102e8761c6ef127902e2b74f760fec1a8701d96e5bcef5f01c704e7215e061437cac2577c38e100464cccfe03909aa42ee1e318e

data/README.md

@@ -33,7 +33,7 @@ The Ruby LSP features include
 - Completion for classes, modules, constants and require paths
 - Fuzzy search classes, modules and constants anywhere in the project and its dependencies (workspace symbol)
 
-Adding method support for definition, completion, hover and workspace symbol is planned, but not yet completed.
+Adding method support for definition, completion, hover and workspace symbol is partially supported, but not yet complete. Follow progress in https://github.com/Shopify/ruby-lsp/issues/899
 
 See complete information about features [here](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 

data/VERSION

@@ -1 +1 @@
-0.16.6
+0.16.7

data/exe/ruby-lsp

@@ -18,6 +18,10 @@ parser = OptionParser.new do |opts|
     options[:debug] = true
   end
 
+  opts.on("--time-index", "Measure the time it takes to index the project") do
+    options[:time_index] = true
+  end
+
   opts.on(
     "--branch [BRANCH]",
     "Launch the Ruby LSP using the specified branch rather than the release version",
@@ -80,14 +84,27 @@ if options[:debug]
   end
 
   begin
-    original_stdout = $stdout
-    $stdout = $stderr
+    ENV.delete("RUBY_DEBUG_IRB_CONSOLE")
     require "debug/open_nonstop"
   rescue LoadError
     $stderr.puts("You need to install the debug gem to use the --debug flag")
-  ensure
-    $stdout = original_stdout
   end
 end
 
+if options[:time_index]
+  require "benchmark"
+
+  index = RubyIndexer::Index.new
+
+  result = Benchmark.realtime { index.index_all }
+  entries = index.instance_variable_get(:@entries)
+  entries_by_entry_type = entries.values.flatten.group_by(&:class)
+
+  puts <<~MSG
+    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{result.round(5)} seconds and generated:
+    - #{entries_by_entry_type.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
+  MSG
+  return
+end
+
 RubyLsp::Server.new.start

data/exe/ruby-lsp-check

@@ -47,9 +47,7 @@ index = RubyIndexer::Index.new
 indexables = RubyIndexer.configuration.indexables
 
 indexables.each_with_index do |indexable, i|
-  result = Prism.parse(File.read(indexable.full_path))
-  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
-  collector.collect(result.value)
+  index.index_single(indexable)
 rescue => e
   errors[indexable.full_path] = e
 ensure

data/exe/ruby-lsp-doctor

@@ -19,8 +19,5 @@ puts "Globbing for indexable files"
 
 RubyIndexer.configuration.indexables.each do |indexable|
   puts "indexing: #{indexable.full_path}"
-  content = File.read(indexable.full_path)
-  result = Prism.parse(content)
-  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
-  collector.collect(result.value)
+  index.index_single(indexable)
 end

data/lib/core_ext/uri.rb

@@ -11,6 +11,9 @@ module URI
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
           DEFAULT_PARSER.escape("/#{path}")
+        elsif path.start_with?("//?/")
+          # Some paths on Windows start with "//?/". This is a special prefix that allows for long file paths
+          DEFAULT_PARSER.escape(path.delete_prefix("//?"))
         else
           DEFAULT_PARSER.escape(path)
         end

data/lib/ruby_indexer/lib/ruby_indexer/{collector.rb → declaration_listener.rb}

@@ -2,79 +2,103 @@
 # frozen_string_literal: true
 
 module RubyIndexer
-  class Collector
+  class DeclarationListener
     extend T::Sig
 
-    LEAVE_EVENT = T.let(Object.new.freeze, Object)
-
-    sig { params(index: Index, parse_result: Prism::ParseResult, file_path: String).void }
-    def initialize(index, parse_result, file_path)
+    sig do
+      params(index: Index, dispatcher: Prism::Dispatcher, parse_result: Prism::ParseResult, file_path: String).void
+    end
+    def initialize(index, dispatcher, parse_result, file_path)
       @index = index
       @file_path = file_path
-      @stack = T.let([], T::Array[String])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
           [c.location.start_line, c]
         end,
         T::Hash[Integer, Prism::Comment],
       )
-      @queue = T.let([], T::Array[Object])
-      @current_owner = T.let(nil, T.nilable(Entry::Namespace))
+      @inside_def = T.let(false, T::Boolean)
+
+      # The nesting stack we're currently inside. Used to determine the fully qualified name of constants, but only
+      # stored by unresolved aliases which need the original nesting to be lazily resolved
+      @stack = T.let([], T::Array[String])
 
-      super()
+      # A stack of namespace entries that represent where we currently are. Used to properly assign methods to an owner
+      @owner_stack = T.let([], T::Array[Entry::Namespace])
+
+      dispatcher.register(
+        self,
+        :on_class_node_enter,
+        :on_class_node_leave,
+        :on_module_node_enter,
+        :on_module_node_leave,
+        :on_def_node_enter,
+        :on_def_node_leave,
+        :on_call_node_enter,
+        :on_multi_write_node_enter,
+        :on_constant_path_write_node_enter,
+        :on_constant_path_or_write_node_enter,
+        :on_constant_path_operator_write_node_enter,
+        :on_constant_path_and_write_node_enter,
+        :on_constant_or_write_node_enter,
+        :on_constant_write_node_enter,
+        :on_constant_or_write_node_enter,
+        :on_constant_and_write_node_enter,
+        :on_constant_operator_write_node_enter,
+      )
     end
 
-    sig { params(node: Prism::Node).void }
-    def collect(node)
-      @queue = [node]
-
-      until @queue.empty?
-        node_or_event = @queue.shift
-
-        case node_or_event
-        when Prism::ProgramNode
-          @queue << node_or_event.statements
-        when Prism::StatementsNode
-          T.unsafe(@queue).prepend(*node_or_event.body)
-        when Prism::ClassNode
-          add_class_entry(node_or_event)
-        when Prism::ModuleNode
-          add_module_entry(node_or_event)
-        when Prism::MultiWriteNode
-          handle_multi_write_node(node_or_event)
-        when Prism::ConstantPathWriteNode
-          handle_constant_path_write_node(node_or_event)
-        when Prism::ConstantPathOrWriteNode
-          handle_constant_path_or_write_node(node_or_event)
-        when Prism::ConstantPathOperatorWriteNode
-          handle_constant_path_operator_write_node(node_or_event)
-        when Prism::ConstantPathAndWriteNode
-          handle_constant_path_and_write_node(node_or_event)
-        when Prism::ConstantWriteNode
-          handle_constant_write_node(node_or_event)
-        when Prism::ConstantOrWriteNode
-          name = fully_qualify_name(node_or_event.name.to_s)
-          add_constant(node_or_event, name)
-        when Prism::ConstantAndWriteNode
-          name = fully_qualify_name(node_or_event.name.to_s)
-          add_constant(node_or_event, name)
-        when Prism::ConstantOperatorWriteNode
-          name = fully_qualify_name(node_or_event.name.to_s)
-          add_constant(node_or_event, name)
-        when Prism::CallNode
-          handle_call_node(node_or_event)
-        when Prism::DefNode
-          handle_def_node(node_or_event)
-        when LEAVE_EVENT
-          @stack.pop
-        end
+    sig { params(node: Prism::ClassNode).void }
+    def on_class_node_enter(node)
+      name = node.constant_path.location.slice
+
+      comments = collect_comments(node)
+
+      superclass = node.superclass
+      parent_class = case superclass
+      when Prism::ConstantReadNode, Prism::ConstantPathNode
+        superclass.slice
       end
+
+      entry = Entry::Class.new(
+        fully_qualify_name(name),
+        @file_path,
+        node.location,
+        comments,
+        parent_class,
+      )
+
+      @owner_stack << entry
+      @index << entry
+      @stack << name
     end
 
-    private
+    sig { params(node: Prism::ClassNode).void }
+    def on_class_node_leave(node)
+      @stack.pop
+      @owner_stack.pop
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_enter(node)
+      name = node.constant_path.location.slice
+
+      comments = collect_comments(node)
+      entry = Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+
+      @owner_stack << entry
+      @index << entry
+      @stack << name
+    end
+
+    sig { params(node: Prism::ModuleNode).void }
+    def on_module_node_leave(node)
+      @stack.pop
+      @owner_stack.pop
+    end
 
     sig { params(node: Prism::MultiWriteNode).void }
-    def handle_multi_write_node(node)
+    def on_multi_write_node_enter(node)
       value = node.value
       values = value.is_a?(Prism::ArrayNode) && value.opening_loc ? value.elements : []
 
@@ -94,7 +118,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathWriteNode).void }
-    def handle_constant_path_write_node(node)
+    def on_constant_path_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -104,7 +128,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathOrWriteNode).void }
-    def handle_constant_path_or_write_node(node)
+    def on_constant_path_or_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -114,7 +138,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
-    def handle_constant_path_operator_write_node(node)
+    def on_constant_path_operator_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -124,7 +148,7 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantPathAndWriteNode).void }
-    def handle_constant_path_and_write_node(node)
+    def on_constant_path_and_write_node_enter(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -134,13 +158,31 @@ module RubyIndexer
     end
 
     sig { params(node: Prism::ConstantWriteNode).void }
-    def handle_constant_write_node(node)
+    def on_constant_write_node_enter(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { params(node: Prism::ConstantOrWriteNode).void }
+    def on_constant_or_write_node_enter(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { params(node: Prism::ConstantAndWriteNode).void }
+    def on_constant_and_write_node_enter(node)
+      name = fully_qualify_name(node.name.to_s)
+      add_constant(node, name)
+    end
+
+    sig { params(node: Prism::ConstantOperatorWriteNode).void }
+    def on_constant_operator_write_node_enter(node)
       name = fully_qualify_name(node.name.to_s)
       add_constant(node, name)
     end
 
     sig { params(node: Prism::CallNode).void }
-    def handle_call_node(node)
+    def on_call_node_enter(node)
       message = node.name
 
       case message
@@ -153,14 +195,15 @@ module RubyIndexer
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
       when :include
-        handle_include(node)
+        handle_module_operation(node, :included_modules)
       when :prepend
-        handle_prepend(node)
+        handle_module_operation(node, :prepended_modules)
       end
     end
 
     sig { params(node: Prism::DefNode).void }
-    def handle_def_node(node)
+    def on_def_node_enter(node)
+      @inside_def = true
       method_name = node.name.to_s
       comments = collect_comments(node)
       case node.receiver
@@ -171,7 +214,7 @@ module RubyIndexer
           node.location,
           comments,
           node.parameters,
-          @current_owner,
+          @owner_stack.last,
         )
       when Prism::SelfNode
         @index << Entry::SingletonMethod.new(
@@ -180,11 +223,18 @@ module RubyIndexer
           node.location,
           comments,
           node.parameters,
-          @current_owner,
+          @owner_stack.last,
         )
       end
     end
 
+    sig { params(node: Prism::DefNode).void }
+    def on_def_node_leave(node)
+      @inside_def = false
+    end
+
+    private
+
     sig { params(node: Prism::CallNode).void }
     def handle_private_constant(node)
       arguments = node.arguments&.arguments
@@ -240,62 +290,16 @@ module RubyIndexer
 
         # If the right hand side is another constant assignment, we need to visit it because that constant has to be
         # indexed too
-        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
       when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
       else
         Entry::Constant.new(name, @file_path, node.location, comments)
       end
     end
 
-    sig { params(node: Prism::ModuleNode).void }
-    def add_module_entry(node)
-      name = node.constant_path.location.slice
-      unless /^[A-Z:]/.match?(name)
-        @queue << node.body
-        return
-      end
-
-      comments = collect_comments(node)
-      @current_owner = Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
-      @index << @current_owner
-      @stack << name
-      @queue.prepend(node.body, LEAVE_EVENT)
-    end
-
-    sig { params(node: Prism::ClassNode).void }
-    def add_class_entry(node)
-      name = node.constant_path.location.slice
-
-      unless /^[A-Z:]/.match?(name)
-        @queue << node.body
-        return
-      end
-
-      comments = collect_comments(node)
-
-      superclass = node.superclass
-      parent_class = case superclass
-      when Prism::ConstantReadNode, Prism::ConstantPathNode
-        superclass.slice
-      end
-
-      @current_owner = Entry::Class.new(
-        fully_qualify_name(name),
-        @file_path,
-        node.location,
-        comments,
-        parent_class,
-      )
-      @index << @current_owner
-      @stack << name
-      @queue.prepend(node.body, LEAVE_EVENT)
-    end
-
     sig { params(node: Prism::Node).returns(T::Array[String]) }
     def collect_comments(node)
       comments = []
@@ -350,24 +354,17 @@ module RubyIndexer
 
         next unless name && loc
 
-        @index << Entry::Accessor.new(name, @file_path, loc, comments, @current_owner) if reader
-        @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @current_owner) if writer
+        @index << Entry::Accessor.new(name, @file_path, loc, comments, @owner_stack.last) if reader
+        @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @owner_stack.last) if writer
       end
     end
 
-    sig { params(node: Prism::CallNode).void }
-    def handle_include(node)
-      handle_module_operation(node, :included_modules)
-    end
-
-    sig { params(node: Prism::CallNode).void }
-    def handle_prepend(node)
-      handle_module_operation(node, :prepended_modules)
-    end
-
     sig { params(node: Prism::CallNode, operation: Symbol).void }
     def handle_module_operation(node, operation)
-      return unless @current_owner
+      return if @inside_def
+
+      owner = @owner_stack.last
+      return unless owner
 
       arguments = node.arguments&.arguments
       return unless arguments
@@ -381,7 +378,7 @@ module RubyIndexer
         # If a constant path reference is dynamic or missing parts, we can't
         # index it
       end
-      collection = operation == :included_modules ? @current_owner.included_modules : @current_owner.prepended_modules
+      collection = operation == :included_modules ? owner.included_modules : owner.prepended_modules
       collection.concat(names)
     end
   end

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

@@ -185,9 +185,11 @@ module RubyIndexer
     sig { params(indexable_path: IndexablePath, source: T.nilable(String)).void }
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
+      dispatcher = Prism::Dispatcher.new
+
       result = Prism.parse(content)
-      collector = Collector.new(self, result, indexable_path.full_path)
-      collector.collect(result.value)
+      DeclarationListener.new(self, dispatcher, result, indexable_path.full_path)
+      dispatcher.dispatch(result.value)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path

data/lib/ruby_indexer/ruby_indexer.rb

@@ -5,7 +5,7 @@ require "yaml"
 require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
-require "ruby_indexer/lib/ruby_indexer/collector"
+require "ruby_indexer/lib/ruby_indexer/declaration_listener"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -14,6 +14,15 @@ module RubyIndexer
       assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
     end
 
+    def test_conditional_class
+      index(<<~RUBY)
+        class Foo
+        end if condition
+      RUBY
+
+      assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
+    end
+
     def test_class_with_statements
       index(<<~RUBY)
         class Foo
@@ -60,7 +69,23 @@ module RubyIndexer
         end
       RUBY
 
+      assert_entry("self::Bar", Entry::Class, "/fake/path/foo.rb:0-0:1-3")
+    end
+
+    def test_dynamically_namespaced_class_doesnt_affect_other_classes
+      index(<<~RUBY)
+        class Foo
+          class self::Bar
+          end
+
+          class Bar
+          end
+        end
+      RUBY
+
       refute_entry("self::Bar")
+      assert_entry("Foo", Entry::Class, "/fake/path/foo.rb:0-0:6-3")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:4-2:5-5")
     end
 
     def test_empty_statements_module
@@ -72,6 +97,15 @@ module RubyIndexer
       assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:1-3")
     end
 
+    def test_conditional_module
+      index(<<~RUBY)
+        module Foo
+        end if condition
+      RUBY
+
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:1-3")
+    end
+
     def test_module_with_statements
       index(<<~RUBY)
         module Foo
@@ -106,7 +140,23 @@ module RubyIndexer
         end
       RUBY
 
-      refute_entry("self::Bar")
+      assert_entry("self::Bar", Entry::Module, "/fake/path/foo.rb:0-0:1-3")
+    end
+
+    def test_dynamically_namespaced_module_doesnt_affect_other_modules
+      index(<<~RUBY)
+        module Foo
+          class self::Bar
+          end
+
+          module Bar
+          end
+        end
+      RUBY
+
+      assert_entry("Foo::self::Bar", Entry::Class, "/fake/path/foo.rb:1-2:2-5")
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:6-3")
+      assert_entry("Foo::Bar", Entry::Module, "/fake/path/foo.rb:4-2:5-5")
     end
 
     def test_nested_modules_and_classes

data/lib/ruby_indexer/test/constant_test.rb

@@ -12,10 +12,13 @@ module RubyIndexer
         class ::Bar
           FOO = 2
         end
+
+        BAR = 3 if condition
       RUBY
 
       assert_entry("FOO", Entry::Constant, "/fake/path/foo.rb:0-0:0-7")
       assert_entry("Bar::FOO", Entry::Constant, "/fake/path/foo.rb:3-2:3-9")
+      assert_entry("BAR", Entry::Constant, "/fake/path/foo.rb:6-0:6-7")
     end
 
     def test_constant_or_writes

data/lib/ruby_indexer/test/method_test.rb

@@ -16,6 +16,17 @@ module RubyIndexer
       assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
     end
 
+    def test_conditional_method
+      index(<<~RUBY)
+        class Foo
+          def bar
+          end if condition
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+    end
+
     def test_singleton_method_using_self_receiver
       index(<<~RUBY)
         class Foo
@@ -38,6 +49,28 @@ module RubyIndexer
       assert_no_entry("bar")
     end
 
+    def test_method_under_dynamic_class_or_module
+      index(<<~RUBY)
+        module Foo
+          class self::Bar
+            def bar
+            end
+          end
+        end
+
+        module Bar
+          def bar
+          end
+        end
+      RUBY
+
+      assert_equal(2, @index["bar"].length)
+      first_entry = T.must(@index["bar"].first)
+      assert_equal("Foo::self::Bar", first_entry.owner.name)
+      second_entry = T.must(@index["bar"].last)
+      assert_equal("Bar", second_entry.owner.name)
+    end
+
     def test_method_with_parameters
       index(<<~RUBY)
         class Foo
@@ -285,5 +318,28 @@ module RubyIndexer
 
       assert_no_entry("bar")
     end
+
+    def test_properly_tracks_multiple_levels_of_nesting
+      index(<<~RUBY)
+        module Foo
+          def first; end
+
+          module Bar
+            def second; end
+          end
+
+          def third; end
+        end
+      RUBY
+
+      entry = T.must(@index["first"]&.first)
+      assert_equal("Foo", T.must(entry.owner).name)
+
+      entry = T.must(@index["second"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+
+      entry = T.must(@index["third"]&.first)
+      assert_equal("Foo", T.must(entry.owner).name)
+    end
   end
 end

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -42,6 +42,8 @@ module RubyLsp
         @group_stack = T.let([], T::Array[String])
         @group_id = T.let(1, Integer)
         @group_id_stack = T.let([], T::Array[Integer])
+        # We want to avoid adding code lenses for nested definitions
+        @def_depth = T.let(0, Integer)
 
         dispatcher.register(
           self,
@@ -50,6 +52,7 @@ module RubyLsp
           :on_module_node_enter,
           :on_module_node_leave,
           :on_def_node_enter,
+          :on_def_node_leave,
           :on_call_node_enter,
           :on_call_node_leave,
         )
@@ -88,6 +91,9 @@ module RubyLsp
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
+        @def_depth += 1
+        return if @def_depth > 1
+
         class_name = @group_stack.last
         return unless class_name&.end_with?("Test")
 
@@ -105,6 +111,11 @@ module RubyLsp
         end
       end
 
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_leave(node)
+        @def_depth -= 1
+      end
+
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
         if (path = namespace_constant_name(node))

data/lib/ruby_lsp/listeners/completion.rb

@@ -47,7 +47,7 @@ module RubyLsp
           @response_builder << build_entry_completion(
             complete_name,
             name,
-            node,
+            range_from_location(node.location),
             entries,
             top_level?(complete_name),
           )
@@ -62,6 +62,53 @@ module RubyLsp
         name = constant_name(node)
         return if name.nil?
 
+        constant_path_completion(name, range_from_location(node.location))
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        receiver = node.receiver
+
+        # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke singleton
+        # methods). However, in addition to providing method completion, we also need to show possible constant
+        # completions
+        if (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) &&
+            node.call_operator == "::"
+
+          name = constant_name(receiver)
+
+          if name
+            start_loc = node.location
+            end_loc = T.must(node.call_operator_loc)
+
+            constant_path_completion(
+              "#{name}::",
+              Interface::Range.new(
+                start: Interface::Position.new(line: start_loc.start_line - 1, character: start_loc.start_column),
+                end: Interface::Position.new(line: end_loc.end_line - 1, character: end_loc.end_column),
+              ),
+            )
+            return
+          end
+        end
+
+        name = node.message
+        return unless name
+
+        case name
+        when "require"
+          complete_require(node)
+        when "require_relative"
+          complete_require_relative(node)
+        else
+          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
+        end
+      end
+
+      private
+
+      sig { params(name: String, range: Interface::Range).void }
+      def constant_path_completion(name, range)
         top_level_reference = if name.start_with?("::")
           name = name.delete_prefix("::")
           true
@@ -71,8 +118,13 @@ module RubyLsp
 
         # If we're trying to provide completion for an aliased namespace, we need to first discover it's real name in
         # order to find which possible constants match the desired search
-        *namespace, incomplete_name = name.split("::")
-        aliased_namespace = T.must(namespace).join("::")
+        aliased_namespace = if name.end_with?("::")
+          name.delete_suffix("::")
+        else
+          *namespace, incomplete_name = name.split("::")
+          T.must(namespace).join("::")
+        end
+
         namespace_entries = @index.resolve(aliased_namespace, @nesting)
         return unless namespace_entries
 
@@ -88,37 +140,19 @@ module RubyLsp
           first_entry = T.must(entries.first)
           next if first_entry.visibility == :private && !first_entry.name.start_with?("#{@nesting}::")
 
-          constant_name = T.must(first_entry.name.split("::").last)
-
+          constant_name = first_entry.name.delete_prefix("#{real_namespace}::")
           full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
 
           @response_builder << build_entry_completion(
             full_name,
             name,
-            node,
+            range,
             entries,
             top_level_reference || top_level?(T.must(entries.first).name),
           )
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
-        name = node.message
-        return unless name
-
-        case name
-        when "require"
-          complete_require(node)
-        when "require_relative"
-          complete_require_relative(node)
-        else
-          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
-        end
-      end
-
-      private
-
       sig { params(node: Prism::CallNode).void }
       def complete_require(node)
         arguments_node = node.arguments
@@ -223,12 +257,12 @@ module RubyLsp
         params(
           real_name: String,
           incomplete_name: String,
-          node: Prism::Node,
+          range: Interface::Range,
           entries: T::Array[RubyIndexer::Entry],
           top_level: T::Boolean,
         ).returns(Interface::CompletionItem)
       end
-      def build_entry_completion(real_name, incomplete_name, node, entries, top_level)
+      def build_entry_completion(real_name, incomplete_name, range, entries, top_level)
         first_entry = T.must(entries.first)
         kind = case first_entry
         when RubyIndexer::Entry::Class
@@ -263,20 +297,22 @@ module RubyLsp
         #
         #  Foo::B # --> completion inserts `Bar` instead of `Foo::Bar`
         # end
-        @nesting.each do |namespace|
-          prefix = "#{namespace}::"
-          shortened_name = insertion_text.delete_prefix(prefix)
-
-          # If a different entry exists for the shortened name, then there's a conflict and we should not shorten it
-          conflict_name = "#{@nesting.join("::")}::#{shortened_name}"
-          break if real_name != conflict_name && @index[conflict_name]
-
-          insertion_text = shortened_name
-
-          # If the user is typing a fully qualified name `Foo::Bar::Baz`, then we should not use the short name (e.g.:
-          # `Baz`) as filtering. So we only shorten the filter text if the user is not including the namespaces in their
-          # typing
-          filter_text.delete_prefix!(prefix) unless incomplete_name.start_with?(prefix)
+        unless @nesting.join("::").start_with?(incomplete_name)
+          @nesting.each do |namespace|
+            prefix = "#{namespace}::"
+            shortened_name = insertion_text.delete_prefix(prefix)
+
+            # If a different entry exists for the shortened name, then there's a conflict and we should not shorten it
+            conflict_name = "#{@nesting.join("::")}::#{shortened_name}"
+            break if real_name != conflict_name && @index[conflict_name]
+
+            insertion_text = shortened_name
+
+            # If the user is typing a fully qualified name `Foo::Bar::Baz`, then we should not use the short name (e.g.:
+            # `Baz`) as filtering. So we only shorten the filter text if the user is not including the namespaces in
+            # their typing
+            filter_text.delete_prefix!(prefix) unless incomplete_name.start_with?(prefix)
+          end
         end
 
         # When using a top level constant reference (e.g.: `::Bar`), the editor includes the `::` as part of the filter.
@@ -286,7 +322,7 @@ module RubyLsp
           label: real_name,
           filter_text: filter_text,
           text_edit: Interface::TextEdit.new(
-            range: range_from_node(node),
+            range: range,
             new_text: insertion_text,
           ),
           kind: kind,

data/lib/ruby_lsp/listeners/definition.rb

@@ -30,6 +30,7 @@ module RubyLsp
         dispatcher.register(
           self,
           :on_call_node_enter,
+          :on_block_argument_node_enter,
           :on_constant_read_node_enter,
           :on_constant_path_node_enter,
         )
@@ -42,10 +43,21 @@ module RubyLsp
         if message == :require || message == :require_relative
           handle_require_definition(node)
         else
-          handle_method_definition(node)
+          handle_method_definition(message.to_s, self_receiver?(node))
         end
       end
 
+      sig { params(node: Prism::BlockArgumentNode).void }
+      def on_block_argument_node_enter(node)
+        expression = node.expression
+        return unless expression.is_a?(Prism::SymbolNode)
+
+        value = expression.value
+        return unless value
+
+        handle_method_definition(value, false)
+      end
+
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
         name = constant_name(node)
@@ -64,12 +76,9 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode).void }
-      def handle_method_definition(node)
-        message = node.message
-        return unless message
-
-        methods = if self_receiver?(node)
+      sig { params(message: String, self_receiver: T::Boolean).void }
+      def handle_method_definition(message, self_receiver)
+        methods = if self_receiver
           @index.resolve_method(message, @nesting.join("::"))
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -271,7 +271,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return unless matches?(node, CONSTANT_PATH_NODES)
 
-        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+        add_highlight(Constant::DocumentHighlightKind::READ, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantReadNode).void }

data/lib/ruby_lsp/listeners/document_link.rb

@@ -30,7 +30,7 @@ module RubyLsp
                 lookup[spec.name] = {}
                 lookup[spec.name][spec.version.to_s] = {}
 
-                Dir.glob("**/*.rb", base: "#{spec.full_gem_path}/").each do |path|
+                Dir.glob("**/*.rb", base: "#{spec.full_gem_path.delete_prefix("//?/")}/").each do |path|
                   lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
                 end
               end

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -58,6 +58,7 @@ module RubyLsp
           :on_constant_operator_write_node_enter,
           :on_constant_or_write_node_enter,
           :on_constant_target_node_enter,
+          :on_constant_path_node_enter,
           :on_local_variable_and_write_node_enter,
           :on_local_variable_operator_write_node_enter,
           :on_local_variable_or_write_node_enter,
@@ -302,17 +303,64 @@ module RubyLsp
       def on_class_node_enter(node)
         return unless visible?(node, @range)
 
-        @response_builder.add_token(node.constant_path.location, :class, [:declaration])
+        constant_path = node.constant_path
+
+        if constant_path.is_a?(Prism::ConstantReadNode)
+          @response_builder.add_token(constant_path.location, :class, [:declaration])
+        else
+          each_constant_path_part(constant_path) do |part|
+            loc = case part
+            when Prism::ConstantPathNode
+              part.name_loc
+            when Prism::ConstantReadNode
+              part.location
+            end
+            next unless loc
+
+            @response_builder.add_token(loc, :class, [:declaration])
+          end
+        end
 
         superclass = node.superclass
-        @response_builder.add_token(superclass.location, :class) if superclass
+
+        if superclass.is_a?(Prism::ConstantReadNode)
+          @response_builder.add_token(superclass.location, :class)
+        elsif superclass
+          each_constant_path_part(superclass) do |part|
+            loc = case part
+            when Prism::ConstantPathNode
+              part.name_loc
+            when Prism::ConstantReadNode
+              part.location
+            end
+            next unless loc
+
+            @response_builder.add_token(loc, :class)
+          end
+        end
       end
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
         return unless visible?(node, @range)
 
-        @response_builder.add_token(node.constant_path.location, :namespace, [:declaration])
+        constant_path = node.constant_path
+
+        if constant_path.is_a?(Prism::ConstantReadNode)
+          @response_builder.add_token(constant_path.location, :namespace, [:declaration])
+        else
+          each_constant_path_part(constant_path) do |part|
+            loc = case part
+            when Prism::ConstantPathNode
+              part.name_loc
+            when Prism::ConstantReadNode
+              part.location
+            end
+            next unless loc
+
+            @response_builder.add_token(loc, :namespace, [:declaration])
+          end
+        end
       end
 
       sig { params(node: Prism::ImplicitNode).void }
@@ -327,6 +375,14 @@ module RubyLsp
         @inside_implicit_node = false
       end
 
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
+        return if @inside_implicit_node
+        return unless visible?(node, @range)
+
+        @response_builder.add_token(node.name_loc, :namespace)
+      end
+
       private
 
       # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that

data/lib/ruby_lsp/requests/completion.rb

@@ -11,6 +11,7 @@ module RubyLsp
     # suggests possible completions according to what the developer is typing.
     #
     # Currently supported targets:
+    #
     # - Classes
     # - Modules
     # - Constants
@@ -34,7 +35,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'"],
+            trigger_characters: ["/", "\"", "'", ":"],
             completion_item: {
               labelDetailsSupport: true,
             },

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -36,20 +36,27 @@ module RubyLsp
         @item = item
       end
 
-      sig { override.returns(Interface::CompletionItem) }
+      sig { override.returns(T::Hash[Symbol, T.untyped]) }
       def perform
+        # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
+        # a completion resolve request must always return the original completion item without modifying ANY fields
+        # other than label details and documentation. If we modify anything, the completion behaviour might be broken.
+        #
+        # For example, forgetting to return the `insertText` included in the original item will make the editor use the
+        # `label` for the text edit instead
         label = @item[:label]
         entries = @index[label] || []
-        Interface::CompletionItem.new(
-          label: label,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES),
-          ),
+
+        @item[:labelDetails] = Interface::CompletionItemLabelDetails.new(
+          description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
+        )
+
+        @item[:documentation] = Interface::MarkupContent.new(
+          kind: "markdown",
+          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES),
         )
+
+        @item
       end
     end
   end

data/lib/ruby_lsp/requests/definition.rb

@@ -12,6 +12,7 @@ module RubyLsp
     # definition of the symbol under the cursor.
     #
     # Currently supported targets:
+    #
     # - Classes
     # - Modules
     # - Constants
@@ -47,7 +48,7 @@ module RubyLsp
 
         target, parent, nesting = document.locate_node(
           position,
-          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
+          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::BlockArgumentNode],
         )
 
         if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)

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

@@ -50,12 +50,12 @@ module RubyLsp
           params(
             node: Prism::Node,
             title: String,
-            command_name: String,
+            command_name: T.nilable(String),
             arguments: T.nilable(T::Array[T.untyped]),
             data: T.nilable(T::Hash[T.untyped, T.untyped]),
           ).returns(Interface::CodeLens)
         end
-        def create_code_lens(node, title:, command_name:, arguments:, data:)
+        def create_code_lens(node, title:, command_name: nil, arguments: nil, data: nil)
           range = range_from_node(node)
 
           Interface::CodeLens.new(
@@ -167,6 +167,24 @@ module RubyLsp
             constant_name(path)
           end
         end
+
+        # Iterates over each part of a constant path, so that we can easily push response items for each section of the
+        # name. For example, for `Foo::Bar::Baz`, this method will invoke the block with `Foo`, then `Bar` and finally
+        # `Baz`.
+        sig do
+          params(
+            node: Prism::Node,
+            block: T.proc.params(part: Prism::Node).void,
+          ).void
+        end
+        def each_constant_path_part(node, &block)
+          current = T.let(node, T.nilable(Prism::Node))
+
+          while current.is_a?(Prism::ConstantPathNode)
+            block.call(current)
+            current = current.parent
+          end
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.16.6
+  version: 0.16.7
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 2024-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: 0.29.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.28'
+        version: '0.30'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.23.0
+        version: 0.29.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.28'
+        version: '0.30'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -78,8 +78,8 @@ files:
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
 - lib/ruby-lsp.rb
-- lib/ruby_indexer/lib/ruby_indexer/collector.rb
 - lib/ruby_indexer/lib/ruby_indexer/configuration.rb
+- lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb
 - lib/ruby_indexer/lib/ruby_indexer/entry.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
 - lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
@@ -178,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.10
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby