ruby-lsp 0.26.8 → 0.27.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54c4bc57589939f89d9db6539395d9036679979455346126c6bb1e1421364a20
-  data.tar.gz: debb4a5808a5d0ef964b919fd613743aa452e7ef686fb28c9fd78c1a2d178b21
+  metadata.gz: 4e5c88483f280d13f2691e131a16e35df07df898e8f380071d077479cd24133e
+  data.tar.gz: 7630ce8844fcb532ca63c77e299b692471b145530a623dcbc78ecbb50ce08596
 SHA512:
-  metadata.gz: 2de6eb23b63121880662e02ebff976e69023b1fbf57a6c1a34ea620623f68ed9e6628a9e546237e93fd21e2a76050ad3033c08017539b020727e5607304e891c
-  data.tar.gz: 1d62a8f58593ad5a04667a6bf4c64ce0111a42de7940b8d6408eaa886055f946760203898e35905d07b163764e4f12cb689264848908e97381b68fbfbc7298b8
+  metadata.gz: 7757882e6e441d49705a389bad6b0b617b7f9a26fb1e5f34ebd3fc93eeb8921b31a703253cff79ed123ae411333fc7d91f0555ae162cafee1d10adfb13b76cf4
+  data.tar.gz: c215743ab00113e4dd3186732faabd462fef6a3be425f1c76bb65b045846effd7db0673478244218f1087e3fa9ca96f8668c86970def65bf2e5fbb4ea0728a8d

data/VERSION

@@ -1 +1 @@
-0.26.8
+0.27.0.beta1

data/exe/ruby-lsp

@@ -21,13 +21,6 @@ parser = OptionParser.new do |opts|
     options[:time_index] = true
   end
 
-  opts.on(
-    "--branch [BRANCH]",
-    "Launch the Ruby LSP using the specified branch rather than the release version",
-  ) do |branch|
-    options[:branch] = branch
-  end
-
   opts.on("--doctor", "Run troubleshooting steps") do
     options[:doctor] = true
   end
@@ -70,7 +63,6 @@ if ENV["BUNDLE_GEMFILE"].nil?
     flags = []
     flags << "--debug" if options[:debug]
     flags << "--beta" if options[:beta]
-    flags.push("--branch", options[:branch]) if options[:branch]
     exit exec(Gem.ruby, File.expand_path("ruby-lsp-launcher", __dir__), *flags)
   end
 

data/exe/ruby-lsp-launcher

@@ -20,10 +20,8 @@ reboot = false
 workspace_uri = ARGV.first
 raw_initialize_path = File.join(".ruby-lsp", "raw_initialize")
 
-# Extract CLI options that affect bundle composition (e.g. --branch, --beta) from the arguments passed by the server
+# Extract CLI options that affect bundle composition (e.g. --beta) from the arguments passed by the server
 cli_options = {}
-branch_index = ARGV.index("--branch")
-cli_options[:branch] = ARGV[branch_index + 1] if branch_index
 cli_options[:beta] = true if ARGV.include?("--beta")
 
 raw_initialize = if workspace_uri && !workspace_uri.start_with?("--")
@@ -57,7 +55,6 @@ pid = if Gem.win_platform?
 
   cli_flags = []
   cli_flags << "--beta" if cli_options[:beta]
-  cli_flags.push("--branch", cli_options[:branch]) if cli_options[:branch]
 
   Process.spawn(
     Gem.ruby,

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -129,7 +129,7 @@ module RubyIndexer
 
       if current_owner
         expression = node.expression
-        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{last_name_in_stack}>" : "<Class:#{expression.slice}>")
+        name = (expression.is_a?(Prism::SelfNode) ? "<#{last_name_in_stack}>" : "<#{expression.slice}>")
         real_nesting = Index.actual_nesting(@stack, name)
 
         existing_entries = @index[real_nesting.join("::")] #: as Array[Entry::SingletonClass]?
@@ -577,7 +577,7 @@ module RubyIndexer
 
       # set the class variable's owner to the attached context when defined within a singleton scope.
       if owner.is_a?(Entry::SingletonClass)
-        owner = @owner_stack.reverse.find { |entry| !entry.name.include?("<Class:") }
+        owner = @owner_stack.reverse.find { |entry| !entry.name.include?("<") }
       end
 
       @index.add(Entry::ClassVariable.new(

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

@@ -507,7 +507,7 @@ module RubyIndexer
       singleton_levels = 0
 
       parts.reverse_each do |part|
-        break unless part.include?("<Class:")
+        break unless part.start_with?("<")
 
         singleton_levels += 1
         parts.pop
@@ -551,7 +551,7 @@ module RubyIndexer
 
       if nesting.any?
         singleton_levels.times do
-          nesting << "<Class:#{nesting.last}>"
+          nesting << "<#{nesting.last}>"
         end
       end
 
@@ -616,7 +616,7 @@ module RubyIndexer
       if class_variables.any?
         name_parts = owner_name.split("::")
 
-        if name_parts.last&.start_with?("<Class:")
+        if name_parts.last&.start_with?("<")
           attached_name = name_parts[0..-2] #: as !nil
             .join("::")
           attached_ancestors = linearized_ancestors_of(attached_name)
@@ -707,7 +707,7 @@ module RubyIndexer
     #: (String name) -> Entry::SingletonClass
     def existing_or_new_singleton_class(name)
       *_namespace, unqualified_name = name.split("::")
-      full_singleton_name = "#{name}::<Class:#{unqualified_name}>"
+      full_singleton_name = "#{name}::<#{unqualified_name}>"
       singleton = self[full_singleton_name]&.first #: as Entry::SingletonClass?
 
       unless singleton
@@ -744,7 +744,7 @@ module RubyIndexer
     def linearized_attached_ancestors(name)
       name_parts = name.split("::")
 
-      if name_parts.last&.start_with?("<Class:")
+      if name_parts.last&.start_with?("<")
         attached_name = name_parts[0..-2] #: as !nil
           .join("::")
         linearized_ancestors_of(attached_name)
@@ -866,7 +866,7 @@ module RubyIndexer
 
           parent_name_parts = parent_class_name.split("::")
           singleton_levels.times do
-            parent_name_parts << "<Class:#{parent_name_parts.last}>"
+            parent_name_parts << "<#{parent_name_parts.last}>"
           end
 
           ancestors.concat(linearized_ancestors_of(parent_name_parts.join("::")))
@@ -878,7 +878,7 @@ module RubyIndexer
           class_class_name_parts = ["Class"]
 
           (singleton_levels - 1).times do
-            class_class_name_parts << "<Class:#{class_class_name_parts.last}>"
+            class_class_name_parts << "<#{class_class_name_parts.last}>"
           end
 
           ancestors.concat(linearized_ancestors_of(class_class_name_parts.join("::")))
@@ -892,7 +892,7 @@ module RubyIndexer
           module_class_name_parts = ["Module"]
 
           (singleton_levels - 1).times do
-            module_class_name_parts << "<Class:#{module_class_name_parts.last}>"
+            module_class_name_parts << "<#{module_class_name_parts.last}>"
           end
 
           ancestors.concat(linearized_ancestors_of(module_class_name_parts.join("::")))

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -134,7 +134,7 @@ module RubyIndexer
       expression = node.expression
       return unless expression.is_a?(Prism::SelfNode)
 
-      @stack << "<Class:#{@stack.last}>"
+      @stack << "<#{@stack.last}>"
     end
 
     #: (Prism::SingletonClassNode node) -> void
@@ -239,7 +239,7 @@ module RubyIndexer
       end
 
       if node.receiver.is_a?(Prism::SelfNode)
-        @stack << "<Class:#{@stack.last}>"
+        @stack << "<#{@stack.last}>"
       end
     end
 

data/lib/ruby_lsp/global_state.rb

@@ -30,6 +30,9 @@ module RubyLsp
     #: RubyIndexer::Index
     attr_reader :index
 
+    #: Rubydex::Graph
+    attr_reader :graph
+
     #: Encoding
     attr_reader :encoding
 
@@ -58,8 +61,9 @@ module RubyLsp
       @test_library = "minitest" #: String
       @has_type_checker = true #: bool
       @index = RubyIndexer::Index.new #: RubyIndexer::Index
+      @graph = Rubydex::Graph.new #: Rubydex::Graph
       @supported_formatters = {} #: Hash[String, Requests::Support::Formatter]
-      @type_inferrer = TypeInferrer.new(@index) #: TypeInferrer
+      @type_inferrer = TypeInferrer.new(@graph) #: TypeInferrer
       @addon_settings = {} #: Hash[String, untyped]
       @top_level_bundle = begin
         Bundler.with_original_env { Bundler.default_gemfile }
@@ -117,6 +121,7 @@ module RubyLsp
       all_dependencies = gather_direct_and_indirect_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
+      @graph.workspace_path = workspace_path
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
       rubocop_has_addon = defined?(::RuboCop::Version::STRING) &&
@@ -189,12 +194,16 @@ module RubyLsp
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
+        @graph.encoding = "utf16"
         Encoding::UTF_16LE
       elsif encodings.include?(Constant::PositionEncodingKind::UTF8)
+        @graph.encoding = "utf8"
         Encoding::UTF_8
       elsif encodings.include?(Constant::PositionEncodingKind::UTF16)
+        @graph.encoding = "utf16"
         Encoding::UTF_16LE
       else
+        @graph.encoding = "utf32"
         Encoding::UTF_32
       end
       @index.configuration.encoding = @encoding

data/lib/ruby_lsp/internal.rb

@@ -20,6 +20,7 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.5")
 end
 require "set"
 require "strscan"
+require "rubydex"
 require "prism"
 require "prism/visitor"
 require "language_server-protocol"
@@ -30,6 +31,10 @@ require "securerandom"
 require "shellwords"
 require "set"
 
+# Rubydex LSP additions
+require "ruby_lsp/rubydex/definition"
+require "ruby_lsp/rubydex/reference"
+
 require "ruby-lsp"
 require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"

data/lib/ruby_lsp/listeners/definition.rb

@@ -12,7 +12,7 @@ module RubyLsp
       def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
-        @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
         @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @language_id = language_id
         @uri = uri
@@ -109,7 +109,7 @@ module RubyLsp
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
-        find_in_index(name)
+        handle_constant_definition(name)
       end
 
       #: (Prism::ConstantReadNode node) -> void
@@ -117,7 +117,7 @@ module RubyLsp
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
 
-        find_in_index(name)
+        handle_constant_definition(name)
       end
 
       #: (Prism::GlobalVariableAndWriteNode node) -> void
@@ -152,32 +152,32 @@ module RubyLsp
 
       #: (Prism::InstanceVariableReadNode node) -> void
       def on_instance_variable_read_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableWriteNode node) -> void
       def on_instance_variable_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableAndWriteNode node) -> void
       def on_instance_variable_and_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableOperatorWriteNode node) -> void
       def on_instance_variable_operator_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableOrWriteNode node) -> void
       def on_instance_variable_or_write_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::InstanceVariableTargetNode node) -> void
       def on_instance_variable_target_node_enter(node)
-        handle_instance_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::SuperNode node) -> void
@@ -192,32 +192,32 @@ module RubyLsp
 
       #: (Prism::ClassVariableAndWriteNode node) -> void
       def on_class_variable_and_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableOperatorWriteNode node) -> void
       def on_class_variable_operator_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableOrWriteNode node) -> void
       def on_class_variable_or_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableTargetNode node) -> void
       def on_class_variable_target_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableReadNode node) -> void
       def on_class_variable_read_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       #: (Prism::ClassVariableWriteNode node) -> void
       def on_class_variable_write_node_enter(node)
-        handle_class_variable_definition(node.name.to_s)
+        handle_variable_definition(node.name.to_s)
       end
 
       private
@@ -257,93 +257,63 @@ module RubyLsp
 
       #: (String name) -> void
       def handle_global_variable_definition(name)
-        entries = @index[name]
+        declaration = @graph[name]
+        return unless declaration
 
-        return unless entries
-
-        entries.each do |entry|
-          location = entry.location
-
-          @response_builder << Interface::Location.new(
-            uri: entry.uri.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
-      end
-
-      #: (String name) -> void
-      def handle_class_variable_definition(name)
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        return unless type
-
-        entries = @index.resolve_class_variable(name, type.name)
-        return unless entries
-
-        entries.each do |entry|
-          @response_builder << Interface::Location.new(
-            uri: entry.uri.to_s,
-            range: range_from_location(entry.location),
-          )
-        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
+        declaration.definitions.each { |definition| @response_builder << definition.to_lsp_selection_location }
       end
 
+      # Handle class or instance variables. We collect all definitions across the ancestors of the type
+      #
       #: (String name) -> void
-      def handle_instance_variable_definition(name)
-        # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
-        # to provide all features for them
+      def handle_variable_definition(name)
+        # Sorbet enforces that all variables be declared on typed strict or higher, which means it will be able to
+        # provide all features for them
         return if @sorbet_level.strict?
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        entries = @index.resolve_instance_variable(name, type.name)
-        return unless entries
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
 
-        entries.each do |entry|
-          location = entry.location
+        owner.ancestors.each do |ancestor|
+          member = ancestor.member(name)
+          next unless member
 
-          @response_builder << Interface::Location.new(
-            uri: entry.uri.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),
-            ),
-          )
+          member.definitions.each { |definition| @response_builder << definition.to_lsp_selection_location }
         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
 
       #: (String message, TypeInferrer::Type? receiver_type, ?inherited_only: bool) -> void
       def handle_method_definition(message, receiver_type, inherited_only: false)
-        methods = if receiver_type
-          @index.resolve_method(message, receiver_type.name, inherited_only: inherited_only)
+        declaration = if receiver_type
+          owner = @graph[receiver_type.name]
+          owner.find_member("#{message}()", only_inherited: inherited_only) if owner.is_a?(Rubydex::Namespace)
         end
 
-        # If the method doesn't have a receiver, or the guessed receiver doesn't have any matched candidates,
-        # then we provide a few candidates to jump to
-        # But we don't want to provide too many candidates, as it can be overwhelming
-        if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && methods.nil?)
-          methods = @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
+        # If the method doesn't have a receiver, or the guessed receiver doesn't have any matched candidates, then we
+        # provide a few candidates to jump to. However, we don't want to provide too many candidates, as it can be
+        # overwhelming
+        if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && declaration.nil?)
+          declaration = @graph.search("##{message}()").take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
         end
 
-        return unless methods
+        return unless declaration
 
-        methods.each do |target_method|
-          uri = target_method.uri
-          full_path = uri.full_path
-          next if @sorbet_level.true_or_higher? && (!full_path || not_in_dependencies?(full_path))
+        Array(declaration).each do |decl|
+          decl.definitions.each do |definition|
+            location = definition.location
+            uri = URI(location.uri)
+            full_path = uri.full_path
+            next if @sorbet_level.true_or_higher? && (!full_path || not_in_dependencies?(full_path))
 
-          @response_builder << Interface::LocationLink.new(
-            target_uri: uri.to_s,
-            target_range: range_from_location(target_method.location),
-            target_selection_range: range_from_location(target_method.name_location),
-          )
+            @response_builder << Interface::LocationLink.new(
+              target_uri: uri.to_s,
+              target_range: definition.to_lsp_selection_range,
+              target_selection_range: definition.to_lsp_name_range || definition.to_lsp_selection_range,
+            )
+          end
         end
       end
 
@@ -351,12 +321,10 @@ module RubyLsp
       def handle_require_definition(node, message)
         case message
         when :require
-          entry = @index.search_require_paths(node.content).find do |uri|
-            uri.require_path == node.content
-          end
+          document = @graph.resolve_require_path(node.content, $LOAD_PATH)
 
-          if entry
-            candidate = entry.full_path
+          if document
+            candidate = URI(document.uri).full_path
 
             if candidate
               @response_builder << Interface::Location.new(
@@ -392,35 +360,33 @@ module RubyLsp
         constant_name = argument.value
         return unless constant_name
 
-        find_in_index(constant_name)
+        handle_constant_definition(constant_name)
       end
 
       #: (String value) -> void
-      def find_in_index(value)
-        entries = @index.resolve(value, @node_context.nesting)
-        return unless entries
+      def handle_constant_definition(value)
+        declaration = @graph.resolve_constant(value, @node_context.nesting)
+        return unless declaration
 
+        # [RUBYDEX] TODO: temporarily commented out until we have the visibility API
+        #
         # 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 = entries.first #: as !nil
-        return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{value}"
+        #
+        # return if declaration.private? && declaration.name != "#{@node_context.fully_qualified_name}::#{value}"
 
-        entries.each do |entry|
+        declaration.definitions.each do |definition|
           # 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. The only sigil where Sorbet cannot handle constants is typed
           # ignore
-          uri = entry.uri
+          uri = URI(definition.location.uri)
           full_path = uri.full_path
 
           if !@sorbet_level.ignore? && (!full_path || not_in_dependencies?(full_path))
             next
           end
 
-          @response_builder << Interface::LocationLink.new(
-            target_uri: uri.to_s,
-            target_range: range_from_location(entry.location),
-            target_selection_range: range_from_location(entry.name_location),
-          )
+          @response_builder << definition.to_lsp_location_link
         end
       end
     end

data/lib/ruby_lsp/listeners/document_link.rb

@@ -60,6 +60,7 @@ module RubyLsp
         @lines_to_comments = comments.to_h do |comment|
           [comment.location.end_line, comment]
         end #: Hash[Integer, Prism::Comment]
+        @sig_comments = {} #: Hash[Integer, Prism::Comment]
 
         dispatcher.register(
           self,
@@ -68,9 +69,20 @@ module RubyLsp
           :on_module_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_write_node_enter,
+          :on_call_node_enter,
         )
       end
 
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node)
+        return unless node.name == :sig
+
+        comment = @lines_to_comments[node.location.start_line - 1]
+        return unless comment
+
+        @sig_comments[node.location.end_line] = comment
+      end
+
       #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         extract_document_link(node)
@@ -100,7 +112,7 @@ module RubyLsp
 
       #: (Prism::Node node) -> void
       def extract_document_link(node)
-        comment = @lines_to_comments[node.location.start_line - 1]
+        comment = @lines_to_comments[node.location.start_line - 1] || @sig_comments[node.location.start_line - 1]
         return unless comment
 
         match = comment.location.slice.match(%r{(source://.*#\d+|pkg:gem/.*#.*)$})