ruby-lsp 0.11.1 → 0.12.0

data/lib/ruby_lsp/requests/completion.rb

@@ -30,42 +30,53 @@ module RubyLsp
         params(
           index: RubyIndexer::Index,
           nesting: T::Array[String],
-          emitter: EventEmitter,
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).void
       end
-      def initialize(index, nesting, emitter, message_queue)
-        super(emitter, message_queue)
+      def initialize(index, nesting, dispatcher, message_queue)
+        super(dispatcher, message_queue)
         @_response = T.let([], ResponseType)
         @index = index
         @nesting = nesting
 
-        emitter.register(self, :on_string, :on_constant_path, :on_constant_read)
+        dispatcher.register(
+          self,
+          :on_string_node_enter,
+          :on_constant_path_node_enter,
+          :on_constant_read_node_enter,
+        )
       end
 
-      sig { params(node: YARP::StringNode).void }
-      def on_string(node)
+      sig { params(node: Prism::StringNode).void }
+      def on_string_node_enter(node)
         @index.search_require_paths(node.content).map!(&:require_path).sort!.each do |path|
           @_response << build_completion(T.must(path), node)
         end
       end
 
       # Handle completion on regular constant references (e.g. `Bar`)
-      sig { params(node: YARP::ConstantReadNode).void }
-      def on_constant_read(node)
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
         name = node.slice
         candidates = @index.prefix_search(name, @nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
-          @_response << build_entry_completion(complete_name, node, entries, top_level?(complete_name, candidates))
+          @_response << build_entry_completion(
+            complete_name,
+            name,
+            node,
+            entries,
+            top_level?(complete_name),
+          )
         end
       end
 
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
-      sig { params(node: YARP::ConstantPathNode).void }
-      def on_constant_path(node)
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
         return if DependencyDetector.instance.typechecker
 
         name = node.slice
@@ -80,7 +91,7 @@ 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 = namespace.join("::")
+        aliased_namespace = T.must(namespace).join("::")
         namespace_entries = @index.resolve(aliased_namespace, @nesting)
         return unless namespace_entries
 
@@ -99,16 +110,17 @@ module RubyLsp
 
           @_response << build_entry_completion(
             full_name,
+            name,
             node,
             entries,
-            top_level_reference || top_level?(T.must(entries.first).name, candidates),
+            top_level_reference || top_level?(T.must(entries.first).name),
           )
         end
       end
 
       private
 
-      sig { params(label: String, node: YARP::StringNode).returns(Interface::CompletionItem) }
+      sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
         Interface::CompletionItem.new(
           label: label,
@@ -122,33 +134,38 @@ module RubyLsp
 
       sig do
         params(
-          name: String,
-          node: YARP::Node,
-          entries: T::Array[RubyIndexer::Index::Entry],
+          real_name: String,
+          incomplete_name: String,
+          node: Prism::Node,
+          entries: T::Array[RubyIndexer::Entry],
           top_level: T::Boolean,
         ).returns(Interface::CompletionItem)
       end
-      def build_entry_completion(name, node, entries, top_level)
+      def build_entry_completion(real_name, incomplete_name, node, entries, top_level)
         first_entry = T.must(entries.first)
         kind = case first_entry
-        when RubyIndexer::Index::Entry::Class
+        when RubyIndexer::Entry::Class
           Constant::CompletionItemKind::CLASS
-        when RubyIndexer::Index::Entry::Module
+        when RubyIndexer::Entry::Module
           Constant::CompletionItemKind::MODULE
-        when RubyIndexer::Index::Entry::Constant
+        when RubyIndexer::Entry::Constant
           Constant::CompletionItemKind::CONSTANT
         else
           Constant::CompletionItemKind::REFERENCE
         end
 
-        insertion_text = name.dup
+        insertion_text = real_name.dup
+        filter_text = real_name.dup
 
         # If we have two entries with the same name inside the current namespace and the user selects the top level
         # option, we have to ensure it's prefixed with `::` or else we're completing the wrong constant. For example:
         # If we have the index with ["Foo::Bar", "Bar"], and we're providing suggestions for `B` inside a `Foo` module,
         # then selecting the `Foo::Bar` option needs to complete to `Bar` and selecting the top level `Bar` option needs
         # to complete to `::Bar`.
-        insertion_text.prepend("::") if top_level
+        if top_level
+          insertion_text.prepend("::")
+          filter_text.prepend("::")
+        end
 
         # If the user is searching for a constant inside the current namespace, then we prefer completing the short name
         # of that constant. E.g.:
@@ -159,14 +176,28 @@ module RubyLsp
         #
         #  Foo::B # --> completion inserts `Bar` instead of `Foo::Bar`
         # end
-        @nesting.each { |namespace| insertion_text.delete_prefix!("#{namespace}::") }
+        @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
 
         # When using a top level constant reference (e.g.: `::Bar`), the editor includes the `::` as part of the filter.
         # For these top level references, we need to include the `::` as part of the filter text or else it won't match
         # the right entries in the index
         Interface::CompletionItem.new(
-          label: name,
-          filter_text: top_level ? "::#{name}" : name,
+          label: real_name,
+          filter_text: filter_text,
           text_edit: Interface::TextEdit.new(
             range: range_from_node(node),
             new_text: insertion_text,
@@ -175,15 +206,35 @@ module RubyLsp
           label_details: Interface::CompletionItemLabelDetails.new(
             description: entries.map(&:file_name).join(","),
           ),
-          documentation: markdown_from_index_entries(name, entries),
+          documentation: markdown_from_index_entries(real_name, entries),
         )
       end
 
-      # Check if the `entry_name` has potential conflicts in `candidates`, so that we use a top level reference instead
-      # of a short name
-      sig { params(entry_name: String, candidates: T::Array[T::Array[RubyIndexer::Index::Entry]]).returns(T::Boolean) }
-      def top_level?(entry_name, candidates)
-        candidates.any? { |entries| T.must(entries.first).name == "#{@nesting.join("::")}::#{entry_name}" }
+      # Check if there are any conflicting names for `entry_name`, which would require us to use a top level reference.
+      # For example:
+      #
+      # ```ruby
+      # class Bar; end
+      #
+      # module Foo
+      #   class Bar; end
+      #
+      #   # in this case, the completion for `Bar` conflicts with `Foo::Bar`, so we can't suggest `Bar` as the
+      #   # completion, but instead need to suggest `::Bar`
+      #   B
+      # end
+      # ```
+      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("::")
+          full_name = prefix.empty? ? entry_name : "#{prefix}::#{entry_name}"
+          next if full_name == entry_name
+
+          return true if @index[full_name]
+        end
+
+        false
       end
     end
   end

data/lib/ruby_lsp/requests/definition.rb

@@ -31,23 +31,29 @@ module RubyLsp
           uri: URI::Generic,
           nesting: T::Array[String],
           index: RubyIndexer::Index,
-          emitter: EventEmitter,
+          dispatcher: Prism::Dispatcher,
           message_queue: Thread::Queue,
         ).void
       end
-      def initialize(uri, nesting, index, emitter, message_queue)
+      def initialize(uri, nesting, index, dispatcher, message_queue)
         @uri = uri
         @nesting = nesting
         @index = index
         @_response = T.let(nil, ResponseType)
 
-        super(emitter, message_queue)
+        super(dispatcher, message_queue)
 
-        emitter.register(self, :on_call, :on_constant_read, :on_constant_path)
+        dispatcher.register(
+          self,
+          :on_call_node_enter,
+          :on_constant_read_node_enter,
+          :on_constant_path_node_enter,
+        )
       end
+
       sig { override.params(addon: Addon).returns(T.nilable(RubyLsp::Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_definition_listener(@uri, @nesting, @index, @emitter, @message_queue)
+        addon.create_definition_listener(@uri, @nesting, @index, @dispatcher, @message_queue)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
@@ -66,19 +72,19 @@ module RubyLsp
         self
       end
 
-      sig { params(node: YARP::CallNode).void }
-      def on_call(node)
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
         message = node.name
-        return unless message == "require" || message == "require_relative"
+        return unless message == :require || message == :require_relative
 
         arguments = node.arguments
         return unless arguments
 
         argument = arguments.arguments.first
-        return unless argument.is_a?(YARP::StringNode)
+        return unless argument.is_a?(Prism::StringNode)
 
         case message
-        when "require"
+        when :require
           entry = @index.search_require_paths(argument.content).find do |indexable_path|
             indexable_path.require_path == argument.content
           end
@@ -94,7 +100,7 @@ module RubyLsp
               ),
             )
           end
-        when "require_relative"
+        when :require_relative
           required_file = "#{argument.content}.rb"
           path = @uri.to_standardized_path
           current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
@@ -110,13 +116,13 @@ module RubyLsp
         end
       end
 
-      sig { params(node: YARP::ConstantPathNode).void }
-      def on_constant_path(node)
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
         find_in_index(node.slice)
       end
 
-      sig { params(node: YARP::ConstantReadNode).void }
-      def on_constant_read(node)
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
         find_in_index(node.slice)
       end
 

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -60,7 +60,7 @@ module RubyLsp
             ),
             message: error.message,
             severity: Constant::DiagnosticSeverity::ERROR,
-            source: "YARP",
+            source: "Prism",
           )
         end
       end