ruby-lsp 0.0.2 → 0.1.0

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -1,116 +1,187 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # The [semantic
+    # highlighting](https://microsoft.github.io/language-server-protocol/specification#textDocument_semanticTokens)
+    # request informs the editor of the correct token types to provide consistent and accurate highlighting for themes.
+    #
+    # # Example
+    #
+    # ```ruby
+    # def foo
+    #   var = 1 # --> semantic highlighting: local variable
+    #   some_invocation # --> semantic highlighting: method invocation
+    #   var # --> semantic highlighting: local variable
+    # end
+    # ```
     class SemanticHighlighting < BaseRequest
-      TOKEN_TYPES = [
+      extend T::Sig
+
+      TOKEN_TYPES = T.let([
         :variable,
         :method,
-      ].freeze
-      TOKEN_MODIFIERS = [].freeze
-
-      def initialize(document)
-        super
-
-        @tokens = []
-        @tree = document.tree
-        @current_row = 0
-        @current_column = 0
+        :namespace,
+      ].freeze, T::Array[Symbol])
+
+      TOKEN_MODIFIERS = T.let({
+        declaration: 0,
+        definition: 1,
+        readonly: 2,
+        static: 3,
+        deprecated: 4,
+        abstract: 5,
+        async: 6,
+        modification: 7,
+        documentation: 8,
+        default_library: 9,
+      }.freeze, T::Hash[Symbol, Integer])
+
+      class SemanticToken < T::Struct
+        const :location, SyntaxTree::Location
+        const :length, Integer
+        const :type, Integer
+        const :modifier, T::Array[Integer]
       end
 
-      def run
-        visit(@tree)
-        LanguageServer::Protocol::Interface::SemanticTokens.new(data: @tokens)
-      end
+      sig { params(document: Document, encoder: T.nilable(Support::SemanticTokenEncoder)).void }
+      def initialize(document, encoder: nil)
+        super(document)
 
-      def visit_m_assign(node)
-        node.target.parts.each do |var_ref|
-          add_token(var_ref.value.location, :variable)
-        end
+        @encoder = encoder
+        @tokens = T.let([], T::Array[SemanticToken])
+        @tree = T.let(document.tree, SyntaxTree::Node)
       end
 
-      def visit_var_field(node)
-        case node.value
-        when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
-        end
+      sig do
+        override.returns(
+          T.any(
+            LanguageServer::Protocol::Interface::SemanticTokens,
+            T.all(T::Array[SemanticToken], Object),
+          )
+        )
       end
+      def run
+        visit(@tree)
+        return @tokens unless @encoder
 
-      def visit_var_ref(node)
-        case node.value
-        when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
-        end
+        @encoder.encode(@tokens)
       end
 
+      sig { params(node: SyntaxTree::ARefField).void }
       def visit_a_ref_field(node)
         add_token(node.collection.value.location, :variable)
       end
 
+      sig { params(node: SyntaxTree::Call).void }
       def visit_call(node)
         visit(node.receiver)
         add_token(node.message.location, :method)
         visit(node.arguments)
       end
 
+      sig { params(node: SyntaxTree::Command).void }
       def visit_command(node)
         add_token(node.message.location, :method)
         visit(node.arguments)
       end
 
+      sig { params(node: SyntaxTree::CommandCall).void }
       def visit_command_call(node)
         visit(node.receiver)
         add_token(node.message.location, :method)
         visit(node.arguments)
       end
 
-      def visit_fcall(node)
-        add_token(node.value.location, :method)
-        visit(node.arguments)
+      sig { params(node: SyntaxTree::Const).void }
+      def visit_const(node)
+        add_token(node.location, :namespace)
       end
 
-      def visit_vcall(node)
-        add_token(node.value.location, :method)
+      sig { params(node: SyntaxTree::Def).void }
+      def visit_def(node)
+        add_token(node.name.location, :method, [:declaration])
+        visit(node.params)
+        visit(node.bodystmt)
       end
 
-      def add_token(location, classification)
-        length = location.end_char - location.start_char
-
-        compute_delta(location) do |delta_line, delta_column|
-          @tokens.push(delta_line, delta_column, length, TOKEN_TYPES.index(classification), 0)
-        end
+      sig { params(node: SyntaxTree::DefEndless).void }
+      def visit_def_endless(node)
+        add_token(node.name.location, :method, [:declaration])
+        visit(node.paren)
+        visit(node.operator)
+        visit(node.statement)
       end
 
-      # The delta array is computed according to the LSP specification:
-      # > The protocol for the token format relative uses relative
-      # > positions, because most tokens remain stable relative to
-      # > each other when edits are made in a file. This simplifies
-      # > the computation of a delta if a server supports it. So each
-      # > token is represented using 5 integers.
+      sig { params(node: SyntaxTree::Defs).void }
+      def visit_defs(node)
+        visit(node.target)
+        visit(node.operator)
+        add_token(node.name.location, :method, [:declaration])
+        visit(node.params)
+        visit(node.bodystmt)
+      end
 
-      # For more information on how each number is calculated, read:
-      # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
-      def compute_delta(location)
-        row = location.start_line - 1
-        column = location.start_column
+      sig { params(node: SyntaxTree::FCall).void }
+      def visit_fcall(node)
+        add_token(node.value.location, :method)
+        visit(node.arguments)
+      end
 
-        if row < @current_row
-          raise InvalidTokenRowError, "Invalid token row detected: " \
-            "Ensure tokens are added in the expected order."
+      sig { params(node: SyntaxTree::Kw).void }
+      def visit_kw(node)
+        case node.value
+        when "self"
+          add_token(node.location, :variable, [:default_library])
         end
+      end
 
-        delta_line = row - @current_row
+      sig { params(node: SyntaxTree::MAssign).void }
+      def visit_m_assign(node)
+        node.target.parts.each do |var_ref|
+          add_token(var_ref.value.location, :variable)
+        end
+      end
 
-        delta_column = column
-        delta_column -= @current_column if delta_line == 0
+      sig { params(node: SyntaxTree::VarField).void }
+      def visit_var_field(node)
+        case node.value
+        when SyntaxTree::Ident
+          add_token(node.value.location, :variable)
+        else
+          visit(node.value)
+        end
+      end
 
-        yield delta_line, delta_column
+      sig { params(node: SyntaxTree::VarRef).void }
+      def visit_var_ref(node)
+        case node.value
+        when SyntaxTree::Ident
+          add_token(node.value.location, :variable)
+        else
+          visit(node.value)
+        end
+      end
 
-        @current_row = row
-        @current_column = column
+      sig { params(node: SyntaxTree::VCall).void }
+      def visit_vcall(node)
+        add_token(node.value.location, :method)
       end
 
-      class InvalidTokenRowError < StandardError; end
+      sig { params(location: SyntaxTree::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
+      def add_token(location, type, modifiers = [])
+        length = location.end_char - location.start_char
+        modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
+        @tokens.push(
+          SemanticToken.new(
+            location: location,
+            length: length,
+            type: T.must(TOKEN_TYPES.index(type)),
+            modifier: modifiers_indices
+          )
+        )
+      end
     end
   end
 end

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

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class RuboCopDiagnostic
+        extend T::Sig
+
+        RUBOCOP_TO_LSP_SEVERITY = T.let({
+          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, T::Hash[Symbol, Integer])
+
+        sig { returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
+        attr_reader :replacements
+
+        sig { params(offense: RuboCop::Cop::Offense, uri: String).void }
+        def initialize(offense, uri)
+          @offense = offense
+          @uri = uri
+          @replacements = T.let(
+            offense.correctable? ? offense_replacements : [],
+            T::Array[LanguageServer::Protocol::Interface::TextEdit]
+          )
+        end
+
+        sig { returns(T::Boolean) }
+        def correctable?
+          @offense.correctable?
+        end
+
+        sig { params(range: T::Range[Integer]).returns(T::Boolean) }
+        def in_range?(range)
+          range.cover?(@offense.line - 1)
+        end
+
+        sig { returns(LanguageServer::Protocol::Interface::CodeAction) }
+        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
+
+        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
+        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
+
+        sig { returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class SelectionRange < LanguageServer::Protocol::Interface::SelectionRange
+        extend T::Sig
+
+        sig { params(position: Document::PositionShape).returns(T::Boolean) }
+        def cover?(position)
+          line_range = (range.start.line..range.end.line)
+          character_range = (range.start.character..range.end.character)
+
+          line_range.cover?(position[:line]) && character_range.cover?(position[:character])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class SemanticTokenEncoder
+        extend T::Sig
+
+        sig { void }
+        def initialize
+          @current_row = T.let(0, Integer)
+          @current_column = T.let(0, Integer)
+        end
+
+        sig do
+          params(
+            tokens: T::Array[SemanticHighlighting::SemanticToken]
+          ).returns(LanguageServer::Protocol::Interface::SemanticTokens)
+        end
+        def encode(tokens)
+          delta = tokens
+            .sort_by do |token|
+              [token.location.start_line, token.location.start_column]
+            end
+            .flat_map do |token|
+              compute_delta(token)
+            end
+
+          LanguageServer::Protocol::Interface::SemanticTokens.new(data: delta)
+        end
+
+        # The delta array is computed according to the LSP specification:
+        # > The protocol for the token format relative uses relative
+        # > positions, because most tokens remain stable relative to
+        # > each other when edits are made in a file. This simplifies
+        # > the computation of a delta if a server supports it. So each
+        # > token is represented using 5 integers.
+
+        # For more information on how each number is calculated, read:
+        # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
+        sig { params(token: SemanticHighlighting::SemanticToken).returns(T::Array[Integer]) }
+        def compute_delta(token)
+          row = token.location.start_line - 1
+          column = token.location.start_column
+          delta_line = row - @current_row
+
+          delta_column = column
+          delta_column -= @current_column if delta_line == 0
+
+          [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.
+        sig { params(modifiers: T::Array[Integer]).returns(Integer) }
+        def encode_modifiers(modifiers)
+          modifiers.inject(0) do |encoded_modifiers, modifier|
+            encoded_modifiers | (1 << modifier)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class SyntaxErrorDiagnostic
+        extend T::Sig
+
+        sig { params(edit: Document::EditShape).void }
+        def initialize(edit)
+          @edit = edit
+        end
+
+        sig { returns(FalseClass) }
+        def correctable?
+          false
+        end
+
+        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
+        def to_lsp_diagnostic
+          LanguageServer::Protocol::Interface::Diagnostic.new(
+            message: "Syntax error",
+            source: "SyntaxTree",
+            severity: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+            range: @edit[:range]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -5,10 +6,19 @@ module RubyLsp
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
     autoload :DocumentSymbol, "ruby_lsp/requests/document_symbol"
     autoload :FoldingRanges, "ruby_lsp/requests/folding_ranges"
+    autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
     autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
     autoload :RuboCopRequest, "ruby_lsp/requests/rubocop_request"
     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"
+      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"
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "cgi"
@@ -6,32 +7,52 @@ 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)
+      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
+      type_parameters(:T)
+        .params(
+          uri: String,
+          request_name: Symbol,
+          block: T.proc.params(document: Document).returns(T.type_parameter(:T))
+        ).returns(T.type_parameter(:T))
+    end
     def cache_fetch(uri, request_name, &block)
       get(uri).cache_fetch(request_name, &block)
     end

data/rakelib/check_docs.rake

@@ -0,0 +1,57 @@
+# typed: false
+# frozen_string_literal: true
+
+desc "Check if all LSP requests are documented"
+task :check_docs do
+  require "sorbet-runtime"
+  require "language_server-protocol"
+  require "syntax_tree"
+  require "logger"
+  require "ruby_lsp/requests/base_request"
+  require "ruby_lsp/requests/rubocop_request"
+
+  Dir["#{Dir.pwd}/lib/ruby_lsp/requests/*.rb"].each do |file|
+    require(file)
+    YARD.parse(file, [], Logger::Severity::FATAL)
+  end
+
+  spec_matcher = %r{\(https://microsoft.github.io/language-server-protocol/specification#.*\)}
+  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)
+
+    if docs.empty?
+      errors[full_name] << "Missing documentation for request handler class"
+    elsif !spec_matcher.match?(docs)
+      errors[full_name] << <<~MESSAGE
+        Documentation for request handler classes must link to the official LSP specification.
+
+        For example, if your request handles text document hover, you should add a link to
+        https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_hover.
+      MESSAGE
+    elsif !/# Example/.match?(docs)
+      errors[full_name] << <<~MESSAGE
+        Documentation for request handler class must contain an example.
+
+        = Example
+            def my_method # <-- something happens here
+            end
+      MESSAGE
+    end
+  end
+
+  formatted_errors = error_messages.map { |name, errors| "#{name}: #{errors.join(", ")}" }
+
+  if error_messages.any?
+    puts <<~MESSAGE
+      The following requests have invalid documentation:
+
+      #{formatted_errors.join("\n")}
+    MESSAGE
+
+    exit!
+  end
+end

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("syntax_tree", ">= 2.3")
+  s.add_dependency("sorbet-runtime")
+  s.add_dependency("syntax_tree", ">= 2.4")
 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