ruby-lsp 0.16.6 → 0.17.0

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,65 @@ 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_visibility_tracking
+      index(<<~RUBY)
+        private def foo
+        end
+
+        def bar; end
+
+        protected
+
+        def baz; end
+      RUBY
+
+      assert_entry("foo", Entry::InstanceMethod, "/fake/path/foo.rb:0-8:1-3", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:3-0:3-12", visibility: Entry::Visibility::PUBLIC)
+      assert_entry("baz", Entry::InstanceMethod, "/fake/path/foo.rb:7-0:7-12", visibility: Entry::Visibility::PROTECTED)
+    end
+
+    def test_visibility_tracking_with_nested_class_or_modules
+      index(<<~RUBY)
+        class Foo
+          private
+
+          def foo; end
+
+          class Bar
+            def bar; end
+          end
+
+          def baz; end
+        end
+      RUBY
+
+      assert_entry("foo", Entry::InstanceMethod, "/fake/path/foo.rb:3-2:3-14", visibility: Entry::Visibility::PRIVATE)
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:6-4:6-16", visibility: Entry::Visibility::PUBLIC)
+      assert_entry("baz", Entry::InstanceMethod, "/fake/path/foo.rb:9-2:9-14", visibility: Entry::Visibility::PRIVATE)
+    end
+
     def test_method_with_parameters
       index(<<~RUBY)
         class Foo
@@ -285,5 +355,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_indexer/test/test_case.rb

@@ -15,7 +15,7 @@ module RubyIndexer
       @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), source)
     end
 
-    def assert_entry(expected_name, type, expected_location)
+    def assert_entry(expected_name, type, expected_location, visibility: nil)
       entries = @index[expected_name]
       refute_empty(entries, "Expected #{expected_name} to be indexed")
 
@@ -28,6 +28,8 @@ module RubyIndexer
           ":#{location.end_line - 1}-#{location.end_column}"
 
       assert_equal(expected_location, location_string)
+
+      assert_equal(visibility, entry.visibility) if visibility
     end
 
     def refute_entry(expected_name)

data/lib/ruby_lsp/addon.rb

@@ -99,8 +99,8 @@ module RubyLsp
     end
 
     sig { returns(String) }
-    def backtraces
-      @errors.filter_map(&:backtrace).join("\n\n")
+    def errors_details
+      @errors.map(&:full_message).join("\n\n")
     end
 
     # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
@@ -131,11 +131,11 @@ module RubyLsp
     sig do
       overridable.params(
         response_builder: ResponseBuilders::Hover,
-        nesting: T::Array[String],
+        node_context: NodeContext,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_hover_listener(response_builder, nesting, dispatcher); end
+    def create_hover_listener(response_builder, node_context, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
@@ -159,21 +159,21 @@ module RubyLsp
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
         uri: URI::Generic,
-        nesting: T::Array[String],
+        node_context: NodeContext,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_definition_listener(response_builder, uri, nesting, dispatcher); end
+    def create_definition_listener(response_builder, uri, node_context, dispatcher); end
 
     # Creates a new Completion listener. This method is invoked on every Completion request
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        nesting: T::Array[String],
+        node_context: NodeContext,
         dispatcher: Prism::Dispatcher,
         uri: URI::Generic,
       ).void
     end
-    def create_completion_listener(response_builder, nesting, dispatcher, uri); end
+    def create_completion_listener(response_builder, node_context, dispatcher, uri); end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -110,7 +110,7 @@ module RubyLsp
       params(
         position: T::Hash[Symbol, T.untyped],
         node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns([T.nilable(Prism::Node), T.nilable(Prism::Node), T::Array[String]])
+      ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
       locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
@@ -121,7 +121,7 @@ module RubyLsp
         node: Prism::Node,
         char_position: Integer,
         node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns([T.nilable(Prism::Node), T.nilable(Prism::Node), T::Array[String]])
+      ).returns(NodeContext)
     end
     def locate(node, char_position, node_types: [])
       queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
@@ -170,7 +170,7 @@ module RubyLsp
         end
       end
 
-      [closest, parent, nesting.map { |n| n.constant_path.location.slice }]
+      NodeContext.new(closest, parent, nesting.map { |n| n.constant_path.location.slice })
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/internal.rb

@@ -29,6 +29,7 @@ require "ruby_lsp/global_state"
 require "ruby_lsp/server"
 require "ruby_lsp/requests"
 require "ruby_lsp/response_builders"
+require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"

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

@@ -11,17 +11,17 @@ module RubyLsp
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
           global_state: GlobalState,
-          nesting: T::Array[String],
+          node_context: NodeContext,
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
         ).void
       end
-      def initialize(response_builder, global_state, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, node_context, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
-        @nesting = nesting
+        @node_context = node_context
         @typechecker_enabled = typechecker_enabled
         @uri = uri
 
@@ -30,6 +30,12 @@ module RubyLsp
           :on_constant_path_node_enter,
           :on_constant_read_node_enter,
           :on_call_node_enter,
+          :on_instance_variable_read_node_enter,
+          :on_instance_variable_write_node_enter,
+          :on_instance_variable_and_write_node_enter,
+          :on_instance_variable_operator_write_node_enter,
+          :on_instance_variable_or_write_node_enter,
+          :on_instance_variable_target_node_enter,
         )
       end
 
@@ -41,13 +47,13 @@ module RubyLsp
         name = constant_name(node)
         return if name.nil?
 
-        candidates = @index.prefix_search(name, @nesting)
+        candidates = @index.prefix_search(name, @node_context.nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
           @response_builder << build_entry_completion(
             complete_name,
             name,
-            node,
+            range_from_location(node.location),
             entries,
             top_level?(complete_name),
           )
@@ -62,6 +68,83 @@ 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
+
+      sig { params(node: Prism::InstanceVariableReadNode).void }
+      def on_instance_variable_read_node_enter(node)
+        handle_instance_variable_completion(node.name.to_s, node.location)
+      end
+
+      sig { params(node: Prism::InstanceVariableWriteNode).void }
+      def on_instance_variable_write_node_enter(node)
+        handle_instance_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+      def on_instance_variable_and_write_node_enter(node)
+        handle_instance_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+      def on_instance_variable_operator_write_node_enter(node)
+        handle_instance_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+      def on_instance_variable_or_write_node_enter(node)
+        handle_instance_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::InstanceVariableTargetNode).void }
+      def on_instance_variable_target_node_enter(node)
+        handle_instance_variable_completion(node.name.to_s, node.location)
+      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,54 +154,63 @@ 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("::")
-        namespace_entries = @index.resolve(aliased_namespace, @nesting)
+        aliased_namespace = if name.end_with?("::")
+          name.delete_suffix("::")
+        else
+          *namespace, incomplete_name = name.split("::")
+          T.must(namespace).join("::")
+        end
+
+        nesting = @node_context.nesting
+        namespace_entries = @index.resolve(aliased_namespace, nesting)
         return unless namespace_entries
 
         real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
 
         candidates = @index.prefix_search(
           "#{real_namespace}::#{incomplete_name}",
-          top_level_reference ? [] : @nesting,
+          top_level_reference ? [] : nesting,
         )
         candidates.each do |entries|
           # The only time we may have a private constant reference from outside of the namespace is if we're dealing
           # with ConstantPath and the entry name doesn't start with the current nesting
           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)
+          next if first_entry.private? && !first_entry.name.start_with?("#{nesting}::")
 
+          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)
+      sig { params(name: String, location: Prism::Location).void }
+      def handle_instance_variable_completion(name, location)
+        @index.instance_variable_completion_candidates(name, @node_context.fully_qualified_name).each do |entry|
+          variable_name = entry.name
+
+          @response_builder << Interface::CompletionItem.new(
+            label: variable_name,
+            text_edit: Interface::TextEdit.new(
+              range: range_from_location(location),
+              new_text: variable_name,
+            ),
+            kind: Constant::CompletionItemKind::FIELD,
+            data: {
+              owner_name: entry.owner&.name,
+            },
+          )
         end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      private
-
       sig { params(node: Prism::CallNode).void }
       def complete_require(node)
         arguments_node = node.arguments
@@ -166,15 +258,12 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode, name: String).void }
       def complete_self_receiver_method(node, name)
-        receiver_entries = @index[@nesting.join("::")]
+        receiver_entries = @index[@node_context.fully_qualified_name]
         return unless receiver_entries
 
         receiver = T.must(receiver_entries.first)
 
-        @index.prefix_search(name).each do |entries|
-          entry = entries.find { |e| e.is_a?(RubyIndexer::Entry::Member) && e.owner&.name == receiver.name }
-          next unless entry
-
+        @index.method_completion_candidates(name, receiver.name).each do |entry|
           @response_builder << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
         end
       end
@@ -223,12 +312,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 +352,23 @@ 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)
+        nesting = @node_context.nesting
+        unless @node_context.fully_qualified_name.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 = "#{@node_context.fully_qualified_name}::#{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 +378,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,
@@ -309,8 +401,9 @@ module RubyLsp
       # ```
       sig { params(entry_name: String).returns(T::Boolean) }
       def top_level?(entry_name)
-        @nesting.length.downto(0).each do |i|
-          prefix = T.must(@nesting[0...i]).join("::")
+        nesting = @node_context.nesting
+        nesting.length.downto(0).each do |i|
+          prefix = T.must(nesting[0...i]).join("::")
           full_name = prefix.empty? ? entry_name : "#{prefix}::#{entry_name}"
           next if full_name == entry_name