ruby-lsp 0.13.1 → 0.13.3

data/lib/ruby_lsp/requests/completion.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/completion"
+
 module RubyLsp
   module Requests
     # ![Completion demo](../../completion.gif)
@@ -22,271 +24,87 @@ module RubyLsp
     #
     # RubyLsp::Requests:: # --> completion: suggests `Completion`, `Hover`, ...
     # ```
-    class Completion < Listener
+    class Completion < Request
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
-
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
-
-      sig do
-        params(
-          index: RubyIndexer::Index,
-          nesting: T::Array[String],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
-      def initialize(index, nesting, dispatcher)
-        super(dispatcher)
-        @_response = T.let([], ResponseType)
-        @index = index
-        @nesting = nesting
-
-        dispatcher.register(
-          self,
-          :on_string_node_enter,
-          :on_constant_path_node_enter,
-          :on_constant_read_node_enter,
-          :on_call_node_enter,
-        )
-      end
-
-      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: 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,
-            name,
-            node,
-            entries,
-            top_level?(complete_name),
-          )
-        end
-      end
-
-      # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
-      sig { params(node: Prism::ConstantPathNode).void }
-      def on_constant_path_node_enter(node)
-        return if DependencyDetector.instance.typechecker
-
-        name = node.slice
-
-        top_level_reference = if name.start_with?("::")
-          name = name.delete_prefix("::")
-          true
-        else
-          false
-        end
-
-        # 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)
-        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)
-        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)
-
-          full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
-
-          @_response << build_entry_completion(
-            full_name,
-            name,
-            node,
-            entries,
-            top_level_reference || top_level?(T.must(entries.first).name),
+      class << self
+        extend T::Sig
+
+        sig { returns(Interface::CompletionOptions) }
+        def provider
+          Interface::CompletionOptions.new(
+            resolve_provider: false,
+            trigger_characters: ["/"],
+            completion_item: {
+              labelDetailsSupport: true,
+            },
           )
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
-        return if DependencyDetector.instance.typechecker
-        return unless self_receiver?(node)
-
-        name = node.message
-        return unless name
-
-        receiver_entries = @index[@nesting.join("::")]
-        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
-
-          @_response << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
-        end
-      end
-
-      private
+      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
 
       sig do
         params(
-          entry: RubyIndexer::Entry::Member,
-          node: Prism::CallNode,
-        ).returns(Interface::CompletionItem)
+          document: Document,
+          index: RubyIndexer::Index,
+          position: T::Hash[Symbol, T.untyped],
+          typechecker_enabled: T::Boolean,
+          dispatcher: Prism::Dispatcher,
+        ).void
       end
-      def build_method_completion(entry, node)
-        name = entry.name
-        parameters = entry.parameters
-        new_text = parameters.empty? ? name : "#{name}(#{parameters.map(&:name).join(", ")})"
-
-        Interface::CompletionItem.new(
-          label: name,
-          filter_text: name,
-          text_edit: Interface::TextEdit.new(range: range_from_node(node), new_text: new_text),
-          kind: Constant::CompletionItemKind::METHOD,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            description: entry.file_name,
-          ),
-          documentation: markdown_from_index_entries(name, entry),
+      def initialize(document, index, position, typechecker_enabled, dispatcher)
+        super()
+        @target = T.let(nil, T.nilable(Prism::Node))
+        @dispatcher = dispatcher
+        # Completion always receives the position immediately after the character that was just typed. Here we adjust it
+        # back by 1, so that we find the right node
+        char_position = document.create_scanner.find_char_position(position) - 1
+        matched, parent, nesting = document.locate(
+          document.tree,
+          char_position,
+          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
         )
-      end
 
-      sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
-      def build_completion(label, node)
-        # We should use the content location as we only replace the content and not the delimiters of the string
-        loc = node.content_loc
-
-        Interface::CompletionItem.new(
-          label: label,
-          text_edit: Interface::TextEdit.new(
-            range: range_from_location(loc),
-            new_text: label,
-          ),
-          kind: Constant::CompletionItemKind::FILE,
+        @listener = T.let(
+          Listeners::Completion.new(index, nesting, typechecker_enabled, dispatcher),
+          Listener[ResponseType],
         )
-      end
 
-      sig do
-        params(
-          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(real_name, incomplete_name, node, entries, top_level)
-        first_entry = T.must(entries.first)
-        kind = case first_entry
-        when RubyIndexer::Entry::Class
-          Constant::CompletionItemKind::CLASS
-        when RubyIndexer::Entry::Module
-          Constant::CompletionItemKind::MODULE
-        when RubyIndexer::Entry::Constant
-          Constant::CompletionItemKind::CONSTANT
-        else
-          Constant::CompletionItemKind::REFERENCE
-        end
-
-        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`.
-        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.:
-        #
-        # module Foo
-        #  class Bar
-        #  end
-        #
-        #  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)
+        return unless matched && parent
+
+        @target = case matched
+        when Prism::CallNode
+          message = matched.message
+
+          if message == "require"
+            args = matched.arguments&.arguments
+            return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
+
+            argument = args.first
+            return unless argument.is_a?(Prism::StringNode)
+            return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
+
+            argument
+          else
+            matched
+          end
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
+            parent
+          else
+            matched
+          end
         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: real_name,
-          filter_text: filter_text,
-          text_edit: Interface::TextEdit.new(
-            range: range_from_node(node),
-            new_text: insertion_text,
-          ),
-          kind: kind,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            description: entries.map(&:file_name).join(","),
-          ),
-          documentation: markdown_from_index_entries(real_name, entries),
-        )
       end
 
-      # 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
+      sig { override.returns(ResponseType) }
+      def perform
+        return [] unless @target
 
-        false
+        @dispatcher.dispatch_once(@target)
+        @listener.response
       end
     end
   end

data/lib/ruby_lsp/requests/definition.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/definition"
+
 module RubyLsp
   module Requests
     # ![Definition demo](../../definition.gif)
@@ -22,174 +24,59 @@ module RubyLsp
     # require "some_gem/file" # <- Request go to definition on this string will take you to the file
     # Product.new # <- Request go to definition on this class name will take you to its declaration.
     # ```
-    class Definition < ExtensibleListener
+    class Definition < Request
       extend T::Sig
       extend T::Generic
 
       ResponseType = type_member { { fixed: T.nilable(T.any(T::Array[Interface::Location], Interface::Location)) } }
 
-      sig { override.returns(ResponseType) }
-      attr_reader :_response
-
       sig do
         params(
-          uri: URI::Generic,
-          nesting: T::Array[String],
+          document: Document,
           index: RubyIndexer::Index,
+          position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
+          typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(uri, nesting, index, dispatcher)
-        @uri = uri
-        @nesting = nesting
-        @index = index
-        @_response = T.let(nil, ResponseType)
-
-        super(dispatcher)
-
-        dispatcher.register(
-          self,
-          :on_call_node_enter,
-          :on_constant_read_node_enter,
-          :on_constant_path_node_enter,
+      def initialize(document, index, position, dispatcher, typechecker_enabled)
+        super()
+        target, parent, nesting = document.locate_node(
+          position,
+          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
         )
-      end
-
-      sig { override.params(addon: Addon).returns(T.nilable(RubyLsp::Listener[ResponseType])) }
-      def initialize_external_listener(addon)
-        addon.create_definition_listener(@uri, @nesting, @index, @dispatcher)
-      end
 
-      sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
-      def merge_response!(other)
-        other_response = other._response
-
-        case @_response
-        when Interface::Location
-          @_response = [@_response, *other_response]
-        when Array
-          @_response.concat(Array(other_response))
-        when nil
-          @_response = other_response
-        end
+        target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
 
-        self
-      end
-
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
-        message = node.name
-
-        if message == :require || message == :require_relative
-          handle_require_definition(node)
-        else
-          handle_method_definition(node)
+        @listeners = T.let(
+          [Listeners::Definition.new(document.uri, nesting, index, dispatcher, typechecker_enabled)],
+          T::Array[Listener[T.nilable(T.any(T::Array[Interface::Location], Interface::Location))]],
+        )
+        Addon.addons.each do |addon|
+          addon_listener = addon.create_definition_listener(document.uri, nesting, index, dispatcher)
+          @listeners << addon_listener if addon_listener
         end
-      end
 
-      sig { params(node: Prism::ConstantPathNode).void }
-      def on_constant_path_node_enter(node)
-        find_in_index(node.slice)
+        @target = T.let(target, T.nilable(Prism::Node))
+        @dispatcher = dispatcher
       end
 
-      sig { params(node: Prism::ConstantReadNode).void }
-      def on_constant_read_node_enter(node)
-        find_in_index(node.slice)
-      end
-
-      private
-
-      sig { params(node: Prism::CallNode).void }
-      def handle_method_definition(node)
-        return unless self_receiver?(node)
-
-        message = node.message
-        return unless message
-
-        target_method = @index.resolve_method(message, @nesting.join("::"))
-        return unless target_method
-
-        location = target_method.location
-        file_path = target_method.file_path
-        return if defined_in_gem?(file_path)
-
-        @_response = Interface::Location.new(
-          uri: URI::Generic.from_path(path: file_path).to_s,
-          range: Interface::Range.new(
-            start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-            end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-          ),
-        )
-      end
-
-      sig { params(node: Prism::CallNode).void }
-      def handle_require_definition(node)
-        message = node.name
-        arguments = node.arguments
-        return unless arguments
-
-        argument = arguments.arguments.first
-        return unless argument.is_a?(Prism::StringNode)
-
-        case message
-        when :require
-          entry = @index.search_require_paths(argument.content).find do |indexable_path|
-            indexable_path.require_path == argument.content
-          end
-
-          if entry
-            candidate = entry.full_path
-
-            @_response = Interface::Location.new(
-              uri: URI::Generic.from_path(path: candidate).to_s,
-              range: Interface::Range.new(
-                start: Interface::Position.new(line: 0, character: 0),
-                end: Interface::Position.new(line: 0, character: 0),
-              ),
-            )
+      sig { override.returns(ResponseType) }
+      def perform
+        @dispatcher.dispatch_once(@target)
+        result = []
+
+        @listeners.each do |listener|
+          res = listener.response
+          case res
+          when Interface::Location
+            result << res
+          when Array
+            result.concat(res)
           end
-        when :require_relative
-          required_file = "#{argument.content}.rb"
-          path = @uri.to_standardized_path
-          current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
-          candidate = File.expand_path(File.join(current_folder, required_file))
-
-          @_response = Interface::Location.new(
-            uri: URI::Generic.from_path(path: candidate).to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: 0, character: 0),
-              end: Interface::Position.new(line: 0, character: 0),
-            ),
-          )
         end
-      end
 
-      sig { params(value: String).void }
-      def find_in_index(value)
-        entries = @index.resolve(value, @nesting)
-        return unless entries
-
-        # We should only allow jumping to the definition of private constants if the constant is defined in the same
-        # namespace as the reference
-        first_entry = T.must(entries.first)
-        return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{value}"
-
-        @_response = entries.filter_map do |entry|
-          location = entry.location
-          # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
-          # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
-          # in the project, even if the files are typed false
-          file_path = entry.file_path
-          next if defined_in_gem?(file_path)
-
-          Interface::Location.new(
-            uri: URI::Generic.from_path(path: file_path).to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
-          )
-        end
+        result if result.any?
       end
     end
   end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -18,21 +18,33 @@ module RubyLsp
     # puts "Hello" # --> diagnostics: incorrect indentation
     # end
     # ```
-    class Diagnostics < BaseRequest
+    class Diagnostics < Request
       extend T::Sig
 
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Hash[Symbol, T::Boolean]) }
+        def provider
+          {
+            interFileDependencies: false,
+            workspaceDiagnostics: false,
+          }
+        end
+      end
+
       sig { params(document: Document).void }
       def initialize(document)
-        super(document)
-
+        super()
+        @document = document
         @uri = T.let(document.uri, URI::Generic)
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::Diagnostic], Object))) }
-      def run
+      def perform
         # Running RuboCop is slow, so to avoid excessive runs we only do so if the file is syntactically valid
         return syntax_error_diagnostics if @document.syntax_error?
-        return unless defined?(Support::RuboCopDiagnosticsRunner)
+        return [] unless defined?(Support::RuboCopDiagnosticsRunner)
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document).map!(&:to_lsp_diagnostic)
       end