ruby-lsp 0.17.4 → 0.17.5

data/lib/ruby_lsp/listeners/definition.rb

@@ -11,19 +11,24 @@ module RubyLsp
 
       sig do
         params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
+            Interface::Location,
+            Interface::LocationLink,
+          )],
           global_state: GlobalState,
+          language_id: Document::LanguageId,
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
         @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
+        @language_id = language_id
         @uri = uri
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
@@ -49,7 +54,15 @@ module RubyLsp
         message = node.message
         return unless message
 
-        handle_method_definition(message, @type_inferrer.infer_receiver_type(@node_context))
+        inferrer_receiver_type = @type_inferrer.infer_receiver_type(@node_context)
+
+        # Until we can properly infer the receiver type in erb files (maybe with ruby-lsp-rails),
+        # treating method calls' type as `nil` will allow users to get some completion support first
+        if @language_id == Document::LanguageId::ERB && inferrer_receiver_type == "Object"
+          inferrer_receiver_type = nil
+        end
+
+        handle_method_definition(message, inferrer_receiver_type)
       end
 
       sig { params(node: Prism::StringNode).void }
@@ -158,16 +171,13 @@ module RubyLsp
         return unless methods
 
         methods.each do |target_method|
-          location = target_method.location
           file_path = target_method.file_path
           next if @typechecker_enabled && not_in_dependencies?(file_path)
 
-          @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: file_path).to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
+          @response_builder << Interface::LocationLink.new(
+            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_range: range_from_location(target_method.location),
+            target_selection_range: range_from_location(target_method.name_location),
           )
         end
       end
@@ -218,19 +228,16 @@ module RubyLsp
         return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{value}"
 
         entries.each do |entry|
-          location = entry.location
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
           # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
           # in the project, even if the files are typed false
           file_path = entry.file_path
           next if @typechecker_enabled && not_in_dependencies?(file_path)
 
-          @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: file_path).to_s,
-            range: Interface::Range.new(
-              start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
-              end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
-            ),
+          @response_builder << Interface::LocationLink.new(
+            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_range: range_from_location(entry.location),
+            target_selection_range: range_from_location(entry.name_location),
           )
         end
       end

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -69,7 +69,7 @@ module RubyLsp
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = @document
-          .locate(@document.tree, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
+          .locate(@document.parse_result.value, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
@@ -164,7 +164,7 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
-        node_context = @document.locate(@document.tree, start_index, node_types: [Prism::DefNode])
+        node_context = @document.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
         closest_def = T.cast(node_context.node, Prism::DefNode)
         return Error::InvalidTargetRange if closest_def.nil?
 

data/lib/ruby_lsp/requests/completion.rb

@@ -61,7 +61,7 @@ module RubyLsp
         # back by 1, so that we find the right node
         char_position = document.create_scanner.find_char_position(params[:position]) - 1
         node_context = document.locate(
-          document.tree,
+          document.parse_result.value,
           char_position,
           node_types: [
             Prism::CallNode,

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -40,7 +40,8 @@ module RubyLsp
       def perform
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
-        # other than label details and documentation. If we modify anything, the completion behaviour might be broken.
+        # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behaviour might
+        # be broken.
         #
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
@@ -59,15 +60,9 @@ module RubyLsp
         first_entry = T.must(entries.first)
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
-          detail = first_entry.decorated_parameters
           label = "#{label}#{first_entry.decorated_parameters}"
         end
 
-        @item[:labelDetails] = Interface::CompletionItemLabelDetails.new(
-          description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
-          detail: detail,
-        )
-
         @item[:documentation] = Interface::MarkupContent.new(
           kind: "markdown",
           value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES),

data/lib/ruby_lsp/requests/definition.rb

@@ -42,8 +42,8 @@ module RubyLsp
       def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
         @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::Location].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          ResponseBuilders::CollectionResponseBuilder[T.any(Interface::Location, Interface::LocationLink)].new,
+          ResponseBuilders::CollectionResponseBuilder[T.any(Interface::Location, Interface::LocationLink)],
         )
         @dispatcher = dispatcher
 
@@ -90,6 +90,7 @@ module RubyLsp
           Listeners::Definition.new(
             @response_builder,
             global_state,
+            document.language_id,
             document.uri,
             node_context,
             dispatcher,
@@ -104,7 +105,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
       end
 
-      sig { override.returns(T::Array[Interface::Location]) }
+      sig { override.returns(T::Array[T.any(Interface::Location, Interface::LocationLink)]) }
       def perform
         @dispatcher.dispatch_once(@target) if @target
         @response_builder.response

data/lib/ruby_lsp/requests/formatting.rb

@@ -40,6 +40,8 @@ module RubyLsp
         return unless @active_formatter
         return if @document.syntax_error?
 
+        # We don't format erb documents yet
+
         formatted_text = @active_formatter.run_formatting(@uri, @document)
         return unless formatted_text
 

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -34,7 +34,7 @@ module RubyLsp
       sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def perform
         # [node, parent]
-        queue = [[@document.tree, nil]]
+        queue = [[@document.parse_result.value, nil]]
 
         until queue.empty?
           node, parent = queue.shift

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -25,6 +25,7 @@ module RubyLsp
         super()
         @document = document
         @range = range
+        @tree = T.let(document.parse_result.value, Prism::ProgramNode)
       end
 
       sig { override.returns(String) }
@@ -32,7 +33,7 @@ module RubyLsp
         return ast_for_range if @range
 
         output_string = +""
-        PP.pp(@document.tree, output_string)
+        PP.pp(@tree, output_string)
         output_string
       end
 
@@ -46,7 +47,7 @@ module RubyLsp
         start_char = scanner.find_char_position(range[:start])
         end_char = scanner.find_char_position(range[:end])
 
-        queue = @document.tree.statements.body.dup
+        queue = @tree.statements.body.dup
         found_nodes = []
 
         until queue.empty?

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -54,8 +54,6 @@ module RubyLsp
           end
 
           entry.mixin_operations.each do |mixin_operation|
-            next if mixin_operation.is_a?(RubyIndexer::Entry::Extend)
-
             mixin_name = mixin_operation.module_name
             resolved_mixin_entries = @index.resolve(mixin_name, entry.nesting)
             next unless resolved_mixin_entries
@@ -75,14 +73,12 @@ module RubyLsp
 
       sig { params(entry: RubyIndexer::Entry).returns(Interface::TypeHierarchyItem) }
       def hierarchy_item(entry)
-        range = range_from_location(entry.location)
-
         Interface::TypeHierarchyItem.new(
           name: entry.name,
           kind: kind_for_entry(entry),
           uri: URI::Generic.from_path(path: entry.file_path).to_s,
-          range: range,
-          selection_range: range,
+          range: range_from_location(entry.location),
+          selection_range: range_from_location(entry.name_location),
           detail: entry.file_name,
         )
       end

data/lib/ruby_lsp/ruby_document.rb

@@ -10,5 +10,15 @@ module RubyLsp
       @needs_parsing = false
       @parse_result = Prism.parse(@source)
     end
+
+    sig { override.returns(T::Boolean) }
+    def syntax_error?
+      @parse_result.failure?
+    end
+
+    sig { override.returns(LanguageId) }
+    def language_id
+      LanguageId::Ruby
+    end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -98,7 +98,16 @@ module RubyLsp
     rescue StandardError, LoadError => e
       # If an error occurred in a request, we have to return an error response or else the editor will hang
       if message[:id]
-        send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::INTERNAL_ERROR, message: e.full_message))
+        send_message(Error.new(
+          id: message[:id],
+          code: Constant::ErrorCodes::INTERNAL_ERROR,
+          message: e.full_message,
+          data: {
+            errorClass: e.class.name,
+            errorMessage: e.message,
+            backtrace: e.backtrace&.join("\n"),
+          },
+        ))
       end
 
       $stderr.puts("Error processing #{message[:method]}: #{e.full_message}")
@@ -137,7 +146,6 @@ module RubyLsp
       progress = options.dig(:capabilities, :window, :workDoneProgress)
       @store.supports_progress = progress.nil? ? true : progress
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
-      @store.experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
 
       configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
       T.must(@store.features_configuration.dig(:inlayHint)).configuration.merge!(configured_hints) if configured_hints
@@ -280,11 +288,18 @@ module RubyLsp
     def text_document_did_open(message)
       @mutex.synchronize do
         text_document = message.dig(:params, :textDocument)
+        language_id = case text_document[:languageId]
+        when "erb"
+          Document::LanguageId::ERB
+        else
+          Document::LanguageId::Ruby
+        end
         @store.set(
           uri: text_document[:uri],
           source: text_document[:text],
           version: text_document[:version],
           encoding: @global_state.encoding,
+          language_id: language_id,
         )
       end
     end
@@ -348,15 +363,17 @@ module RubyLsp
         return
       end
 
+      parse_result = document.parse_result
+
       # Run requests for the document
       dispatcher = Prism::Dispatcher.new
-      folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher)
+      folding_range = Requests::FoldingRanges.new(parse_result.comments, dispatcher)
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
-      document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher)
+      document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
 
       semantic_highlighting = Requests::SemanticHighlighting.new(@global_state, dispatcher)
-      dispatcher.dispatch(document.tree)
+      dispatcher.dispatch(parse_result.value)
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
       # we actually received
@@ -388,7 +405,7 @@ module RubyLsp
 
       dispatcher = Prism::Dispatcher.new
       request = Requests::SemanticHighlighting.new(@global_state, dispatcher, range: start_line..end_line)
-      dispatcher.visit(document.tree)
+      dispatcher.visit(document.parse_result.value)
 
       response = request.perform
       send_message(Result.new(id: message[:id], response: response))
@@ -411,7 +428,11 @@ module RubyLsp
         return
       end
 
-      response = Requests::Formatting.new(@global_state, @store.get(uri)).perform
+      document = @store.get(uri)
+
+      return send_empty_response(message[:id]) if document.is_a?(ERBDocument)
+
+      response = Requests::Formatting.new(@global_state, document).perform
       send_message(Result.new(id: message[:id], response: response))
     rescue Requests::Request::InvalidFormatter => error
       send_message(Notification.window_show_error("Configuration error: #{error.message}"))
@@ -427,19 +448,22 @@ module RubyLsp
       dispatcher = Prism::Dispatcher.new
       document = @store.get(params.dig(:textDocument, :uri))
       request = Requests::DocumentHighlight.new(document, params[:position], dispatcher)
-      dispatcher.dispatch(document.tree)
+      dispatcher.dispatch(document.parse_result.value)
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_on_type_formatting(message)
       params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+
+      return send_empty_response(message[:id]) if document.is_a?(ERBDocument)
 
       send_message(
         Result.new(
           id: message[:id],
           response: Requests::OnTypeFormatting.new(
-            @store.get(params.dig(:textDocument, :uri)),
+            document,
             params[:position],
             params[:ch],
             @store.client_name,
@@ -480,7 +504,7 @@ module RubyLsp
       dispatcher = Prism::Dispatcher.new
       document = @store.get(params.dig(:textDocument, :uri))
       request = Requests::InlayHints.new(document, params[:range], hints_configurations, dispatcher)
-      dispatcher.visit(document.tree)
+      dispatcher.visit(document.parse_result.value)
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
@@ -489,6 +513,8 @@ module RubyLsp
       params = message[:params]
       document = @store.get(params.dig(:textDocument, :uri))
 
+      return send_empty_response(message[:id]) if document.is_a?(ERBDocument)
+
       send_message(
         Result.new(
           id: message[:id],
@@ -542,7 +568,11 @@ module RubyLsp
         return
       end
 
-      response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
+      document = @store.get(uri)
+
+      return send_empty_response(message[:id]) if document.is_a?(ERBDocument)
+
+      response = document.cache_fetch("textDocument/diagnostic") do |document|
         Requests::Diagnostics.new(@global_state, document).perform
       end
 

data/lib/ruby_lsp/store.rb

@@ -8,9 +8,6 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_accessor :supports_progress
 
-    sig { returns(T::Boolean) }
-    attr_accessor :experimental_features
-
     sig { returns(T::Hash[Symbol, RequestConfig]) }
     attr_accessor :features_configuration
 
@@ -21,7 +18,6 @@ module RubyLsp
     def initialize
       @state = T.let({}, T::Hash[String, Document])
       @supports_progress = T.let(true, T::Boolean)
-      @experimental_features = T.let(false, T::Boolean)
       @features_configuration = T.let(
         {
           inlayHint: RequestConfig.new({
@@ -41,13 +37,32 @@ module RubyLsp
       return document unless document.nil?
 
       path = T.must(uri.to_standardized_path)
-      set(uri: uri, source: File.binread(path), version: 0)
+      ext = File.extname(path)
+      language_id = if ext == ".erb" || ext == ".rhtml"
+        Document::LanguageId::ERB
+      else
+        Document::LanguageId::Ruby
+      end
+      set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
       T.must(@state[uri.to_s])
     end
 
-    sig { params(uri: URI::Generic, source: String, version: Integer, encoding: Encoding).void }
-    def set(uri:, source:, version:, encoding: Encoding::UTF_8)
-      document = RubyDocument.new(source: source, version: version, uri: uri, encoding: encoding)
+    sig do
+      params(
+        uri: URI::Generic,
+        source: String,
+        version: Integer,
+        language_id: Document::LanguageId,
+        encoding: Encoding,
+      ).void
+    end
+    def set(uri:, source:, version:, language_id:, encoding: Encoding::UTF_8)
+      document = case language_id
+      when Document::LanguageId::ERB
+        ERBDocument.new(source: source, version: version, uri: uri, encoding: encoding)
+      else
+        RubyDocument.new(source: source, version: version, uri: uri, encoding: encoding)
+      end
       @state[uri.to_s] = document
     end
 

data/lib/ruby_lsp/test_helper.rb

@@ -22,6 +22,7 @@ module RubyLsp
       server = RubyLsp::Server.new(test_mode: true)
       server.global_state.stubs(:has_type_checker).returns(false) if stub_no_typechecker
       server.global_state.apply_options({})
+      language_id = uri.to_s.end_with?(".erb") ? "erb" : "ruby"
 
       if source
         server.process_message({
@@ -31,6 +32,7 @@ module RubyLsp
               uri: uri,
               text: source,
               version: 1,
+              languageId: language_id,
             },
           },
         })

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.4
+  version: 0.17.5
 platform: ruby
 authors:
 - Shopify
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2024-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -120,6 +120,7 @@ files:
 - lib/ruby_lsp/base_server.rb
 - lib/ruby_lsp/check_docs.rb
 - lib/ruby_lsp/document.rb
+- lib/ruby_lsp/erb_document.rb
 - lib/ruby_lsp/global_state.rb
 - lib/ruby_lsp/internal.rb
 - lib/ruby_lsp/listeners/code_lens.rb
@@ -190,7 +191,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   documentation_uri: https://shopify.github.io/ruby-lsp/
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -205,8 +206,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key: 
+rubygems_version: 3.5.14
+signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []