ruby-lsp 0.23.15 → 0.26.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e54bcceea5e2a289c338ab213823ea63915ad96901f99c1976e6ad746c5c5402
-  data.tar.gz: 643f3843f6085d5cf7f29e1d577a94c8d994cbe932708da875e6600ca4fe4c64
+  metadata.gz: 7b12b079fa54de3410e0d0ab2db9bf2241c6413c3c61d3ead21d4bbcc9b4e7d6
+  data.tar.gz: dede13048ef29f79079271c7d20d505160f8fe24d495863e08be96c95207c6bf
 SHA512:
-  metadata.gz: 49b288356198fbfe6d66e4c6f4765585e44e6b46c5bb81d18d5df547914c5f167b9ac781add2d725f5f9fda9e042dc585323672c60e27c034c80a46eb8f121e3
-  data.tar.gz: 95a7119a9272c5a012ea17fd90c86dc70fa6d66bf81a056ad19dd7ab891d7db9c9c596aff6342432505dd2b487212d48bbb8a28f35468268370d3856b8d1d7ee
+  metadata.gz: 922edf8dadc38fa037d2c157c8e0b9bbbd3c759931ac6cda3070b615a3039597028672e8632507e80689f6a8f6cc793e7a1006a49bba28d72489f541e75f2fc3
+  data.tar.gz: 046d2d369c16a743f71750a9a6dfed945d8e21b43bb58ad357ce1098fd731dc4e7060ffebcc96e1b78a43a3b2571ac9e31d94dc6c25c380478cb54a979c0f461

data/VERSION

@@ -1 +1 @@
-0.23.15
+0.26.9

data/exe/ruby-lsp

@@ -3,7 +3,6 @@
 
 require "optparse"
 
-original_args = ARGV.dup
 options = {}
 parser = OptionParser.new do |opts|
   opts.banner = "Usage: ruby-lsp [options]"
@@ -22,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
@@ -37,6 +29,10 @@ parser = OptionParser.new do |opts|
     options[:launcher] = true
   end
 
+  opts.on("--beta", "Use pre-release server gems") do
+    options[:beta] = true
+  end
+
   opts.on("-h", "--help", "Print this help") do
     puts opts.help
     puts
@@ -46,7 +42,7 @@ parser = OptionParser.new do |opts|
 end
 
 begin
-  parser.parse!
+  parser.parse(ARGV)
 rescue OptionParser::InvalidOption => e
   warn(e)
   warn("")
@@ -66,6 +62,7 @@ if ENV["BUNDLE_GEMFILE"].nil?
   if options[:launcher]
     flags = []
     flags << "--debug" if options[:debug]
+    flags << "--beta" if options[:beta]
     exit exec(Gem.ruby, File.expand_path("ruby-lsp-launcher", __dir__), *flags)
   end
 
@@ -85,16 +82,20 @@ if ENV["BUNDLE_GEMFILE"].nil?
     base_command << " _#{env["BUNDLER_VERSION"]}_"
   end
 
-  exit exec(env, "#{base_command} exec ruby-lsp #{original_args.join(" ")}".strip)
+  exit exec(env, "#{base_command} exec ruby-lsp #{ARGV.join(" ")}".strip)
 end
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -147,8 +148,10 @@ if options[:doctor]
   return
 end
 
+server = RubyLsp::Server.new
+
 # Ensure all output goes out stderr by default to allow puts/p/pp to work
 # without specifying output device.
 $> = $stderr
 
-RubyLsp::Server.new.start
+server.start

data/exe/ruby-lsp-check

@@ -3,13 +3,9 @@
 
 # This executable checks if all automatic LSP requests run successfully on every Ruby file under the current directory
 
-require "ruby_lsp/load_sorbet"
-
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 files = Dir.glob("#{Dir.pwd}/**/*.rb")
 
 puts "Verifying that all automatic LSP requests execute successfully. This may take a while..."

data/exe/ruby-lsp-launcher

@@ -6,6 +6,13 @@
 # composed bundle
 # !!!!!!!
 
+$stdin.sync = true
+$stdout.sync = true
+$stderr.sync = true
+$stdin.binmode
+$stdout.binmode
+$stderr.binmode
+
 setup_error = nil
 install_error = nil
 reboot = false
@@ -13,6 +20,10 @@ reboot = false
 workspace_uri = ARGV.first
 raw_initialize_path = File.join(".ruby-lsp", "raw_initialize")
 
+# Extract CLI options that affect bundle composition (e.g. --beta) from the arguments passed by the server
+cli_options = {}
+cli_options[:beta] = true if ARGV.include?("--beta")
+
 raw_initialize = if workspace_uri && !workspace_uri.start_with?("--")
   # If there's an argument without `--`, then it's the server asking to compose the bundle and passing to this
   # executable the workspace URI. We can't require gems at this point, so we built a fake initialize request manually
@@ -28,7 +39,6 @@ else
   # Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
   # Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
   # to ensure that we're setting up the bundle in the right place
-  $stdin.binmode
   headers = $stdin.gets("\r\n\r\n")
   content_length = headers[/Content-Length: (\d+)/i, 1].to_i
   $stdin.read(content_length)
@@ -43,16 +53,20 @@ pid = if Gem.win_platform?
     ["-I", File.expand_path(path)]
   end
 
+  cli_flags = []
+  cli_flags << "--beta" if cli_options[:beta]
+
   Process.spawn(
     Gem.ruby,
     *load_path,
     File.expand_path("../lib/ruby_lsp/scripts/compose_bundle_windows.rb", __dir__),
     raw_initialize,
+    *cli_flags,
   )
 else
   fork do
     require_relative "../lib/ruby_lsp/scripts/compose_bundle"
-    compose(raw_initialize)
+    compose(raw_initialize, **cli_options)
   end
 end
 
@@ -83,23 +97,33 @@ begin
     # This Marshal load can only happen after requiring Bundler because it will load a custom error class from Bundler
     # itself. If we try to load before requiring, the class will not be defined and loading will fail
     error_path = File.join(".ruby-lsp", "install_error")
-    install_error = if File.exist?(error_path)
-      Marshal.load(File.read(error_path))
+    install_error = begin
+      Marshal.load(File.read(error_path)) if File.exist?(error_path)
+    rescue ArgumentError
+      # The class we tried to load is not defined. This might happen when the user upgrades Bundler and new error
+      # classes are introduced or removed
+      File.delete(error_path)
+      nil
     end
 
     Bundler.setup
     $stderr.puts("Composed Bundle set up successfully")
   end
-rescue Bundler::GemNotFound, Bundler::GitError
+rescue Bundler::GemNotFound, Bundler::GitError => e
   # Sometimes, we successfully set up the bundle, but users either change their Gemfile or uninstall gems from an
   # external process. If there's no install error, but the gem is still not found, then we need to attempt to start from
   # scratch
   unless install_error || ARGV.include?("--retry")
     $stderr.puts("Initial bundle compose succeeded, but Bundler.setup failed. Trying to restart from scratch...")
     File.write(raw_initialize_path, raw_initialize)
-    exec(Gem.ruby, __FILE__, *ARGV, "--retry")
+
+    Bundler.with_unbundled_env do
+      exec(Gem.ruby, __FILE__, *ARGV, "--retry")
+    end
   end
 
+  setup_error = e
+  $stderr.puts("Failed to set up composed Bundle\n#{e.full_message}")
   $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 rescue StandardError => e
   setup_error = e
@@ -120,11 +144,8 @@ end
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
 # configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
 # paths into the load path manually or we may end up requiring the wrong version of the gem
-require "ruby_lsp/load_sorbet"
 require "ruby_lsp/internal"
 
-T::Utils.run_all_sig_blocks
-
 if ARGV.include?("--debug")
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     $stderr.puts "Debugging is not supported on Windows"
@@ -138,22 +159,28 @@ if ARGV.include?("--debug")
   end
 end
 
-# Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
-$> = $stderr
-
 initialize_request = JSON.parse(raw_initialize, symbolize_names: true) if raw_initialize
 
 begin
-  RubyLsp::Server.new(
+  server = RubyLsp::Server.new(
     install_error: install_error,
     setup_error: setup_error,
     initialize_request: initialize_request,
-  ).start
+  )
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
+  server.start
 rescue ArgumentError
   # If the launcher is booting an outdated version of the server, then the initializer doesn't accept a keyword splat
   # and we already read the initialize request from the stdin pipe. In this case, we need to process the initialize
   # request manually and then start the main loop
   server = RubyLsp::Server.new
+
+  # Ensure all output goes out stderr by default to allow puts/p/pp to work without specifying output device.
+  $> = $stderr
+
   server.process_message(initialize_request)
   server.start
 end

data/exe/ruby-lsp-test-exec

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This executable will be removed thanks to the changes in https://github.com/Shopify/ruby-lsp/pull/3661.
+# Remove this a few months after extension updates have rolled out
+exec(*ARGV)

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop

data/lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "rubocop"
-require "sorbet-runtime"
 
 module RuboCop
   module Cop

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -66,7 +66,7 @@ module RubyIndexer
       flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
 
       uris = @included_patterns.flat_map do |pattern|
-        load_path_entry = T.let(nil, T.nilable(String))
+        load_path_entry = nil #: String?
 
         Dir.glob(File.join(@workspace_path, pattern), flags).map! do |path|
           # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
@@ -227,7 +227,7 @@ module RubyIndexer
       others.uniq!
       others.map!(&:name)
 
-      excluded.each do |dependency|
+      transitive_excluded = excluded.each_with_object([]) do |dependency, acc|
         next unless dependency.runtime?
 
         spec = dependency.to_spec
@@ -236,7 +236,7 @@ module RubyIndexer
         spec.dependencies.each do |transitive_dependency|
           next if others.include?(transitive_dependency.name)
 
-          excluded << transitive_dependency
+          acc << transitive_dependency
         end
       rescue Gem::MissingSpecError
         # If a gem is scoped only to some specific platform, then its dependencies may not be installed either, but they
@@ -244,6 +244,7 @@ module RubyIndexer
         # just ignore if they're missing
       end
 
+      excluded.concat(transitive_excluded)
       excluded.uniq!
       excluded.map(&:name)
     rescue Bundler::GemfileNotFound

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

@@ -9,7 +9,7 @@ module RubyIndexer
     #: Array[String]
     attr_reader :indexing_errors
 
-    #: (Index index, Prism::Dispatcher dispatcher, Prism::ParseResult parse_result, URI::Generic uri, ?collect_comments: bool) -> void
+    #: (Index index, Prism::Dispatcher dispatcher, Prism::ParseLexResult | Prism::ParseResult parse_result, URI::Generic uri, ?collect_comments: bool) -> void
     def initialize(index, dispatcher, parse_result, uri, collect_comments: false)
       @index = index
       @uri = uri
@@ -132,7 +132,7 @@ module RubyIndexer
         name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{last_name_in_stack}>" : "<Class:#{expression.slice}>")
         real_nesting = Index.actual_nesting(@stack, name)
 
-        existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
+        existing_entries = @index[real_nesting.join("::")] #: as Array[Entry::SingletonClass]?
 
         if existing_entries
           entry = existing_entries.first #: as !nil
@@ -143,6 +143,7 @@ module RubyIndexer
           )
         else
           entry = Entry::SingletonClass.new(
+            @index.configuration,
             real_nesting,
             @uri,
             Location.from_prism_location(node.location, @code_units_cache),
@@ -260,16 +261,19 @@ module RubyIndexer
         handle_attribute(node, reader: false, writer: true)
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
+      when :attr
+        has_writer = node.arguments&.arguments&.last&.is_a?(Prism::TrueNode) || false
+        handle_attribute(node, reader: true, writer: has_writer)
       when :alias_method
         handle_alias_method(node)
       when :include, :prepend, :extend
         handle_module_operation(node, message)
       when :public
-        handle_visibility_change(node, Entry::Visibility::PUBLIC)
+        handle_visibility_change(node, :public)
       when :protected
-        handle_visibility_change(node, Entry::Visibility::PROTECTED)
+        handle_visibility_change(node, :protected)
       when :private
-        handle_visibility_change(node, Entry::Visibility::PRIVATE)
+        handle_visibility_change(node, :private)
       when :module_function
         handle_module_function(node)
       when :private_class_method
@@ -323,6 +327,7 @@ module RubyIndexer
         signatures = [Entry::Signature.new(list_params(node.parameters))]
 
         @index.add(Entry::Method.new(
+          @index.configuration,
           method_name,
           @uri,
           location,
@@ -337,13 +342,14 @@ module RubyIndexer
           singleton = @index.existing_or_new_singleton_class(owner.name)
 
           @index.add(Entry::Method.new(
+            @index.configuration,
             method_name,
             @uri,
             location,
             name_location,
             comments,
             signatures,
-            Entry::Visibility::PUBLIC,
+            :public,
             singleton,
           ))
         end
@@ -351,6 +357,7 @@ module RubyIndexer
         singleton = @index.existing_or_new_singleton_class(owner.name)
 
         @index.add(Entry::Method.new(
+          @index.configuration,
           method_name,
           @uri,
           Location.from_prism_location(node.location, @code_units_cache),
@@ -430,6 +437,7 @@ module RubyIndexer
       comments = collect_comments(node)
       @index.add(
         Entry::UnresolvedMethodAlias.new(
+          @index.configuration,
           method_name,
           node.old_name.slice,
           @owner_stack.last,
@@ -465,11 +473,12 @@ module RubyIndexer
       handle_class_variable(node, node.name_loc)
     end
 
-    #: (String name, Prism::Location node_location, Array[Entry::Signature] signatures, ?visibility: Entry::Visibility, ?comments: String?) -> void
-    def add_method(name, node_location, signatures, visibility: Entry::Visibility::PUBLIC, comments: nil)
+    #: (String name, Prism::Location node_location, Array[Entry::Signature] signatures, ?visibility: Symbol, ?comments: String?) -> void
+    def add_method(name, node_location, signatures, visibility: :public, comments: nil)
       location = Location.from_prism_location(node_location, @code_units_cache)
 
       @index.add(Entry::Method.new(
+        @index.configuration,
         name,
         @uri,
         location,
@@ -487,6 +496,7 @@ module RubyIndexer
       name_loc = Location.from_prism_location(name_location, @code_units_cache)
 
       entry = Entry::Module.new(
+        @index.configuration,
         Index.actual_nesting(@stack, name),
         @uri,
         location,
@@ -501,6 +511,7 @@ module RubyIndexer
     def add_class(name_or_nesting, full_location, name_location, parent_class_name: nil, comments: nil)
       nesting = name_or_nesting.is_a?(Array) ? name_or_nesting : Index.actual_nesting(@stack, name_or_nesting)
       entry = Entry::Class.new(
+        @index.configuration,
         nesting,
         @uri,
         Location.from_prism_location(full_location, @code_units_cache),
@@ -545,6 +556,7 @@ module RubyIndexer
       comments = collect_comments(node)
 
       @index.add(Entry::GlobalVariable.new(
+        @index.configuration,
         name,
         @uri,
         Location.from_prism_location(loc, @code_units_cache),
@@ -569,6 +581,7 @@ module RubyIndexer
       end
 
       @index.add(Entry::ClassVariable.new(
+        @index.configuration,
         name,
         @uri,
         Location.from_prism_location(loc, @code_units_cache),
@@ -591,6 +604,7 @@ module RubyIndexer
       end
 
       @index.add(Entry::InstanceVariable.new(
+        @index.configuration,
         name,
         @uri,
         Location.from_prism_location(loc, @code_units_cache),
@@ -621,7 +635,7 @@ module RubyIndexer
       # The private_constant method does not resolve the constant name. It always points to a constant that needs to
       # exist in the current namespace
       entries = @index[fully_qualify_name(name)]
-      entries&.each { |entry| entry.visibility = Entry::Visibility::PRIVATE }
+      entries&.each { |entry| entry.visibility = :private }
     end
 
     #: (Prism::CallNode node) -> void
@@ -653,6 +667,7 @@ module RubyIndexer
       comments = collect_comments(node)
       @index.add(
         Entry::UnresolvedMethodAlias.new(
+          @index.configuration,
           new_name_value,
           old_name_value,
           @owner_stack.last,
@@ -672,6 +687,7 @@ module RubyIndexer
         case value
         when Prism::ConstantReadNode, Prism::ConstantPathNode
           Entry::UnresolvedConstantAlias.new(
+            @index.configuration,
             value.slice,
             @stack.dup,
             name,
@@ -685,6 +701,7 @@ module RubyIndexer
           # If the right hand side is another constant assignment, we need to visit it because that constant has to be
           # indexed too
           Entry::UnresolvedConstantAlias.new(
+            @index.configuration,
             value.name.to_s,
             @stack.dup,
             name,
@@ -696,6 +713,7 @@ module RubyIndexer
         Prism::ConstantPathAndWriteNode
 
           Entry::UnresolvedConstantAlias.new(
+            @index.configuration,
             value.target.slice,
             @stack.dup,
             name,
@@ -705,6 +723,7 @@ module RubyIndexer
           )
         else
           Entry::Constant.new(
+            @index.configuration,
             name,
             @uri,
             Location.from_prism_location(node.location, @code_units_cache),
@@ -726,6 +745,9 @@ module RubyIndexer
         comment = @comments_by_line[line]
         break unless comment
 
+        # a trailing comment from a previous line is not a comment for this node
+        break if comment.trailing?
+
         comment_content = comment.location.slice
 
         # invalid encodings would raise an "invalid byte sequence" exception
@@ -779,6 +801,7 @@ module RubyIndexer
 
         if reader
           @index.add(Entry::Accessor.new(
+            @index.configuration,
             name,
             @uri,
             Location.from_prism_location(loc, @code_units_cache),
@@ -791,6 +814,7 @@ module RubyIndexer
         next unless writer
 
         @index.add(Entry::Accessor.new(
+          @index.configuration,
           "#{name}=",
           @uri,
           Location.from_prism_location(loc, @code_units_cache),
@@ -868,18 +892,19 @@ module RubyIndexer
           entry_owner_name = entry.owner&.name
           next unless entry_owner_name
 
-          entry.visibility = Entry::Visibility::PRIVATE
+          entry.visibility = :private
 
           singleton = @index.existing_or_new_singleton_class(entry_owner_name)
           location = Location.from_prism_location(argument.location, @code_units_cache)
           @index.add(Entry::Method.new(
+            @index.configuration,
             method_name,
             @uri,
             location,
             location,
             collect_comments(node)&.concat(entry.comments),
             entry.signatures,
-            Entry::Visibility::PUBLIC,
+            :public,
             singleton,
           ))
         end
@@ -894,7 +919,7 @@ module RubyIndexer
       # If we're passing a method definition directly to `private_class_method`, push a new private scope. That will be
       # applied when the indexer finds the method definition and then popped on `call_node_leave`
       if arguments.first.is_a?(Prism::DefNode)
-        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
+        @visibility_stack.push(VisibilityScope.new(visibility: :private))
         return
       end
 
@@ -903,10 +928,9 @@ module RubyIndexer
 
       # private_class_method accepts strings, symbols or arrays of strings and symbols as arguments. Here we build a
       # single list of all of the method names that have to be made private
-      arrays, others = T.cast(
-        arguments.partition { |argument| argument.is_a?(Prism::ArrayNode) },
-        [T::Array[Prism::ArrayNode], T::Array[Prism::Node]],
-      )
+      arrays, others = arguments.partition do |argument|
+        argument.is_a?(Prism::ArrayNode)
+      end #: as [Array[Prism::ArrayNode], Array[Prism::Node]]
       arrays.each { |array| others.concat(array.elements) }
 
       names = others.filter_map do |argument|
@@ -922,9 +946,7 @@ module RubyIndexer
         entries = @index.resolve_method(name, @index.existing_or_new_singleton_class(owner_name).name)
         next unless entries
 
-        entries.each do |entry|
-          entry.visibility = Entry::Visibility::PRIVATE
-        end
+        entries.each { |entry| entry.visibility = :private }
       end
     end
 
@@ -1038,7 +1060,7 @@ module RubyIndexer
       name.split("::").last
     end
 
-    #: (Prism::CallNode, Entry::Visibility) -> void
+    #: (Prism::CallNode, Symbol) -> void
     def handle_visibility_change(node, visibility)
       owner  = @owner_stack.last
       return unless owner

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -2,17 +2,11 @@
 # frozen_string_literal: true
 
 module RubyIndexer
+  # @abstract
   class Enhancement
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     @enhancements = [] #: Array[Class[Enhancement]]
 
     class << self
-      extend T::Sig
-
       #: (Class[Enhancement] child) -> void
       def inherited(child)
         @enhancements << child