ruby-lsp 0.0.3 → 0.0.4

data/lib/ruby_lsp/handler.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "ruby_lsp/requests"
@@ -6,24 +7,25 @@ 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|
@@ -31,26 +33,39 @@ module RubyLsp
       end
     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
+      handler = @handlers[request[:method]]
+      return unless handler
+
+      result = handler.call(request)
+      @writer.write(id: request[:id], result: result) unless result == VOID
     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(
@@ -70,7 +85,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: {
@@ -90,23 +105,32 @@ 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)
       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)
       end
     end
 
+    sig do
+      params(
+        uri: String,
+        positions: T::Array[Document::PositionShape]
+      ).returns(T::Array[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)
@@ -123,16 +147,19 @@ 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
       end
     end
 
+    sig { params(uri: String).returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
     def respond_with_formatting(uri)
       Requests::Formatting.run(uri, store.get(uri))
     end
 
+    sig { params(uri: String).void }
     def send_diagnostics(uri)
       response = store.cache_fetch(uri, :diagnostics) do |document|
         Requests::Diagnostics.run(uri, document)
@@ -147,35 +174,63 @@ module RubyLsp
       )
     end
 
+    sig do
+      params(uri: String, range: T::Range[Integer]).returns(T::Array[LanguageServer::Protocol::Interface::Diagnostic])
+    end
     def respond_with_code_actions(uri, range)
       store.cache_fetch(uri, :code_actions) do |document|
         Requests::CodeActions.run(uri, document, range)
       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.run(store.get(uri), position)
     end
 
-    def with_telemetry(request)
-      return yield unless @telemetry_enabled && !IGNORED_FOR_TELEMETRY.include?(request[:method])
+    sig { params(request: T::Hash[Symbol, T.untyped], block: T.proc.void).returns(T.untyped) }
+    def with_telemetry(request, &block)
+      result = T.let(nil, T.untyped)
+      error = T.let(nil, T.nilable(StandardError))
 
-      result = nil
       request_time = Benchmark.realtime do
-        result = yield
+        result = block.call
+      rescue StandardError => e
+        error = e
       end
 
+      @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
+      result
+    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 if uri
+      params
     end
   end
 end

data/lib/ruby_lsp/requests/base_request.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
@@ -17,6 +18,16 @@ module RubyLsp
       def run
         raise NotImplementedError, "#{self.class}#run must be implemented"
       end
+
+      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
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -0,0 +1,96 @@
+# typed: true
+# 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
+      def self.run(document, position)
+        new(document, position).run
+      end
+
+      def initialize(document, position)
+        @highlights = []
+        position = Document::Scanner.new(document.source).find_position(position)
+        @target = find(document.tree, position)
+
+        super(document)
+      end
+
+      def run
+        # no @target means the target is not highlightable
+        return [] unless @target
+
+        visit(@document.tree)
+        @highlights
+      end
+
+      def visit_var_field(node)
+        if matches_target?(node.value)
+          add_highlight(
+            node.value,
+            LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+          )
+        end
+
+        super
+      end
+
+      def visit_var_ref(node)
+        if matches_target?(node.value)
+          add_highlight(
+            node.value,
+            LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
+          )
+        end
+
+        super
+      end
+
+      private
+
+      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
+
+      def matches_target?(node)
+        node.is_a?(@target.class) && node.value == @target.value
+      end
+
+      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

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
@@ -210,16 +211,6 @@ module RubyLsp
 
         symbol
       end
-
-      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
 end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
@@ -148,7 +149,7 @@ module RubyLsp
       end
 
       def add_call_range(node)
-        receiver = node.receiver
+        receiver = T.let(node.receiver, SyntaxTree::Node)
         loop do
           case receiver
           when SyntaxTree::Call
@@ -184,7 +185,7 @@ module RubyLsp
       end
 
       def add_string_concat(node)
-        left = node.left
+        left = T.let(node.left, SyntaxTree::Node)
         left = left.left while left.is_a?(SyntaxTree::StringConcat)
 
         add_lines_range(left.location.start_line, node.right.location.end_line)

data/lib/ruby_lsp/requests/formatting.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
@@ -14,7 +15,7 @@ module RubyLsp
     # end
     # ```
     class Formatting < RuboCopRequest
-      RUBOCOP_FLAGS = (COMMON_RUBOCOP_FLAGS + ["--auto-correct"]).freeze
+      RUBOCOP_FLAGS = (COMMON_RUBOCOP_FLAGS + ["--autocorrect"]).freeze
 
       def initialize(uri, document)
         super

data/lib/ruby_lsp/requests/rubocop_request.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require "rubocop"

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
@@ -20,7 +21,19 @@ module RubyLsp
         :variable,
         :method,
       ].freeze
-      TOKEN_MODIFIERS = [].freeze
+
+      TOKEN_MODIFIERS = {
+        declaration: 0,
+        definition: 1,
+        readonly: 2,
+        static: 3,
+        deprecated: 4,
+        abstract: 5,
+        async: 6,
+        modification: 7,
+        documentation: 8,
+        default_library: 9,
+      }.freeze
 
       SemanticToken = Struct.new(:location, :length, :type, :modifier)
 
@@ -89,9 +102,10 @@ module RubyLsp
         add_token(node.value.location, :method)
       end
 
-      def add_token(location, type)
+      def add_token(location, type, modifiers = [])
         length = location.end_char - location.start_char
-        @tokens.push(SemanticToken.new(location, length, TOKEN_TYPES.index(type), 0))
+        modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
+        @tokens.push(SemanticToken.new(location, length, TOKEN_TYPES.index(type), modifiers_indices))
       end
     end
   end

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
@@ -38,11 +39,21 @@ module RubyLsp
           delta_column = column
           delta_column -= @current_column if delta_line == 0
 
-          [delta_line, delta_column, token.length, token.type, token.modifier]
+          [delta_line, delta_column, token.length, token.type, encode_modifiers(token.modifier)]
         ensure
           @current_row = row
           @current_column = column
         end
+
+        # Encode an array of modifiers to positions onto a bit flag
+        # For example, [:default_library] will be encoded as
+        # 0b1000000000, as :default_library is the 10th bit according
+        # to the token modifiers index map.
+        def encode_modifiers(modifiers)
+          modifiers.inject(0) do |encoded_modifiers, modifier|
+            encoded_modifiers | (1 << modifier)
+          end
+        end
       end
     end
   end

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

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp

data/lib/ruby_lsp/requests.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module RubyLsp
@@ -11,6 +12,7 @@ module RubyLsp
     autoload :Formatting, "ruby_lsp/requests/formatting"
     autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
     autoload :CodeActions, "ruby_lsp/requests/code_actions"
+    autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
 
     module Support
       autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"

data/lib/ruby_lsp/store.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "cgi"
@@ -6,36 +7,51 @@ require "ruby_lsp/document"
 
 module RubyLsp
   class Store
+    extend T::Sig
+
+    sig { void }
     def initialize
-      @state = {}
+      @state = T.let({}, T::Hash[String, Document])
     end
 
+    sig { params(uri: String).returns(Document) }
     def get(uri)
       document = @state[uri]
       return document unless document.nil?
 
       set(uri, File.binread(CGI.unescape(URI.parse(uri).path)))
-      @state[uri]
+      T.must(@state[uri])
     end
 
+    sig { params(uri: String, content: String).void }
     def set(uri, content)
       @state[uri] = Document.new(content)
     rescue SyntaxTree::Parser::ParseError
       # Do not update the store if there are syntax errors
     end
 
+    sig { params(uri: String, edits: T::Array[Document::EditShape]).void }
     def push_edits(uri, edits)
-      @state[uri].push_edits(edits)
+      T.must(@state[uri]).push_edits(edits)
     end
 
+    sig { void }
     def clear
       @state.clear
     end
 
+    sig { params(uri: String).void }
     def delete(uri)
       @state.delete(uri)
     end
 
+    sig do
+      params(
+        uri: String,
+        request_name: Symbol,
+        block: T.proc.params(document: Document).returns(T.untyped)
+      ).returns(T.untyped)
+    end
     def cache_fetch(uri, request_name, &block)
       get(uri).cache_fetch(request_name, &block)
     end

data/rakelib/check_docs.rake

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 desc "Check if all LSP requests are documented"
@@ -14,7 +15,9 @@ task :check_docs do
   end
 
   spec_matcher = %r{\(https://microsoft.github.io/language-server-protocol/specification#.*\)}
-  error_messages = RubyLsp::Requests.constants.each_with_object(Hash.new { |h, k| h[k] = [] }) do |request, errors|
+  error_messages = RubyLsp::Requests
+    .constants # rubocop:disable Sorbet/ConstantsFromStrings
+    .each_with_object(Hash.new { |h, k| h[k] = [] }) do |request, errors|
     full_name = "RubyLsp::Requests::#{request}"
     docs = YARD::Registry.at(full_name).docstring
     next if /:nodoc:/.match?(docs)

data/ruby-lsp.gemspec

@@ -21,5 +21,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency("language_server-protocol")
   s.add_dependency("rubocop", ">= 1.0")
+  s.add_dependency("sorbet-runtime")
   s.add_dependency("syntax_tree", ">= 2.3")
 end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=vendor/
+--ignore=test/fixtures/

data/sorbet/rbi/.rubocop.yml

@@ -0,0 +1,8 @@
+inherit_gem:
+  rubocop-sorbet: config/rbi.yml
+
+Lint/EmptyFile:
+  Enabled: false
+
+Sorbet/TypeAliasName:
+  Enabled: false