ruby-lsp 0.0.2 → 0.1.0

data/lib/ruby_lsp/handler.rb

@@ -1,50 +1,81 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "ruby_lsp/requests"
 require "ruby_lsp/store"
+require "benchmark"
 
 module RubyLsp
   class Handler
+    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|
-        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
+
+          @writer.write(id: request[:id], result: result) unless result == VOID
+        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(
@@ -64,7 +95,7 @@ module RubyLsp
           document_selector: { scheme: "file", language: "ruby" },
           legend: Interface::SemanticTokensLegend.new(
             token_types: Requests::SemanticHighlighting::TOKEN_TYPES,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS
+            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys
           ),
           range: false,
           full: {
@@ -76,43 +107,75 @@ module RubyLsp
       Interface::InitializeResult.new(
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(
-            change: Constant::TextDocumentSyncKind::FULL,
+            change: Constant::TextDocumentSyncKind::INCREMENTAL,
             open_close: true,
           ),
+          selection_range_provider: enabled_features.include?("selectionRanges"),
           document_symbol_provider: document_symbol_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")
         )
       )
     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.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.
+      positions.map do |position|
+        ranges.find do |range|
+          range.cover?(position)
+        end
       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.run(document)
+        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(
@@ -124,10 +187,48 @@ module RubyLsp
       )
     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
+
+    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
+
+    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],
+        lspVersion: RubyLsp::VERSION,
+        requestTime: request_time,
+      }
+
+      if error
+        params[:errorClass] = error.class.name
+        params[:errorMessage] = error.message
       end
+
+      params[:uri] = uri 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,20 +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,24 +1,45 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
-    class CodeActions
-      def self.run(uri, document, range)
-        new(uri, document, range).run
-      end
+    # 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.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def say_hello
+    # puts "Hello" # --> code action: quick fix indentation
+    # 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) }
-        return if corrections.empty?
+        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,96 +1,48 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # The
+    # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
+    # request informs the editor of RuboCop offenses for a given file.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def say_hello
+    # puts "Hello" # --> diagnostics: incorrect indentantion
+    # end
+    # ```
     class Diagnostics < RuboCopRequest
-      RUBOCOP_TO_LSP_SEVERITY = {
-        convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-        info: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-        refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-        warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
-        error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-        fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-      }.freeze
+      extend T::Sig
 
+      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?
+
         super
 
         @diagnostics
       end
 
+      sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
       def file_finished(_file, offenses)
-        @diagnostics = offenses.map { |offense| Diagnostic.new(offense, @uri) }
+        @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, @uri) }
       end
 
-      class Diagnostic
-        attr_reader :replacements
-
-        def initialize(offense, uri)
-          @offense = offense
-          @uri = uri
-          @replacements = offense.correctable? ? offense_replacements : []
-        end
-
-        def correctable?
-          @offense.correctable?
-        end
-
-        def in_range?(range)
-          range.cover?(@offense.line - 1)
-        end
-
-        def to_lsp_code_action
-          LanguageServer::Protocol::Interface::CodeAction.new(
-            title: "Autocorrect #{@offense.cop_name}",
-            kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
-            edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
-              document_changes: [
-                LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-                  text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
-                    uri: @uri,
-                    version: nil
-                  ),
-                  edits: @replacements
-                ),
-              ]
-            ),
-            is_preferred: true,
-          )
-        end
-
-        def to_lsp_diagnostic
-          LanguageServer::Protocol::Interface::Diagnostic.new(
-            message: @offense.message,
-            source: "RuboCop",
-            code: @offense.cop_name,
-            severity: RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name],
-            range: LanguageServer::Protocol::Interface::Range.new(
-              start: LanguageServer::Protocol::Interface::Position.new(
-                line: @offense.line - 1,
-                character: @offense.column
-              ),
-              end: LanguageServer::Protocol::Interface::Position.new(
-                line: @offense.last_line - 1,
-                character: @offense.last_column
-              )
-            )
-          )
-        end
-
-        private
+      private
 
-        def offense_replacements
-          @offense.corrector.as_replacements.map do |range, replacement|
-            LanguageServer::Protocol::Interface::TextEdit.new(
-              range: LanguageServer::Protocol::Interface::Range.new(
-                start: LanguageServer::Protocol::Interface::Position.new(line: range.line - 1, character: range.column),
-                end: LanguageServer::Protocol::Interface::Position.new(line: range.last_line - 1,
-                  character: range.last_column)
-              ),
-              new_text: replacement
-            )
-          end
-        end
+      sig { returns(T::Array[Support::SyntaxErrorDiagnostic]) }
+      def syntax_error_diagnostics
+        @document.syntax_error_edits.map { |e| Support::SyntaxErrorDiagnostic.new(e) }
       end
     end
   end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # 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