ruby-lsp 0.23.23 → 0.26.0

data/lib/ruby_lsp/addon.rb

@@ -19,12 +19,8 @@ module RubyLsp
   #   end
   # end
   # ```
+  # @abstract
   class Addon
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     @addons = [] #: Array[Addon]
     @addon_classes = [] #: Array[singleton(Addon)]
     # Add-on instances that have declared a handler to accept file watcher events
@@ -60,7 +56,28 @@ module RubyLsp
         addon_files = Gem.find_files("ruby_lsp/**/addon.rb")
 
         if include_project_addons
-          addon_files.concat(Dir.glob(File.join(global_state.workspace_path, "**", "ruby_lsp/**/addon.rb")))
+          project_addons = Dir.glob("#{global_state.workspace_path}/**/ruby_lsp/**/addon.rb")
+          bundle_path = Bundler.bundle_path.to_s
+          gems_dir = Bundler.bundle_path.join("gems")
+
+          # Create an array of rejection glob patterns to ignore add-ons already discovered through Gem.find_files if
+          # they are also copied inside the workspace for whatever reason. We received reports of projects having gems
+          # installed in vendor/bundle despite BUNDLE_PATH pointing elsewhere. Without this mechanism, we will
+          # double-require the same add-on, potentially for different versions of the same gem, which leads to incorrect
+          # behavior
+          reject_glob_patterns = addon_files.map do |path|
+            relative_gem_path = Pathname.new(path).relative_path_from(gems_dir)
+            first_part, *parts = relative_gem_path.to_s.split(File::SEPARATOR)
+            first_part&.gsub!(/-([0-9.]+)$/, "*")
+            "**/#{first_part}/#{parts.join("/")}"
+          end
+
+          project_addons.reject! do |path|
+            path.start_with?(bundle_path) ||
+              reject_glob_patterns.any? { |pattern| File.fnmatch?(pattern, path, File::Constants::FNM_PATHNAME) }
+          end
+
+          addon_files.concat(project_addons)
         end
 
         errors = addon_files.filter_map do |addon_path|
@@ -178,22 +195,34 @@ module RubyLsp
 
     # Each add-on should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
-    def activate(global_state, outgoing_queue); end
+    # @abstract
+    #: (GlobalState, Thread::Queue) -> void
+    def activate(global_state, outgoing_queue)
+      raise AbstractMethodInvokedError
+    end
 
-    # Each add-on should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
+    # Each add-on must implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
-    sig { abstract.void }
-    def deactivate; end
+    # @abstract
+    #: -> void
+    def deactivate
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `name` method to return the add-on name
-    sig { abstract.returns(String) }
-    def name; end
+    # @abstract
+    #: -> String
+    def name
+      raise AbstractMethodInvokedError
+    end
 
     # Add-ons should override the `version` method to return a semantic version string representing the add-on's
     # version. This is used for compatibility checks
-    sig { abstract.returns(String) }
-    def version; end
+    # @abstract
+    #: -> String
+    def version
+      raise AbstractMethodInvokedError
+    end
 
     # Handle a response from a window/showMessageRequest request. Add-ons must include the addon_name as part of the
     # original request so that the response is delegated to the correct add-on and must override this method to handle

data/lib/ruby_lsp/base_server.rb

@@ -2,19 +2,15 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
   class BaseServer
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     #: (**untyped options) -> void
     def initialize(**options)
+      @reader = MessageReader.new(options[:reader] || $stdin) #: MessageReader
+      @writer = MessageWriter.new(options[:writer] || $stdout) #: MessageWriter
       @test_mode = options[:test_mode] #: bool?
       @setup_error = options[:setup_error] #: StandardError?
       @install_error = options[:install_error] #: StandardError?
-      @writer = Transport::Stdio::Writer.new #: Transport::Stdio::Writer
-      @reader = Transport::Stdio::Reader.new #: Transport::Stdio::Reader
       @incoming_queue = Thread::Queue.new #: Thread::Queue
       @outgoing_queue = Thread::Queue.new #: Thread::Queue
       @cancelled_requests = [] #: Array[Integer]
@@ -40,7 +36,7 @@ module RubyLsp
 
     #: -> void
     def start
-      @reader.read do |message|
+      @reader.each_message do |message|
         method = message[:method]
 
         # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
@@ -87,8 +83,7 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
-          "rubyLsp/diagnoseState"
+        when "initialize", "initialized", "rubyLsp/diagnoseState"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do
@@ -98,13 +93,36 @@ module RubyLsp
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
         when "exit"
-          @global_state.synchronize { exit(@incoming_queue.closed? ? 0 : 1) }
+          exit(@incoming_queue.closed? ? 0 : 1)
         else
           @incoming_queue << message
         end
       end
     end
 
+    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
+    #: -> untyped
+    def pop_response
+      @outgoing_queue.pop
+    end
+
+    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
+    #: (Hash[Symbol, untyped] message) -> void
+    def push_message(message)
+      @incoming_queue << message
+    end
+
+    # @abstract
+    #: (Hash[Symbol, untyped] message) -> void
+    def process_message(message)
+      raise AbstractMethodInvokedError
+    end
+
+    #: -> bool?
+    def test_mode?
+      @test_mode
+    end
+
     #: -> void
     def run_shutdown
       @incoming_queue.clear
@@ -118,24 +136,14 @@ module RubyLsp
       @store.clear
     end
 
-    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
-    #: -> untyped
-    def pop_response
-      @outgoing_queue.pop
-    end
+    private
 
-    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
-    #: (Hash[Symbol, untyped] message) -> void
-    def push_message(message)
-      @incoming_queue << message
+    # @abstract
+    #: -> void
+    def shutdown
+      raise AbstractMethodInvokedError
     end
 
-    sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
-    def process_message(message); end
-
-    sig { abstract.void }
-    def shutdown; end
-
     #: (Integer id, String message, ?type: Integer) -> void
     def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)
       send_message(Error.new(id: id, code: Constant::ErrorCodes::REQUEST_FAILED, message: message))

data/lib/ruby_lsp/document.rb

@@ -2,21 +2,16 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  # @abstract
   #: [ParseResultType]
   class Document
-    extend T::Sig
-    extend T::Helpers
-    extend T::Generic
-
-    class LocationNotFoundError < StandardError; end
+    class InvalidLocationError < StandardError; end
 
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
     # This is the same number used by the TypeScript extension in VS Code
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
     EMPTY_CACHE = Object.new.freeze #: Object
 
-    abstract!
-
     #: ParseResultType
     attr_reader :parse_result
 
@@ -63,8 +58,11 @@ module RubyLsp
       self.class == other.class && uri == other.uri && @source == other.source
     end
 
-    sig { abstract.returns(Symbol) }
-    def language_id; end
+    # @abstract
+    #: -> Symbol
+    def language_id
+      raise AbstractMethodInvokedError
+    end
 
     #: [T] (String request_name) { (Document[ParseResultType] document) -> T } -> T
     def cache_fetch(request_name, &block)
@@ -122,11 +120,17 @@ module RubyLsp
     end
 
     # Returns `true` if the document was parsed and `false` if nothing needed parsing
-    sig { abstract.returns(T::Boolean) }
-    def parse!; end
+    # @abstract
+    #: -> bool
+    def parse!
+      raise AbstractMethodInvokedError
+    end
 
-    sig { abstract.returns(T::Boolean) }
-    def syntax_error?; end
+    # @abstract
+    #: -> bool
+    def syntax_error?
+      raise AbstractMethodInvokedError
+    end
 
     #: -> bool
     def past_expensive_limit?
@@ -135,27 +139,28 @@ module RubyLsp
 
     #: (Hash[Symbol, untyped] start_pos, ?Hash[Symbol, untyped]? end_pos) -> [Integer, Integer?]
     def find_index_by_position(start_pos, end_pos = nil)
-      @global_state.synchronize do
-        scanner = create_scanner
-        start_index = scanner.find_char_position(start_pos)
-        end_index = scanner.find_char_position(end_pos) if end_pos
-        [start_index, end_index]
-      end
+      scanner = create_scanner
+      start_index = scanner.find_char_position(start_pos)
+      end_index = scanner.find_char_position(end_pos) if end_pos
+      [start_index, end_index]
     end
 
     private
 
     #: -> Scanner
     def create_scanner
-      Scanner.new(@source, @encoding)
+      case @encoding
+      when Encoding::UTF_8
+        Utf8Scanner.new(@source)
+      when Encoding::UTF_16LE
+        Utf16Scanner.new(@source)
+      else
+        Utf32Scanner.new(@source)
+      end
     end
 
+    # @abstract
     class Edit
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
       #: Hash[Symbol, untyped]
       attr_reader :range
 
@@ -169,33 +174,114 @@ module RubyLsp
     class Replace < Edit; end
     class Delete < Edit; end
 
+    # Parent class for all position scanners. Scanners are used to translate a position given by the editor into a
+    # string index that we can use to find the right place in the document source. The logic for finding the correct
+    # index depends on the encoding negotiated with the editor, so we have different subclasses for each encoding.
+    # See https://microsoft.github.io/language-server-protocol/specification/#positionEncodingKind for more information
+    # @abstract
     class Scanner
-      extend T::Sig
-
       LINE_BREAK = 0x0A #: Integer
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
       SURROGATE_PAIR_START = 0xFFFF #: Integer
 
-      #: (String source, Encoding encoding) -> void
-      def initialize(source, encoding)
+      #: -> void
+      def initialize
         @current_line = 0 #: Integer
         @pos = 0 #: Integer
-        @source = source.codepoints #: Array[Integer]
-        @encoding = encoding
       end
 
-      # Finds the character index inside the source string for a given line and column
+      # Finds the character index inside the source string for a given line and column. This method always returns the
+      # character index regardless of whether we are searching positions based on bytes, code units, or codepoints.
+      # @abstract
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        raise AbstractMethodInvokedError
+      end
+    end
+
+    # For the UTF-8 encoding, positions correspond to bytes
+    class Utf8Scanner < Scanner
+      #: (String source) -> void
+      def initialize(source)
+        super()
+        @bytes = source.bytes #: Array[Integer]
+        @character_length = 0 #: Integer
+      end
+
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Each group of bytes is a character. We advance based on the number of bytes to count how many full characters
+        # we have in the requested offset
+        until @current_line == position[:line]
+          byte = @bytes[@pos] #: Integer?
+          raise InvalidLocationError unless byte
+
+          until LINE_BREAK == byte
+            @pos += character_byte_length(byte)
+            @character_length += 1
+            byte = @bytes[@pos]
+            raise InvalidLocationError unless byte
+          end
+
+          @pos += 1
+          @character_length += 1
+          @current_line += 1
+        end
+
+        # @character_length has the number of characters until the beginning of the line. We don't accumulate on it for
+        # the character part because locating the same position twice must return the same value
+        line_byte_offset = 0
+        line_characters = 0
+
+        while line_byte_offset < position[:character]
+          byte = @bytes[@pos + line_byte_offset] #: Integer?
+          raise InvalidLocationError unless byte
+
+          line_byte_offset += character_byte_length(byte)
+          line_characters += 1
+        end
+
+        @character_length + line_characters
+      end
+
+      private
+
+      #: (Integer) -> Integer
+      def character_byte_length(byte)
+        if byte < 0x80 # 1-byte character
+          1
+        elsif byte < 0xE0 # 2-byte character
+          2
+        elsif byte < 0xF0 # 3-byte character
+          3
+        else # 4-byte character
+          4
+        end
+      end
+    end
+
+    # For the UTF-16 encoding, positions correspond to UTF-16 code units, which count characters beyond the surrogate
+    # pair as length 2
+    class Utf16Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
+      end
+
+      # @override
       #: (Hash[Symbol, untyped] position) -> Integer
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
-          until LINE_BREAK == @source[@pos]
-            @pos += 1
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
 
-            if @pos >= @source.length
-              # Pack the code points back into the original string to provide context in the error message
-              raise LocationNotFoundError, "Requested position: #{position}\nSource:\n\n#{@source.pack("U*")}"
-            end
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
           end
 
           @pos += 1
@@ -204,29 +290,53 @@ module RubyLsp
 
         # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
         # need to adjust for surrogate pairs
-        requested_position = @pos + position[:character]
+        line_characters = 0
+        line_code_units = 0
 
-        if @encoding == Encoding::UTF_16LE
-          requested_position -= utf_16_character_position_correction(@pos, requested_position)
+        while line_code_units < position[:character]
+          code_point = @codepoints[@pos + line_characters]
+          raise InvalidLocationError unless code_point
+
+          line_code_units += if code_point > SURROGATE_PAIR_START
+            2 # Surrogate pair, so we skip the next code unit
+          else
+            1 # Single code unit character
+          end
+
+          line_characters += 1
         end
 
-        requested_position
+        @pos + line_characters
       end
+    end
 
-      # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
-      # right character in the UTF-8 representation
-      #: (Integer current_position, Integer requested_position) -> Integer
-      def utf_16_character_position_correction(current_position, requested_position)
-        utf16_unicode_correction = 0
+    # For the UTF-32 encoding, positions correspond directly to codepoints
+    class Utf32Scanner < Scanner
+      #: (String) -> void
+      def initialize(source)
+        super()
+        @codepoints = source.codepoints #: Array[Integer]
+      end
+
+      # @override
+      #: (Hash[Symbol, untyped] position) -> Integer
+      def find_char_position(position)
+        # Find the character index for the beginning of the requested line
+        until @current_line == position[:line]
+          codepoint = @codepoints[@pos] #: Integer?
+          raise InvalidLocationError unless codepoint
 
-        until current_position == requested_position
-          codepoint = @source[current_position]
-          utf16_unicode_correction += 1 if codepoint && codepoint > SURROGATE_PAIR_START
+          until LINE_BREAK == @codepoints[@pos]
+            @pos += 1
+            codepoint = @codepoints[@pos] #: Integer?
+            raise InvalidLocationError unless codepoint
+          end
 
-          current_position += 1
+          @pos += 1
+          @current_line += 1
         end
 
-        utf16_unicode_correction
+        @pos + position[:character]
       end
     end
   end

data/lib/ruby_lsp/erb_document.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  #: [ParseResultType = Prism::ParseResult]
+  #: [ParseResultType = Prism::ParseLexResult]
   class ERBDocument < Document
     #: String
     attr_reader :host_language_source
@@ -31,11 +31,16 @@ module RubyLsp
       @host_language_source = scanner.host_language
       # Use partial script to avoid syntax errors in ERB files where keywords may be used without the full context in
       # which they will be evaluated
-      @parse_result = Prism.parse(scanner.ruby, partial_script: true)
+      @parse_result = Prism.parse_lex(scanner.ruby, partial_script: true)
       @code_units_cache = @parse_result.code_units_cache(@encoding)
       true
     end
 
+    #: -> Prism::ProgramNode
+    def ast
+      @parse_result.value.first
+    end
+
     # @override
     #: -> bool
     def syntax_error?
@@ -53,7 +58,7 @@ module RubyLsp
       char_position, _ = find_index_by_position(position)
 
       RubyDocument.locate(
-        @parse_result.value,
+        ast,
         char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,

data/lib/ruby_lsp/global_state.rb

@@ -56,6 +56,17 @@ module RubyLsp
       @enabled_feature_flags = {} #: Hash[Symbol, bool]
       @mutex = Mutex.new #: Mutex
       @telemetry_machine_id = nil #: String?
+      @feature_configuration = {
+        inlayHint: RequestConfig.new({
+          enableAll: false,
+          implicitRescue: false,
+          implicitHashValue: false,
+        }),
+        codeLens: RequestConfig.new({
+          enableAll: false,
+          enableTestCodeLens: true,
+        }),
+      } #: Hash[Symbol, RequestConfig]
     end
 
     #: [T] { -> T } -> T
@@ -175,9 +186,19 @@ module RubyLsp
       @enabled_feature_flags = enabled_flags if enabled_flags
 
       @telemetry_machine_id = options.dig(:initializationOptions, :telemetryMachineId)
+
+      options.dig(:initializationOptions, :featuresConfiguration)&.each do |feature_name, config|
+        @feature_configuration[feature_name]&.merge!(config)
+      end
+
       notifications
     end
 
+    #: (Symbol) -> RequestConfig?
+    def feature_configuration(feature_name)
+      @feature_configuration[feature_name]
+    end
+
     #: (Symbol flag) -> bool?
     def enabled_feature?(flag)
       @enabled_feature_flags[:all] || @enabled_feature_flags[flag]

data/lib/ruby_lsp/internal.rb

@@ -6,8 +6,6 @@
 yarp_require_paths = Gem.loaded_specs["yarp"]&.full_require_paths
 $LOAD_PATH.delete_if { |path| yarp_require_paths.include?(path) } if yarp_require_paths
 
-require "sorbet-runtime"
-
 # Set Bundler's UI level to silent as soon as possible to prevent any prints to STDOUT
 require "bundler"
 Bundler.ui.level = :silent

data/lib/ruby_lsp/listeners/completion.rb

@@ -445,11 +445,14 @@ module RubyLsp
         return unless arguments_node
 
         path_node_to_complete = arguments_node.arguments.first
-
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        origin_dir = Pathname.new(@uri.to_standardized_path).dirname
+        # If the file is unsaved (e.g.: untitled:Untitled-1), we can't provide relative completion as we don't know
+        # where the user intends to save it
+        full_path = @uri.to_standardized_path
+        return unless full_path
 
+        origin_dir = Pathname.new(full_path).dirname
         content = path_node_to_complete.content
         # if the path is not a directory, glob all possible next characters
         # for example ../somethi| (where | is the cursor position)
@@ -516,6 +519,14 @@ module RubyLsp
 
           entry_name = entry.name
           owner_name = entry.owner&.name
+          new_text = entry_name
+
+          if entry_name.end_with?("=")
+            method_name = entry_name.delete_suffix("=")
+
+            # For writer methods, format as assignment and prefix "self." when no receiver is specified
+            new_text = node.receiver.nil? ? "self.#{method_name} = " : "#{method_name} = "
+          end
 
           label_details = Interface::CompletionItemLabelDetails.new(
             description: entry.file_name,
@@ -525,7 +536,7 @@ module RubyLsp
             label: entry_name,
             filter_text: entry_name,
             label_details: label_details,
-            text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
+            text_edit: Interface::TextEdit.new(range: range, new_text: new_text),
             kind: Constant::CompletionItemKind::METHOD,
             data: {
               owner_name: owner_name,

data/lib/ruby_lsp/listeners/hover.rb

@@ -7,6 +7,7 @@ module RubyLsp
       include Requests::Support::Common
 
       ALLOWED_TARGETS = [
+        Prism::BreakNode,
         Prism::CallNode,
         Prism::ConstantReadNode,
         Prism::ConstantWriteNode,
@@ -54,6 +55,7 @@ module RubyLsp
 
         dispatcher.register(
           self,
+          :on_break_node_enter,
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
@@ -84,6 +86,11 @@ module RubyLsp
         )
       end
 
+      #: (Prism::BreakNode node) -> void
+      def on_break_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         if @path && File.basename(@path) == GEMFILE_NAME

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -8,10 +8,12 @@ module RubyLsp
 
       RESCUE_STRING_LENGTH = "rescue".length #: Integer
 
-      #: (ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint] response_builder, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
-      def initialize(response_builder, hints_configuration, dispatcher)
+      #: (GlobalState, ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint], Prism::Dispatcher) -> void
+      def initialize(global_state, response_builder, dispatcher)
         @response_builder = response_builder
-        @hints_configuration = hints_configuration
+        @hints_configuration = ( # rubocop:disable Style/RedundantParentheses
+          global_state.feature_configuration(:inlayHint) #: as !nil
+        ) #: RequestConfig
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end