ruby-lsp 0.17.3 → 0.17.5

data/lib/ruby_lsp/server.rb

@@ -68,6 +68,12 @@ module RubyLsp
         text_document_signature_help(message)
       when "textDocument/definition"
         text_document_definition(message)
+      when "textDocument/prepareTypeHierarchy"
+        text_document_prepare_type_hierarchy(message)
+      when "typeHierarchy/supertypes"
+        type_hierarchy_supertypes(message)
+      when "typeHierarchy/subtypes"
+        type_hierarchy_subtypes(message)
       when "workspace/didChangeWatchedFiles"
         workspace_did_change_watched_files(message)
       when "workspace/symbol"
@@ -76,13 +82,32 @@ module RubyLsp
         text_document_show_syntax_tree(message)
       when "rubyLsp/workspace/dependencies"
         workspace_dependencies(message)
+      when "rubyLsp/workspace/addons"
+        send_message(
+          Result.new(
+            id: message[:id],
+            response:
+              Addon.addons.map do |addon|
+                { name: addon.name, errored: addon.error? }
+              end,
+          ),
+        )
       when "$/cancelRequest"
         @mutex.synchronize { @cancelled_requests << message[:params][:id] }
       end
     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}")
@@ -104,7 +129,7 @@ module RubyLsp
           ),
         )
 
-        $stderr.puts(errored_addons.map(&:errors_details).join("\n\n"))
+        $stderr.puts(errored_addons.map(&:errors_details).join("\n\n")) unless @test_mode
       end
     end
 
@@ -121,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
@@ -152,6 +176,7 @@ module RubyLsp
       inlay_hint_provider = Requests::InlayHints.provider if enabled_features["inlayHint"]
       completion_provider = Requests::Completion.provider if enabled_features["completion"]
       signature_help_provider = Requests::SignatureHelp.provider if enabled_features["signatureHelp"]
+      type_hierarchy_provider = Requests::PrepareTypeHierarchy.provider if enabled_features["typeHierarchy"]
 
       response = {
         capabilities: Interface::ServerCapabilities.new(
@@ -175,8 +200,12 @@ module RubyLsp
           completion_provider: completion_provider,
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
-          workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.typechecker,
+          workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.has_type_checker,
           signature_help_provider: signature_help_provider,
+          type_hierarchy_provider: type_hierarchy_provider,
+          experimental: {
+            addon_detection: true,
+          },
         ),
         serverInfo: {
           name: "Ruby LSP",
@@ -259,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
@@ -327,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
@@ -367,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))
@@ -390,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}"))
@@ -406,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,
@@ -449,7 +494,7 @@ module RubyLsp
 
     sig { params(document: Document).returns(T::Boolean) }
     def typechecker_enabled?(document)
-      @global_state.typechecker && document.sorbet_sigil_is_true_or_higher
+      @global_state.has_type_checker && document.sorbet_sigil_is_true_or_higher
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -459,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
 
@@ -468,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],
@@ -521,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
 
@@ -551,7 +602,7 @@ module RubyLsp
           response: Requests::Completion.new(
             document,
             @global_state,
-            params[:position],
+            params,
             typechecker_enabled?(document),
             dispatcher,
           ).perform,
@@ -660,6 +711,33 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_prepare_type_hierarchy(message)
+      params = message[:params]
+      response = Requests::PrepareTypeHierarchy.new(
+        @store.get(params.dig(:textDocument, :uri)),
+        @global_state.index,
+        params[:position],
+      ).perform
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def type_hierarchy_supertypes(message)
+      response = Requests::TypeHierarchySupertypes.new(
+        @global_state.index,
+        message.dig(:params, :item),
+      ).perform
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def type_hierarchy_subtypes(message)
+      # TODO: implement subtypes
+      # The current index representation doesn't allow us to find the children of an entry.
+      send_message(Result.new(id: message[:id], response: nil))
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_dependencies(message)
       response = begin
@@ -690,23 +768,14 @@ module RubyLsp
 
     sig { params(config_hash: T::Hash[String, T.untyped]).void }
     def perform_initial_indexing(config_hash)
-      index_ruby_core
-      index_ruby_code(config_hash)
-    end
-
-    sig { void }
-    def index_ruby_core
-      RubyIndexer::RBSIndexer.new(@global_state.index).index_ruby_core
-    end
-
-    sig { params(config_hash: T::Hash[String, T.untyped]).void }
-    def index_ruby_code(config_hash)
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
       RubyIndexer.configuration.apply_config(config_hash)
 
       Thread.new do
         begin
+          RubyIndexer::RBSIndexer.new(@global_state.index).index_ruby_core
+
           @global_state.index.index_all do |percentage|
             progress("indexing-progress", percentage)
             true

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

@@ -20,8 +20,9 @@ module RubyLsp
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)
       server = RubyLsp::Server.new(test_mode: true)
-      server.global_state.stubs(:typechecker).returns(false) if stub_no_typechecker
+      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,
             },
           },
         })

data/lib/ruby_lsp/type_inferrer.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # A minimalistic type checker to try to resolve types that can be inferred without requiring a type system or
+  # annotations
+  class TypeInferrer
+    extend T::Sig
+
+    sig { params(index: RubyIndexer::Index).void }
+    def initialize(index)
+      @index = index
+    end
+
+    sig { params(node_context: NodeContext).returns(T.nilable(String)) }
+    def infer_receiver_type(node_context)
+      node = node_context.node
+
+      case node
+      when Prism::CallNode
+        infer_receiver_for_call_node(node, node_context)
+      when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
+        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode
+        nesting = node_context.nesting
+        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
+        # inherits from Object
+        return "Object" if nesting.empty?
+
+        fully_qualified_name = node_context.fully_qualified_name
+        return fully_qualified_name if node_context.surrounding_method
+
+        "#{fully_qualified_name}::<Class:#{nesting.last}>"
+      end
+    end
+
+    private
+
+    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(String)) }
+    def infer_receiver_for_call_node(node, node_context)
+      receiver = node.receiver
+
+      case receiver
+      when Prism::SelfNode, nil
+        nesting = node_context.nesting
+        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
+        # inherits from Object
+        return "Object" if nesting.empty?
+        return node_context.fully_qualified_name if node_context.surrounding_method
+
+        # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
+        # context
+        "#{nesting.join("::")}::<Class:#{nesting.last}>"
+      when Prism::ConstantPathNode, Prism::ConstantReadNode
+        # When the receiver is a constant reference, we have to try to resolve it to figure out the right
+        # receiver. But since the invocation is directly on the constant, that's the singleton context of that
+        # class/module
+        receiver_name = constant_name(receiver)
+        return unless receiver_name
+
+        resolved_receiver = @index.resolve(receiver_name, node_context.nesting)
+        name = resolved_receiver&.first&.name
+        return unless name
+
+        *parts, last = name.split("::")
+        return "#{last}::<Class:#{last}>" if parts.empty?
+
+        "#{parts.join("::")}::#{last}::<Class:#{last}>"
+      end
+    end
+
+    sig do
+      params(
+        node: T.any(
+          Prism::ConstantPathNode,
+          Prism::ConstantReadNode,
+        ),
+      ).returns(T.nilable(String))
+    end
+    def constant_name(node)
+      node.full_name
+    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+           Prism::ConstantPathNode::MissingNodesInConstantPathError
+      nil
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.3
+  version: 0.17.5
 platform: ruby
 authors:
 - Shopify
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-11 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
@@ -152,6 +153,7 @@ files:
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
+- lib/ruby_lsp/requests/prepare_type_hierarchy.rb
 - lib/ruby_lsp/requests/request.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
@@ -167,6 +169,7 @@ files:
 - lib/ruby_lsp/requests/support/sorbet.rb
 - lib/ruby_lsp/requests/support/source_uri.rb
 - lib/ruby_lsp/requests/support/syntax_tree_formatter.rb
+- lib/ruby_lsp/requests/type_hierarchy_supertypes.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
 - lib/ruby_lsp/response_builders.rb
 - lib/ruby_lsp/response_builders/collection_response_builder.rb
@@ -180,6 +183,7 @@ files:
 - lib/ruby_lsp/setup_bundler.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
+- lib/ruby_lsp/type_inferrer.rb
 - lib/ruby_lsp/utils.rb
 homepage: https://github.com/Shopify/ruby-lsp
 licenses:
@@ -187,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
@@ -202,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: []