ruby-lsp 0.0.3 → 0.2.0

data/lib/ruby_lsp/handler.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "ruby_lsp/requests"
@@ -6,51 +7,84 @@ require "benchmark"
 
 module RubyLsp
   class Handler
-    IGNORED_FOR_TELEMETRY = [
-      "initialized",
-      "$/cancelRequest",
-    ].freeze
+    extend T::Sig
+    VOID = T.let(Object.new.freeze, Object)
 
+    sig { returns(Store) }
     attr_reader :store
 
     Interface = LanguageServer::Protocol::Interface
     Constant = LanguageServer::Protocol::Constant
     Transport = LanguageServer::Protocol::Transport
 
+    sig { void }
     def initialize
-      @writer = Transport::Stdio::Writer.new
-      @reader = Transport::Stdio::Reader.new
-      @handlers = {}
-      @store = Store.new
+      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
+      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
+      @handlers = T.let({}, T::Hash[String, T.proc.params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)])
+      @store = T.let(Store.new, Store)
     end
 
+    sig { void }
     def start
       $stderr.puts "Starting Ruby LSP..."
-      @reader.read do |request|
-        with_telemetry(request) { handle(request) }
-      end
+      @reader.read { |request| handle(request) }
     end
 
+    sig { params(blk: T.proc.bind(Handler).params(arg0: T.untyped).void).void }
     def config(&blk)
       instance_exec(&blk)
     end
 
     private
 
+    sig do
+      params(
+        msg: String,
+        blk: T.proc.bind(Handler).params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped)
+      ).void
+    end
     def on(msg, &blk)
-      @handlers[msg.to_s] = blk
+      @handlers[msg] = blk
     end
 
+    sig { params(request: T::Hash[Symbol, T.untyped]).void }
     def handle(request)
-      result = @handlers[request[:method]]&.call(request)
-      @writer.write(id: request[:id], result: result) if result
+      result = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(StandardError))
+      handler = @handlers[request[:method]]
+
+      request_time = Benchmark.realtime do
+        if handler
+          begin
+            result = handler.call(request)
+          rescue StandardError => e
+            error = e
+          end
+
+          if error
+            @writer.write(
+              {
+                id: request[:id],
+                error: { code: Constant::ErrorCodes::INTERNAL_ERROR, message: error.inspect, data: request.to_json },
+              }
+            )
+          elsif result != VOID
+            @writer.write(id: request[:id], result: result)
+          end
+        end
+      end
+
+      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
     end
 
+    sig { void }
     def shutdown
       $stderr.puts "Shutting down Ruby LSP..."
       store.clear
     end
 
+    sig { params(enabled_features: T::Array[String]).returns(Interface::InitializeResult) }
     def respond_with_capabilities(enabled_features)
       document_symbol_provider = if enabled_features.include?("documentSymbols")
         Interface::DocumentSymbolClientCapabilities.new(
@@ -69,8 +103,8 @@ module RubyLsp
         Interface::SemanticTokensRegistrationOptions.new(
           document_selector: { scheme: "file", language: "ruby" },
           legend: Interface::SemanticTokensLegend.new(
-            token_types: Requests::SemanticHighlighting::TOKEN_TYPES,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS
+            token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
+            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys
           ),
           range: false,
           full: {
@@ -90,26 +124,35 @@ module RubyLsp
           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")
         )
       )
     end
 
+    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
     def respond_with_document_symbol(uri)
       store.cache_fetch(uri, :document_symbol) do |document|
-        RubyLsp::Requests::DocumentSymbol.run(document)
+        RubyLsp::Requests::DocumentSymbol.new(document).run
       end
     end
 
+    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::FoldingRange]) }
     def respond_with_folding_ranges(uri)
       store.cache_fetch(uri, :folding_ranges) do |document|
-        Requests::FoldingRanges.run(document)
+        Requests::FoldingRanges.new(document).run
       end
     end
 
+    sig do
+      params(
+        uri: String,
+        positions: T::Array[Document::PositionShape]
+      ).returns(T::Array[T.nilable(RubyLsp::Requests::Support::SelectionRange)])
+    end
     def respond_with_selection_ranges(uri, positions)
       ranges = store.cache_fetch(uri, :selection_ranges) do |document|
-        Requests::SelectionRanges.run(document)
+        Requests::SelectionRanges.new(document).run
       end
 
       # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
@@ -123,19 +166,25 @@ module RubyLsp
       end
     end
 
+    sig { params(uri: String).returns(LanguageServer::Protocol::Interface::SemanticTokens) }
     def respond_with_semantic_highlighting(uri)
       store.cache_fetch(uri, :semantic_highlighting) do |document|
-        Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run
+        T.cast(
+          Requests::SemanticHighlighting.new(document, encoder: Requests::Support::SemanticTokenEncoder.new).run,
+          LanguageServer::Protocol::Interface::SemanticTokens
+        )
       end
     end
 
+    sig { params(uri: String).returns(T.nilable(T::Array[LanguageServer::Protocol::Interface::TextEdit])) }
     def respond_with_formatting(uri)
-      Requests::Formatting.run(uri, store.get(uri))
+      Requests::Formatting.new(uri, store.get(uri)).run
     end
 
+    sig { params(uri: String).void }
     def send_diagnostics(uri)
       response = store.cache_fetch(uri, :diagnostics) do |document|
-        Requests::Diagnostics.run(uri, document)
+        Requests::Diagnostics.new(uri, document).run
       end
 
       @writer.write(
@@ -147,35 +196,56 @@ module RubyLsp
       )
     end
 
+    sig { params(uri: String).void }
+    def clear_diagnostics(uri)
+      @writer.write(
+        method: "textDocument/publishDiagnostics",
+        params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: [])
+      )
+    end
+
+    sig do
+      params(uri: String, range: T::Range[Integer]).returns(T::Array[LanguageServer::Protocol::Interface::CodeAction])
+    end
     def respond_with_code_actions(uri, range)
       store.cache_fetch(uri, :code_actions) do |document|
-        Requests::CodeActions.run(uri, document, range)
+        Requests::CodeActions.new(uri, document, range).run
       end
     end
 
-    def configure_options(initialization_options)
-      @telemetry_enabled = initialization_options.fetch(:telemetryEnabled, false)
+    sig do
+      params(
+        uri: String,
+        position: Document::PositionShape
+      ).returns(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
+    end
+    def respond_with_document_highlight(uri, position)
+      Requests::DocumentHighlight.new(store.get(uri), position).run
     end
 
-    def with_telemetry(request)
-      return yield unless @telemetry_enabled && !IGNORED_FOR_TELEMETRY.include?(request[:method])
-
-      result = nil
-      request_time = Benchmark.realtime do
-        result = yield
-      end
+    sig do
+      params(
+        request: T::Hash[Symbol, T.untyped],
+        request_time: Float,
+        error: T.nilable(StandardError)
+      ).returns(T::Hash[Symbol, T.any(String, Float)])
+    end
+    def telemetry_params(request, request_time, error)
+      uri = request.dig(:params, :textDocument, :uri)
 
       params = {
         request: request[:method],
-        requestTime: request_time,
         lspVersion: RubyLsp::VERSION,
+        requestTime: request_time,
       }
 
-      uri = request.dig(:params, :textDocument, :uri)
-      params[:uri] = uri if uri
+      if error
+        params[:errorClass] = error.class.name
+        params[:errorMessage] = error.message
+      end
 
-      @writer.write(method: "telemetry/event", params: params)
-      result
+      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
+      params
     end
   end
 end

data/lib/ruby_lsp/internal.rb

@@ -0,0 +1,7 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "syntax_tree"
+require "ruby-lsp"
+require "ruby_lsp/cli"

data/lib/ruby_lsp/requests/base_request.rb

@@ -1,21 +1,34 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     # :nodoc:
     class BaseRequest < SyntaxTree::Visitor
-      def self.run(document)
-        new(document).run
-      end
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
 
+      sig { params(document: Document).void }
       def initialize(document)
         @document = document
 
         super()
       end
 
-      def run
-        raise NotImplementedError, "#{self.class}#run must be implemented"
+      sig { abstract.returns(Object) }
+      def run; end
+
+      sig { params(node: SyntaxTree::Node).returns(LanguageServer::Protocol::Interface::Range) }
+      def range_from_syntax_tree_node(node)
+        loc = node.location
+
+        LanguageServer::Protocol::Interface::Range.new(
+          start: LanguageServer::Protocol::Interface::Position.new(line: loc.start_line - 1,
+            character: loc.start_column),
+          end: LanguageServer::Protocol::Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
+        )
       end
     end
   end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -1,7 +1,10 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Code actions demo](../../misc/code_actions.gif)
+    #
     # The [code actions](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeAction)
     # request informs the editor of RuboCop quick fixes that can be applied. These are accesible by hovering over a
     # specific diagnostic.
@@ -13,23 +16,32 @@ module RubyLsp
     # puts "Hello" # --> code action: quick fix indentation
     # end
     # ```
-    class CodeActions
-      def self.run(uri, document, range)
-        new(uri, document, range).run
-      end
+    class CodeActions < BaseRequest
+      extend T::Sig
 
+      sig do
+        params(
+          uri: String,
+          document: Document,
+          range: T::Range[Integer]
+        ).void
+      end
       def initialize(uri, document, range)
-        @document = document
+        super(document)
+
         @uri = uri
         @range = range
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CodeAction], Object)) }
       def run
-        diagnostics = Diagnostics.run(@uri, @document)
-        corrections = diagnostics.select { |diagnostic| diagnostic.correctable? && diagnostic.in_range?(@range) }
+        diagnostics = Diagnostics.new(@uri, @document).run
+        corrections = diagnostics.select do |diagnostic|
+          diagnostic.correctable? && T.cast(diagnostic, Support::RuboCopDiagnostic).in_range?(@range)
+        end
         return [] if corrections.empty?
 
-        corrections.map!(&:to_lsp_code_action)
+        T.cast(corrections, T::Array[Support::RuboCopDiagnostic]).map!(&:to_lsp_code_action)
       end
     end
   end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -1,7 +1,12 @@
+# typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/requests/support/rubocop_diagnostics_runner"
+
 module RubyLsp
   module Requests
+    # ![Diagnostics demo](../../misc/diagnostics.gif)
+    #
     # The
     # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
     # request informs the editor of RuboCop offenses for a given file.
@@ -13,21 +18,34 @@ module RubyLsp
     # puts "Hello" # --> diagnostics: incorrect indentantion
     # end
     # ```
-    class Diagnostics < RuboCopRequest
-      def run
-        return syntax_error_diagnostics if @document.syntax_errors?
+    class Diagnostics < BaseRequest
+      extend T::Sig
 
-        super
+      sig { params(uri: String, document: Document).void }
+      def initialize(uri, document)
+        super(document)
 
-        @diagnostics
+        @uri = uri
       end
 
-      def file_finished(_file, offenses)
-        @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, @uri) }
+      sig do
+        override.returns(
+          T.any(
+            T.all(T::Array[Support::RuboCopDiagnostic], Object),
+            T.all(T::Array[Support::SyntaxErrorDiagnostic], Object),
+          )
+        )
+      end
+      def run
+        return syntax_error_diagnostics if @document.syntax_errors?
+        return [] unless defined?(Support::RuboCopDiagnosticsRunner)
+
+        Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end
 
       private
 
+      sig { returns(T::Array[Support::SyntaxErrorDiagnostic]) }
       def syntax_error_diagnostics
         @document.syntax_error_edits.map { |e| Support::SyntaxErrorDiagnostic.new(e) }
       end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -0,0 +1,113 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Document highlight demo](../../misc/document_highlight.gif)
+    #
+    # The [document highlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
+    # informs the editor all relevant elements of the currently pointed item for highlighting. For example, when
+    # the cursor is on the `F` of the constant `FOO`, the editor should identify other occurences of `FOO`
+    # and highlight them.
+    #
+    # For writable elements like constants or variables, their read/write occurrences should be highlighted differently.
+    # This is achieved by sending different "kind" attributes to the editor (2 for read and 3 for write).
+    #
+    # # Example
+    #
+    # ```ruby
+    # FOO = 1 # should be highlighted as "write"
+    #
+    # def foo
+    #   FOO # should be highlighted as "read"
+    # end
+    # ```
+    class DocumentHighlight < BaseRequest
+      extend T::Sig
+
+      VarNodes = T.type_alias do
+        T.any(
+          SyntaxTree::GVar,
+          SyntaxTree::Ident,
+          SyntaxTree::IVar,
+          SyntaxTree::Const,
+          SyntaxTree::CVar
+        )
+      end
+
+      sig { params(document: Document, position: Document::PositionShape).void }
+      def initialize(document, position)
+        @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
+        position = Document::Scanner.new(document.source).find_position(position)
+        @target = T.let(find(document.tree, position), T.nilable(VarNodes))
+
+        super(document)
+      end
+
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight], Object)) }
+      def run
+        # no @target means the target is not highlightable
+        return [] unless @target
+
+        visit(@document.tree)
+        @highlights
+      end
+
+      sig { params(node: SyntaxTree::VarField).void }
+      def visit_var_field(node)
+        if matches_target?(node.value)
+          add_highlight(
+            node.value,
+            LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+          )
+        end
+
+        super
+      end
+
+      sig { params(node: SyntaxTree::VarRef).void }
+      def visit_var_ref(node)
+        if matches_target?(node.value)
+          add_highlight(
+            node.value,
+            LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
+          )
+        end
+
+        super
+      end
+
+      private
+
+      sig { params(node: SyntaxTree::Node, position: Integer).returns(T.nilable(VarNodes)) }
+      def find(node, position)
+        matched =
+          node.child_nodes.compact.bsearch do |child|
+            if (child.location.start_char...child.location.end_char).cover?(position)
+              0
+            else
+              position <=> child.location.start_char
+            end
+          end
+
+        case matched
+        when SyntaxTree::GVar, SyntaxTree::Ident, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar
+          matched
+        when SyntaxTree::Node
+          find(matched, position)
+        end
+      end
+
+      sig { params(node: SyntaxTree::Node).returns(T::Boolean) }
+      def matches_target?(node)
+        node.is_a?(@target.class) && T.cast(node, VarNodes).value == T.must(@target).value
+      end
+
+      sig { params(node: SyntaxTree::Node, kind: Integer).void }
+      def add_highlight(node, kind)
+        range = range_from_syntax_tree_node(node)
+        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: kind)
+      end
+    end
+  end
+end