ruby-lsp 0.17.4 → 0.17.6

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -63,5 +63,264 @@ module RubyIndexer
       assert_instance_of(Entry::SingletonClass, owner)
       assert_equal("File::<Class:File>", owner.name)
     end
+
+    def test_location_and_name_location_are_the_same
+      # NOTE: RBS does not store the name location for classes, modules or methods. This behaviour is not exactly what
+      # we would like, but for now we assign the same location to both
+
+      entries = @index["Array"]
+      refute_nil(entries)
+      entry = entries.find { |entry| entry.is_a?(Entry::Class) }
+
+      assert_same(entry.location, entry.name_location)
+    end
+
+    def test_rbs_method_with_required_positionals
+      entries = @index["crypt"]
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+      signatures = entry.signatures
+      assert_equal(1, signatures.length)
+
+      first_signature = signatures.first
+
+      # (::string salt_str) -> ::String
+
+      assert_equal(1, first_signature.parameters.length)
+      assert_kind_of(Entry::RequiredParameter, first_signature.parameters[0])
+      assert_equal(:salt_str, first_signature.parameters[0].name)
+    end
+
+    def test_rbs_method_with_unnamed_required_positionals
+      entries = @index["try_convert"]
+      entry = entries.find { |entry| entry.owner.name == "Array::<Class:Array>" }
+
+      parameters = entry.signatures[0].parameters
+
+      assert_equal([:arg0], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+    end
+
+    def test_rbs_method_with_optional_positionals
+      entries = @index["polar"]
+      entry = entries.find { |entry| entry.owner.name == "Complex::<Class:Complex>" }
+
+      # def self.polar: (Numeric, ?Numeric) -> Complex
+
+      parameters = entry.signatures[0].parameters
+
+      assert_equal([:arg0, :arg1], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+    end
+
+    def test_rbs_method_with_optional_parameter
+      entries = @index["chomp"]
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+      signatures = entry.signatures
+      assert_equal(1, signatures.length)
+
+      first_signature = signatures.first
+
+      # (?::string? separator) -> ::String
+
+      assert_equal(1, first_signature.parameters.length)
+      assert_kind_of(Entry::OptionalParameter, first_signature.parameters[0])
+      assert_equal(:separator, first_signature.parameters[0].name)
+    end
+
+    def test_rbs_method_with_required_and_optional_parameters
+      entries = @index["gsub"]
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+
+      signatures = entry.signatures
+      assert_equal(3, signatures.length)
+
+      # (::Regexp | ::string pattern, ::string | ::hash[::String, ::_ToS] replacement) -> ::String
+      # | (::Regexp | ::string pattern) -> ::Enumerator[::String, ::String]
+      # | (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String
+
+      parameters = signatures[0].parameters
+      assert_equal([:pattern, :replacement], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::RequiredParameter, parameters[1])
+
+      parameters = signatures[1].parameters
+      assert_equal([:pattern], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+
+      parameters = signatures[2].parameters
+      assert_equal([:pattern, :"<anonymous block>"], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::BlockParameter, parameters[1])
+    end
+
+    def test_rbs_anonymous_block_parameter
+      entries = @index["open"]
+      entry = entries.find { |entry| entry.owner.name == "File::<Class:File>" }
+
+      assert_equal(2, entry.signatures.length)
+
+      # (::String name, ?::String mode, ?::Integer perm) -> ::IO?
+      # | [T] (::String name, ?::String mode, ?::Integer perm) { (::IO) -> T } -> T
+
+      parameters = entry.signatures[0].parameters
+      assert_equal([:file_name, :mode, :perm], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+
+      parameters = entry.signatures[1].parameters
+      assert_equal([:file_name, :mode, :perm, :"<anonymous block>"], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+      assert_kind_of(Entry::BlockParameter, parameters[3])
+    end
+
+    def test_rbs_method_with_rest_positionals
+      entries = @index["count"]
+      entry = entries.find { |entry| entry.owner.name == "String" }
+
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, entry.signatures.length)
+
+      # (::String::selector selector_0, *::String::selector more_selectors) -> ::Integer
+
+      assert_equal([:selector_0, :more_selectors], parameters.map(&:name))
+      assert_kind_of(RubyIndexer::Entry::RequiredParameter, parameters[0])
+      assert_kind_of(RubyIndexer::Entry::RestParameter, parameters[1])
+    end
+
+    def test_rbs_method_with_trailing_positionals
+      entries = @index["select"] # https://ruby-doc.org/3.3.3/IO.html#method-c-select
+      entry = entries.find { |entry| entry.owner.name == "IO::<Class:IO>" }
+
+      signatures = entry.signatures
+      assert_equal(2, signatures.length)
+
+      # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ] # rubocop:disable Layout/LineLength
+      #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]? # rubocop:disable Layout/LineLength
+
+      parameters = signatures[0].parameters
+      assert_equal([:read_array, :write_array, :error_array], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+
+      parameters = signatures[1].parameters
+      assert_equal([:read_array, :write_array, :error_array, :timeout], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+      assert_kind_of(Entry::OptionalParameter, parameters[3])
+    end
+
+    def test_rbs_method_with_optional_keywords
+      entries = @index["step"]
+      entry = entries.find { |entry| entry.owner.name == "Numeric" }
+
+      signatures = entry.signatures
+      assert_equal(4, signatures.length)
+
+      # (?::Numeric limit, ?::Numeric step) { (::Numeric) -> void } -> self
+      # | (?::Numeric limit, ?::Numeric step) -> ::Enumerator[::Numeric, self]
+      # | (?by: ::Numeric, ?to: ::Numeric) { (::Numeric) -> void } -> self
+      # | (?by: ::Numeric, ?to: ::Numeric) -> ::Enumerator[::Numeric, self]
+
+      parameters = signatures[0].parameters
+      assert_equal([:limit, :step, :"<anonymous block>"], parameters.map(&:name))
+      assert_kind_of(Entry::OptionalParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::BlockParameter, parameters[2])
+
+      parameters = signatures[1].parameters
+      assert_equal([:limit, :step], parameters.map(&:name))
+      assert_kind_of(Entry::OptionalParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+
+      parameters = signatures[2].parameters
+      assert_equal([:by, :to, :"<anonymous block>"], parameters.map(&:name))
+      assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
+      assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
+      assert_kind_of(Entry::BlockParameter, parameters[2])
+
+      parameters = signatures[3].parameters
+      assert_equal([:by, :to], parameters.map(&:name))
+      assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
+      assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
+    end
+
+    def test_rbs_method_with_required_keywords
+      # There are no methods in Core that have required keyword arguments,
+      # so we test against RBS directly
+
+      rbs = <<~RBS
+        class File
+          def foo: (a: ::Numeric sz, b: ::Numeric) -> void
+        end
+      RBS
+      signatures = parse_rbs_methods(rbs, "foo")
+      parameters = signatures[0].parameters
+      assert_equal([:a, :b], parameters.map(&:name))
+      assert_kind_of(Entry::KeywordParameter, parameters[0])
+      assert_kind_of(Entry::KeywordParameter, parameters[1])
+    end
+
+    def test_rbs_method_with_rest_keywords
+      entries = @index["method_missing"]
+      entry = entries.find { |entry| entry.owner.name == "BasicObject" }
+      signatures = entry.signatures
+      assert_equal(1, signatures.length)
+
+      # (Symbol, *untyped, **untyped) ?{ (*untyped, **untyped) -> untyped } -> untyped
+
+      parameters = signatures[0].parameters
+      assert_equal([:arg0, :"<anonymous splat>", :"<anonymous keyword splat>"], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::RestParameter, parameters[1])
+      assert_kind_of(Entry::KeywordRestParameter, parameters[2])
+    end
+
+    def test_parse_simple_rbs
+      rbs = <<~RBS
+        class File
+          def self?.open: (String name, ?String mode, ?Integer perm) -> IO?
+              | [T] (String name, ?String mode, ?Integer perm) { (IO) -> T } -> T
+        end
+      RBS
+      signatures = parse_rbs_methods(rbs, "open")
+      assert_equal(2, signatures.length)
+      parameters = signatures[0].parameters
+      assert_equal([:name, :mode, :perm], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+
+      parameters = signatures[1].parameters
+      assert_equal([:name, :mode, :perm, :"<anonymous block>"], parameters.map(&:name))
+      assert_kind_of(Entry::RequiredParameter, parameters[0])
+      assert_kind_of(Entry::OptionalParameter, parameters[1])
+      assert_kind_of(Entry::OptionalParameter, parameters[2])
+      assert_kind_of(Entry::BlockParameter, parameters[3])
+    end
+
+    private
+
+    def parse_rbs_methods(rbs, method_name)
+      buffer = RBS::Buffer.new(content: rbs, name: "")
+      _, _, declarations = RBS::Parser.parse_signature(buffer)
+      index = RubyIndexer::Index.new
+      indexer = RubyIndexer::RBSIndexer.new(index)
+      pathname = Pathname.new("file.rbs")
+      indexer.process_signature(pathname, declarations)
+      entry = T.must(index[method_name]).first
+      T.cast(entry, Entry::Method).signatures
+    end
   end
 end

data/lib/ruby_indexer/test/test_case.rb

@@ -40,16 +40,12 @@ module RubyIndexer
       assert_nil(entries, "Expected #{expected_name} to not be indexed")
     end
 
-    def assert_no_entries
-      assert_empty(@index.instance_variable_get(:@entries), "Expected nothing to be indexed")
-    end
-
     def assert_no_indexed_entries
       assert_equal(@default_indexed_entries, @index.instance_variable_get(:@entries))
     end
 
     def assert_no_entry(entry)
-      refute(@index.instance_variable_get(:@entries).key?(entry), "Expected '#{entry}' to not be indexed")
+      refute(@index.indexed?(entry), "Expected '#{entry}' to not be indexed")
     end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -72,6 +72,15 @@ module RubyLsp
           addon.add_error(e)
         end
       end
+
+      # Intended for use by tests for addons
+      sig { params(addon_name: String).returns(Addon) }
+      def get(addon_name)
+        addon = addons.find { |addon| addon.name == addon_name }
+        raise "Could not find addon '#{addon_name}'" unless addon
+
+        addon
+      end
     end
 
     sig { void }
@@ -157,7 +166,10 @@ module RubyLsp
     # Creates a new Definition listener. This method is invoked on every Definition request
     sig do
       overridable.params(
-        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+        response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
+          Interface::Location,
+          Interface::LocationLink,
+        )],
         uri: URI::Generic,
         node_context: NodeContext,
         dispatcher: Prism::Dispatcher,

data/lib/ruby_lsp/document.rb

@@ -3,6 +3,13 @@
 
 module RubyLsp
   class Document
+    class LanguageId < T::Enum
+      enums do
+        Ruby = new("ruby")
+        ERB = new("erb")
+      end
+    end
+
     extend T::Sig
     extend T::Helpers
 
@@ -34,21 +41,14 @@ module RubyLsp
       @parse_result = T.let(parse, Prism::ParseResult)
     end
 
-    sig { returns(Prism::ProgramNode) }
-    def tree
-      @parse_result.value
-    end
-
-    sig { returns(T::Array[Prism::Comment]) }
-    def comments
-      @parse_result.comments
-    end
-
     sig { params(other: Document).returns(T::Boolean) }
     def ==(other)
-      @source == other.source
+      self.class == other.class && uri == other.uri && @source == other.source
     end
 
+    sig { abstract.returns(LanguageId) }
+    def language_id; end
+
     # TODO: remove this method once all nonpositional requests have been migrated to the listener pattern
     sig do
       type_parameters(:T)
@@ -96,10 +96,8 @@ module RubyLsp
     sig { abstract.returns(Prism::ParseResult) }
     def parse; end
 
-    sig { returns(T::Boolean) }
-    def syntax_error?
-      @parse_result.failure?
-    end
+    sig { abstract.returns(T::Boolean) }
+    def syntax_error?; end
 
     sig { returns(Scanner) }
     def create_scanner

data/lib/ruby_lsp/erb_document.rb

@@ -0,0 +1,125 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class ERBDocument < Document
+    extend T::Sig
+
+    sig { override.returns(Prism::ParseResult) }
+    def parse
+      return @parse_result unless @needs_parsing
+
+      @needs_parsing = false
+      scanner = ERBScanner.new(@source)
+      scanner.scan
+      @parse_result = Prism.parse(scanner.ruby)
+    end
+
+    sig { override.returns(T::Boolean) }
+    def syntax_error?
+      @parse_result.failure?
+    end
+
+    sig { override.returns(LanguageId) }
+    def language_id
+      LanguageId::ERB
+    end
+
+    class ERBScanner
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :ruby, :html
+
+      sig { params(source: String).void }
+      def initialize(source)
+        @source = source
+        @html = T.let(+"", String)
+        @ruby = T.let(+"", String)
+        @current_pos = T.let(0, Integer)
+        @inside_ruby = T.let(false, T::Boolean)
+      end
+
+      sig { void }
+      def scan
+        while @current_pos < @source.length
+          scan_char
+          @current_pos += 1
+        end
+      end
+
+      private
+
+      sig { void }
+      def scan_char
+        char = @source[@current_pos]
+
+        case char
+        when "<"
+          if next_char == "%"
+            @inside_ruby = true
+            @current_pos += 1
+            push_char("  ")
+
+            if next_char == "=" && @source[@current_pos + 2] == "="
+              @current_pos += 2
+              push_char("  ")
+            elsif next_char == "=" || next_char == "-"
+              @current_pos += 1
+              push_char(" ")
+            end
+          else
+            push_char(T.must(char))
+          end
+        when "-"
+          if @inside_ruby && next_char == "%" &&
+              @source[@current_pos + 2] == ">"
+            @current_pos += 2
+            push_char("   ")
+            @inside_ruby = false
+          else
+            push_char(T.must(char))
+          end
+        when "%"
+          if @inside_ruby && next_char == ">"
+            @inside_ruby = false
+            @current_pos += 1
+            push_char("  ")
+          else
+            push_char(T.must(char))
+          end
+        when "\r"
+          @ruby << char
+          @html << char
+
+          if next_char == "\n"
+            @ruby << next_char
+            @html << next_char
+            @current_pos += 1
+          end
+        when "\n"
+          @ruby << char
+          @html << char
+        else
+          push_char(T.must(char))
+        end
+      end
+
+      sig { params(char: String).void }
+      def push_char(char)
+        if @inside_ruby
+          @ruby << char
+          @html << " " * char.length
+        else
+          @ruby << " " * char.length
+          @html << char
+        end
+      end
+
+      sig { returns(String) }
+      def next_char
+        @source[@current_pos + 1] || ""
+      end
+    end
+  end
+end

data/lib/ruby_lsp/global_state.rb

@@ -21,7 +21,7 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :supports_watching_files
+    attr_reader :supports_watching_files, :experimental_features
 
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
@@ -39,6 +39,7 @@ module RubyLsp
       @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
       @supports_watching_files = T.let(false, T::Boolean)
+      @experimental_features = T.let(false, T::Boolean)
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -87,6 +88,8 @@ module RubyLsp
       if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
         @supports_watching_files = true
       end
+
+      @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/internal.rb

@@ -15,6 +15,7 @@ Bundler.ui.level = :silent
 require "uri"
 require "cgi"
 require "set"
+require "strscan"
 require "prism"
 require "prism/visitor"
 require "language_server-protocol"
@@ -34,6 +35,7 @@ require "ruby_lsp/response_builders"
 require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
+require "ruby_lsp/erb_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"

data/lib/ruby_lsp/listeners/completion.rb

@@ -209,8 +209,13 @@ module RubyLsp
         @index.instance_variable_completion_candidates(name, type).each do |entry|
           variable_name = entry.name
 
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+          )
+
           @response_builder << Interface::CompletionItem.new(
             label: variable_name,
+            label_details: label_details,
             text_edit: Interface::TextEdit.new(
               range: range_from_location(location),
               new_text: variable_name,
@@ -283,19 +288,29 @@ module RubyLsp
         range = if method_name
           range_from_location(T.must(node.message_loc))
         else
-          loc = T.must(node.call_operator_loc)
-          Interface::Range.new(
-            start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
-            end: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
-          )
+          loc = node.call_operator_loc
+
+          if loc
+            Interface::Range.new(
+              start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+              end: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+            )
+          end
         end
 
+        return unless range
+
         @index.method_completion_candidates(method_name, type).each do |entry|
           entry_name = entry.name
 
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+            detail: entry.decorated_parameters,
+          )
           @response_builder << Interface::CompletionItem.new(
             label: entry_name,
             filter_text: entry_name,
+            label_details: label_details,
             text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
             kind: Constant::CompletionItemKind::METHOD,
             data: {
@@ -307,31 +322,6 @@ module RubyLsp
         # We have not indexed this namespace, so we can't provide any completions
       end
 
-      sig do
-        params(
-          entry: T.any(RubyIndexer::Entry::Member, RubyIndexer::Entry::MethodAlias),
-          node: Prism::CallNode,
-        ).returns(Interface::CompletionItem)
-      end
-      def build_method_completion(entry, node)
-        name = entry.name
-
-        Interface::CompletionItem.new(
-          label: name,
-          filter_text: name,
-          text_edit: Interface::TextEdit.new(range: range_from_location(T.must(node.message_loc)), new_text: name),
-          kind: Constant::CompletionItemKind::METHOD,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            detail: entry.decorated_parameters,
-            description: entry.file_name,
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(name, entry),
-          ),
-        )
-      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
@@ -413,8 +403,14 @@ module RubyLsp
         # 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
+
+        label_details = Interface::CompletionItemLabelDetails.new(
+          description: entries.map(&:file_name).join(","),
+        )
+
         Interface::CompletionItem.new(
           label: real_name,
+          label_details: label_details,
           filter_text: filter_text,
           text_edit: Interface::TextEdit.new(
             range: range,