ruby-lsp 0.3.8 → 0.4.1

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -16,6 +16,22 @@ end
 module RubyLsp
   module Requests
     module Support
+      class InternalRuboCopError < StandardError
+        extend T::Sig
+
+        MESSAGE = <<~EOS
+          An internal error occurred for the %s cop.
+          Updating to a newer version of RuboCop may solve this.
+          For more details, run RuboCop on the command line.
+        EOS
+
+        sig { params(rubocop_error: RuboCop::ErrorWithAnalyzedFileLocation).void }
+        def initialize(rubocop_error)
+          message = format(MESSAGE, rubocop_error.cop.name)
+          super(message)
+        end
+      end
+
       # :nodoc:
       class RuboCopRunner < RuboCop::Runner
         extend T::Sig
@@ -31,10 +47,18 @@ module RubyLsp
             "--force-exclusion",
             "--format",
             "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-          ].freeze,
+          ],
           T::Array[String],
         )
 
+        begin
+          RuboCop::Options.new.parse(["--raise-cop-error"])
+          DEFAULT_ARGS << "--raise-cop-error"
+        rescue OptionParser::InvalidOption
+          # older versions of RuboCop don't support this flag
+        end
+        DEFAULT_ARGS.freeze
+
         sig { params(args: String).void }
         def initialize(*args)
           @options = T.let({}, T::Hash[Symbol, T.untyped])
@@ -63,6 +87,8 @@ module RubyLsp
           raise Formatting::Error, error.message
         rescue RuboCop::ValidationError => error
           raise ConfigurationError, error.message
+        rescue RuboCop::ErrorWithAnalyzedFileLocation => error
+          raise InternalRuboCopError, error
         end
 
         sig { returns(String) }

data/lib/ruby_lsp/requests/support/sorbet.rb

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class Sorbet
+        class << self
+          extend T::Sig
+
+          ANNOTATIONS = T.let(
+            {
+              "abstract!" => Annotation.new(arity: 0),
+              "absurd" => Annotation.new(arity: 1, receiver: true),
+              "all" => Annotation.new(arity: (2..), receiver: true),
+              "any" => Annotation.new(arity: (2..), receiver: true),
+              "assert_type!" => Annotation.new(arity: 2, receiver: true),
+              "attached_class" => Annotation.new(arity: 0, receiver: true),
+              "bind" => Annotation.new(arity: 2, receiver: true),
+              "cast" => Annotation.new(arity: 2, receiver: true),
+              "class_of" => Annotation.new(arity: 1, receiver: true),
+              "enums" => Annotation.new(arity: 0),
+              "interface!" => Annotation.new(arity: 0),
+              "let" => Annotation.new(arity: 2, receiver: true),
+              "mixes_in_class_methods" => Annotation.new(arity: 1),
+              "must" => Annotation.new(arity: 1, receiver: true),
+              "must_because" => Annotation.new(arity: 1, receiver: true),
+              "nilable" => Annotation.new(arity: 1, receiver: true),
+              "noreturn" => Annotation.new(arity: 0, receiver: true),
+              "requires_ancestor" => Annotation.new(arity: 0),
+              "reveal_type" => Annotation.new(arity: 1, receiver: true),
+              "sealed!" => Annotation.new(arity: 0),
+              "self_type" => Annotation.new(arity: 0, receiver: true),
+              "sig" => Annotation.new(arity: 0),
+              "type_member" => Annotation.new(arity: (0..1)),
+              "type_template" => Annotation.new(arity: 0),
+              "unsafe" => Annotation.new(arity: 1),
+              "untyped" => Annotation.new(arity: 0, receiver: true),
+            },
+            T::Hash[String, Annotation],
+          )
+
+          sig do
+            params(
+              node: T.any(SyntaxTree::CallNode, SyntaxTree::VCall),
+            ).returns(T::Boolean)
+          end
+          def annotation?(node)
+            annotation = annotation(node)
+
+            return false if annotation.nil?
+
+            return false unless annotation.supports_receiver?(receiver_name(node))
+
+            annotation.supports_arity?(node.arity)
+          end
+
+          private
+
+          sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::VCall)).returns(T.nilable(Annotation)) }
+          def annotation(node)
+            case node
+            when SyntaxTree::VCall
+              ANNOTATIONS[node.value.value]
+            when SyntaxTree::CallNode
+              ANNOTATIONS[node.message.value]
+            else
+              T.absurd(node)
+            end
+          end
+
+          sig do
+            params(receiver: T.any(SyntaxTree::CallNode, SyntaxTree::VCall)).returns(T.nilable(String))
+          end
+          def receiver_name(receiver)
+            case receiver
+            when SyntaxTree::CallNode
+              node_name(receiver.receiver)
+            when SyntaxTree::VCall
+              nil
+            else
+              T.absurd(receiver)
+            end
+          end
+
+          sig do
+            params(node: T.nilable(T.any(
+              SyntaxTree::VarRef,
+              SyntaxTree::CallNode,
+              SyntaxTree::VCall,
+              SyntaxTree::Ident,
+              SyntaxTree::Backtick,
+              SyntaxTree::Const,
+              SyntaxTree::Op,
+              Symbol,
+            ))).returns(T.nilable(String))
+          end
+          def node_name(node)
+            case node
+            when NilClass
+              nil
+            when SyntaxTree::VarRef
+              node.value.value
+            when SyntaxTree::CallNode
+              node_name(node.receiver)
+            when SyntaxTree::VCall
+              node_name(node.value)
+            when SyntaxTree::Ident, SyntaxTree::Backtick, SyntaxTree::Const, SyntaxTree::Op
+              node.value
+            when Symbol
+              node.to_s
+            else
+              T.absurd(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -14,8 +14,10 @@ module RubyLsp
   # - {RubyLsp::Requests::OnTypeFormatting}
   # - {RubyLsp::Requests::Diagnostics}
   # - {RubyLsp::Requests::CodeActions}
+  # - {RubyLsp::Requests::CodeActionResolve}
   # - {RubyLsp::Requests::DocumentHighlight}
   # - {RubyLsp::Requests::InlayHints}
+  # - {RubyLsp::Requests::PathCompletion}
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
@@ -29,17 +31,21 @@ module RubyLsp
     autoload :OnTypeFormatting, "ruby_lsp/requests/on_type_formatting"
     autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
     autoload :CodeActions, "ruby_lsp/requests/code_actions"
+    autoload :CodeActionResolve, "ruby_lsp/requests/code_action_resolve"
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
+    autoload :PathCompletion, "ruby_lsp/requests/path_completion"
 
     # :nodoc:
     module Support
       autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
       autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"
       autoload :SemanticTokenEncoder, "ruby_lsp/requests/support/semantic_token_encoder"
-      autoload :SyntaxErrorDiagnostic, "ruby_lsp/requests/support/syntax_error_diagnostic"
+      autoload :Annotation, "ruby_lsp/requests/support/annotation"
+      autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
       autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
+      autoload :PrefixTree, "ruby_lsp/requests/support/prefix_tree"
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -1,250 +1,158 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/internal"
-
 module RubyLsp
-  Handler.start do
-    on("initialize") do |request|
-      store.clear
-      store.encoding = request.dig(:params, :capabilities, :general, :positionEncodings)
-
-      initialization_options = request.dig(:params, :initializationOptions)
-      enabled_features = initialization_options.fetch(:enabledFeatures, [])
-
-      document_symbol_provider = if enabled_features.include?("documentSymbols")
-        Interface::DocumentSymbolClientCapabilities.new(
-          hierarchical_document_symbol_support: true,
-          symbol_kind: {
-            value_set: Requests::DocumentSymbol::SYMBOL_KIND.values,
-          },
-        )
-      end
-
-      document_link_provider = if enabled_features.include?("documentLink")
-        Interface::DocumentLinkOptions.new(resolve_provider: false)
-      end
-
-      hover_provider = if enabled_features.include?("hover")
-        Interface::HoverClientCapabilities.new(dynamic_registration: false)
-      end
-
-      folding_ranges_provider = if enabled_features.include?("foldingRanges")
-        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
-      end
-
-      semantic_tokens_provider = if enabled_features.include?("semanticHighlighting")
-        Interface::SemanticTokensRegistrationOptions.new(
-          document_selector: { scheme: "file", language: "ruby" },
-          legend: Interface::SemanticTokensLegend.new(
-            token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys,
-          ),
-          range: true,
-          full: { delta: false },
-        )
-      end
-
-      diagnostics_provider = if enabled_features.include?("diagnostics")
-        {
-          interFileDependencies: false,
-          workspaceDiagnostics: false,
-        }
-      end
-
-      on_type_formatting_provider = if enabled_features.include?("onTypeFormatting")
-        Interface::DocumentOnTypeFormattingOptions.new(
-          first_trigger_character: "{",
-          more_trigger_character: ["\n", "|"],
-        )
-      end
-
-      inlay_hint_provider = if enabled_features.include?("inlayHint")
-        Interface::InlayHintOptions.new(resolve_provider: false)
+  Interface = LanguageServer::Protocol::Interface
+  Constant = LanguageServer::Protocol::Constant
+  Transport = LanguageServer::Protocol::Transport
+
+  class Server
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
+      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
+      @store = T.let(Store.new, Store)
+
+      # The job queue is the actual list of requests we have to process
+      @job_queue = T.let(Thread::Queue.new, Thread::Queue)
+      # The jobs hash is just a way of keeping a handle to jobs based on the request ID, so we can cancel them
+      @jobs = T.let({}, T::Hash[T.any(String, Integer), Job])
+      @mutex = T.let(Mutex.new, Mutex)
+      @worker = T.let(new_worker, Thread)
+
+      Thread.main.priority = 1
+    end
+
+    sig { void }
+    def start
+      warn("Starting Ruby LSP...")
+
+      # Requests that have to be executed sequentially or in the main process are implemented here. All other requests
+      # fall under the else branch which just pushes requests to the queue
+      @reader.read do |request|
+        case request[:method]
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+          result = Executor.new(@store).execute(request)
+          finalize_request(result, request)
+        when "$/cancelRequest"
+          # Cancel the job if it's still in the queue
+          @mutex.synchronize { @jobs[request[:params][:id]]&.cancel }
+        when "shutdown"
+          warn("Shutting down Ruby LSP...")
+
+          # Close the queue so that we can no longer receive items
+          @job_queue.close
+          # Clear any remaining jobs so that the thread can terminate
+          @job_queue.clear
+          @jobs.clear
+          # Wait until the thread is finished
+          @worker.join
+          @store.clear
+
+          finalize_request(Result.new(response: nil, notifications: []), request)
+        when "exit"
+          # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
+          # https://microsoft.github.io/language-server-protocol/specification/#exit
+          status = @store.empty? ? 0 : 1
+          warn("Shutdown complete with status #{status}")
+          exit(status)
+        else
+          # Default case: push the request to the queue to be executed by the worker
+          job = Job.new(request: request, cancelled: false)
+
+          # Remember a handle to the job, so that we can cancel it
+          @mutex.synchronize { @jobs[request[:id]] = job }
+          @job_queue << job
+        end
       end
-
-      Interface::InitializeResult.new(
-        capabilities: Interface::ServerCapabilities.new(
-          text_document_sync: Interface::TextDocumentSyncOptions.new(
-            change: Constant::TextDocumentSyncKind::INCREMENTAL,
-            open_close: true,
-          ),
-          selection_range_provider: enabled_features.include?("selectionRanges"),
-          hover_provider: hover_provider,
-          document_symbol_provider: document_symbol_provider,
-          document_link_provider: document_link_provider,
-          folding_range_provider: folding_ranges_provider,
-          semantic_tokens_provider: semantic_tokens_provider,
-          document_formatting_provider: enabled_features.include?("formatting"),
-          document_highlight_provider: enabled_features.include?("documentHighlights"),
-          code_action_provider: enabled_features.include?("codeActions"),
-          document_on_type_formatting_provider: on_type_formatting_provider,
-          diagnostic_provider: diagnostics_provider,
-          inlay_hint_provider: inlay_hint_provider,
-        ),
-      )
     end
 
-    on("textDocument/didChange") do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      store.push_edits(uri, request.dig(:params, :contentChanges))
-
-      Handler::VOID
-    end
-
-    on("textDocument/didOpen") do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      text = request.dig(:params, :textDocument, :text)
-      store.set(uri, text)
-
-      Handler::VOID
-    end
-
-    on("textDocument/didClose") do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      store.delete(uri)
-      clear_diagnostics(uri)
+    private
 
-      Handler::VOID
-    end
-
-    on("textDocument/documentSymbol", parallel: true) do |request|
-      store.cache_fetch(request.dig(:params, :textDocument, :uri), :document_symbol) do |document|
-        Requests::DocumentSymbol.new(document).run
-      end
-    end
-
-    on("textDocument/documentLink", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      store.cache_fetch(uri, :document_link) do |document|
-        RubyLsp::Requests::DocumentLink.new(uri, document).run
-      end
-    end
+    sig { returns(Thread) }
+    def new_worker
+      Thread.new do
+        # Thread::Queue#pop is thread safe and will wait until an item is available
+        loop do
+          job = T.let(@job_queue.pop, T.nilable(Job))
+          # The only time when the job is nil is when the queue is closed and we can then terminate the thread
+          break if job.nil?
 
-    on("textDocument/hover") do |request|
-      position = request.dig(:params, :position)
-      document = store.get(request.dig(:params, :textDocument, :uri))
+          request = job.request
+          @mutex.synchronize { @jobs.delete(request[:id]) }
 
-      RubyLsp::Requests::Hover.new(document, position).run
-    end
+          result = if job.cancelled
+            # We need to return nil to the client even if the request was cancelled
+            Result.new(response: nil, notifications: [])
+          else
+            Executor.new(@store).execute(request)
+          end
 
-    on("textDocument/foldingRange", parallel: true) do |request|
-      store.cache_fetch(request.dig(:params, :textDocument, :uri), :folding_ranges) do |document|
-        Requests::FoldingRanges.new(document).run
+          finalize_request(result, request)
+        end
       end
     end
 
-    on("textDocument/selectionRange", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      positions = request.dig(:params, :positions)
-
-      ranges = store.cache_fetch(uri, :selection_ranges) do |document|
-        Requests::SelectionRanges.new(document).run
-      end
-
-      # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
-      # every position in the positions array should have an element at the same index in the response
-      # array. For positions without a valid selection range, the corresponding element in the response
-      # array will be nil.
-
-      unless ranges.nil?
-        positions.map do |position|
-          ranges.find do |range|
-            range.cover?(position)
-          end
+    # Finalize a Queue::Result. All IO operations should happen here to avoid any issues with cancelling requests
+    sig { params(result: Result, request: T::Hash[Symbol, T.untyped]).void }
+    def finalize_request(result, request)
+      @mutex.synchronize do
+        error = result.error
+        response = result.response
+
+        # If the response include any notifications, go through them and publish each one
+        result.notifications.each { |n| @writer.write(method: n.message, params: n.params) }
+
+        if error
+          @writer.write(
+            id: request[:id],
+            error: {
+              code: Constant::ErrorCodes::INTERNAL_ERROR,
+              message: error.inspect,
+              data: request.to_json,
+            },
+          )
+        elsif response != VOID
+          @writer.write(id: request[:id], result: response)
         end
-      end
-    end
 
-    on("textDocument/semanticTokens/full", parallel: true) do |request|
-      store.cache_fetch(request.dig(:params, :textDocument, :uri), :semantic_highlighting) do |document|
-        T.cast(
-          Requests::SemanticHighlighting.new(
-            document,
-            encoder: Requests::Support::SemanticTokenEncoder.new,
-          ).run,
-          LanguageServer::Protocol::Interface::SemanticTokens,
-        )
+        request_time = result.request_time
+        if request_time
+          @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
+        end
       end
     end
 
-    on("textDocument/semanticTokens/range", parallel: true) do |request|
-      document = store.get(request.dig(:params, :textDocument, :uri))
-      range = request.dig(:params, :range)
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      Requests::SemanticHighlighting.new(
-        document,
-        range: start_line..end_line,
-        encoder: Requests::Support::SemanticTokenEncoder.new,
-      ).run
+    sig do
+      params(
+        request: T::Hash[Symbol, T.untyped],
+        request_time: Float,
+        error: T.nilable(Exception),
+      ).returns(T::Hash[Symbol, T.any(String, Float)])
     end
-
-    on("textDocument/formatting", parallel: true) do |request|
+    def telemetry_params(request, request_time, error)
       uri = request.dig(:params, :textDocument, :uri)
+      params = {
+        request: request[:method],
+        lspVersion: RubyLsp::VERSION,
+        requestTime: request_time,
+      }
 
-      Requests::Formatting.new(uri, store.get(uri)).run
-    end.on_error do |error|
-      show_message(Constant::MessageType::ERROR, "Formatting error: #{error.message}")
-    end
-
-    on("textDocument/onTypeFormatting", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      position = request.dig(:params, :position)
-      character = request.dig(:params, :ch)
+      if error
+        params[:errorClass] = error.class.name
+        params[:errorMessage] = error.message
 
-      Requests::OnTypeFormatting.new(store.get(uri), position, character).run
-    end
+        log_params = request[:params]
+        params[:params] = log_params.reject { |k, _| k == :textDocument }.to_json if log_params
 
-    on("textDocument/documentHighlight", parallel: true) do |request|
-      document = store.get(request.dig(:params, :textDocument, :uri))
-
-      Requests::DocumentHighlight.new(document, request.dig(:params, :position)).run
-    end
-
-    on("textDocument/codeAction", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      document = store.get(uri)
-      range = request.dig(:params, :range)
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      Requests::CodeActions.new(uri, document, start_line..end_line).run
-    end
-
-    on("textDocument/inlayHint", parallel: true) do |request|
-      document = store.get(request.dig(:params, :textDocument, :uri))
-      range = request.dig(:params, :range)
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      Requests::InlayHints.new(document, start_line..end_line).run
-    end
-
-    on("$/cancelRequest") do |request|
-      cancel_request(request[:params][:id])
-      Handler::VOID
-    end
-
-    on("textDocument/diagnostic", parallel: true) do |request|
-      uri = request.dig(:params, :textDocument, :uri)
-      response = store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.new(uri, document).run
+        backtrace = error.backtrace
+        params[:backtrace] = backtrace.map { |bt| bt.sub(/^#{Dir.home}/, "~") }.join("\n") if backtrace
       end
 
-      { kind: "full", items: response.map(&:to_lsp_diagnostic) } if response
-    end.on_error do |error|
-      show_message(Constant::MessageType::ERROR, "Error running diagnostics: #{error.message}")
-    end
-
-    on("shutdown") { shutdown }
-
-    on("exit") do
-      # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
-      # https://microsoft.github.io/language-server-protocol/specification/#exit
-      status = store.empty? ? 0 : 1
-      exit(status)
+      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
+      params
     end
   end
 end

data/lib/ruby_lsp/utils.rb

@@ -0,0 +1,78 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # Used to indicate that a request shouldn't return a response
+  VOID = T.let(Object.new.freeze, Object)
+
+  # A notification to be sent to the client
+  class Notification
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(Object) }
+    attr_reader :params
+
+    sig { params(message: String, params: Object).void }
+    def initialize(message:, params:)
+      @message = message
+      @params = params
+    end
+  end
+
+  # The final result of running a request before its IO is finalized
+  class Result
+    extend T::Sig
+
+    sig { returns(T.untyped) }
+    attr_reader :response
+
+    sig { returns(T::Array[Notification]) }
+    attr_reader :notifications
+
+    sig { returns(T.nilable(Exception)) }
+    attr_reader :error
+
+    sig { returns(T.nilable(Float)) }
+    attr_reader :request_time
+
+    sig do
+      params(
+        response: T.untyped,
+        notifications: T::Array[Notification],
+        error: T.nilable(Exception),
+        request_time: T.nilable(Float),
+      ).void
+    end
+    def initialize(response:, notifications:, error: nil, request_time: nil)
+      @response = response
+      @notifications = notifications
+      @error = error
+      @request_time = request_time
+    end
+  end
+
+  # A request that will sit in the queue until it's executed
+  class Job
+    extend T::Sig
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    attr_reader :request
+
+    sig { returns(T::Boolean) }
+    attr_reader :cancelled
+
+    sig { params(request: T::Hash[Symbol, T.untyped], cancelled: T::Boolean).void }
+    def initialize(request:, cancelled:)
+      @request = request
+      @cancelled = cancelled
+    end
+
+    sig { void }
+    def cancel
+      @cancelled = true
+    end
+  end
+end