ruby-lsp 0.17.4 → 0.17.13

data/lib/ruby_lsp/server.rb

@@ -19,10 +19,10 @@ module RubyLsp
     def process_message(message)
       case message[:method]
       when "initialize"
-        $stderr.puts("Initializing Ruby LSP v#{VERSION}...")
+        send_log_message("Initializing Ruby LSP v#{VERSION}...")
         run_initialize(message)
       when "initialized"
-        $stderr.puts("Finished initializing Ruby LSP!") unless @test_mode
+        send_log_message("Finished initializing Ruby LSP!") unless @test_mode
         run_initialized
       when "textDocument/didOpen"
         text_document_did_open(message)
@@ -98,15 +98,43 @@ 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))
+        # If a document is deleted before we are able to process all of its enqueued requests, we will try to read it
+        # from disk and it raise this error. This is expected, so we don't include the `data` attribute to avoid
+        # reporting these to our telemetry
+        if e.is_a?(Store::NonExistingDocumentError)
+          send_message(Error.new(
+            id: message[:id],
+            code: Constant::ErrorCodes::INVALID_PARAMS,
+            message: e.full_message,
+          ))
+        else
+          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
       end
 
-      $stderr.puts("Error processing #{message[:method]}: #{e.full_message}")
+      send_log_message("Error processing #{message[:method]}: #{e.full_message}", type: Constant::MessageType::ERROR)
     end
 
     sig { void }
     def load_addons
-      Addon.load_addons(@global_state, @outgoing_queue)
+      errors = Addon.load_addons(@global_state, @outgoing_queue)
+
+      if errors.any?
+        send_log_message(
+          "Error loading addons:\n\n#{errors.map(&:full_message).join("\n\n")}",
+          type: Constant::MessageType::WARNING,
+        )
+      end
+
       errored_addons = Addon.addons.select(&:error?)
 
       if errored_addons.any?
@@ -120,7 +148,12 @@ module RubyLsp
           ),
         )
 
-        $stderr.puts(errored_addons.map(&:errors_details).join("\n\n")) unless @test_mode
+        unless @test_mode
+          send_log_message(
+            errored_addons.map(&:errors_details).join("\n\n"),
+            type: Constant::MessageType::WARNING,
+          )
+        end
       end
     end
 
@@ -129,7 +162,7 @@ module RubyLsp
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def run_initialize(message)
       options = message[:params]
-      @global_state.apply_options(options)
+      global_state_notifications = @global_state.apply_options(options)
 
       client_name = options.dig(:clientInfo, :name)
       @store.client_name = client_name if client_name
@@ -137,7 +170,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
@@ -162,6 +194,7 @@ module RubyLsp
       hover_provider = Requests::Hover.provider if enabled_features["hover"]
       folding_ranges_provider = Requests::FoldingRanges.provider if enabled_features["foldingRanges"]
       semantic_tokens_provider = Requests::SemanticHighlighting.provider if enabled_features["semanticHighlighting"]
+      document_formatting_provider = Requests::Formatting.provider if enabled_features["formatting"]
       diagnostics_provider = Requests::Diagnostics.provider if enabled_features["diagnostics"]
       on_type_formatting_provider = Requests::OnTypeFormatting.provider if enabled_features["onTypeFormatting"]
       code_action_provider = Requests::CodeActions.provider if enabled_features["codeActions"]
@@ -183,7 +216,7 @@ module RubyLsp
           document_link_provider: document_link_provider,
           folding_range_provider: folding_ranges_provider,
           semantic_tokens_provider: semantic_tokens_provider,
-          document_formatting_provider: enabled_features["formatting"] && @global_state.formatter != "none",
+          document_formatting_provider: document_formatting_provider && @global_state.formatter != "none",
           document_highlight_provider: enabled_features["documentHighlights"],
           code_action_provider: code_action_provider,
           document_on_type_formatting_provider: on_type_formatting_provider,
@@ -235,7 +268,11 @@ module RubyLsp
         )
       end
 
+      process_indexing_configuration(options.dig(:initializationOptions, :indexing))
+
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
+
+      global_state_notifications.each { |notification| send_message(notification) }
     end
 
     sig { void }
@@ -243,28 +280,6 @@ module RubyLsp
       load_addons
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
-      indexing_config = {}
-
-      # Need to use the workspace URI, otherwise, this will fail for people working on a project that is a symlink.
-      index_path = File.join(@global_state.workspace_path, ".index.yml")
-
-      if File.exist?(index_path)
-        begin
-          indexing_config = YAML.parse_file(index_path).to_ruby
-        rescue Psych::SyntaxError => e
-          message = "Syntax error while loading configuration: #{e.message}"
-          send_message(
-            Notification.new(
-              method: "window/showMessage",
-              params: Interface::ShowMessageParams.new(
-                type: Constant::MessageType::WARNING,
-                message: message,
-              ),
-            ),
-          )
-        end
-      end
-
       if defined?(Requests::Support::RuboCopFormatter)
         @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
       end
@@ -272,7 +287,7 @@ module RubyLsp
         @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
       end
 
-      perform_initial_indexing(indexing_config)
+      perform_initial_indexing
       check_formatter_is_available
     end
 
@@ -280,11 +295,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", "eruby"
+          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 +370,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 +412,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 +435,9 @@ module RubyLsp
         return
       end
 
-      response = Requests::Formatting.new(@global_state, @store.get(uri)).perform
+      document = @store.get(uri)
+
+      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 +453,20 @@ 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))
 
       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,
@@ -462,15 +489,18 @@ module RubyLsp
             @global_state,
             params[:position],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
     end
 
-    sig { params(document: Document).returns(T::Boolean) }
-    def typechecker_enabled?(document)
-      @global_state.has_type_checker && document.sorbet_sigil_is_true_or_higher
+    sig { params(document: Document).returns(RubyDocument::SorbetLevel) }
+    def sorbet_level(document)
+      return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker
+      return RubyDocument::SorbetLevel::Ignore unless document.is_a?(RubyDocument)
+
+      document.sorbet_level
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -480,7 +510,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
 
@@ -506,6 +536,12 @@ module RubyLsp
       params = message[:params]
       uri = URI(params.dig(:data, :uri))
       document = @store.get(uri)
+
+      unless document.is_a?(RubyDocument)
+        send_message(Notification.window_show_error("Code actions are currently only available for Ruby documents"))
+        raise Requests::CodeActionResolve::CodeActionError
+      end
+
       result = Requests::CodeActionResolve.new(document, params).perform
 
       case result
@@ -542,7 +578,9 @@ module RubyLsp
         return
       end
 
-      response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
+      document = @store.get(uri)
+
+      response = document.cache_fetch("textDocument/diagnostic") do |document|
         Requests::Diagnostics.new(@global_state, document).perform
       end
 
@@ -573,7 +611,7 @@ module RubyLsp
             document,
             @global_state,
             params,
-            typechecker_enabled?(document),
+            sorbet_level(document),
             dispatcher,
           ).perform,
         ),
@@ -603,7 +641,7 @@ module RubyLsp
             params[:position],
             params[:context],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
@@ -623,7 +661,7 @@ module RubyLsp
             @global_state,
             params[:position],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
@@ -736,16 +774,12 @@ module RubyLsp
       Addon.addons.each(&:deactivate)
     end
 
-    sig { params(config_hash: T::Hash[String, T.untyped]).void }
-    def perform_initial_indexing(config_hash)
+    sig { void }
+    def perform_initial_indexing
       # 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
@@ -842,5 +876,46 @@ module RubyLsp
         )
       end
     end
+
+    sig { params(indexing_options: T.nilable(T::Hash[Symbol, T.untyped])).void }
+    def process_indexing_configuration(indexing_options)
+      # Need to use the workspace URI, otherwise, this will fail for people working on a project that is a symlink.
+      index_path = File.join(@global_state.workspace_path, ".index.yml")
+
+      if File.exist?(index_path)
+        begin
+          @global_state.index.configuration.apply_config(YAML.parse_file(index_path).to_ruby)
+          send_message(
+            Notification.new(
+              method: "window/showMessage",
+              params: Interface::ShowMessageParams.new(
+                type: Constant::MessageType::WARNING,
+                message: "The .index.yml configuration file is deprecated. " \
+                  "Please use editor settings to configure the index",
+              ),
+            ),
+          )
+        rescue Psych::SyntaxError => e
+          message = "Syntax error while loading configuration: #{e.message}"
+          send_message(
+            Notification.new(
+              method: "window/showMessage",
+              params: Interface::ShowMessageParams.new(
+                type: Constant::MessageType::WARNING,
+                message: message,
+              ),
+            ),
+          )
+        end
+        return
+      end
+
+      return unless indexing_options
+
+      # The index expects snake case configurations, but VS Code standardizes on camel case settings
+      @global_state.index.configuration.apply_config(
+        indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase },
+      )
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -5,11 +5,10 @@ module RubyLsp
   class Store
     extend T::Sig
 
-    sig { returns(T::Boolean) }
-    attr_accessor :supports_progress
+    class NonExistingDocumentError < StandardError; end
 
     sig { returns(T::Boolean) }
-    attr_accessor :experimental_features
+    attr_accessor :supports_progress
 
     sig { returns(T::Hash[Symbol, RequestConfig]) }
     attr_accessor :features_configuration
@@ -21,7 +20,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({
@@ -40,14 +38,40 @@ module RubyLsp
       document = @state[uri.to_s]
       return document unless document.nil?
 
-      path = T.must(uri.to_standardized_path)
-      set(uri: uri, source: File.binread(path), version: 0)
+      # For unsaved files (`untitled:Untitled-1` uris), there's no path to read from. If we don't have the untitled file
+      # already present in the store, then we have to raise non existing document error
+      path = uri.to_standardized_path
+      raise NonExistingDocumentError, uri.to_s unless path
+
+      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])
+    rescue Errno::ENOENT
+      raise NonExistingDocumentError, 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

@@ -21,7 +21,8 @@ module RubyLsp
       &block)
       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({})
+      server.global_state.apply_options({ initializationOptions: { experimentalFeaturesEnabled: true } })
+      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

@@ -7,12 +7,16 @@ module RubyLsp
   class TypeInferrer
     extend T::Sig
 
-    sig { params(index: RubyIndexer::Index).void }
-    def initialize(index)
+    sig { params(experimental_features: T::Boolean).returns(T::Boolean) }
+    attr_writer :experimental_features
+
+    sig { params(index: RubyIndexer::Index, experimental_features: T::Boolean).void }
+    def initialize(index, experimental_features = true)
       @index = index
+      @experimental_features = experimental_features
     end
 
-    sig { params(node_context: NodeContext).returns(T.nilable(String)) }
+    sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
     def infer_receiver_type(node_context)
       node = node_context.node
 
@@ -20,36 +24,21 @@ module RubyLsp
       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}>"
+        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
+        Prism::SuperNode, Prism::ForwardingSuperNode
+        self_receiver_handling(node_context)
       end
     end
 
     private
 
-    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(String)) }
+    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(Type)) }
     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}>"
+        self_receiver_handling(node_context)
       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
@@ -62,12 +51,42 @@ module RubyLsp
         return unless name
 
         *parts, last = name.split("::")
-        return "#{last}::<Class:#{last}>" if parts.empty?
+        return Type.new("#{last}::<Class:#{last}>") if parts.empty?
+
+        Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
+      else
+        return unless @experimental_features
 
-        "#{parts.join("::")}::#{last}::<Class:#{last}>"
+        raw_receiver = node.receiver&.slice
+
+        if raw_receiver
+          guessed_name = raw_receiver
+            .delete_prefix("@")
+            .delete_prefix("@@")
+            .split("_")
+            .map(&:capitalize)
+            .join
+
+          entries = @index.resolve(guessed_name, node_context.nesting) || @index.first_unqualified_const(guessed_name)
+          name = entries&.first&.name
+          GuessedType.new(name) if name
+        end
       end
     end
 
+    sig { params(node_context: NodeContext).returns(Type) }
+    def self_receiver_handling(node_context)
+      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 Type.new("Object") if nesting.empty?
+      return Type.new(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
+      Type.new("#{nesting.join("::")}::<Class:#{nesting.last}>")
+    end
+
     sig do
       params(
         node: T.any(
@@ -82,5 +101,22 @@ module RubyLsp
            Prism::ConstantPathNode::MissingNodesInConstantPathError
       nil
     end
+
+    # A known type
+    class Type
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    # A type that was guessed based on the receiver raw name
+    class GuessedType < Type
+    end
   end
 end

data/lib/ruby_lsp/utils.rb

@@ -25,6 +25,7 @@ module RubyLsp
     end,
     String,
   )
+  GUESSED_TYPES_URL = "https://github.com/Shopify/ruby-lsp/blob/main/DESIGN_AND_ROADMAP.md#guessed-types"
 
   # A notification to be sent to the client
   class Message
@@ -52,6 +53,7 @@ module RubyLsp
   class Notification < Message
     class << self
       extend T::Sig
+
       sig { params(message: String).returns(Notification) }
       def window_show_error(message)
         new(
@@ -62,6 +64,14 @@ module RubyLsp
           ),
         )
       end
+
+      sig { params(message: String, type: Integer).returns(Notification) }
+      def window_log_message(message, type: Constant::MessageType::LOG)
+        new(
+          method: "window/logMessage",
+          params: Interface::LogMessageParams.new(type: type, message: message),
+        )
+      end
     end
 
     extend T::Sig
@@ -121,6 +131,9 @@ module RubyLsp
     sig { returns(T.untyped) }
     attr_reader :response
 
+    sig { returns(Integer) }
+    attr_reader :id
+
     sig { params(id: Integer, response: T.untyped).void }
     def initialize(id:, response:)
       @id = id